[NFC] Derive from PassInfoMixin for no-op/printing passes

[aeubanks]

Summary

PassInfoMixin should be used for all NPM passes, rater than a custom
name().

This caused ambiguous references in LegacyPassManager.cpp, so had to
remove "using namespace llvm::legacy" and move some things around.

The passes had to be moved to the llvm namespace, or else they would get
printed as "(anonymous namespace)::FooPass".

[ychen]

I was aware of this recently. Thanks for fixing this. Just one nit. Please wait for one other reviewer.

llvm/lib/Passes/PassBuilder.cpp

300

How about keeping this local? These are only for testing.

[aeubanks]

llvm/lib/Passes/PassBuilder.cpp

300

Do you mean keeping this in an anonymous namespace?
As mentioned in the commit, that makes the printed name messed up.

[ychen]

llvm/lib/Passes/PassBuilder.cpp

300

Add some regex in lit tests?
Running pass: {{.*}}NoOpModulePass

[aeubanks]

llvm/lib/Passes/PassBuilder.cpp

300

I don't see any reason to distinguish it from other passes, even if it's only used for testing. It's a useful tool for sanity checks. Having a (anonymous namespace) printed anywhere doesn't look good.
And it'd require updating more tests than I really want to.

[ychen]

llvm/lib/Passes/PassBuilder.cpp

300

If we really treat them as normal passes, they should be moved to a header file. If we treat them as testing tools only, we put them in .cpp file in an anonymous namespace. It looks confusing to be not in header file and in llvm namespace.

Or perhaps, we don't touch these no-op passes, and add a comment saying we're overriding the name() computing here to make tests cleaner?

[aeubanks]

Put passes/analyses in PassBuilder.cpp back into anonymous namespace, override name

[asbirlea]

llvm/lib/Passes/PassBuilder.cpp

300

IMO a comment clarifying these are a special case will work here.

[aeubanks]

Update comment

[davide]

This broke the modules build on macOS.

warning: /Applications/Xcode5.app/Contents/Developer/Toolchains/OSX10.15.xctoolchain/usr/bin/libtool: warning for library: lib/libLLVMExtensions.a the table of contents is empty (no object file members in the library define global symbols)
[320/3939] Building CXX object lib/Remarks/CMakeFiles/LLVMRemarks.dir/RemarkLinker.cpp.o
FAILED: lib/Remarks/CMakeFiles/LLVMRemarks.dir/RemarkLinker.cpp.o 
/Applications/Xcode5.app/Contents/Developer/Toolchains/OSX10.15.xctoolchain/usr/bin/c++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib/Remarks -I/Users/davide/work/llvm-project/llvm/lib/Remarks -I/Applications/Xcode5.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.Internal.sdk/usr/include/libxml2 -Iinclude -I/Users/davide/work/llvm-project/llvm/include -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -fmodules -fmodules-cache-path=/Users/davide/work/build-modules/module.cache -fcxx-modules -Xclang -fmodules-local-submodule-visibility -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -O3  -isysroot /Applications/Xcode5.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.Internal.sdk    -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT lib/Remarks/CMakeFiles/LLVMRemarks.dir/RemarkLinker.cpp.o -MF lib/Remarks/CMakeFiles/LLVMRemarks.dir/RemarkLinker.cpp.o.d -o lib/Remarks/CMakeFiles/LLVMRemarks.dir/RemarkLinker.cpp.o -c /Users/davide/work/llvm-project/llvm/lib/Remarks/RemarkLinker.cpp
While building module 'LLVM_Object' imported from /Users/davide/work/llvm-project/llvm/include/llvm/Remarks/RemarkLinker.h:16:
While building module 'LLVM_IR' imported from /Users/davide/work/llvm-project/llvm/include/llvm/Object/IRSymtab.h:29:
While building module 'LLVM_intrinsic_gen' imported from /Users/davide/work/llvm-project/llvm/include/llvm/IR/IRPrintingPasses.h:22:
In file included from <module-includes>:1:
In file included from /Users/davide/work/llvm-project/llvm/include/llvm/IR/Argument.h:18:
/Users/davide/work/llvm-project/llvm/include/llvm/IR/Attributes.h:75:14: fatal error: 'llvm/IR/Attributes.inc' file not found
    #include "llvm/IR/Attributes.inc"
             ^~~~~~~~~~~~~~~~~~~~~~~~
