Skip to content

[NFC][LLVM] Namespace cleanup in GVNSink #163305

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Oct 15, 2025
Merged

[NFC][LLVM] Namespace cleanup in GVNSink #163305

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
48 changes: 23 additions & 25 deletions llvm/lib/Transforms/Scalar/GVNSink.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -73,24 +73,17 @@
#include <utility>

using namespace llvm;
using namespace llvm::GVNExpression;

#define DEBUG_TYPE "gvn-sink"

STATISTIC(NumRemoved, "Number of instructions removed");

namespace llvm {
namespace GVNExpression {

LLVM_DUMP_METHOD void Expression::dump() const {
print(dbgs());
dbgs() << "\n";
}

} // end namespace GVNExpression
} // end namespace llvm

namespace {

static bool isMemoryInst(const Instruction *I) {
return isa<LoadInst>(I) || isa<StoreInst>(I) ||
(isa<InvokeInst>(I) && !cast<InvokeInst>(I)->doesNotAccessMemory()) ||
Expand All @@ -99,6 +92,8 @@ static bool isMemoryInst(const Instruction *I) {

//===----------------------------------------------------------------------===//

namespace {

/// Candidate solution for sinking. There may be different ways to
/// sink instructions, differing in the number of instructions sunk,
/// the number of predecessors sunk from and the number of PHIs
Expand All @@ -125,14 +120,6 @@ struct SinkingInstructionCandidate {
}
};

#ifndef NDEBUG
raw_ostream &operator<<(raw_ostream &OS, const SinkingInstructionCandidate &C) {
OS << "<Candidate Cost=" << C.Cost << " #Blocks=" << C.NumBlocks
<< " #Insts=" << C.NumInstructions << " #PHIs=" << C.NumPHIs << ">";
return OS;
}
#endif

//===----------------------------------------------------------------------===//

/// Describes a PHI node that may or may not exist. These track the PHIs
Expand Down Expand Up @@ -256,8 +243,18 @@ class ModelledPHI {
return Values == Other.Values && Blocks == Other.Blocks;
}
};
} // namespace

template <typename ModelledPHI> struct DenseMapInfo {
#ifndef NDEBUG
static raw_ostream &operator<<(raw_ostream &OS,
const SinkingInstructionCandidate &C) {
OS << "<Candidate Cost=" << C.Cost << " #Blocks=" << C.NumBlocks
<< " #Insts=" << C.NumInstructions << " #PHIs=" << C.NumPHIs << ">";
return OS;
}
#endif

template <> struct llvm::DenseMapInfo<ModelledPHI> {
static inline ModelledPHI &getEmptyKey() {
static ModelledPHI Dummy = ModelledPHI::createDummy(0);
return Dummy;
Expand All @@ -275,7 +272,9 @@ template <typename ModelledPHI> struct DenseMapInfo {
}
};

using ModelledPHISet = DenseSet<ModelledPHI, DenseMapInfo<ModelledPHI>>;
using ModelledPHISet = DenseSet<ModelledPHI>;

namespace {

//===----------------------------------------------------------------------===//
// ValueTable
Expand All @@ -290,15 +289,15 @@ using ModelledPHISet = DenseSet<ModelledPHI, DenseMapInfo<ModelledPHI>>;
///
/// This class also contains fields for discriminators used when determining
/// equivalence of instructions with sideeffects.
class InstructionUseExpr : public GVNExpression::BasicExpression {
class InstructionUseExpr : public BasicExpression {
unsigned MemoryUseOrder = -1;
bool Volatile = false;
ArrayRef<int> ShuffleMask;

public:
InstructionUseExpr(Instruction *I, ArrayRecycler<Value *> &R,
BumpPtrAllocator &A)
: GVNExpression::BasicExpression(I->getNumUses()) {
: BasicExpression(I->getNumUses()) {
allocateOperands(R, A);
setOpcode(I->getOpcode());
setType(I->getType());
Expand All @@ -315,8 +314,8 @@ class InstructionUseExpr : public GVNExpression::BasicExpression {
void setVolatile(bool V) { Volatile = V; }

hash_code getHashValue() const override {
return hash_combine(GVNExpression::BasicExpression::getHashValue(),
MemoryUseOrder, Volatile, ShuffleMask);
return hash_combine(BasicExpression::getHashValue(), MemoryUseOrder,
Volatile, ShuffleMask);
}

template <typename Function> hash_code getHashValue(Function MapFn) {
Expand All @@ -332,7 +331,7 @@ using BasicBlocksSet = SmallPtrSet<const BasicBlock *, 32>;

class ValueTable {
DenseMap<Value *, uint32_t> ValueNumbering;
DenseMap<GVNExpression::Expression *, uint32_t> ExpressionNumbering;
DenseMap<Expression *, uint32_t> ExpressionNumbering;
DenseMap<size_t, uint32_t> HashNumbering;
BumpPtrAllocator Allocator;
ArrayRecycler<Value *> Recycler;
Expand Down Expand Up @@ -594,6 +593,7 @@ class GVNSink {
}
}
};
} // namespace

std::optional<SinkingInstructionCandidate>
GVNSink::analyzeInstructionForSinking(LockstepReverseIterator<false> &LRI,
Expand Down Expand Up @@ -851,8 +851,6 @@ void GVNSink::sinkLastInstruction(ArrayRef<BasicBlock *> Blocks,
NumRemoved += Insts.size() - 1;
}

} // end anonymous namespace

PreservedAnalyses GVNSinkPass::run(Function &F, FunctionAnalysisManager &AM) {
GVNSink G;
if (!G.run(F))
Expand Down