[llvm] [NFC][LLVM] Namespace cleanup in LegacyPassManagerTest (PR #196811)
via llvm-commits
llvm-commits at lists.llvm.org
Sun May 10 08:28:17 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
Author: Rahul Joshi (jurahul)
<details>
<summary>Changes</summary>
Remove llvm namespace surrounding the entire file, and remove extra indentation of the code within the anonymous namespace.
---
Patch is 35.17 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/196811.diff
1 Files Affected:
- (modified) llvm/unittests/IR/LegacyPassManagerTest.cpp (+562-567)
``````````diff
diff --git a/llvm/unittests/IR/LegacyPassManagerTest.cpp b/llvm/unittests/IR/LegacyPassManagerTest.cpp
index cf455fc0a3028..3a3982763bb06 100644
--- a/llvm/unittests/IR/LegacyPassManagerTest.cpp
+++ b/llvm/unittests/IR/LegacyPassManagerTest.cpp
@@ -39,617 +39,612 @@
using namespace llvm;
namespace llvm {
- void initializeModuleNDMPass(PassRegistry&);
- void initializeFPassPass(PassRegistry&);
- void initializeCGPassPass(PassRegistry&);
- void initializeLPassPass(PassRegistry&);
-
- namespace {
- // ND = no deps
- // NM = no modifications
- struct ModuleNDNM: public ModulePass {
- public:
- static char run;
- static char ID;
- ModuleNDNM() : ModulePass(ID) { }
- bool runOnModule(Module &M) override {
- run++;
- return false;
- }
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.setPreservesAll();
- }
- };
- char ModuleNDNM::ID=0;
- char ModuleNDNM::run=0;
-
- struct ModuleNDM : public ModulePass {
- public:
- static char run;
- static char ID;
- ModuleNDM() : ModulePass(ID) {}
- bool runOnModule(Module &M) override {
- run++;
- return true;
- }
- };
- char ModuleNDM::ID=0;
- char ModuleNDM::run=0;
-
- struct ModuleNDM2 : public ModulePass {
- public:
- static char run;
- static char ID;
- ModuleNDM2() : ModulePass(ID) {}
- bool runOnModule(Module &M) override {
- run++;
- return true;
- }
- };
- char ModuleNDM2::ID=0;
- char ModuleNDM2::run=0;
-
- struct ModuleDNM : public ModulePass {
- public:
- static char run;
- static char ID;
- ModuleDNM() : ModulePass(ID) {
- initializeModuleNDMPass(*PassRegistry::getPassRegistry());
- }
- bool runOnModule(Module &M) override {
- run++;
- return false;
- }
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.addRequired<ModuleNDM>();
- AU.setPreservesAll();
- }
- };
- char ModuleDNM::ID=0;
- char ModuleDNM::run=0;
-
- template<typename P>
- struct PassTestBase : public P {
- protected:
- static int runc;
- static bool initialized;
- static bool finalized;
- int allocated;
- void run() {
- EXPECT_TRUE(initialized);
- EXPECT_FALSE(finalized);
- EXPECT_EQ(0, allocated);
- allocated++;
- runc++;
- }
- public:
- static char ID;
- static void finishedOK(int run) {
- EXPECT_GT(runc, 0);
- EXPECT_TRUE(initialized);
- EXPECT_TRUE(finalized);
- EXPECT_EQ(run, runc);
- }
- PassTestBase() : P(ID), allocated(0) {
- initialized = false;
- finalized = false;
- runc = 0;
- }
+void initializeModuleNDMPass(PassRegistry &);
+void initializeFPassPass(PassRegistry &);
+void initializeCGPassPass(PassRegistry &);
+void initializeLPassPass(PassRegistry &);
+} // namespace llvm
+
+namespace {
+// ND = no deps
+// NM = no modifications
+struct ModuleNDNM : public ModulePass {
+public:
+ static char run;
+ static char ID;
+ ModuleNDNM() : ModulePass(ID) {}
+ bool runOnModule(Module &M) override {
+ run++;
+ return false;
+ }
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.setPreservesAll();
+ }
+};
+char ModuleNDNM::ID = 0;
+char ModuleNDNM::run = 0;
+
+struct ModuleNDM : public ModulePass {
+public:
+ static char run;
+ static char ID;
+ ModuleNDM() : ModulePass(ID) {}
+ bool runOnModule(Module &M) override {
+ run++;
+ return true;
+ }
+};
+char ModuleNDM::ID = 0;
+char ModuleNDM::run = 0;
+
+struct ModuleNDM2 : public ModulePass {
+public:
+ static char run;
+ static char ID;
+ ModuleNDM2() : ModulePass(ID) {}
+ bool runOnModule(Module &M) override {
+ run++;
+ return true;
+ }
+};
+char ModuleNDM2::ID = 0;
+char ModuleNDM2::run = 0;
+
+struct ModuleDNM : public ModulePass {
+public:
+ static char run;
+ static char ID;
+ ModuleDNM() : ModulePass(ID) {
+ initializeModuleNDMPass(*PassRegistry::getPassRegistry());
+ }
+ bool runOnModule(Module &M) override {
+ run++;
+ return false;
+ }
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.addRequired<ModuleNDM>();
+ AU.setPreservesAll();
+ }
+};
+char ModuleDNM::ID = 0;
+char ModuleDNM::run = 0;
+
+template <typename P> struct PassTestBase : public P {
+protected:
+ static int runc;
+ static bool initialized;
+ static bool finalized;
+ int allocated;
+ void run() {
+ EXPECT_TRUE(initialized);
+ EXPECT_FALSE(finalized);
+ EXPECT_EQ(0, allocated);
+ allocated++;
+ runc++;
+ }
- void releaseMemory() override {
- EXPECT_GT(runc, 0);
- EXPECT_GT(allocated, 0);
- allocated--;
- }
- };
- template<typename P> char PassTestBase<P>::ID;
- template<typename P> int PassTestBase<P>::runc;
- template<typename P> bool PassTestBase<P>::initialized;
- template<typename P> bool PassTestBase<P>::finalized;
-
- template<typename T, typename P>
- struct PassTest : public PassTestBase<P> {
- public:
+public:
+ static char ID;
+ static void finishedOK(int run) {
+ EXPECT_GT(runc, 0);
+ EXPECT_TRUE(initialized);
+ EXPECT_TRUE(finalized);
+ EXPECT_EQ(run, runc);
+ }
+ PassTestBase() : P(ID), allocated(0) {
+ initialized = false;
+ finalized = false;
+ runc = 0;
+ }
+
+ void releaseMemory() override {
+ EXPECT_GT(runc, 0);
+ EXPECT_GT(allocated, 0);
+ allocated--;
+ }
+};
+template <typename P> char PassTestBase<P>::ID;
+template <typename P> int PassTestBase<P>::runc;
+template <typename P> bool PassTestBase<P>::initialized;
+template <typename P> bool PassTestBase<P>::finalized;
+
+template <typename T, typename P> struct PassTest : public PassTestBase<P> {
+public:
#ifndef _MSC_VER // MSVC complains that Pass is not base class.
- using llvm::Pass::doInitialization;
- using llvm::Pass::doFinalization;
+ using llvm::Pass::doFinalization;
+ using llvm::Pass::doInitialization;
#endif
- bool doInitialization(T &t) override {
- EXPECT_FALSE(PassTestBase<P>::initialized);
- PassTestBase<P>::initialized = true;
- return false;
- }
- bool doFinalization(T &t) override {
- EXPECT_FALSE(PassTestBase<P>::finalized);
- PassTestBase<P>::finalized = true;
- EXPECT_EQ(0, PassTestBase<P>::allocated);
- return false;
- }
- };
-
- struct CGPass : public PassTest<CallGraph, CallGraphSCCPass> {
- public:
- CGPass() {
- initializeCGPassPass(*PassRegistry::getPassRegistry());
- }
- bool runOnSCC(CallGraphSCC &SCMM) override {
- run();
- return false;
- }
- };
-
- struct FPass : public PassTest<Module, FunctionPass> {
- public:
- bool runOnFunction(Function &F) override {
- // FIXME: PR4112
- // EXPECT_TRUE(getAnalysisIfAvailable<DataLayout>());
- run();
- return false;
- }
- };
-
- struct LPass : public PassTestBase<LoopPass> {
- private:
- static int initcount;
- static int fincount;
- public:
- LPass() {
- initializeLPassPass(*PassRegistry::getPassRegistry());
- initcount = 0; fincount=0;
- EXPECT_FALSE(initialized);
- }
- static void finishedOK(int run, int finalized) {
- PassTestBase<LoopPass>::finishedOK(run);
- EXPECT_EQ(run, initcount);
- EXPECT_EQ(finalized, fincount);
- }
- using llvm::Pass::doInitialization;
- using llvm::Pass::doFinalization;
- bool doInitialization(Loop* L, LPPassManager &LPM) override {
- initialized = true;
- initcount++;
- return false;
- }
- bool runOnLoop(Loop *L, LPPassManager &LPM) override {
- run();
- return false;
- }
- bool doFinalization() override {
- fincount++;
- finalized = true;
- return false;
- }
- };
- int LPass::initcount=0;
- int LPass::fincount=0;
-
- struct OnTheFlyTest: public ModulePass {
- public:
- static char ID;
- OnTheFlyTest() : ModulePass(ID) {
- initializeFPassPass(*PassRegistry::getPassRegistry());
- }
- bool runOnModule(Module &M) override {
- for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) {
- Function &F = *I;
- {
- SCOPED_TRACE("Running on the fly function pass");
- getAnalysis<FPass>(F);
- }
- }
- return false;
- }
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.addRequired<FPass>();
+ bool doInitialization(T &t) override {
+ EXPECT_FALSE(PassTestBase<P>::initialized);
+ PassTestBase<P>::initialized = true;
+ return false;
+ }
+ bool doFinalization(T &t) override {
+ EXPECT_FALSE(PassTestBase<P>::finalized);
+ PassTestBase<P>::finalized = true;
+ EXPECT_EQ(0, PassTestBase<P>::allocated);
+ return false;
+ }
+};
+
+struct CGPass : public PassTest<CallGraph, CallGraphSCCPass> {
+public:
+ CGPass() { initializeCGPassPass(*PassRegistry::getPassRegistry()); }
+ bool runOnSCC(CallGraphSCC &SCMM) override {
+ run();
+ return false;
+ }
+};
+
+struct FPass : public PassTest<Module, FunctionPass> {
+public:
+ bool runOnFunction(Function &F) override {
+ // FIXME: PR4112
+ // EXPECT_TRUE(getAnalysisIfAvailable<DataLayout>());
+ run();
+ return false;
+ }
+};
+
+struct LPass : public PassTestBase<LoopPass> {
+private:
+ static int initcount;
+ static int fincount;
+
+public:
+ LPass() {
+ initializeLPassPass(*PassRegistry::getPassRegistry());
+ initcount = 0;
+ fincount = 0;
+ EXPECT_FALSE(initialized);
+ }
+ static void finishedOK(int run, int finalized) {
+ PassTestBase<LoopPass>::finishedOK(run);
+ EXPECT_EQ(run, initcount);
+ EXPECT_EQ(finalized, fincount);
+ }
+ using llvm::Pass::doFinalization;
+ using llvm::Pass::doInitialization;
+ bool doInitialization(Loop *L, LPPassManager &LPM) override {
+ initialized = true;
+ initcount++;
+ return false;
+ }
+ bool runOnLoop(Loop *L, LPPassManager &LPM) override {
+ run();
+ return false;
+ }
+ bool doFinalization() override {
+ fincount++;
+ finalized = true;
+ return false;
+ }
+};
+int LPass::initcount = 0;
+int LPass::fincount = 0;
+
+struct OnTheFlyTest : public ModulePass {
+public:
+ static char ID;
+ OnTheFlyTest() : ModulePass(ID) {
+ initializeFPassPass(*PassRegistry::getPassRegistry());
+ }
+ bool runOnModule(Module &M) override {
+ for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
+ Function &F = *I;
+ {
+ SCOPED_TRACE("Running on the fly function pass");
+ getAnalysis<FPass>(F);
}
- };
- char OnTheFlyTest::ID=0;
-
- TEST(PassManager, RunOnce) {
- LLVMContext Context;
- Module M("test-once", Context);
- struct ModuleNDNM *mNDNM = new ModuleNDNM();
- struct ModuleDNM *mDNM = new ModuleDNM();
- struct ModuleNDM *mNDM = new ModuleNDM();
- struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
-
- mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
-
- legacy::PassManager Passes;
- Passes.add(mNDM2);
- Passes.add(mNDM);
- Passes.add(mNDNM);
- Passes.add(mDNM);
-
- Passes.run(M);
- // each pass must be run exactly once, since nothing invalidates them
- EXPECT_EQ(1, mNDM->run);
- EXPECT_EQ(1, mNDNM->run);
- EXPECT_EQ(1, mDNM->run);
- EXPECT_EQ(1, mNDM2->run);
}
+ return false;
+ }
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.addRequired<FPass>();
+ }
+};
+char OnTheFlyTest::ID = 0;
+
+TEST(PassManager, RunOnce) {
+ LLVMContext Context;
+ Module M("test-once", Context);
+ struct ModuleNDNM *mNDNM = new ModuleNDNM();
+ struct ModuleDNM *mDNM = new ModuleDNM();
+ struct ModuleNDM *mNDM = new ModuleNDM();
+ struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
+
+ mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
+
+ legacy::PassManager Passes;
+ Passes.add(mNDM2);
+ Passes.add(mNDM);
+ Passes.add(mNDNM);
+ Passes.add(mDNM);
+
+ Passes.run(M);
+ // each pass must be run exactly once, since nothing invalidates them
+ EXPECT_EQ(1, mNDM->run);
+ EXPECT_EQ(1, mNDNM->run);
+ EXPECT_EQ(1, mDNM->run);
+ EXPECT_EQ(1, mNDM2->run);
+}
- TEST(PassManager, ReRun) {
- LLVMContext Context;
- Module M("test-rerun", Context);
- struct ModuleNDNM *mNDNM = new ModuleNDNM();
- struct ModuleDNM *mDNM = new ModuleDNM();
- struct ModuleNDM *mNDM = new ModuleNDM();
- struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
-
- mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
-
- legacy::PassManager Passes;
- Passes.add(mNDM);
- Passes.add(mNDNM);
- Passes.add(mNDM2);// invalidates mNDM needed by mDNM
- Passes.add(mDNM);
-
- Passes.run(M);
- // Some passes must be rerun because a pass that modified the
- // module/function was run in between
- EXPECT_EQ(2, mNDM->run);
- EXPECT_EQ(1, mNDNM->run);
- EXPECT_EQ(1, mNDM2->run);
- EXPECT_EQ(1, mDNM->run);
- }
+TEST(PassManager, ReRun) {
+ LLVMContext Context;
+ Module M("test-rerun", Context);
+ struct ModuleNDNM *mNDNM = new ModuleNDNM();
+ struct ModuleDNM *mDNM = new ModuleDNM();
+ struct ModuleNDM *mNDM = new ModuleNDM();
+ struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
+
+ mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
+
+ legacy::PassManager Passes;
+ Passes.add(mNDM);
+ Passes.add(mNDNM);
+ Passes.add(mNDM2); // invalidates mNDM needed by mDNM
+ Passes.add(mDNM);
+
+ Passes.run(M);
+ // Some passes must be rerun because a pass that modified the
+ // module/function was run in between
+ EXPECT_EQ(2, mNDM->run);
+ EXPECT_EQ(1, mNDNM->run);
+ EXPECT_EQ(1, mNDM2->run);
+ EXPECT_EQ(1, mDNM->run);
+}
- Module *makeLLVMModule(LLVMContext &Context);
-
- template<typename T>
- void MemoryTestHelper(int run) {
- LLVMContext Context;
- std::unique_ptr<Module> M(makeLLVMModule(Context));
- T *P = new T();
- legacy::PassManager Passes;
- Passes.add(P);
- Passes.run(*M);
- T::finishedOK(run);
- }
+Module *makeLLVMModule(LLVMContext &Context);
- template<typename T>
- void MemoryTestHelper(int run, int N) {
- LLVMContext Context;
- Module *M = makeLLVMModule(Context);
- T *P = new T();
- legacy::PassManager Passes;
- Passes.add(P);
- Passes.run(*M);
- T::finishedOK(run, N);
- delete M;
- }
+template <typename T> void MemoryTestHelper(int run) {
+ LLVMContext Context;
+ std::unique_ptr<Module> M(makeLLVMModule(Context));
+ T *P = new T();
+ legacy::PassManager Passes;
+ Passes.add(P);
+ Passes.run(*M);
+ T::finishedOK(run);
+}
- TEST(PassManager, Memory) {
- // SCC#1: test1->test2->test3->test1
- // SCC#2: test4
- // SCC#3: indirect call node
- {
- SCOPED_TRACE("Callgraph pass");
- MemoryTestHelper<CGPass>(3);
- }
+template <typename T> void MemoryTestHelper(int run, int N) {
+ LLVMContext Context;
+ Module *M = makeLLVMModule(Context);
+ T *P = new T();
+ legacy::PassManager Passes;
+ Passes.add(P);
+ Passes.run(*M);
+ T::finishedOK(run, N);
+ delete M;
+}
- {
- SCOPED_TRACE("Function pass");
- MemoryTestHelper<FPass>(4);// 4 functions
- }
+TEST(PassManager, Memory) {
+ // SCC#1: test1->test2->test3->test1
+ // SCC#2: test4
+ // SCC#3: indirect call node
+ {
+ SCOPED_TRACE("Callgraph pass");
+ MemoryTestHelper<CGPass>(3);
+ }
- {
- SCOPED_TRACE("Loop pass");
- MemoryTestHelper<LPass>(2, 1); //2 loops, 1 function
- }
+ {
+ SCOPED_TRACE("Function pass");
+ MemoryTestHelper<FPass>(4); // 4 functions
+ }
- }
+ {
+ SCOPED_TRACE("Loop pass");
+ MemoryTestHelper<LPass>(2, 1); // 2 loops, 1 function
+ }
+}
- TEST(PassManager, MemoryOnTheFly) {
- LLVMContext Context;
- Module *M = makeLLVMModule(Context);
- {
- SCOPED_TRACE("Running OnTheFlyTest");
- struct OnTheFlyTest *O = new OnTheFlyTest();
- legacy::PassManager Passes;
- Passes.add(O);
- Passes.run(*M);
+TEST(PassManager, MemoryOnTheFly) {
+ LLVMContext Context;
+ Module *M = makeLLVMModule(Context);
+ {
+ SCOPED_TRACE("Running OnTheFlyTest");
+ struct OnTheFlyTest *O = new OnTheFlyTest();
+ legacy::PassManager Passes;
+ Passes.add(O);
+ Passes.run(*M);
+
+ FPass::finishedOK(4);
+ }
+ delete M;
+}
- FPass::finishedOK(4);
- }
- delete M;
- }
+// Skips or runs optional passes.
+struct CustomOptPassGate : public OptPassGate {
+ bool Skip;
+ CustomOptPassGate(bool Skip) : Skip(Skip) {}
+ bool shouldRunPass(StringRef PassName,
+ StringRef IRDescription) const override {
+ return !Skip;
+ }
+ bool isEnabled() const override { return true; }
+};
+
+// Optional module pass.
+struct ModuleOpt : public ModulePass {
+ char run = 0;
+ static char ID;
+ ModuleOpt() : ModulePass(ID) {}
+ bool runOnModule(Module &M) override {
+ if (!skipModule(M))
+ run++;
+ return false;
+ }
+};
+char ModuleOpt::ID = 0;
- // Skips or runs optional passes.
- struct CustomOptPassGate : public OptPassGate {
- bool Skip;
- CustomOptPassGate(bool Skip) : Skip(Skip) { }
- bool shouldRunPass(StringRef PassName,
- StringRef IRDescription) const override {
- return !Skip;
- }
- bool isEnabled() const override { return true; }
- };
-
- // Optional module pass.
- struct ModuleOpt: public ModulePass {
- char run = 0;
- static char ID;
- ModuleOpt() : ModulePass(ID) { }
- bool runOnModule(Module &M) override {
- if (!skipModule(M))
- run++;
- return false;
- }
- };
- char ModuleOpt::ID=0;
+TEST(PassManager, CustomOptPassGate) {
+ LLVMContext Context0;
+ LLVMContext Context1;
+ LLVMContext Context2;
+ CustomOptPassGate SkipOptionalPasses(true);
+ CustomOptPassGate RunOptionalPasses(false);
- TEST(PassManager, CustomOptPassGate) {
- LLVMContext Context0;
- LLVMContext Context1;
- LLVMContext Context2;
- CustomOptPassGate SkipOptionalPasses(true);
- CustomOptPassGate RunOptionalPasses(false);
+ Module M0("custom-opt-bisect", Context0);
+ Module M1("custom-opt-bisect", Context1);
+ Module M2("custom-opt-bisect2", Context2);
+ struct ModuleOpt *mOpt0 = new ModuleOpt();
+ struct ModuleOpt *mOpt1 = new ModuleOpt();
+ struct ModuleOpt *mOpt2 = new ModuleOpt();
- Module M0("custom-opt-bisect", Context0);
- Module M1("custom-opt-bisect", Context1);
- Module M2("custom-opt-bisect2", Context2);
- struct ModuleOpt *mOpt0 = new ModuleOpt();
- struct ModuleOpt *mOpt1 = new ModuleOpt();
- struct ModuleOpt *mOpt2 = new ModuleOpt();
+ mOpt0->run = mOpt1->run = mOpt2->run = 0;
- mOpt0->run = mOpt1->run = mOpt2->run = 0;
+ legacy::PassManager Passes0;
+ legacy::PassManager Passes1;
+ legacy::PassManager Passes2;
- legacy::PassManager Passes0;
- legacy::PassManager Passes1;
- legacy::PassManager Passes2;
+ Passes0.add(mOpt0);
+ Passes1.add(mOpt1);
+ Passes2.add(mOpt2);
- Passes0.add(mOpt0);
- Passes1.add(mOpt1);
- Passes2.add(mOpt2);
+ Context1.setOptPassGate(SkipOptionalPasses);
+ Context2.setOptPassGate(RunOptionalPasses);
- Context1.setOptPassGate(SkipOptionalPasses);
- Context2.setOptPassGate(RunOptionalPasses);
+ Passes0.run(M0);
+ Passes1.run(M1);
+ Passes2.run(M2);
- Passes0.run(M0);
- Passes1.run(M1);
- Passes2.run(M2);
+ // By default optional passes are run.
+ EXPECT_EQ(1, mOpt0->run);
- // By default optional passes are run.
- EXPECT_EQ(1, mOpt0->run);
+ // The first context skips optional passes.
+ EXPECT_EQ(0, mOpt1->run);
- // The first context skips optional passes.
- EXPECT_EQ(0, mOpt1->run);
+ // The second context runs optional passes.
+ EXPECT_EQ(1, mOpt2->run);
+}
- // The second context runs optional passes.
- EXPECT_EQ(1, mOpt2->run);
- }
+Module *makeLLVMModule(LLVMContext &Context) {
+ // Module Construction
+ Module *mod = new Module("test-mem", Context);
+ mod->set...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/196811
More information about the llvm-commits
mailing list