While building module 'LLVM_Object' imported from /Users/davide/work/llvm-project/llvm/include/llvm/Remarks/RemarkLinker.h:16:
While building module 'LLVM_IR' imported from /Users/davide/work/llvm-project/llvm/include/llvm/Object/IRSymtab.h:29:
In file included from <module-includes>:4:
/Users/davide/work/llvm-project/llvm/include/llvm/IR/IRPrintingPasses.h:22:10: fatal error: could not build module 'LLVM_intrinsic_gen'
#include "llvm/IR/PassManager.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
While building module 'LLVM_Object' imported from /Users/davide/work/llvm-project/llvm/include/llvm/Remarks/RemarkLinker.h:16:
In file included from <module-includes>:4:
/Users/davide/work/llvm-project/llvm/include/llvm/Object/IRSymtab.h:29:10: fatal error: could not build module 'LLVM_IR'
#include "llvm/IR/GlobalValue.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
In file included from /Users/davide/work/llvm-project/llvm/lib/Remarks/RemarkLinker.cpp:13:
/Users/davide/work/llvm-project/llvm/include/llvm/Remarks/RemarkLinker.h:16:10: fatal error: could not build module 'LLVM_Object'
#include "llvm/Object/ObjectFile.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
4 errors generated.

I'm going to revert, and I'm going to follow up with precise instructions on how to repro.

[davide]

on any recent'ish macOS (although, I don't think the OS quite matters)

% xcrun cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_MODULES=On -DLLVM_ENABLE_ASSERTIONS:BOOL=TRUE -DLLDB_ENABLE_PYTHON=On

then

% ninja check-lldb

I feel the only relevant bit is -DLLVM_ENABLE_MODULES=On , YMMV.

[davide]

Reverted in:

commit fdb7856d54a1f81bab0ac0c8a4e984620589e699 (HEAD -> master, origin/master, origin/HEAD)
Author: Davide Italiano <[e-mail]>
Date:   Fri Jul 10 11:16:33 2020 -0700

    Revert "[NFC] Derive from PassInfoMixin for no-op/printing passes"
    
    This reverts commit 8039d2c3bf14585ef37dc9343bf393ecad9aead9 as
    it breaks the modules build on macOS.

Don't hesitate to ping me if you need any other info to reproduce.

[aeubanks]

In D83498#2144732, @davide wrote:

Reverted in:

commit fdb7856d54a1f81bab0ac0c8a4e984620589e699 (HEAD -> master, origin/master, origin/HEAD)
Author: Davide Italiano <[e-mail]>
Date:   Fri Jul 10 11:16:33 2020 -0700

    Revert "[NFC] Derive from PassInfoMixin for no-op/printing passes"
    
    This reverts commit 8039d2c3bf14585ef37dc9343bf393ecad9aead9 as
    it breaks the modules build on macOS.

Don't hesitate to ping me if you need any other info to reproduce.

Repro'ed, fixed (hopefully), and relanded in 21b4cc1db9f4eb6d6956802257e3a80f86045c67.

llvm/include/llvm/IR/IRPrintingPasses.h

 /// are processed.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_IRPRINTINGPASSES_H
 #define LLVM_IR_IRPRINTINGPASSES_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/PassManager.h"
 #include <string>
 
 namespace llvm {
-class Pass;
-class Function;
-class FunctionPass;
-class Module;
-class ModulePass;
-class PreservedAnalyses;
-class raw_ostream;
-template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
 
 /// Create and return a pass that writes the module to the specified
 /// \c raw_ostream.
 ModulePass *createPrintModulePass(raw_ostream &OS,
                                   const std::string &Banner = "",
                                   bool ShouldPreserveUseListOrder = false);
 
 /// Create and return a pass that prints functions to the specified

 extern bool shouldPrintBeforePass(StringRef);
 extern bool shouldPrintAfterPass();
 extern bool shouldPrintAfterPass(StringRef);
 
 /// Pass for printing a Module as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
-class PrintModulePass {
+class PrintModulePass : public PassInfoMixin<PrintModulePass> {
   raw_ostream &OS;
   std::string Banner;
   bool ShouldPreserveUseListOrder;
 
 public:
   PrintModulePass();
   PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
                   bool ShouldPreserveUseListOrder = false);
 
   PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
-
-  static StringRef name() { return "PrintModulePass"; }
 };
 
 /// Pass for printing a Function as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
-class PrintFunctionPass {
+class PrintFunctionPass : public PassInfoMixin<PrintFunctionPass> {
   raw_ostream &OS;
   std::string Banner;
 
 public:
   PrintFunctionPass();
   PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");
 
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
-
-  static StringRef name() { return "PrintFunctionPass"; }
 };
 
 } // End llvm namespace
 
 #endif

llvm/lib/IR/LegacyPassManager.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <unordered_set>
 using namespace llvm;
-using namespace llvm::legacy;
 
 // See PassManagers.h for Pass Manager infrastructure overview.
 
 //===----------------------------------------------------------------------===//
 // Pass debugging information.  Often it is useful to find out what pass is
 // running when a crash occurs in a utility.  When this library is compiled with
 // debugging on, a command line option (--debug-pass) is enabled that causes the
 // pass name to be printed before it executes.
void dumpPassStructure(unsigned Offset) override {
     for (unsigned I = 0; I < getNumContainedManagers(); ++I)
       getContainedManager(I)->dumpPassStructure(Offset);
   }
 };
 
 void FunctionPassManagerImpl::anchor() {}
 
 char FunctionPassManagerImpl::ID = 0;
+
+//===----------------------------------------------------------------------===//
+// FunctionPassManagerImpl implementation
+//
+bool FunctionPassManagerImpl::doInitialization(Module &M) {
+  bool Changed = false;
+
+  dumpArguments();
+  dumpPasses();
+
+  for (ImmutablePass *ImPass : getImmutablePasses())
+    Changed |= ImPass->doInitialization(M);
+
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    Changed |= getContainedManager(Index)->doInitialization(M);
+
+  return Changed;
+}
+
+bool FunctionPassManagerImpl::doFinalization(Module &M) {
+  bool Changed = false;
+
+  for (int Index = getNumContainedManagers() - 1; Index >= 0; --Index)
+    Changed |= getContainedManager(Index)->doFinalization(M);
+
+  for (ImmutablePass *ImPass : getImmutablePasses())
+    Changed |= ImPass->doFinalization(M);
+
+  return Changed;
+}
+
+void FunctionPassManagerImpl::releaseMemoryOnTheFly() {
+  if (!wasRun)
+    return;
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
+    FPPassManager *FPPM = getContainedManager(Index);
+    for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) {
+      FPPM->getContainedPass(Index)->releaseMemory();
+    }
+  }
+  wasRun = false;
+}
+
+// Execute all the passes managed by this top level manager.
+// Return true if any function is modified by a pass.
+bool FunctionPassManagerImpl::run(Function &F) {
+  bool Changed = false;
+
+  initializeAllAnalysisInfo();
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
+    Changed |= getContainedManager(Index)->runOnFunction(F);
+    F.getContext().yield();
+  }
+
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
+    getContainedManager(Index)->cleanup();
+
+  wasRun = true;
+  return Changed;
+}
 } // namespace legacy
 } // namespace llvm
 
 namespace {
 //===----------------------------------------------------------------------===//
 // MPPassManager
 //
 /// MPPassManager manages ModulePasses and function pass managers.
 /// It batches all Module passes and function pass managers together and
 /// sequences them to process one module.
 class MPPassManager : public Pass, public PMDataManager {
 public:
   static char ID;
   explicit MPPassManager() :
     Pass(PT_PassManager, ID), PMDataManager() { }
 
   // Delete on the fly managers.
   ~MPPassManager() override {
     for (auto &OnTheFlyManager : OnTheFlyManagers) {
-      FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
+      legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
       delete FPP;
     }
   }
 
   /// createPrinterPass - Get a module printer pass.
   Pass *createPrinterPass(raw_ostream &O,
                           const std::string &Banner) const override {
     return createPrintModulePass(O, Banner);
public:
   Pass *getAsPass() override { return this; }
 
   // Print passes managed by this manager
   void dumpPassStructure(unsigned Offset) override {
     dbgs().indent(Offset*2) << "ModulePass Manager\n";
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       ModulePass *MP = getContainedPass(Index);
       MP->dumpPassStructure(Offset + 1);
-      MapVector<Pass *, FunctionPassManagerImpl *>::const_iterator I =
+      MapVector<Pass *, legacy::FunctionPassManagerImpl *>::const_iterator I =
           OnTheFlyManagers.find(MP);
       if (I != OnTheFlyManagers.end())
         I->second->dumpPassStructure(Offset + 2);
       dumpLastUses(MP, Offset+1);
     }
   }
 
   ModulePass *getContainedPass(unsigned N) {
     assert(N < PassVector.size() && "Pass number out of range!");
     return static_cast<ModulePass *>(PassVector[N]);
   }
 
   PassManagerType getPassManagerType() const override {
     return PMT_ModulePassManager;
   }
 
  private:
   /// Collection of on the fly FPPassManagers. These managers manage
   /// function passes that are required by module passes.
-   MapVector<Pass *, FunctionPassManagerImpl *> OnTheFlyManagers;
+   MapVector<Pass *, legacy::FunctionPassManagerImpl *> OnTheFlyManagers;
 };
 
 char MPPassManager::ID = 0;
 } // End anonymous namespace
 
 namespace llvm {
 namespace legacy {
 //===----------------------------------------------------------------------===//
MPPassManager *getContainedManager(unsigned N) {
     MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]);
     return MP;
   }
 };
 
 void PassManagerImpl::anchor() {}
 
 char PassManagerImpl::ID = 0;
+
+//===----------------------------------------------------------------------===//
+// PassManagerImpl implementation
+
+//
+/// run - Execute all of the passes scheduled for execution.  Keep track of
+/// whether any of the passes modifies the module, and if so, return true.
+bool PassManagerImpl::run(Module &M) {
+  bool Changed = false;
+
+  dumpArguments();
+  dumpPasses();
+
+  for (ImmutablePass *ImPass : getImmutablePasses())
+    Changed |= ImPass->doInitialization(M);
+
+  initializeAllAnalysisInfo();
+  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
+    Changed |= getContainedManager(Index)->runOnModule(M);
+    M.getContext().yield();
+  }
+
+  for (ImmutablePass *ImPass : getImmutablePasses())
+    Changed |= ImPass->doFinalization(M);
+
+  return Changed;
+}
 } // namespace legacy
 } // namespace llvm
 
 //===----------------------------------------------------------------------===//
 // PMTopLevelManager implementation
 
 /// Initialize top level manager. Create first pass manager.
 PMTopLevelManager::PMTopLevelManager(PMDataManager *PMDM) {
Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID, bool dir) const {
   return PM.findAnalysisPass(ID, dir);
 }
 
 std::tuple<Pass *, bool>
 AnalysisResolver::findImplPass(Pass *P, AnalysisID AnalysisPI, Function &F) {
   return PM.getOnTheFlyPass(P, AnalysisPI, F);
 }
 
+namespace llvm {
+namespace legacy {
+
 //===----------------------------------------------------------------------===//
 // FunctionPassManager implementation
 
 /// Create new Function pass manager
 FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
-  FPM = new FunctionPassManagerImpl();
+  FPM = new legacy::FunctionPassManagerImpl();
   // FPM is the top level manager.
   FPM->setTopLevelManager(FPM);
 
   AnalysisResolver *AR = new AnalysisResolver(*FPM);
   FPM->setResolver(AR);
 }
 
 FunctionPassManager::~FunctionPassManager() {
bool FunctionPassManager::doInitialization() {
   return FPM->doInitialization(*M);
 }
 
 /// doFinalization - Run all of the finalizers for the function passes.
 ///
 bool FunctionPassManager::doFinalization() {
   return FPM->doFinalization(*M);
 }
-
-//===----------------------------------------------------------------------===//
-// FunctionPassManagerImpl implementation
-//
-bool FunctionPassManagerImpl::doInitialization(Module &M) {
-  bool Changed = false;
-
-  dumpArguments();
-  dumpPasses();
-
-  for (ImmutablePass *ImPass : getImmutablePasses())
-    Changed |= ImPass->doInitialization(M);
-
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
-    Changed |= getContainedManager(Index)->doInitialization(M);
-
-  return Changed;
-}
-
-bool FunctionPassManagerImpl::doFinalization(Module &M) {
-  bool Changed = false;
-
-  for (int Index = getNumContainedManagers() - 1; Index >= 0; --Index)
-    Changed |= getContainedManager(Index)->doFinalization(M);
-
-  for (ImmutablePass *ImPass : getImmutablePasses())
-    Changed |= ImPass->doFinalization(M);
-
-  return Changed;
-}
+} // namespace legacy
+} // namespace llvm
 
 /// cleanup - After running all passes, clean up pass manager cache.
 void FPPassManager::cleanup() {
  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
     AnalysisResolver *AR = FP->getResolver();
     assert(AR && "Analysis Resolver is not set");
     AR->clearAnalysisImpls();
  }
 }
 
-void FunctionPassManagerImpl::releaseMemoryOnTheFly() {
-  if (!wasRun)
-    return;
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
-    FPPassManager *FPPM = getContainedManager(Index);
-    for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) {
-      FPPM->getContainedPass(Index)->releaseMemory();
-    }
-  }
-  wasRun = false;
-}
-
-// Execute all the passes managed by this top level manager.
-// Return true if any function is modified by a pass.
-bool FunctionPassManagerImpl::run(Function &F) {
-  bool Changed = false;
-
-  initializeAllAnalysisInfo();
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
-    Changed |= getContainedManager(Index)->runOnFunction(F);
-    F.getContext().yield();
-  }
-
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
-    getContainedManager(Index)->cleanup();
-
-  wasRun = true;
-  return Changed;
-}
 
 //===----------------------------------------------------------------------===//
 // FPPassManager implementation
 
 char FPPassManager::ID = 0;
 /// Print passes managed by this manager
 void FPPassManager::dumpPassStructure(unsigned Offset) {
   dbgs().indent(Offset*2) << "FunctionPass Manager\n";

 bool
 MPPassManager::runOnModule(Module &M) {
   llvm::TimeTraceScope TimeScope("OptModule", M.getName());
 
   bool Changed = false;
 
   // Initialize on-the-fly passes
   for (auto &OnTheFlyManager : OnTheFlyManagers) {
-    FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
+    legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
     Changed |= FPP->doInitialization(M);
   }
 
   // Initialize module passes
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
     Changed |= getContainedPass(Index)->doInitialization(M);
 
   unsigned InstrCount;
MPPassManager::runOnModule(Module &M) {
   }
 
   // Finalize module passes
   for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
     Changed |= getContainedPass(Index)->doFinalization(M);
 
   // Finalize on-the-fly passes
   for (auto &OnTheFlyManager : OnTheFlyManagers) {
-    FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
+    legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
     // We don't know when is the last time an on-the-fly pass is run,
     // so we need to releaseMemory / finalize here
     FPP->releaseMemoryOnTheFly();
     Changed |= FPP->doFinalization(M);
   }
 
   return Changed;
 }
 
 /// Add RequiredPass into list of lower level passes required by pass P.
 /// RequiredPass is run on the fly by Pass Manager when P requests it
 /// through getAnalysis interface.
 void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
   assert(RequiredPass && "No required pass?");
   assert(P->getPotentialPassManagerType() == PMT_ModulePassManager &&
          "Unable to handle Pass that requires lower level Analysis pass");
   assert((P->getPotentialPassManagerType() <
           RequiredPass->getPotentialPassManagerType()) &&
          "Unable to handle Pass that requires lower level Analysis pass");
 
-  FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
+  legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[P];
   if (!FPP) {
-    FPP = new FunctionPassManagerImpl();
+    FPP = new legacy::FunctionPassManagerImpl();
     // FPP is the top level manager.
     FPP->setTopLevelManager(FPP);
 
     OnTheFlyManagers[P] = FPP;
   }
   const PassInfo *RequiredPassPI =
       TPM->findAnalysisPassInfo(RequiredPass->getPassID());
 
void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
   FPP->setLastUser(LU,  P);
 }
 
 /// Return function pass corresponding to PassInfo PI, that is
 /// required by module pass MP. Instantiate analysis pass, by using
 /// its runOnFunction() for function F.
 std::tuple<Pass *, bool> MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI,
                                                         Function &F) {
-  FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
+  legacy::FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
   assert(FPP && "Unable to find on the fly pass");
 
   FPP->releaseMemoryOnTheFly();
   bool Changed = FPP->run(F);
   return std::make_tuple(((PMTopLevelManager *)FPP)->findAnalysisPass(PI),
                          Changed);
 }
 
-//===----------------------------------------------------------------------===//
-// PassManagerImpl implementation
-
-//
-/// run - Execute all of the passes scheduled for execution.  Keep track of
-/// whether any of the passes modifies the module, and if so, return true.
-bool PassManagerImpl::run(Module &M) {
-  bool Changed = false;
-
-  dumpArguments();
-  dumpPasses();
-
-  for (ImmutablePass *ImPass : getImmutablePasses())
-    Changed |= ImPass->doInitialization(M);
-
-  initializeAllAnalysisInfo();
-  for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
-    Changed |= getContainedManager(Index)->runOnModule(M);
-    M.getContext().yield();
-  }
-
-  for (ImmutablePass *ImPass : getImmutablePasses())
-    Changed |= ImPass->doFinalization(M);
-
-  return Changed;
-}
+namespace llvm {
+namespace legacy {
 
 //===----------------------------------------------------------------------===//
 // PassManager implementation
 
 /// Create new pass manager
 PassManager::PassManager() {
   PM = new PassManagerImpl();
   // PM is the top level manager
   PM->setTopLevelManager(PM);
 }
 
 PassManager::~PassManager() {
   delete PM;
 }
 
 void PassManager::add(Pass *P) {
   PM->add(P);
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the module, and if so, return true.
 bool PassManager::run(Module &M) {
   return PM->run(M);
 }
+} // namespace legacy
+} // namespace llvm
 
 //===----------------------------------------------------------------------===//
 // PMStack implementation
 //
 
 // Pop Pass Manager from the stack and clear its analysis info.
 void PMStack::pop() {
 
if (PM->getPassManagerType() != PMT_FunctionPassManager) {
     PMS.push(FPP);
     PM = FPP;
   }
 
   // Assign FPP as the manager of this pass.
   PM->add(this);
 }
 
-PassManagerBase::~PassManagerBase() {}
+legacy::PassManagerBase::~PassManagerBase() {}

llvm/lib/Passes/PassBuilder.cpp

const PassBuilder::OptimizationLevel PassBuilder::OptimizationLevel::O3 = {
     /*SizeLevel*/ 0};
 const PassBuilder::OptimizationLevel PassBuilder::OptimizationLevel::Os = {
     /*SpeedLevel*/ 2,
     /*SizeLevel*/ 1};
 const PassBuilder::OptimizationLevel PassBuilder::OptimizationLevel::Oz = {
     /*SpeedLevel*/ 2,
     /*SizeLevel*/ 2};
 
 namespace {
 
+// The following passes/analyses have custom names, otherwise their name will
+// include `(anonymous namespace)`. These are special since they are only for
+// testing purposes and don't live in a header file.
+
 /// No-op module pass which does nothing.
-struct NoOpModulePass {
+struct NoOpModulePass : PassInfoMixin<NoOpModulePass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
     return PreservedAnalyses::all();
   }
+
   static StringRef name() { return "NoOpModulePass"; }
 };
 
 /// No-op module analysis.
 class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
   friend AnalysisInfoMixin<NoOpModuleAnalysis>;
   static AnalysisKey Key;
 
 public:
   struct Result {};
   Result run(Module &, ModuleAnalysisManager &) { return Result(); }
   static StringRef name() { return "NoOpModuleAnalysis"; }
 };
 
 /// No-op CGSCC pass which does nothing.
-struct NoOpCGSCCPass {
+struct NoOpCGSCCPass : PassInfoMixin<NoOpCGSCCPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &,
                         LazyCallGraph &, CGSCCUpdateResult &UR) {
     return PreservedAnalyses::all();
   }
   static StringRef name() { return "NoOpCGSCCPass"; }
 };
 
 /// No-op CGSCC analysis.
 class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
   friend AnalysisInfoMixin<NoOpCGSCCAnalysis>;
   static AnalysisKey Key;
 
 public:
   struct Result {};
   Result run(LazyCallGraph::SCC &, CGSCCAnalysisManager &, LazyCallGraph &G) {
     return Result();
   }
   static StringRef name() { return "NoOpCGSCCAnalysis"; }
 };
 
 /// No-op function pass which does nothing.
-struct NoOpFunctionPass {
+struct NoOpFunctionPass : PassInfoMixin<NoOpFunctionPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
     return PreservedAnalyses::all();
   }
   static StringRef name() { return "NoOpFunctionPass"; }
 };
 
 /// No-op function analysis.
 class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
   friend AnalysisInfoMixin<NoOpFunctionAnalysis>;
   static AnalysisKey Key;
 
 public:
   struct Result {};
   Result run(Function &, FunctionAnalysisManager &) { return Result(); }
   static StringRef name() { return "NoOpFunctionAnalysis"; }
 };
 
 /// No-op loop pass which does nothing.
-struct NoOpLoopPass {
+struct NoOpLoopPass : PassInfoMixin<NoOpLoopPass> {
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
                         LoopStandardAnalysisResults &, LPMUpdater &) {
     return PreservedAnalyses::all();
   }
   static StringRef name() { return "NoOpLoopPass"; }
 };
 
 /// No-op loop analysis.
public:
   static StringRef name() { return "NoOpLoopAnalysis"; }
 };
 
 AnalysisKey NoOpModuleAnalysis::Key;
 AnalysisKey NoOpCGSCCAnalysis::Key;
 AnalysisKey NoOpFunctionAnalysis::Key;
 AnalysisKey NoOpLoopAnalysis::Key;
 
-} // End anonymous namespace.
+} // namespace
 
 void PassBuilder::invokePeepholeEPCallbacks(
     FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
   for (auto &C : PeepholeEPCallbacks)
     C(FPM, Level);
 }
 
 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {