[NewPM] Revamp pass names

[aeubanks]

I'd like to get some feedback to see if this is reasonable before fixing up the tests and adding a description

[ychen]

Thanks for doing this. I'm in favor of the patch to let pass explicitly specifying its own name. Previously we encountered many issues due to this restriction (one host-compiler-dependent name, one user-facing name, and translating between them). With that,

• We have one name for both user-facing options and LLVM internally, the translation table is also dropped.
• PassManager related tests don't need to be host-compiler-dependent anymore (PR48992 may be related to this and several regressions in the past).
• Passes like NoOpModulePass are already doing this to work around test case issues. Now they are no longer special.

I don't see any cons with this approach other than it touches *a lot* of files. Guess that's the price we need to pay.

llvm/lib/Passes/PassBuilder.cpp

340

Delete.

[madhur13490]

In D97722#2595404, @aeubanks wrote:

I'd like to get some feedback to see if this is reasonable before fixing up the tests and adding a description

The downside of this approach is that we no longer see raw strings in PassRegistry.def which were aiding "grep"ing the names of passes. With this pass, developers will have to go to the pass, see its name() to find the name. Another downside, this patch touches a lot of files but since you have already went through that pain, it may no longer seen as pain point.

A slightly different approach:

1. Have a static table of pass class name and its corresponding string representation. Something like,

static std::map<StringRef, StringRef> PassNames = {{"DDGAnalysis", "ddg"}, {"DependeceAnalysis", "da"}}

2. Have a static function getName() in PassInfoMixin which uses __PRETTY_FUNCTION__ to get the name of the derived class to index into this table to retrieve its string representation. This is somewhat similar to current technique except that the name is now used as the index into the above table.

This way all derived mixins and their string representation would reside at one place and easy to look. Moreover, you could avoid touching all the files because PassInfoMixin is providing the definition and deriving the name using derived type name.

(FWIW, for 1, we can write TD files and a new a TableGen backend to emit the table.)

[arsenm]

llvm/include/llvm/Analysis/AliasAnalysis.h

1168

We already have multiple places where pass names are specified. We have getPassName, which many passes unnecessarily overload on top of the pass name set in the macros. Where does this version fit in this?

[ychen]

llvm/include/llvm/Analysis/AliasAnalysis.h

1168

getPassName is for legacy PM. This is the new PM counterpart.

[aeubanks]

I don't really like having C++ class names leak anywhere, it's at best implementation defined and as mentioned leads to incompatibilities between compilers.
If we create a table, we have to duplicate class names and make sure they're in sync which doesn't seem ideal. I'm trying to reduce the number of things to worry about with the new PM, namely the difference between the 2 types of pass names.
The legacy PM already didn't have C++ class names leaked and it seems like people were fine with not having a central list of class names for passes.

For passes added in *TargetMachine, currently the name is duplicated, but I do plan on a follow-up change to easily register passes which will solve that.

[madhur13490]

The purpose of C++ class names is to use it as key to the table. If you can
assign an unique key to each pass inherited from PassInfoMixin then that
will serve the purpose. But the idea of keeping a central map is useful for
programmers' productivity.

[aeubanks]

add back in PassInfoMixin::name() as PassInfoMixin::className() and use that in --print-passes

[aeubanks]

I've made it so opt --print-passes will also display the class name alongside the pass name, does that work?

[madhur13490]

In D97722#2600963, @aeubanks wrote:

I've made it so opt --print-passes will also display the class name alongside the pass name, does that work?

Is that consistent with the old PM?

[aeubanks]

The legacy PM is already worse in that there's no way to find a pass declaration aside from grepping the name, and there's no centralized location of all the passes. (unless there's some mechanism I'm unaware of)

[bjope]

I guess it wouldn't hurt if the pass names generally would match with the DEBUG_TYPE.

Using the same source of information is nice as it kind of ensures that the same name would be used when doing -debug-only=<name>, -start-before=<name>, -passes=<name>, -print-after=<name> etc. And I think that in the legacy PM this usually is handled by using the DEBUG_TYPE macro also when doing INITIALIZE_PASS_BEGIN etc (at least in most CodeGen passes).

A problematic thing with that here is that you can't simply move the DEBUG_TYPE definitions into the header files (well, it might be technically possible, but it might be problematic when including several header files that define the macros). One could ofcourse implement the name() methods in the the .cpp file, but that is also a bit messier implementation-wise.

[madhur13490]

In D97722#2604200, @aeubanks wrote:

The legacy PM is already worse in that there's no way to find a pass declaration aside from grepping the name, and there's no centralized location of all the passes. (unless there's some mechanism I'm unaware of)

The options seems a good step to me then!

[fhahn]

Thanks for tackling this!

I guess it wouldn't hurt if the pass names generally would match with the DEBUG_TYPE.
..
A problematic thing with that here is that you can't simply move the DEBUG_TYPE definitions into the header files (well, it might be technically possible, but it might be problematic when including several header files that define the macros). One could ofcourse implement the name() methods in the the .cpp file, but that is also a bit messier implementation-wise.

Tying it to DEBUG_TYPE would indeed be great. I guess the main downside with implementing the function in the .cpp is that it doubles the number of files touched, but I am not sure if it is really that messy in terms of the code.

Is it possible to add a test checking the new names? I don't think it's worth to check all of them, but I think it would be good to have a test that checks that we generate some of the compact names.

[fhahn]

In D97722#2609124, @fhahn wrote:

Is it possible to add a test checking the new names? I don't think it's worth to check all of them, but I think it would be good to have a test that checks that we generate some of the compact names.

Nevermind that bit, I missed your first comment.

[lebedev.ri]

2c from me:

• there should be no single global map of pass names - how would that work with loadable/out-of-tree passes?
• grepping for the pass name printed should not match some random source file, sending one on a further wild goose chase, but it should match the actual source (well, header isn't bad, either) where said pass is defined.

anything other seems hostile.

llvm/include/llvm/Analysis/AliasAnalysis.h

public:
 
   /// Register a specific AA result.
   template <typename AnalysisT> void registerModuleAnalysis() {
     ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
   }
 
   Result run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "aa"; }
+
 private:
   friend AnalysisInfoMixin<AAManager>;
 
   static AnalysisKey Key;
 
   SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,
                        AAResults &AAResults),
               4> ResultGetters;

llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h

AAEvaluator(AAEvaluator &&Arg)
         MustModRefCount(Arg.MustModRefCount) {
     Arg.FunctionCount = 0;
   }
   ~AAEvaluator();
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "aa-eval"; }
+
 private:
   // Allow the legacy pass to run this using an internal API.
   friend class AAEvalLegacyPass;
 
   void runInternal(Function &F, AAResults &AA);
 };
 
 /// Create a wrapper of the above for the legacy pass manager.
 FunctionPass *createAAEvalPass();
 
 }
 
 #endif

llvm/include/llvm/Analysis/AliasSetTracker.h

 }
 
 class AliasSetsPrinterPass : public PassInfoMixin<AliasSetsPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit AliasSetsPrinterPass(raw_ostream &OS);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print-alias-sets"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_ALIASSETTRACKER_H

llvm/include/llvm/Analysis/AssumptionCache.h

class AssumptionAnalysis : public AnalysisInfoMixin<AssumptionAnalysis> {
   static AnalysisKey Key;
 
 public:
   using Result = AssumptionCache;
 
   AssumptionCache run(Function &F, FunctionAnalysisManager &) {
     return AssumptionCache(F);
   }
+
+  static StringRef name() { return "assumptions"; }
 };
 
 /// Printer pass for the \c AssumptionAnalysis results.
 class AssumptionPrinterPass : public PassInfoMixin<AssumptionPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit AssumptionPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<assumptions>"; }
 };
 
 /// An immutable pass that tracks lazily created \c AssumptionCache
 /// objects.
 ///
 /// This is essentially a workaround for the legacy pass manager's weaknesses
 /// which associates each assumption cache with Function and clears it if the
 /// function is deleted. The nature of the AssumptionCache is that it is not

llvm/include/llvm/Analysis/BasicAliasAnalysis.h

class BasicAA : public AnalysisInfoMixin<BasicAA> {
   friend AnalysisInfoMixin<BasicAA>;
 
   static AnalysisKey Key;
 
 public:
   using Result = BasicAAResult;
 
   BasicAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "basic-aa"; }
 };
 
 /// Legacy wrapper pass to provide the BasicAAResult object.
 class BasicAAWrapperPass : public FunctionPass {
   std::unique_ptr<BasicAAResult> Result;
 
   virtual void anchor();
 

llvm/include/llvm/Analysis/BlockFrequencyInfo.h

class BlockFrequencyAnalysis
   static AnalysisKey Key;
 
 public:
   /// Provide the result type for this analysis pass.
   using Result = BlockFrequencyInfo;
 
   /// Run the analysis pass over a function and produce BFI.
   Result run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "block-freq"; }
 };
 
 /// Printer pass for the \c BlockFrequencyInfo results.
 class BlockFrequencyPrinterPass
     : public PassInfoMixin<BlockFrequencyPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit BlockFrequencyPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<block-freq>"; }
 };
 
 /// Legacy analysis pass which computes \c BlockFrequencyInfo.
 class BlockFrequencyInfoWrapperPass : public FunctionPass {
   BlockFrequencyInfo BFI;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/BranchProbabilityInfo.h

class BranchProbabilityAnalysis
   static AnalysisKey Key;
 
 public:
   /// Provide the result type for this analysis pass.
   using Result = BranchProbabilityInfo;
 
   /// Run the analysis pass over a function and produce BPI.
   BranchProbabilityInfo run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "branch-prob"; }
 };
 
 /// Printer pass for the \c BranchProbabilityAnalysis results.
 class BranchProbabilityPrinterPass
     : public PassInfoMixin<BranchProbabilityPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit BranchProbabilityPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<branch-prob>"; }
 };
 
 /// Legacy analysis pass which computes \c BranchProbabilityInfo.
 class BranchProbabilityInfoWrapperPass : public FunctionPass {
   BranchProbabilityInfo BPI;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/CFGPrinter.h

 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 
 namespace llvm {
 class CFGViewerPass : public PassInfoMixin<CFGViewerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "view-cfg"; }
 };
 
 class CFGOnlyViewerPass : public PassInfoMixin<CFGOnlyViewerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "view-cfg-only"; }
 };
 
 class CFGPrinterPass : public PassInfoMixin<CFGPrinterPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "dot-cfg"; }
 };
 
 class CFGOnlyPrinterPass : public PassInfoMixin<CFGOnlyPrinterPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "dot-cfg-only"; }
 };
 
 class DOTFuncInfo {
 private:
   const Function *F;
   const BlockFrequencyInfo *BFI;
   const BranchProbabilityInfo *BPI;
   uint64_t MaxFreq;

llvm/include/llvm/Analysis/CFLAndersAliasAnalysis.h

class CFLAndersAA : public AnalysisInfoMixin<CFLAndersAA> {
   friend AnalysisInfoMixin<CFLAndersAA>;
 
   static AnalysisKey Key;
 
 public:
   using Result = CFLAndersAAResult;
 
   CFLAndersAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "cfl-anders-aa"; }
 };
 
 /// Legacy wrapper pass to provide the CFLAndersAAResult object.
 class CFLAndersAAWrapperPass : public ImmutablePass {
   std::unique_ptr<CFLAndersAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/CFLSteensAliasAnalysis.h

class CFLSteensAA : public AnalysisInfoMixin<CFLSteensAA> {
   friend AnalysisInfoMixin<CFLSteensAA>;
 
   static AnalysisKey Key;
 
 public:
   using Result = CFLSteensAAResult;
 
   CFLSteensAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "cfl-steens-aa"; }
 };
 
 /// Legacy wrapper pass to provide the CFLSteensAAResult object.
 class CFLSteensAAWrapperPass : public ImmutablePass {
   std::unique_ptr<CFLSteensAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/CGSCCPassManager.h

struct RequireAnalysisPass<AnalysisT, LazyCallGraph::SCC, CGSCCAnalysisManager,
     : PassInfoMixin<RequireAnalysisPass<AnalysisT, LazyCallGraph::SCC,
                                         CGSCCAnalysisManager, LazyCallGraph &,
                                         CGSCCUpdateResult &>> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &) {
     (void)AM.template getResult<AnalysisT>(C, CG);
     return PreservedAnalyses::all();
   }
+  static StringRef name() { return "require-analysis"; }
 };
 
 /// A proxy from a \c CGSCCAnalysisManager to a \c Module.
 using CGSCCAnalysisManagerModuleProxy =
     InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
 
 /// We need a specialized result for the \c CGSCCAnalysisManagerModuleProxy so
 /// it can have access to the call graph in order to walk all the SCCs when
operator=(ModuleToPostOrderCGSCCPassAdaptor RHS) {
     swap(*this, RHS);
     return *this;
   }
 
   /// Runs the CGSCC pass across every SCC in the module.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "module-to-post-order-cgscc-adaptor"; }
 
 private:
   std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename CGSCCPassT>
public:
 
   private:
     FunctionAnalysisManager *FAM;
   };
 
   /// Computes the \c FunctionAnalysisManager and stores it in the result proxy.
   Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &);
 
+  static StringRef name() { return "fam-proxy"; }
+
 private:
   friend AnalysisInfoMixin<FunctionAnalysisManagerCGSCCProxy>;
 
   static AnalysisKey Key;
 };
 
 extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
 
CGSCCToFunctionPassAdaptor &operator=(CGSCCToFunctionPassAdaptor RHS) {
     return *this;
   }
 
   /// Runs the function pass across every function in the module.
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "cgscc-to-function-adaptor"; }
 
 private:
   std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename FunctionPassT>
explicit DevirtSCCRepeatedPass(std::unique_ptr<PassConceptT> Pass,
                                  int MaxIterations)
       : Pass(std::move(Pass)), MaxIterations(MaxIterations) {}
 
   /// Runs the wrapped pass up to \c MaxIterations on the SCC, iterating
   /// whenever an indirect call is refined.
   PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
+  static StringRef name() { return "devirt-repeat"; }
+
 private:
   std::unique_ptr<PassConceptT> Pass;
   int MaxIterations;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename CGSCCPassT>

llvm/include/llvm/Analysis/CallGraph.h

 public:
   /// A formulaic type to inform clients of the result type.
   using Result = CallGraph;
 
   /// Compute the \c CallGraph for the module \c M.
   ///
   /// The real work here is done in the \c CallGraph constructor.
   CallGraph run(Module &M, ModuleAnalysisManager &) { return CallGraph(M); }
+
+  static StringRef name() { return "callgraph"; }
 };
 
 /// Printer pass for the \c CallGraphAnalysis results.
 class CallGraphPrinterPass : public PassInfoMixin<CallGraphPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit CallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-callgraph"; }
 };
 
 /// The \c ModulePass which wraps up a \c CallGraph and the logic to
 /// build it.
 ///
 /// This class exposes both the interface to the call graph container and the
 /// module pass which runs over a module of IR and produces the call graph. The
 /// call graph interface is entirelly a wrapper around a \c CallGraph object

llvm/include/llvm/Analysis/DDG.h

 // DDG Analysis Passes
 //===--------------------------------------------------------------------===//
 
 /// Analysis pass that builds the DDG for a loop.
 class DDGAnalysis : public AnalysisInfoMixin<DDGAnalysis> {
 public:
   using Result = std::unique_ptr<DataDependenceGraph>;
   Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
+  static StringRef name() { return "ddg"; }
 
 private:
   friend AnalysisInfoMixin<DDGAnalysis>;
   static AnalysisKey Key;
 };
 
 /// Textual printer pass for the DDG of a loop.
 class DDGAnalysisPrinterPass : public PassInfoMixin<DDGAnalysisPrinterPass> {
 public:
   explicit DDGAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
 
+  static StringRef name() { return "print<ddg>"; }
+
 private:
   raw_ostream &OS;
 };
 
 //===--------------------------------------------------------------------===//
 // DependenceGraphInfo Implementation
 //===--------------------------------------------------------------------===//
 

llvm/include/llvm/Analysis/DDGPrinter.h

 
 //===--------------------------------------------------------------------===//
 // Implementation of DDG DOT Printer for a loop.
 //===--------------------------------------------------------------------===//
 class DDGDotPrinterPass : public PassInfoMixin<DDGDotPrinterPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "dot-ddg"; }
 };
 
 //===--------------------------------------------------------------------===//
 // Specialization of DOTGraphTraits.
 //===--------------------------------------------------------------------===//
 template <>
 struct DOTGraphTraits<const DataDependenceGraph *>
     : public DefaultDOTGraphTraits {

llvm/include/llvm/Analysis/Delinearization.h

 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 struct DelinearizationPrinterPass
     : public PassInfoMixin<DelinearizationPrinterPass> {
   explicit DelinearizationPrinterPass(raw_ostream &OS);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "print<delinearization>"; }
+
 private:
   raw_ostream &OS;
 };
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_DELINEARIZATION_H

llvm/include/llvm/Analysis/DemandedBits.h

 
 public:
   /// Provide the result type for this analysis pass.
   using Result = DemandedBits;
 
   /// Run the analysis pass over a function and produce demanded bits
   /// information.
   DemandedBits run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "demanded-bits"; }
 };
 
 /// Printer pass for DemandedBits
 class DemandedBitsPrinterPass : public PassInfoMixin<DemandedBitsPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit DemandedBitsPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<demanded-bits>"; }
 };
 
 /// Create a demanded bits analysis pass.
 FunctionPass *createDemandedBitsWrapperPass();
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_DEMANDEDBITS_H

llvm/include/llvm/Analysis/DependenceAnalysis.h

bool checkSubscript(const SCEV *Expr, const Loop *LoopNest,
                         SmallBitVector &Loops, bool IsSrc);
   }; // class DependenceInfo
 
   /// AnalysisPass to compute dependence information in a function
   class DependenceAnalysis : public AnalysisInfoMixin<DependenceAnalysis> {
   public:
     typedef DependenceInfo Result;
     Result run(Function &F, FunctionAnalysisManager &FAM);
+    static StringRef name() { return "da"; }
 
   private:
     static AnalysisKey Key;
     friend struct AnalysisInfoMixin<DependenceAnalysis>;
   }; // class DependenceAnalysis
 
   /// Printer pass to dump DA results.
   struct DependenceAnalysisPrinterPass
       : public PassInfoMixin<DependenceAnalysisPrinterPass> {
     DependenceAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
 
     PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
 
+    static StringRef name() { return "print<da>"; }
+
   private:
     raw_ostream &OS;
   }; // class DependenceAnalysisPrinterPass
 
   /// Legacy pass manager pass to access dependence information
   class DependenceAnalysisWrapperPass : public FunctionPass {
   public:
     static char ID; // Class identification, replacement for typeinfo

llvm/include/llvm/Analysis/DivergenceAnalysis.h

class DivergenceAnalysis : public AnalysisInfoMixin<DivergenceAnalysis> {
 
   static AnalysisKey Key;
 
 public:
   using Result = DivergenceInfo;
 
   /// Runs the divergence analysis on @F, a GPU kernel
   Result run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "divergence"; }
 };
 
 /// Printer pass to dump divergence analysis results.
 struct DivergenceAnalysisPrinterPass
     : public PassInfoMixin<DivergenceAnalysisPrinterPass> {
   DivergenceAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
 
+  static StringRef name() { return "print<divergence>"; }
+
 private:
   raw_ostream &OS;
 }; // class DivergenceAnalysisPrinterPass
 
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_DIVERGENCEANALYSIS_H

llvm/include/llvm/Analysis/DominanceFrontier.h

class DominanceFrontierAnalysis
   static AnalysisKey Key;
 
 public:
   /// Provide the result type for this analysis pass.
   using Result = DominanceFrontier;
 
   /// Run the analysis pass over a function and produce a dominator tree.
   DominanceFrontier run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "domfrontier"; }
 };
 
 /// Printer pass for the \c DominanceFrontier.
 class DominanceFrontierPrinterPass
     : public PassInfoMixin<DominanceFrontierPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit DominanceFrontierPrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<domfrontier>"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_DOMINANCEFRONTIER_H

llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h

class FunctionPropertiesAnalysis
     : public AnalysisInfoMixin<FunctionPropertiesAnalysis> {
 
 public:
   static AnalysisKey Key;
 
   using Result = FunctionPropertiesInfo;
 
   Result run(Function &F, FunctionAnalysisManager &FAM);
+
+  static StringRef name() { return "func-properties"; }
 };
 
 /// Printer pass for the FunctionPropertiesAnalysis results.
 class FunctionPropertiesPrinterPass
     : public PassInfoMixin<FunctionPropertiesPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit FunctionPropertiesPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<func-properties>"; }
 };
 
 } // namespace llvm
 #endif // LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H

llvm/include/llvm/Analysis/GlobalsModRef.h

 class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
   friend AnalysisInfoMixin<GlobalsAA>;
   static AnalysisKey Key;
 
 public:
   typedef GlobalsAAResult Result;
 
   GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "globals-aa"; }
 };
 
 /// Legacy wrapper pass to provide the GlobalsAAResult object.
 class GlobalsAAWrapperPass : public ModulePass {
   std::unique_ptr<GlobalsAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/IRSimilarityIdentifier.h

 
 /// An analysis pass that runs and returns the IRSimilarityIdentifier run on the
 /// Module.
 class IRSimilarityAnalysis : public AnalysisInfoMixin<IRSimilarityAnalysis> {
 public:
   typedef IRSimilarity::IRSimilarityIdentifier Result;
 
   Result run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "ir-similarity"; }
 
 private:
   friend AnalysisInfoMixin<IRSimilarityAnalysis>;
   static AnalysisKey Key;
 };
 
 /// Printer pass that uses \c IRSimilarityAnalysis.
 class IRSimilarityAnalysisPrinterPass
     : public PassInfoMixin<IRSimilarityAnalysisPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit IRSimilarityAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-ir-similarity"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_IRSIMILARITYIDENTIFIER_H

llvm/include/llvm/Analysis/IVUsers.h

class IVUsersAnalysis : public AnalysisInfoMixin<IVUsersAnalysis> {
   friend AnalysisInfoMixin<IVUsersAnalysis>;
   static AnalysisKey Key;
 
 public:
   typedef IVUsers Result;
 
   IVUsers run(Loop &L, LoopAnalysisManager &AM,
               LoopStandardAnalysisResults &AR);
+
+  static StringRef name() { return "iv-users"; }
 };
 
 }
 
 #endif

llvm/include/llvm/Analysis/InlineAdvisor.h

public:
 
   private:
     Module &M;
     ModuleAnalysisManager &MAM;
     std::unique_ptr<InlineAdvisor> Advisor;
   };
 
   Result run(Module &M, ModuleAnalysisManager &MAM) { return Result(M, MAM); }
+  static StringRef name() { return "inline-advisor"; }
 };
 
 #ifdef LLVM_HAVE_TF_AOT
 std::unique_ptr<InlineAdvisor>
 getReleaseModeAdvisor(Module &M, ModuleAnalysisManager &MAM);
 #endif
 
 #ifdef LLVM_HAVE_TF_API

llvm/include/llvm/Analysis/InlineCost.h

 // inliner's decisions when creating new optimizations to InlineCost.
 struct InlineCostAnnotationPrinterPass
     : PassInfoMixin<InlineCostAnnotationPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit InlineCostAnnotationPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+
+  static StringRef name() { return "print<inline-cost>"; }
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Analysis/InlineSizeEstimatorAnalysis.h

public:
   InlineSizeEstimatorAnalysis();
   InlineSizeEstimatorAnalysis(InlineSizeEstimatorAnalysis &&);
   ~InlineSizeEstimatorAnalysis();
 
   static AnalysisKey Key;
   using Result = Optional<size_t>;
   Result run(const Function &F, FunctionAnalysisManager &FAM);
   static bool isEvaluatorRequested();
+  static StringRef name() { return "inliner-size-estimator"; }
 
 private:
   std::unique_ptr<TFModelEvaluator> Evaluator;
 };
 
 class InlineSizeEstimatorAnalysisPrinterPass
     : public PassInfoMixin<InlineSizeEstimatorAnalysisPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit InlineSizeEstimatorAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<inliner-size-estimator>"; }
 };
 } // namespace llvm
 #endif // LLVM_ANALYSIS_INLINESIZEESTIMATORANALYSIS_H

llvm/include/llvm/Analysis/InstCount.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Function;
 
 struct InstCountPass : PassInfoMixin<InstCountPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "instcount"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_INSTCOUNT_H

llvm/include/llvm/Analysis/LazyCallGraph.h

public:
   LazyCallGraph run(Module &M, ModuleAnalysisManager &AM) {
     FunctionAnalysisManager &FAM =
         AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
     auto GetTLI = [&FAM](Function &F) -> TargetLibraryInfo & {
       return FAM.getResult<TargetLibraryAnalysis>(F);
     };
     return LazyCallGraph(M, GetTLI);
   }
+
+  static StringRef name() { return "lcg"; }
 };
 
 /// A pass which prints the call graph to a \c raw_ostream.
 ///
 /// This is primarily useful for testing the analysis.
 class LazyCallGraphPrinterPass
     : public PassInfoMixin<LazyCallGraphPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LazyCallGraphPrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-lcg"; }
 };
 
 /// A pass which prints the call graph as a DOT file to a \c raw_ostream.
 ///
 /// This is primarily useful for visualization purposes.
 class LazyCallGraphDOTPrinterPass
     : public PassInfoMixin<LazyCallGraphDOTPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LazyCallGraphDOTPrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-lcg-dot"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_LAZYCALLGRAPH_H

llvm/include/llvm/Analysis/LazyValueInfo.h

bool invalidate(Function &F, const PreservedAnalyses &PA,
                   FunctionAnalysisManager::Invalidator &Inv);
 };
 
 /// Analysis to compute lazy value information.
 class LazyValueAnalysis : public AnalysisInfoMixin<LazyValueAnalysis> {
 public:
   typedef LazyValueInfo Result;
   Result run(Function &F, FunctionAnalysisManager &FAM);
+  static StringRef name() { return "lazy-value-info"; }
 
 private:
   static AnalysisKey Key;
   friend struct AnalysisInfoMixin<LazyValueAnalysis>;
 };
 
 /// Wrapper around LazyValueInfo.
 class LazyValueInfoWrapperPass : public FunctionPass {

llvm/include/llvm/Analysis/Lint.h

 void lintModule(const Module &M);
 
 // Lint a function.
 void lintFunction(const Function &F);
 
 class LintPass : public PassInfoMixin<LintPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lint"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_LINT_H

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

class LoopAccessAnalysis
     : public AnalysisInfoMixin<LoopAccessAnalysis> {
   friend AnalysisInfoMixin<LoopAccessAnalysis>;
   static AnalysisKey Key;
 
 public:
   typedef LoopAccessInfo Result;
 
   Result run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR);
+
+  static StringRef name() { return "access-info"; }
 };
 
 inline Instruction *MemoryDepChecker::Dependence::getSource(
     const LoopAccessInfo &LAI) const {
   return LAI.getDepChecker().getMemoryInstructions()[Source];
 }
 
 inline Instruction *MemoryDepChecker::Dependence::getDestination(
     const LoopAccessInfo &LAI) const {
   return LAI.getDepChecker().getMemoryInstructions()[Destination];
 }
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Analysis/LoopCacheAnalysis.h

 class LoopCachePrinterPass : public PassInfoMixin<LoopCachePrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LoopCachePrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+
+  static StringRef name() { return "print<loop-cache-cost>"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_LOOPCACHEANALYSIS_H

llvm/include/llvm/Analysis/LoopInfo.h

 class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> {
   friend AnalysisInfoMixin<LoopAnalysis>;
   static AnalysisKey Key;
 
 public:
   typedef LoopInfo Result;
 
   LoopInfo run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "loops"; }
 };
 
 /// Printer pass for the \c LoopAnalysis results.
 class LoopPrinterPass : public PassInfoMixin<LoopPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LoopPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print<loops>"; }
 };
 
 /// Verifier pass for the \c LoopAnalysis results.
 struct LoopVerifierPass : public PassInfoMixin<LoopVerifierPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "verify<loops>"; }
 };
 
 /// The legacy pass manager's analysis pass to compute loop information.
 class LoopInfoWrapperPass : public FunctionPass {
   LoopInfo LI;
 
 public:
   static char ID; // Pass identification, replacement for typeid

llvm/include/llvm/Analysis/LoopNestAnalysis.h

 class LoopNestPrinterPass : public PassInfoMixin<LoopNestPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LoopNestPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "print<loopnest>"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_LOOPNESTANALYSIS_H

llvm/include/llvm/Analysis/MemDerefPrinter.h

 
 namespace llvm {
 class MemDerefPrinterPass : public PassInfoMixin<MemDerefPrinterPass> {
   raw_ostream &OS;
 
 public:
   MemDerefPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print-memderefs"; }
 };
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_MEMDEREFPRINTER_H

llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h

 
 public:
   using Result = MemoryDependenceResults;
 
   MemoryDependenceAnalysis();
   MemoryDependenceAnalysis(unsigned DefaultBlockScanLimit) : DefaultBlockScanLimit(DefaultBlockScanLimit) { }
 
   MemoryDependenceResults run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "memdep"; }
 };
 
 /// A wrapper analysis pass for the legacy pass manager that exposes a \c
 /// MemoryDepnedenceResults instance.
 class MemoryDependenceWrapperPass : public FunctionPass {
   Optional<MemoryDependenceResults> MemDep;
 
 public:

llvm/include/llvm/Analysis/MemorySSA.h

struct Result {
 
     std::unique_ptr<MemorySSA> MSSA;
 
     bool invalidate(Function &F, const PreservedAnalyses &PA,
                     FunctionAnalysisManager::Invalidator &Inv);
   };
 
   Result run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "memoryssa"; }
 };
 
 /// Printer pass for \c MemorySSA.
 class MemorySSAPrinterPass : public PassInfoMixin<MemorySSAPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit MemorySSAPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<memoryssa>"; }
 };
 
 /// Verifier pass for \c MemorySSA.
 struct MemorySSAVerifierPass : PassInfoMixin<MemorySSAVerifierPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "verify<memoryssa>"; }
 };
 
 /// Legacy analysis pass which computes \c MemorySSA.
 class MemorySSAWrapperPass : public FunctionPass {
 public:
   MemorySSAWrapperPass();
 
   static char ID;

llvm/include/llvm/Analysis/ModuleDebugInfoPrinter.h

 class ModuleDebugInfoPrinterPass
     : public PassInfoMixin<ModuleDebugInfoPrinterPass> {
   DebugInfoFinder Finder;
   raw_ostream &OS;
 
 public:
   explicit ModuleDebugInfoPrinterPass(raw_ostream &OS);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print<module-debuginfo>"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_MODULEDEBUGINFOPRINTER_H

llvm/include/llvm/Analysis/ModuleSummaryAnalysis.h

class ModuleSummaryIndexAnalysis
   friend AnalysisInfoMixin<ModuleSummaryIndexAnalysis>;
 
   static AnalysisKey Key;
 
 public:
   using Result = ModuleSummaryIndex;
 
   Result run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "module-summary"; }
 };
 
 /// Legacy wrapper pass to provide the ModuleSummaryIndex object.
 class ModuleSummaryIndexWrapperPass : public ModulePass {
   Optional<ModuleSummaryIndex> Index;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/MustExecute.h

 };
 
 class MustExecutePrinterPass : public PassInfoMixin<MustExecutePrinterPass> {
   raw_ostream &OS;
 
 public:
   MustExecutePrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print-mustexecute"; }
 };
 
 class MustBeExecutedContextPrinterPass
     : public PassInfoMixin<MustBeExecutedContextPrinterPass> {
   raw_ostream &OS;
 
 public:
   MustBeExecutedContextPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-must-be-executed-contexts"; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h

 class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
   friend AnalysisInfoMixin<ObjCARCAA>;
   static AnalysisKey Key;
 
 public:
   typedef ObjCARCAAResult Result;
 
   ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "objc-arc-aa"; }
 };
 
 /// Legacy wrapper pass to provide the ObjCARCAAResult object.
 class ObjCARCAAWrapperPass : public ImmutablePass {
   std::unique_ptr<ObjCARCAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/OptimizationRemarkEmitter.h

class OptimizationRemarkEmitterAnalysis
   static AnalysisKey Key;
 
 public:
   /// Provide the result typedef for this analysis pass.
   typedef OptimizationRemarkEmitter Result;
 
   /// Run the analysis pass over a function and produce BFI.
   Result run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "opt-remark-emit"; }
 };
 }
 #endif // LLVM_ANALYSIS_OPTIMIZATIONREMARKEMITTER_H

llvm/include/llvm/Analysis/PhiValues.h

 /// which will get filled in as it's used.
 class PhiValuesAnalysis : public AnalysisInfoMixin<PhiValuesAnalysis> {
   friend AnalysisInfoMixin<PhiValuesAnalysis>;
   static AnalysisKey Key;
 
 public:
   using Result = PhiValues;
   PhiValues run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "phi-values"; }
 };
 
 /// A pass for printing the PhiValues for a function.
 ///
 /// This pass doesn't print whatever information the PhiValues happens to hold,
 /// but instead first uses the PhiValues to analyze all the phis in the function
 /// so the complete information is printed.
 class PhiValuesPrinterPass : public PassInfoMixin<PhiValuesPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit PhiValuesPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print<phi-values>"; }
 };
 
 /// Wrapper pass for the legacy pass manager
 class PhiValuesWrapperPass : public FunctionPass {
   std::unique_ptr<PhiValues> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/PostDominators.h

 
 public:
   /// Provide the result type for this analysis pass.
   using Result = PostDominatorTree;
 
   /// Run the analysis pass over a function and produce a post dominator
   ///        tree.
   PostDominatorTree run(Function &F, FunctionAnalysisManager &);
+
+  static StringRef name() { return "postdomtree"; }
 };
 
 /// Printer pass for the \c PostDominatorTree.
 class PostDominatorTreePrinterPass
     : public PassInfoMixin<PostDominatorTreePrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit PostDominatorTreePrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<postdomtree>"; }
 };
 
 struct PostDominatorTreeWrapperPass : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
 
   PostDominatorTree DT;
 
   PostDominatorTreeWrapperPass();

llvm/include/llvm/Analysis/ProfileSummaryInfo.h

 
 /// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
 class ProfileSummaryAnalysis
     : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
 public:
   typedef ProfileSummaryInfo Result;
 
   Result run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "profile-summary"; }
 
 private:
   friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
   static AnalysisKey Key;
 };
 
 /// Printer pass that uses \c ProfileSummaryAnalysis.
 class ProfileSummaryPrinterPass
     : public PassInfoMixin<ProfileSummaryPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-profile-summary"; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Analysis/RegionInfo.h

class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> {
   friend AnalysisInfoMixin<RegionInfoAnalysis>;
 
   static AnalysisKey Key;
 
 public:
   using Result = RegionInfo;
 
   RegionInfo run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "regions"; }
 };
 
 /// Printer pass for the \c RegionInfo.
 class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit RegionInfoPrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<regions>"; }
 };
 
 /// Verifier pass for the \c RegionInfo.
 struct RegionInfoVerifierPass : PassInfoMixin<RegionInfoVerifierPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "verify<regions>"; }
 };
 
 template <>
 template <>
 inline BasicBlock *
 RegionNodeBase<RegionTraits<Function>>::getNodeAs<BasicBlock>() const {
   assert(!isSubRegion() && "This is not a BasicBlock RegionNode!");
   return getEntry();

llvm/include/llvm/Analysis/ScalarEvolution.h

class ScalarEvolutionAnalysis
   friend AnalysisInfoMixin<ScalarEvolutionAnalysis>;
 
   static AnalysisKey Key;
 
 public:
   using Result = ScalarEvolution;
 
   ScalarEvolution run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "scalar-evolution"; }
 };
 
 /// Verifier pass for the \c ScalarEvolutionAnalysis results.
 class ScalarEvolutionVerifierPass
     : public PassInfoMixin<ScalarEvolutionVerifierPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "verify<scalar-evolution>"; }
 };
 
 /// Printer pass for the \c ScalarEvolutionAnalysis results.
 class ScalarEvolutionPrinterPass
     : public PassInfoMixin<ScalarEvolutionPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<scalar-evolution>"; }
 };
 
 class ScalarEvolutionWrapperPass : public FunctionPass {
   std::unique_ptr<ScalarEvolution> SE;
 
 public:
   static char ID;
 

llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h

 class SCEVAA : public AnalysisInfoMixin<SCEVAA> {
   friend AnalysisInfoMixin<SCEVAA>;
   static AnalysisKey Key;
 
 public:
   typedef SCEVAAResult Result;
 
   SCEVAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "scev-aa"; }
 };
 
 /// Legacy wrapper pass to provide the SCEVAAResult object.
 class SCEVAAWrapperPass : public FunctionPass {
   std::unique_ptr<SCEVAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/ScopedNoAliasAA.h

class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> {
   friend AnalysisInfoMixin<ScopedNoAliasAA>;
 
   static AnalysisKey Key;
 
 public:
   using Result = ScopedNoAliasAAResult;
 
   ScopedNoAliasAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "scoped-noalias-aa"; }
 };
 
 /// Legacy wrapper pass to provide the ScopedNoAliasAAResult object.
 class ScopedNoAliasAAWrapperPass : public ImmutablePass {
   std::unique_ptr<ScopedNoAliasAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Analysis/StackLifetime.h

class StackLifetimePrinterPass
     : public PassInfoMixin<StackLifetimePrinterPass> {
   StackLifetime::LivenessType Type;
   raw_ostream &OS;
 
 public:
   StackLifetimePrinterPass(raw_ostream &OS, StackLifetime::LivenessType Type)
       : Type(Type), OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print<stack-lifetime>"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_STACKLIFETIME_H

llvm/include/llvm/Analysis/StackSafetyAnalysis.h

 /// StackSafetyInfo wrapper for the new pass manager.
 class StackSafetyAnalysis : public AnalysisInfoMixin<StackSafetyAnalysis> {
   friend AnalysisInfoMixin<StackSafetyAnalysis>;
   static AnalysisKey Key;
 
 public:
   using Result = StackSafetyInfo;
   StackSafetyInfo run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "stack-safety-local"; }
 };
 
 /// Printer pass for the \c StackSafetyAnalysis results.
 class StackSafetyPrinterPass : public PassInfoMixin<StackSafetyPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit StackSafetyPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print<stack-safety-local>"; }
 };
 
 /// StackSafetyInfo wrapper for the legacy pass manager
 class StackSafetyInfoWrapperPass : public FunctionPass {
   StackSafetyInfo SSI;
 
 public:
   static char ID;

 class StackSafetyGlobalAnalysis
     : public AnalysisInfoMixin<StackSafetyGlobalAnalysis> {
   friend AnalysisInfoMixin<StackSafetyGlobalAnalysis>;
   static AnalysisKey Key;
 
 public:
   using Result = StackSafetyGlobalInfo;
   Result run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "stack-safety"; }
 };
 
 /// Printer pass for the \c StackSafetyGlobalAnalysis results.
 class StackSafetyGlobalPrinterPass
     : public PassInfoMixin<StackSafetyGlobalPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit StackSafetyGlobalPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "print-stack-safety"; }
 };
 
 /// This pass performs the global (interprocedural) stack safety analysis
 /// (legacy pass manager).
 class StackSafetyGlobalInfoWrapperPass : public ModulePass {
   StackSafetyGlobalInfo SSGI;
 
 public:

llvm/include/llvm/Analysis/TargetLibraryInfo.h

public:
   /// Construct a library analysis with baseline Module-level info.
   ///
   /// This will be supplemented with Function-specific info in the Result.
   TargetLibraryAnalysis(TargetLibraryInfoImpl BaselineInfoImpl)
       : BaselineInfoImpl(std::move(BaselineInfoImpl)) {}
 
   TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &);
 
+  static StringRef name() { return "targetlibinfo"; }
+
 private:
   friend AnalysisInfoMixin<TargetLibraryAnalysis>;
   static AnalysisKey Key;
 
   Optional<TargetLibraryInfoImpl> BaselineInfoImpl;
 };
 
 class TargetLibraryInfoWrapperPass : public ImmutablePass {

llvm/include/llvm/Analysis/TargetTransformInfo.h

public:
   }
   TargetIRAnalysis &operator=(TargetIRAnalysis &&RHS) {
     TTICallback = std::move(RHS.TTICallback);
     return *this;
   }
 
   Result run(const Function &F, FunctionAnalysisManager &);
 
+  static StringRef name() { return "target-ir"; }
+
 private:
   friend AnalysisInfoMixin<TargetIRAnalysis>;
   static AnalysisKey Key;
 
   /// The callback used to produce a result.
   ///
   /// We use a completely opaque callback so that targets can provide whatever
   /// mechanism they desire for constructing the TTI for a given function.

llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h

class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> {
   friend AnalysisInfoMixin<TypeBasedAA>;
 
   static AnalysisKey Key;
 
 public:
   using Result = TypeBasedAAResult;
 
   TypeBasedAAResult run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "tbaa"; }
 };
 
 /// Legacy wrapper pass to provide the TypeBasedAAResult object.
 class TypeBasedAAWrapperPass : public ImmutablePass {
   std::unique_ptr<TypeBasedAAResult> Result;
 
 public:
   static char ID;

llvm/include/llvm/Bitcode/BitcodeWriterPass.h

explicit BitcodeWriterPass(raw_ostream &OS,
                              bool EmitSummaryIndex = false,
                              bool EmitModuleHash = false)
       : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
   EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {}
 
   /// Run the bitcode writer pass, and output the module to the selected
   /// output stream.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+
+  static StringRef name() { return "bitcode-writer"; }
 };
 
 }
 
 #endif

llvm/include/llvm/IR/Dominators.h

class DominatorTreeAnalysis : public AnalysisInfoMixin<DominatorTreeAnalysis> {
   static AnalysisKey Key;
 
 public:
   /// Provide the result typedef for this analysis pass.
   using Result = DominatorTree;
 
   /// Run the analysis pass over a function and produce a dominator tree.
   DominatorTree run(Function &F, FunctionAnalysisManager &);
+
+  static StringRef name() { return "domtree"; }
 };
 
 /// Printer pass for the \c DominatorTree.
 class DominatorTreePrinterPass
     : public PassInfoMixin<DominatorTreePrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit DominatorTreePrinterPass(raw_ostream &OS);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "print<domtree>"; }
 };
 
 /// Verifier pass for the \c DominatorTree.
 struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "verify<domtree>"; }
 };
 
 /// Legacy analysis pass which computes a \c DominatorTree.
 class DominatorTreeWrapperPass : public FunctionPass {
   DominatorTree DT;
 
 public:
   static char ID;

llvm/include/llvm/IR/IRPrintingPasses.h

 
 public:
   PrintModulePass();
   PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
                   bool ShouldPreserveUseListOrder = false);
 
   PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
   static bool isRequired() { return true; }
+  static StringRef name() { return "print"; }
 };
 
 /// 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 : 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 bool isRequired() { return true; }
+  static StringRef name() { return "print"; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/IR/PassInstrumentation.h

void registerBeforeAnalysisCallback(CallableT C) {
     BeforeAnalysisCallbacks.emplace_back(std::move(C));
   }
 
   template <typename CallableT>
   void registerAfterAnalysisCallback(CallableT C) {
     AfterAnalysisCallbacks.emplace_back(std::move(C));
   }
 
-  /// Add a class name to pass name mapping for use by pass instrumentation.
-  void addClassToPassName(StringRef ClassName, StringRef PassName);
-  /// Get the pass name for a given pass class name.
-  StringRef getPassNameForClassName(StringRef ClassName);
-
 private:
   friend class PassInstrumentation;
 
   /// These are only run on passes that are not required. They return false when
   /// an optional pass should be skipped.
   SmallVector<llvm::unique_function<BeforePassFunc>, 4>
       ShouldRunOptionalPassCallbacks;
   /// These are run on passes that are skipped.
   SmallVector<llvm::unique_function<BeforeSkippedPassFunc>, 4>
       BeforeSkippedPassCallbacks;
   /// These are run on passes that are about to be run.
   SmallVector<llvm::unique_function<BeforeNonSkippedPassFunc>, 4>
       BeforeNonSkippedPassCallbacks;
   /// These are run on passes that have just run.
   SmallVector<llvm::unique_function<AfterPassFunc>, 4> AfterPassCallbacks;
   /// These are run passes that have just run on invalidated IR.
   SmallVector<llvm::unique_function<AfterPassInvalidatedFunc>, 4>
       AfterPassInvalidatedCallbacks;
   /// These are run on analyses that are about to be run.
   SmallVector<llvm::unique_function<BeforeAnalysisFunc>, 4>
       BeforeAnalysisCallbacks;
   /// These are run on analyses that have been run.
   SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>
       AfterAnalysisCallbacks;
-
-  StringMap<std::string> ClassToPassName;
 };
 
 /// This class provides instrumentation entry points for the Pass Manager,
 /// doing calls to callbacks registered in PassInstrumentationCallbacks.
 class PassInstrumentation {
   PassInstrumentationCallbacks *Callbacks;
 
   // Template argument PassT of PassInstrumentation::runBeforePass could be two

llvm/include/llvm/IR/PassManager.h

 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
 
 /// A CRTP mix-in to automatically provide informational APIs needed for
 /// passes.
 ///
 /// This provides some boilerplate for types that are passes.
 template <typename DerivedT> struct PassInfoMixin {
   /// Gets the name of the pass we are mixed into.
-  static StringRef name() {
-    static_assert(std::is_base_of<PassInfoMixin, DerivedT>::value,
-                  "Must pass the derived type as the template argument!");
-    StringRef Name = getTypeName<DerivedT>();
-    if (Name.startswith("llvm::"))
-      Name = Name.drop_front(strlen("llvm::"));
-    return Name;
-  }
+  // static StringRef name() {
+  //   static_assert(std::is_base_of<PassInfoMixin, DerivedT>::value,
+  //                 "Must pass the derived type as the template argument!");
+  //   StringRef Name = getTypeName<DerivedT>();
+  //   if (Name.startswith("llvm::"))
+  //     Name = Name.drop_front(strlen("llvm::"));
+  //   return Name;
+  // }
 };
 
 /// A CRTP mix-in that provides informational APIs needed for analysis passes.
 ///
 /// This provides some boilerplate for types that are analysis passes. It
 /// automatically mixes in \c PassInfoMixin.
 template <typename DerivedT>
 struct AnalysisInfoMixin : PassInfoMixin<DerivedT> {

 /// pass it runs, and will call the analysis manager's invalidation routine with
 /// the PreservedAnalyses of each pass it runs.
 template <typename IRUnitT,
           typename AnalysisManagerT = AnalysisManager<IRUnitT>,
           typename... ExtraArgTs>
 class PassManager : public PassInfoMixin<
                         PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
 public:
+  static StringRef name() { return "pass-manager"; }
+
   /// Construct a pass manager.
   ///
   /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
   explicit PassManager(bool DebugLogging = false) : DebugLogging(DebugLogging) {}
 
   // FIXME: These are equivalent to the default move constructor/move
   // assignment. However, using = default triggers linker errors due to the
   // explicit instantiations below. Find away to use the default and remove the
PassInstrumentationAnalysis(PassInstrumentationCallbacks *Callbacks = nullptr)
       : Callbacks(Callbacks) {}
 
   using Result = PassInstrumentation;
 
   template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
   Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
     return PassInstrumentation(Callbacks);
   }
+  static StringRef name() { return "pass-instrumentation"; }
 };
 
 /// A container for analyses that lazily runs them and caches their
 /// results.
 ///
 /// This class can manage analyses for any IR unit where the address of the IR
 /// unit sufficies as its identity.
 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager {

 ///
 /// Note that the proxy's result is a move-only RAII object.  The validity of
 /// the analyses in the inner analysis manager is tied to its lifetime.
 template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
 class InnerAnalysisManagerProxy
     : public AnalysisInfoMixin<
           InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
 public:
+  static StringRef name() { return "inner-analysis-manager-proxy"; }
+
   class Result {
   public:
     explicit Result(AnalysisManagerT &InnerAM) : InnerAM(&InnerAM) {}
 
     Result(Result &&Arg) : InnerAM(std::move(Arg.InnerAM)) {
       // We have to null out the analysis manager in the moved-from state
       // because we are taking ownership of the responsibilty to clear the
       // analysis state.

 /// recursive return path of each layer of the pass manager.  A consequence of
 /// this is the outer analyses may be stale.  We invalidate the outer analyses
 /// only when we're done running passes over the inner IR units.
 template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
 class OuterAnalysisManagerProxy
     : public AnalysisInfoMixin<
           OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
 public:
+  static StringRef name() { return "outer-analysis-manager-proxy"; }
+
   /// Result proxy object for \c OuterAnalysisManagerProxy.
   class Result {
   public:
     explicit Result(const AnalysisManagerT &OuterAM) : OuterAM(&OuterAM) {}
 
     /// Get a cached analysis. If the analysis can be invalidated, this will
     /// assert.
     template <typename PassT, typename IRUnitTParam>
public:
 
   explicit ModuleToFunctionPassAdaptor(std::unique_ptr<PassConceptT> Pass)
       : Pass(std::move(Pass)) {}
 
   /// Runs the function pass across every function in the module.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "module-to-function-adaptor"; }
 
 private:
   std::unique_ptr<PassConceptT> Pass;
 };
 
 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename FunctionPassT>
struct RequireAnalysisPass
   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
                         ExtraArgTs &&... Args) {
     (void)AM.template getResult<AnalysisT>(Arg,
                                            std::forward<ExtraArgTs>(Args)...);
 
     return PreservedAnalyses::all();
   }
   static bool isRequired() { return true; }
+  static StringRef name() { return "require-analysis"; }
 };
 
 /// A no-op pass template which simply forces a specific analysis result
 /// to be invalidated.
 template <typename AnalysisT>
 struct InvalidateAnalysisPass
     : PassInfoMixin<InvalidateAnalysisPass<AnalysisT>> {
   /// Run this pass over some unit of IR.
   ///
   /// This pass can be run over any unit of IR and use any analysis manager,
   /// provided they satisfy the basic API requirements. When this pass is
   /// created, these methods can be instantiated to satisfy whatever the
   /// context requires.
   template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
     auto PA = PreservedAnalyses::all();
     PA.abandon<AnalysisT>();
     return PA;
   }
+  static StringRef name() { return "invalidate"; }
 };
 
 /// A utility pass that does nothing, but preserves no analyses.
 ///
 /// Because this preserves no analyses, any analysis passes queried after this
 /// pass runs will recompute fresh results.
 struct InvalidateAllAnalysesPass : PassInfoMixin<InvalidateAllAnalysesPass> {
   /// Run this pass over some unit of IR.
   template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
   PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
     return PreservedAnalyses::none();
   }
+  static StringRef name() { return "invalidate<all>"; }
 };
 
 /// A utility pass template that simply runs another pass multiple times.
 ///
 /// This can be useful when debugging or testing passes. It also serves as an
 /// example of how to extend the pass manager in ways beyond composition.
 template <typename PassT>
 class RepeatedPass : public PassInfoMixin<RepeatedPass<PassT>> {
for (int i = 0; i < Count; ++i) {
       if (!PI.runBeforePass<IRUnitT>(P, IR))
         continue;
       PreservedAnalyses IterPA = P.run(IR, AM, std::forward<Ts>(Args)...);
       PA.intersect(IterPA);
       PI.runAfterPass(P, IR, IterPA);
     }
     return PA;
   }
+  static StringRef name() { return "repeat"; }
 
 private:
   int Count;
   PassT P;
 };
 
 template <typename PassT>
 RepeatedPass<PassT> createRepeatedPass(int Count, PassT P) {
   return RepeatedPass<PassT>(Count, std::move(P));
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_PASSMANAGER_H

llvm/include/llvm/IR/SafepointIRVerifier.h

 /// Create an instance of the safepoint verifier pass which can be added to
 /// a pass pipeline to check for relocation bugs.
 class SafepointIRVerifierPass : public PassInfoMixin<SafepointIRVerifierPass> {
 
 public:
   explicit SafepointIRVerifierPass() {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "verify<safepoint-ir>"; }
 };
 }
 
 #endif // LLVM_IR_SAFEPOINTIRVERIFIER_H

llvm/include/llvm/IR/Verifier.h

 public:
   struct Result {
     bool IRBroken, DebugInfoBroken;
   };
 
   Result run(Module &M, ModuleAnalysisManager &);
   Result run(Function &F, FunctionAnalysisManager &);
   static bool isRequired() { return true; }
+  static StringRef name() { return "verify"; }
 };
 
 /// Check a module for errors, but report debug info errors separately.
 /// Otherwise behaves as the normal verifyModule. Debug info errors can be
 /// "recovered" from by stripping the debug info.
 bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
 
 /// Create a verifier pass.
class VerifierPass : public PassInfoMixin<VerifierPass> {
   bool FatalErrors;
 
 public:
   explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "verify"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_VERIFIER_H

llvm/include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h

 
 namespace llvm {
 
 class AggressiveInstCombinePass
     : public PassInfoMixin<AggressiveInstCombinePass> {
 
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "aggressive-instcombine"; }
 };
 
 //===----------------------------------------------------------------------===//
 //
 // AggressiveInstCombiner - Combine expression patterns to form expressions with
 // fewer, simple instructions. This pass does not modify the CFG.
 //
 FunctionPass *createAggressiveInstCombinerPass();
 }
 
 #endif

llvm/include/llvm/Transforms/Coroutines/CoroCleanup.h

 
 namespace llvm {
 
 class Function;
 
 struct CoroCleanupPass : PassInfoMixin<CoroCleanupPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "coro-cleanup"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROCLEANUP_H

llvm/include/llvm/Transforms/Coroutines/CoroEarly.h

 
 namespace llvm {
 
 class Function;
 
 struct CoroEarlyPass : PassInfoMixin<CoroEarlyPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "coro-early"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROEARLY_H

llvm/include/llvm/Transforms/Coroutines/CoroElide.h

 
 namespace llvm {
 
 class Function;
 
 struct CoroElidePass : PassInfoMixin<CoroElidePass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "coro-elide"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROELIDE_H

llvm/include/llvm/Transforms/Coroutines/CoroSplit.h

 namespace llvm {
 
 struct CoroSplitPass : PassInfoMixin<CoroSplitPass> {
   CoroSplitPass(bool ReuseFrameSlot = false) : ReuseFrameSlot(ReuseFrameSlot) {}
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
   static bool isRequired() { return true; }
+  static StringRef name() { return "coro-split"; }
 
   bool ReuseFrameSlot;
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H

llvm/include/llvm/Transforms/IPO/AlwaysInliner.h

class AlwaysInlinerPass : public PassInfoMixin<AlwaysInlinerPass> {
   bool InsertLifetime;
 
 public:
   AlwaysInlinerPass(bool InsertLifetime = true)
       : InsertLifetime(InsertLifetime) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
   static bool isRequired() { return true; }
+  static StringRef name() { return "always-inline"; }
 };
 
 /// Create a legacy pass manager instance of a pass to inline and remove
 /// functions marked as "always_inline".
 Pass *createAlwaysInlinerLegacyPass(bool InsertLifetime = true);
 
 }
 
 #endif // LLVM_TRANSFORMS_IPO_ALWAYSINLINER_H

llvm/include/llvm/Transforms/IPO/Annotation2Metadata.h

 
 namespace llvm {
 
 class Module;
 
 /// Pass to convert @llvm.global.annotations to !annotation metadata.
 struct Annotation2MetadataPass : public PassInfoMixin<Annotation2MetadataPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "annotation2metadata"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H

llvm/include/llvm/Transforms/IPO/ArgumentPromotion.h

static bool areFunctionArgsABICompatible(
       SmallPtrSetImpl<Argument *> &ArgsToPromote,
       SmallPtrSetImpl<Argument *> &ByValArgsToTransform);
 
   /// Checks if a type could have padding bytes.
   static bool isDenselyPacked(Type *type, const DataLayout &DL);
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
+
+  static StringRef name() { return "argpromotion"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H

llvm/include/llvm/Transforms/IPO/Attributor.h

operator<<(raw_ostream &OS,
   return OS << "(" << S.getKnown() << "-" << S.getAssumed() << ")"
             << static_cast<const AbstractState &>(S);
 }
 raw_ostream &operator<<(raw_ostream &OS, const IntegerRangeState &State);
 ///}
 
 struct AttributorPass : public PassInfoMixin<AttributorPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "attributor"; }
 };
 struct AttributorCGSCCPass : public PassInfoMixin<AttributorCGSCCPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
+  static StringRef name() { return "attributor-cgscc"; }
 };
 
 Pass *createAttributorLegacyPass();
 Pass *createAttributorCGSCCLegacyPass();
 
 /// ----------------------------------------------------------------------------
 ///                       Abstract Attribute Classes
 /// ----------------------------------------------------------------------------

llvm/include/llvm/Transforms/IPO/BlockExtractor.h

 #ifndef LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
 #define LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct BlockExtractorPass : PassInfoMixin<BlockExtractorPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "extract-blocks"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H

llvm/include/llvm/Transforms/IPO/CalledValuePropagation.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class CalledValuePropagationPass
     : public PassInfoMixin<CalledValuePropagationPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "called-value-propagation"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_CALLEDVALUEPROPAGATION_H

llvm/include/llvm/Transforms/IPO/ConstantMerge.h

 namespace llvm {
 
 class Module;
 
 /// A pass that merges duplicate global constants into a single constant.
 class ConstantMergePass : public PassInfoMixin<ConstantMergePass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "constmerge"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_CONSTANTMERGE_H

llvm/include/llvm/Transforms/IPO/CrossDSOCFI.h

 #define LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class CrossDSOCFIPass : public PassInfoMixin<CrossDSOCFIPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "cross-dso-cfi"; }
 };
 }
 #endif // LLVM_TRANSFORMS_IPO_CROSSDSOCFI_H
 

llvm/include/llvm/Transforms/IPO/DeadArgumentElimination.h

public:
   LiveFuncSet LiveFunctions;
 
   using UseVector = SmallVector<RetOrArg, 5>;
 
   /// This allows this pass to do double-duty as the dead arg hacking pass
   /// (used only by bugpoint).
   bool ShouldHackArguments = false;
 
+  static StringRef name() { return "deadargelim"; }
+
 private:
   Liveness MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses);
   Liveness SurveyUse(const Use *U, UseVector &MaybeLiveUses,
                      unsigned RetValNum = -1U);
   Liveness SurveyUses(const Value *V, UseVector &MaybeLiveUses);
 
   void SurveyFunction(const Function &F);
   bool IsLive(const RetOrArg &RA);

llvm/include/llvm/Transforms/IPO/ElimAvailExtern.h

 
 class Module;
 
 /// A pass that transforms external global definitions into declarations.
 class EliminateAvailableExternallyPass
     : public PassInfoMixin<EliminateAvailableExternallyPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "elim-avail-extern"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_ELIMAVAILEXTERN_H

llvm/include/llvm/Transforms/IPO/ForceFunctionAttrs.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Pass which forces specific function attributes into the IR, primarily as
 /// a debugging tool.
 struct ForceFunctionAttrsPass : PassInfoMixin<ForceFunctionAttrsPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "forceattrs"; }
 };
 
 /// Create a legacy pass manager instance of a pass to force function attrs.
 Pass *createForceFunctionAttrsLegacyPass();
 
 }
 
 #endif // LLVM_TRANSFORMS_IPO_FORCEFUNCTIONATTRS_H

llvm/include/llvm/Transforms/IPO/FunctionAttrs.h

 /// approach allows powerful interprocedural inference of function attributes
 /// like memory access patterns, etc. It can discover functions that do not
 /// access memory, or only read memory, and give them the readnone/readonly
 /// attribute. It also discovers function arguments that are not captured by
 /// the function and marks them with the nocapture attribute.
 struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
+  static StringRef name() { return "function-attrs"; }
 };
 
 /// Create a legacy pass manager instance of a pass to compute function attrs
 /// in post-order.
 Pass *createPostOrderFunctionAttrsLegacyPass();
 
 /// A pass to do RPO deduction and propagation of function attributes.
 ///
 /// This pass provides a general RPO or "top down" propagation of
 /// function attributes. For a few (rare) cases, we can deduce significantly
 /// more about function attributes by working in RPO, so this pass
 /// provides the complement to the post-order pass above where the majority of
 /// deduction is performed.
 // FIXME: Currently there is no RPO CGSCC pass structure to slide into and so
 // this is a boring module pass, but eventually it should be an RPO CGSCC pass
 // when such infrastructure is available.
 class ReversePostOrderFunctionAttrsPass
     : public PassInfoMixin<ReversePostOrderFunctionAttrsPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "rpo-function-attrs"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/include/llvm/Transforms/IPO/FunctionImport.h

private:
   /// Utils/FunctionImportUtils.h.
   bool ClearDSOLocalOnDeclarations;
 };
 
 /// The function importing pass
 class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "function-import"; }
 };
 
 /// Compute all the imports and exports for every module in the Index.
 ///
 /// \p ModuleToDefinedGVSummaries contains for each Module a map
 /// (GUID -> Summary) for every global defined in the module.
 ///
 /// \p ImportLists will be populated with an entry for every Module we are

llvm/include/llvm/Transforms/IPO/GlobalDCE.h

 #include <unordered_map>
 
 namespace llvm {
 
 /// Pass to remove unused function declarations.
 class GlobalDCEPass : public PassInfoMixin<GlobalDCEPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "globaldce"; }
 
 private:
   SmallPtrSet<GlobalValue*, 32> AliveGlobals;
 
   /// Global -> Global that uses this global.
   DenseMap<GlobalValue *, SmallPtrSet<GlobalValue *, 4>> GVDependencies;
 
   /// Constant -> Globals that use this global cache.

llvm/include/llvm/Transforms/IPO/GlobalOpt.h

 namespace llvm {
 
 class Module;
 
 /// Optimize globals that never have their address taken.
 class GlobalOptPass : public PassInfoMixin<GlobalOptPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "globalopt"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_GLOBALOPT_H

llvm/include/llvm/Transforms/IPO/GlobalSplit.h

 namespace llvm {
 
 class Module;
 
 /// Pass to perform split of global variables.
 class GlobalSplitPass : public PassInfoMixin<GlobalSplitPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "globalsplit"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_GLOBALSPLIT_H

llvm/include/llvm/Transforms/IPO/HotColdSplitting.h

private:
   std::function<OptimizationRemarkEmitter &(Function &)> *GetORE;
   function_ref<AssumptionCache *(Function &)> LookupAC;
 };
 
 /// Pass to outline cold regions.
 class HotColdSplittingPass : public PassInfoMixin<HotColdSplittingPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "hotcoldsplit"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_HOTCOLDSPLITTING_H
 

llvm/include/llvm/Transforms/IPO/IROutliner.h

private:
   /// A InstVisitor used to exclude certain instructions from being outlined.
   InstructionAllowed InstructionClassifier;
 };
 
 /// Pass to outline similar regions.
 class IROutlinerPass : public PassInfoMixin<IROutlinerPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "iroutliner"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_IROUTLINER_H

llvm/include/llvm/Transforms/IPO/InferFunctionAttrs.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// A pass which infers function attributes from the names and signatures of
 /// function declarations in a module.
 struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "inferattrs"; }
 };
 
 /// Create a legacy pass manager instance of a pass to infer function
 /// attributes.
 Pass *createInferFunctionAttrsLegacyPass();
 
 }
 
 #endif // LLVM_TRANSFORMS_IPO_INFERFUNCTIONATTRS_H

llvm/include/llvm/Transforms/IPO/Inliner.h

 class InlinerPass : public PassInfoMixin<InlinerPass> {
 public:
   InlinerPass(bool OnlyMandatory = false) : OnlyMandatory(OnlyMandatory) {}
   InlinerPass(InlinerPass &&Arg) = default;
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
 
+  static StringRef name() { return "inline"; }
+
 private:
   InlineAdvisor &getAdvisor(const ModuleAnalysisManagerCGSCCProxy::Result &MAM,
                             FunctionAnalysisManager &FAM, Module &M);
   std::unique_ptr<InlineAdvisor> OwnedAdvisor;
   const bool OnlyMandatory;
 };
 
 /// Module pass, wrapping the inliner pass. This works in conjunction with the
public:
   /// before run is called, as part of pass pipeline building.
   CGSCCPassManager &getPM() { return PM; }
 
   /// Allow adding module-level analyses benefiting the contained CGSCC passes.
   template <class T> void addRequiredModuleAnalysis() {
     MPM.addPass(RequireAnalysisPass<T, Module>());
   }
 
+  static StringRef name() { return "inliner-wrapper"; }
+
 private:
   const InlineParams Params;
   const InliningAdvisorMode Mode;
   const unsigned MaxDevirtIterations;
   CGSCCPassManager PM;
   ModulePassManager MPM;
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_INLINER_H

llvm/include/llvm/Transforms/IPO/Internalize.h

public:
   /// Run the internalizer on \p TheModule, returns true if any changes was
   /// made.
   ///
   /// If the CallGraph \p CG is supplied, it will be updated when
   /// internalizing a function (by removing any edge from the "external node")
   bool internalizeModule(Module &TheModule, CallGraph *CG = nullptr);
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+  static StringRef name() { return "internalize"; }
 };
 
 /// Helper function to internalize functions and variables in a Module.
 inline bool
 internalizeModule(Module &TheModule,
                   std::function<bool(const GlobalValue &)> MustPreserveGV,
                   CallGraph *CG = nullptr) {
   return InternalizePass(std::move(MustPreserveGV))
       .internalizeModule(TheModule, CG);
 }
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_INTERNALIZE_H

llvm/include/llvm/Transforms/IPO/LoopExtractor.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct LoopExtractorPass : public PassInfoMixin<LoopExtractorPass> {
   LoopExtractorPass(unsigned NumLoops = ~0) : NumLoops(NumLoops) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "loop-extract"; }
 
 private:
   unsigned NumLoops;
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H

llvm/include/llvm/Transforms/IPO/LowerTypeTests.h

 public:
   LowerTypeTestsPass() : UseCommandLine(true) {}
   LowerTypeTestsPass(ModuleSummaryIndex *ExportSummary,
                      const ModuleSummaryIndex *ImportSummary,
                      bool DropTypeTests = false)
       : ExportSummary(ExportSummary), ImportSummary(ImportSummary),
         DropTypeTests(DropTypeTests) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "lowertypetests"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_LOWERTYPETESTS_H

llvm/include/llvm/Transforms/IPO/MergeFunctions.h

 namespace llvm {
 
 class Module;
 
 /// Merge identical functions.
 class MergeFunctionsPass : public PassInfoMixin<MergeFunctionsPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "mergefunc"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_MERGEFUNCTIONS_H

llvm/include/llvm/Transforms/IPO/OpenMPOpt.h

 /// OpenMP optimizations pass.
 class OpenMPOptPass : public PassInfoMixin<OpenMPOptPass> {
   /// Helper to remember if the module contains OpenMP (runtime calls).
   omp::OpenMPInModule OMPInModule;
 
 public:
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
+  static StringRef name() { return "openmpopt"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_OPENMPOPT_H

llvm/include/llvm/Transforms/IPO/PartialInlining.h

 namespace llvm {
 
 class Module;
 
 /// Pass to remove unused function declarations.
 class PartialInlinerPass : public PassInfoMixin<PartialInlinerPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "partial-inliner"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_PARTIALINLINING_H

llvm/include/llvm/Transforms/IPO/SCCP.h

 namespace llvm {
 
 class Module;
 
 /// Pass to perform interprocedural constant propagation.
 class IPSCCPPass : public PassInfoMixin<IPSCCPPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "ipsccp"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_SCCP_H

llvm/include/llvm/Transforms/IPO/SampleProfile.h

public:
   SampleProfileLoaderPass(
       std::string File = "", std::string RemappingFile = "",
       ThinOrFullLTOPhase LTOPhase = ThinOrFullLTOPhase::None)
       : ProfileFileName(File), ProfileRemappingFileName(RemappingFile),
         LTOPhase(LTOPhase) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
+  static StringRef name() { return "sample-profile"; }
+
 private:
   std::string ProfileFileName;
   std::string ProfileRemappingFileName;
   ThinOrFullLTOPhase LTOPhase;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILE_H

llvm/include/llvm/Transforms/IPO/SampleProfileProbe.h

 };
 
 class SampleProfileProbePass : public PassInfoMixin<SampleProfileProbePass> {
   TargetMachine *TM;
 
 public:
   SampleProfileProbePass(TargetMachine *TM) : TM(TM) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pseudo-probe"; }
 };
 
 class PseudoProbeUpdatePass : public PassInfoMixin<PseudoProbeUpdatePass> {
   void runOnFunction(Function &F, FunctionAnalysisManager &FAM);
 
 public:
   PseudoProbeUpdatePass() {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pseudo-probe-update"; }
 };
 
 } // end namespace llvm
 #endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H

llvm/include/llvm/Transforms/IPO/StripDeadPrototypes.h

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Pass to remove unused function declarations.
 struct StripDeadPrototypesPass : PassInfoMixin<StripDeadPrototypesPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "strip-dead-prototype"; }
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_IPO_STRIPDEADPROTOTYPES_H

llvm/include/llvm/Transforms/IPO/StripSymbols.h

 #define LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct StripSymbolsPass : PassInfoMixin<StripSymbolsPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "strip"; }
 };
 
 struct StripNonDebugSymbolsPass : PassInfoMixin<StripNonDebugSymbolsPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "strip-nondebug"; }
 };
 
 struct StripDebugDeclarePass : PassInfoMixin<StripDebugDeclarePass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "strip-debug-declare"; }
 };
 
 struct StripDeadDebugInfoPass : PassInfoMixin<StripDeadDebugInfoPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "strip-dead-debug-info"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H

llvm/include/llvm/Transforms/IPO/SyntheticCountsPropagation.h

 
 namespace llvm {
 class Module;
 
 class SyntheticCountsPropagation
     : public PassInfoMixin<SyntheticCountsPropagation> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+  static StringRef name() { return "synthetic-counts-propagation"; }
 };
 } // namespace llvm
 #endif

llvm/include/llvm/Transforms/IPO/ThinLTOBitcodeWriter.h

 
 public:
   // Writes bitcode to OS. Also write thin link file to ThinLinkOS, if
   // it's not nullptr.
   ThinLTOBitcodeWriterPass(raw_ostream &OS, raw_ostream *ThinLinkOS)
       : OS(OS), ThinLinkOS(ThinLinkOS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+  static StringRef name() { return "thinlto-bitcode-writer"; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/IPO/WholeProgramDevirt.h

struct WholeProgramDevirtPass : public PassInfoMixin<WholeProgramDevirtPass> {
   WholeProgramDevirtPass()
       : ExportSummary(nullptr), ImportSummary(nullptr), UseCommandLine(true) {}
   WholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary,
                          const ModuleSummaryIndex *ImportSummary)
       : ExportSummary(ExportSummary), ImportSummary(ImportSummary) {
     assert(!(ExportSummary && ImportSummary));
   }
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+  static StringRef name() { return "wholeprogramdevirt"; }
 };
 
 struct VTableSlotSummary {
   StringRef TypeID;
   uint64_t ByteOffset;
 };
 
 void updateVCallVisibilityInModule(

llvm/include/llvm/Transforms/InstCombine/InstCombine.h

 
 namespace llvm {
 
 class InstCombinePass : public PassInfoMixin<InstCombinePass> {
   InstCombineWorklist Worklist;
   const unsigned MaxIterations;
 
 public:
-  static StringRef name() { return "InstCombinePass"; }
+  static StringRef name() { return "instcombine"; }
 
   explicit InstCombinePass();
   explicit InstCombinePass(unsigned MaxIterations);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 /// The legacy pass manager's instcombine pass.

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h

 /// AddressSanitizerPass since it collects that metadata.
 /// The legacy pass manager equivalent of this is ASanGlobalsMetadataLegacyPass.
 class ASanGlobalsMetadataAnalysis
     : public AnalysisInfoMixin<ASanGlobalsMetadataAnalysis> {
 public:
   using Result = GlobalsMetadata;
 
   Result run(Module &, ModuleAnalysisManager &);
+  static StringRef name() { return "asan-globals-md"; }
 
 private:
   friend AnalysisInfoMixin<ASanGlobalsMetadataAnalysis>;
   static AnalysisKey Key;
 };
 
 /// Public interface to the address sanitizer pass for instrumenting code to
 /// check for various memory errors at runtime.
 ///
 /// The sanitizer itself is a function pass that works by inserting various
 /// calls to the ASan runtime library functions. The runtime library essentially
 /// replaces malloc() and free() with custom implementations that allow regions
 /// surrounding requested memory to be checked for invalid accesses.
 class AddressSanitizerPass : public PassInfoMixin<AddressSanitizerPass> {
 public:
   explicit AddressSanitizerPass(bool CompileKernel = false,
                                 bool Recover = false,
                                 bool UseAfterScope = false);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "asan"; }
 
 private:
   bool CompileKernel;
   bool Recover;
   bool UseAfterScope;
 };
 
 /// Public interface to the address sanitizer module pass for instrumenting code
 /// to check for various memory errors.
 ///
 /// This adds 'asan.module_ctor' to 'llvm.global_ctors'. This pass may also
 /// run intependently of the function address sanitizer.
 class ModuleAddressSanitizerPass
     : public PassInfoMixin<ModuleAddressSanitizerPass> {
 public:
   explicit ModuleAddressSanitizerPass(
       bool CompileKernel = false, bool Recover = false, bool UseGlobalGC = true,
       bool UseOdrIndicator = false,
       AsanDtorKind DestructorKind = AsanDtorKind::Global);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "asan-module"; }
 
 private:
   bool CompileKernel;
   bool Recover;
   bool UseGlobalGC;
   bool UseOdrIndicator;
   AsanDtorKind DestructorKind;
 };

llvm/include/llvm/Transforms/Instrumentation/BoundsChecking.h

 
 namespace llvm {
 
 /// A pass to instrument code and perform run-time bounds checking on loads,
 /// stores, and other memory intrinsics.
 struct BoundsCheckingPass : PassInfoMixin<BoundsCheckingPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "bounds-checking"; }
 };
 
 
 /// Legacy pass creation function for the above pass.
 FunctionPass *createBoundsCheckingLegacyPass();
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_BOUNDSCHECKING_H

llvm/include/llvm/Transforms/Instrumentation/CGProfile.h

 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class CGProfilePass : public PassInfoMixin<CGProfilePass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "cg-profile"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_CGPROFILE_H

llvm/include/llvm/Transforms/Instrumentation/ControlHeightReduction.h

 
 namespace llvm {
 
 class ControlHeightReductionPass :
       public PassInfoMixin<ControlHeightReductionPass> {
 public:
   ControlHeightReductionPass();
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  static StringRef name() { return "chr"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_CONTROLHEIGHTREDUCTION_H

llvm/include/llvm/Transforms/Instrumentation/DataFlowSanitizer.h

private:
   std::vector<std::string> ABIListFiles;
 
 public:
   DataFlowSanitizerPass(
       const std::vector<std::string> &ABIListFiles = std::vector<std::string>())
       : ABIListFiles(ABIListFiles) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "dfsan"; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Instrumentation/GCOVProfiler.h

 #include "llvm/Transforms/Instrumentation.h"
 
 namespace llvm {
 /// The gcov-style instrumentation pass
 class GCOVProfilerPass : public PassInfoMixin<GCOVProfilerPass> {
 public:
   GCOVProfilerPass(const GCOVOptions &Options = GCOVOptions::getDefault()) : GCOVOpts(Options) { }
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "insert-gcov-profiling"; }
 
 private:
   GCOVOptions GCOVOpts;
 };
 
 } // namespace llvm
 #endif

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

 /// instrumenting code to check for various memory errors at runtime, similar to
 /// AddressSanitizer but based on partial hardware assistance.
 class HWAddressSanitizerPass : public PassInfoMixin<HWAddressSanitizerPass> {
 public:
   explicit HWAddressSanitizerPass(bool CompileKernel = false,
                                   bool Recover = false);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "hwasan"; }
 
 private:
   bool CompileKernel;
   bool Recover;
 };
 
 FunctionPass *createHWAddressSanitizerLegacyPassPass(bool CompileKernel = false,
                                                      bool Recover = false);

llvm/include/llvm/Transforms/Instrumentation/InstrOrderFile.h

 
 namespace llvm {
 class Module;
 
 /// The instrumentation pass for recording function order.
 class InstrOrderFilePass : public PassInfoMixin<InstrOrderFilePass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "instrorderfile"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_INSTRORDERFILE_H

llvm/include/llvm/Transforms/Instrumentation/InstrProfiling.h

 public:
   InstrProfiling() : IsCS(false) {}
   InstrProfiling(const InstrProfOptions &Options, bool IsCS = false)
       : Options(Options), IsCS(IsCS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   bool run(Module &M,
            std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
+  static StringRef name() { return "instrprof"; }
 
 private:
   InstrProfOptions Options;
   Module *M;
   Triple TT;
   std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
   struct PerFunctionProfileData {
     uint32_t NumValueSites[IPVK_Last + 1];

llvm/include/llvm/Transforms/Instrumentation/MemProfiler.h

 /// calls to the MemProfiler runtime library functions. The runtime library
 /// essentially replaces malloc() and free() with custom implementations that
 /// record data about the allocations.
 class MemProfilerPass : public PassInfoMixin<MemProfilerPass> {
 public:
   explicit MemProfilerPass();
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "memprof"; }
 };
 
 /// Public interface to the memory profiler module pass for instrumenting code
 /// to profile memory allocations and accesses.
 class ModuleMemProfilerPass : public PassInfoMixin<ModuleMemProfilerPass> {
 public:
   explicit ModuleMemProfilerPass();
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "memprof-module"; }
 };
 
 // Insert MemProfiler instrumentation
 FunctionPass *createMemProfilerFunctionPass();
 ModulePass *createModuleMemProfilerLegacyPassPass();
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Instrumentation/MemorySanitizer.h

 /// yet, the pass inserts the declarations. Otherwise the existing globals are
 /// used.
 struct MemorySanitizerPass : public PassInfoMixin<MemorySanitizerPass> {
   MemorySanitizerPass(MemorySanitizerOptions Options) : Options(Options) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "msan"; }
 
 private:
   MemorySanitizerOptions Options;
 };
 }
 
 #endif /* LLVM_TRANSFORMS_INSTRUMENTATION_MEMORYSANITIZER_H */

llvm/include/llvm/Transforms/Instrumentation/PGOInstrumentation.h

 // all the COMDAT variables before linking. So we have this pass
 // always run before linking for CSPGO.
 class PGOInstrumentationGenCreateVar
     : public PassInfoMixin<PGOInstrumentationGenCreateVar> {
 public:
   PGOInstrumentationGenCreateVar(std::string CSInstrName = "")
       : CSInstrName(CSInstrName) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pgo-instr-gen-create-var"; }
 
 private:
   std::string CSInstrName;
 };
 
 /// The instrumentation (profile-instr-gen) pass for IR based PGO.
 class PGOInstrumentationGen : public PassInfoMixin<PGOInstrumentationGen> {
 public:
   PGOInstrumentationGen(bool IsCS = false) : IsCS(IsCS) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pgo-instr-gen"; }
 
 private:
   // If this is a context sensitive instrumentation.
   bool IsCS;
 };
 
 /// The profile annotation (profile-instr-use) pass for IR based PGO.
 class PGOInstrumentationUse : public PassInfoMixin<PGOInstrumentationUse> {
 public:
   PGOInstrumentationUse(std::string Filename = "",
                         std::string RemappingFilename = "", bool IsCS = false);
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pgo-instr-use"; }
 
 private:
   std::string ProfileFileName;
   std::string ProfileRemappingFileName;
   // If this is a context sensitive instrumentation.
   bool IsCS;
 };
 
 /// The indirect function call promotion pass.
 class PGOIndirectCallPromotion : public PassInfoMixin<PGOIndirectCallPromotion> {
 public:
   PGOIndirectCallPromotion(bool IsInLTO = false, bool SamplePGO = false)
       : InLTO(IsInLTO), SamplePGO(SamplePGO) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "pgo-icall-prom"; }
 
 private:
   bool InLTO;
   bool SamplePGO;
 };
 
 /// The profile size based optimization pass for memory intrinsics.
 class PGOMemOPSizeOpt : public PassInfoMixin<PGOMemOPSizeOpt> {
 public:
   PGOMemOPSizeOpt() = default;
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "pgo-memop-opt"; }
 };
 
 void setProfMetadata(Module *M, Instruction *TI, ArrayRef<uint64_t> EdgeCounts,
                      uint64_t MaxCount);
 
 void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_PGOINSTRUMENTATION_H

llvm/include/llvm/Transforms/Instrumentation/PoisonChecking.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct PoisonCheckingPass : public PassInfoMixin<PoisonCheckingPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "poison-checking"; }
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_POISONCHECKING_H

llvm/include/llvm/Transforms/Instrumentation/SanitizerCoverage.h

if (AllowlistFiles.size() > 0)
       Allowlist = SpecialCaseList::createOrDie(AllowlistFiles,
                                                *vfs::getRealFileSystem());
     if (BlocklistFiles.size() > 0)
       Blocklist = SpecialCaseList::createOrDie(BlocklistFiles,
                                                *vfs::getRealFileSystem());
   }
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "sancov-module"; }
 
 private:
   SanitizerCoverageOptions Options;
 
   std::unique_ptr<SpecialCaseList> Allowlist;
   std::unique_ptr<SpecialCaseList> Blocklist;
 };
 

llvm/include/llvm/Transforms/Instrumentation/ThreadSanitizer.h

 ///
 /// Instruments functions to detect race conditions reads. This function pass
 /// inserts calls to runtime library functions. If the functions aren't declared
 /// yet, the pass inserts the declarations. Otherwise the existing globals are
 struct ThreadSanitizerPass : public PassInfoMixin<ThreadSanitizerPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "tsan"; }
 };
 
 } // namespace llvm
 #endif /* LLVM_TRANSFORMS_INSTRUMENTATION_THREADSANITIZER_H */

llvm/include/llvm/Transforms/ObjCARC.h

 //===----------------------------------------------------------------------===//
 //
 // ObjCARCOpt - ObjC ARC optimization.
 //
 Pass *createObjCARCOptPass();
 
 struct ObjCARCOptPass : public PassInfoMixin<ObjCARCOptPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "objc-arc"; }
 };
 
 struct ObjCARCContractPass : public PassInfoMixin<ObjCARCContractPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "objc-arc-contract"; }
 };
 
 struct ObjCARCAPElimPass : public PassInfoMixin<ObjCARCAPElimPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "objc-arc-apelim"; }
 };
 
 struct ObjCARCExpandPass : public PassInfoMixin<ObjCARCExpandPass> {
   PreservedAnalyses run(Function &M, FunctionAnalysisManager &AM);
+  static StringRef name() { return "objc-arc-expand"; }
 };
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/Scalar/ADCE.h

 /// A DCE pass that assumes instructions are dead until proven otherwise.
 ///
 /// This pass eliminates dead code by optimistically assuming that all
 /// instructions are dead until proven otherwise. This allows it to eliminate
 /// dead computations that other DCE passes do not catch, particularly involving
 /// loop computations.
 struct ADCEPass : PassInfoMixin<ADCEPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "adce"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_ADCE_H

llvm/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h

bool runImpl(Function &F, AssumptionCache &AC, ScalarEvolution *SE_,
                DominatorTree *DT_);
 
   ScalarEvolution *SE = nullptr;
   DominatorTree *DT = nullptr;
 
   bool extractAlignmentInfo(CallInst *I, unsigned Idx, Value *&AAPtr,
                             const SCEV *&AlignSCEV, const SCEV *&OffSCEV);
   bool processAssumption(CallInst *I, unsigned Idx);
+
+  static StringRef name() { return "alignment-from-assumptions"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_ALIGNMENTFROMASSUMPTIONS_H

llvm/include/llvm/Transforms/Scalar/AnnotationRemarks.h

 #define LLVM_TRANSFORMS_SCALAR_ANNOTATIONREMARKS_H
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct AnnotationRemarksPass : public PassInfoMixin<AnnotationRemarksPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "annotation-remarks"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_ANNOTATIONREMARKS_H

llvm/include/llvm/Transforms/Scalar/BDCE.h

 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 // The Bit-Tracking Dead Code Elimination pass.
 struct BDCEPass : PassInfoMixin<BDCEPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "bdce"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_BDCE_H

llvm/include/llvm/Transforms/Scalar/CallSiteSplitting.h

 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct CallSiteSplittingPass : PassInfoMixin<CallSiteSplittingPass> {
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "callsite-splitting"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING_H

llvm/include/llvm/Transforms/Scalar/ConstantHoisting.h

 };
 
 } // end namespace consthoist
 
 class ConstantHoistingPass : public PassInfoMixin<ConstantHoistingPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "consthoist"; }
+
   // Glue for old PM.
   bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
                BlockFrequencyInfo *BFI, BasicBlock &Entry,
                ProfileSummaryInfo *PSI);
 
   void cleanup() {
     ClonedCastMap.clear();
     ConstIntCandVec.clear();

llvm/include/llvm/Transforms/Scalar/ConstraintElimination.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class ConstraintEliminationPass
     : public PassInfoMixin<ConstraintEliminationPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "constraint-elimination"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H

llvm/include/llvm/Transforms/Scalar/CorrelatedValuePropagation.h

 
 namespace llvm {
 
 class Function;
 
 struct CorrelatedValuePropagationPass
     : PassInfoMixin<CorrelatedValuePropagationPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "correlated-propagation"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_CORRELATEDVALUEPROPAGATION_H

llvm/include/llvm/Transforms/Scalar/DCE.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Basic Dead Code Elimination pass.
 class DCEPass : public PassInfoMixin<DCEPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "dce"; }
 };
 
 class RedundantDbgInstEliminationPass
     : public PassInfoMixin<RedundantDbgInstEliminationPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "redundant-dbg-inst-elim"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_DCE_H

llvm/include/llvm/Transforms/Scalar/DeadStoreElimination.h

 
 class Function;
 
 /// This class implements a trivial dead store elimination. We consider
 /// only the redundant stores that are local to a single Basic Block.
 class DSEPass : public PassInfoMixin<DSEPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  static StringRef name() { return "dse"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_DEADSTOREELIMINATION_H

llvm/include/llvm/Transforms/Scalar/DivRemPairs.h

 
 namespace llvm {
 
 /// Hoist/decompose integer division and remainder instructions to enable CFG
 /// improvements and better codegen.
 struct DivRemPairsPass : public PassInfoMixin<DivRemPairsPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "div-rem-pairs"; }
 };
 
 }
 #endif // LLVM_TRANSFORMS_SCALAR_DIVREMPAIRS_H
 

llvm/include/llvm/Transforms/Scalar/EarlyCSE.h

 /// expected that a later pass of GVN will catch the interesting/hard cases.
 struct EarlyCSEPass : PassInfoMixin<EarlyCSEPass> {
   EarlyCSEPass(bool UseMemorySSA = false) : UseMemorySSA(UseMemorySSA) {}
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   bool UseMemorySSA;
+
+  static StringRef name() { return "early-cse"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_EARLYCSE_H

llvm/include/llvm/Transforms/Scalar/Float2Int.h

 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class Float2IntPass : public PassInfoMixin<Float2IntPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "float2int"; }
+
   // Glue for old PM.
   bool runImpl(Function &F, const DominatorTree &DT);
 
 private:
   void findRoots(Function &F, const DominatorTree &DT);
   void seen(Instruction *I, ConstantRange R);
   ConstantRange badRange();
   ConstantRange unknownRange();

llvm/include/llvm/Transforms/Scalar/GVN.h

 /// The core GVN pass object.
 ///
 /// FIXME: We should have a good summary of the GVN algorithm implemented by
 /// this particular pass here.
 class GVN : public PassInfoMixin<GVN> {
   GVNOptions Options;
 
 public:
+  static StringRef name() { return "gvn"; }
+
   struct Expression;
 
   GVN(GVNOptions Options = {}) : Options(Options) {}
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   /// This removes the specified instruction from

 /// MemDep is enabled.
 FunctionPass *createGVNPass(bool NoMemDepAnalysis = false);
 
 /// A simple and fast domtree-based GVN pass to hoist common expressions
 /// from sibling branches.
 struct GVNHoistPass : PassInfoMixin<GVNHoistPass> {
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "gvn-hoist"; }
 };
 
 /// Uses an "inverted" value numbering to decide the similarity of
 /// expressions and sinks similar expressions into successors.
 struct GVNSinkPass : PassInfoMixin<GVNSinkPass> {
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "gvn-sink"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_GVN_H

llvm/include/llvm/Transforms/Scalar/GuardWidening.h

 namespace llvm {
 
 class Function;
 
 struct GuardWideningPass : public PassInfoMixin<GuardWideningPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "guard-widening"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_GUARDWIDENING_H

llvm/include/llvm/Transforms/Scalar/IVUsersPrinter.h

 /// Printer pass for the \c IVUsers for a loop.
 class IVUsersPrinterPass : public PassInfoMixin<IVUsersPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit IVUsersPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "print<iv-users>"; }
 };
 }
 
 #endif

llvm/include/llvm/Transforms/Scalar/IndVarSimplify.h

 class IndVarSimplifyPass : public PassInfoMixin<IndVarSimplifyPass> {
   /// Perform IV widening during the pass.
   bool WidenIndVars;
 
 public:
   IndVarSimplifyPass(bool WidenIndVars = true) : WidenIndVars(WidenIndVars) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "indvars"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_INDVARSIMPLIFY_H

llvm/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class IRCEPass : public PassInfoMixin<IRCEPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "irce"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_INDUCTIVERANGECHECKELIMINATION_H

llvm/include/llvm/Transforms/Scalar/InferAddressSpaces.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct InferAddressSpacesPass : PassInfoMixin<InferAddressSpacesPass> {
   InferAddressSpacesPass();
   InferAddressSpacesPass(unsigned AddressSpace);
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "infer-address-spaces"; }
 
 private:
   unsigned FlatAddrSpace = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H

llvm/include/llvm/Transforms/Scalar/InstSimplifyPass.h

 /// Many passes use instruction simplification as a library facility, but it may
 /// also be useful (in tests and other contexts) to have access to this very
 /// restricted transform at a pass granularity. However, for a much more
 /// powerful and comprehensive peephole optimization engine, see the
 /// `instcombine` pass instead.
 class InstSimplifyPass : public PassInfoMixin<InstSimplifyPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "instsimplify"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_INSTSIMPLIFYPASS_H

llvm/include/llvm/Transforms/Scalar/JumpThreading.h

#endif
 
   unsigned BBDupThreshold;
   unsigned DefaultBBDupThreshold;
   bool InsertFreezeWhenUnfoldingSelect;
 
 public:
   JumpThreadingPass(bool InsertFreezeWhenUnfoldingSelect = false, int T = -1);
 
+  static StringRef name() { return "jump-threading"; }
+
   // Glue for old PM.
   bool runImpl(Function &F, TargetLibraryInfo *TLI, LazyValueInfo *LVI,
                AAResults *AA, DomTreeUpdater *DTU, bool HasProfileData,
                std::unique_ptr<BlockFrequencyInfo> BFI,
                std::unique_ptr<BranchProbabilityInfo> BPI);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 

llvm/include/llvm/Transforms/Scalar/LICM.h

public:
   LICMPass()
       : LicmMssaOptCap(SetLicmMssaOptCap),
         LicmMssaNoAccForPromotionCap(SetLicmMssaNoAccForPromotionCap) {}
   LICMPass(unsigned LicmMssaOptCap, unsigned LicmMssaNoAccForPromotionCap)
       : LicmMssaOptCap(LicmMssaOptCap),
         LicmMssaNoAccForPromotionCap(LicmMssaNoAccForPromotionCap) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "licm"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LICM_H

llvm/include/llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h

 class LoopAccessInfoPrinterPass
     : public PassInfoMixin<LoopAccessInfoPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit LoopAccessInfoPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "print-access-info"; }
 };
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/Scalar/LoopDataPrefetch.h

 
 /// An optimization pass inserting data prefetches in loops.
 class LoopDataPrefetchPass : public PassInfoMixin<LoopDataPrefetchPass> {
 public:
   LoopDataPrefetchPass() = default;
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "loop-data-prefetch"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPDATAPREFETCH_H

llvm/include/llvm/Transforms/Scalar/LoopDeletion.h

 namespace llvm {
 
 class LoopDeletionPass : public PassInfoMixin<LoopDeletionPass> {
 public:
   LoopDeletionPass() = default;
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-deletion"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPDELETION_H

llvm/include/llvm/Transforms/Scalar/LoopDistribute.h

 
 namespace llvm {
 
 class Function;
 
 class LoopDistributePass : public PassInfoMixin<LoopDistributePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "loop-distribute"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPDISTRIBUTE_H

llvm/include/llvm/Transforms/Scalar/LoopFlatten.h

 
 namespace llvm {
 
 class LoopFlattenPass : public PassInfoMixin<LoopFlattenPass> {
 public:
   LoopFlattenPass() = default;
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "loop-flatten"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H

llvm/include/llvm/Transforms/Scalar/LoopFuse.h

 
 namespace llvm {
 
 class Function;
 
 class LoopFusePass : public PassInfoMixin<LoopFusePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "loop-fusion"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPFUSE_H

llvm/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h

struct DisableLIRP {
   static bool Memcpy;
 };
 
 /// Performs Loop Idiom Recognize Pass.
 class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-idiom"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPIDIOMRECOGNIZE_H

llvm/include/llvm/Transforms/Scalar/LoopInstSimplify.h

 class Loop;
 class LPMUpdater;
 
 /// Performs Loop Inst Simplify Pass.
 class LoopInstSimplifyPass : public PassInfoMixin<LoopInstSimplifyPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-instsimplify"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPINSTSIMPLIFY_H

llvm/include/llvm/Transforms/Scalar/LoopInterchange.h

 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
 struct LoopInterchangePass : public PassInfoMixin<LoopInterchangePass> {
   PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-interchange"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H

llvm/include/llvm/Transforms/Scalar/LoopLoadElimination.h

 namespace llvm {
 
 class Function;
 
 /// Pass to forward loads in a loop around the backedge to subsequent
 /// iterations.
 struct LoopLoadEliminationPass : public PassInfoMixin<LoopLoadEliminationPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "loop-load-elim"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPLOADELIMINATION_H

llvm/include/llvm/Transforms/Scalar/LoopPassManager.h

 // it differs from the primary template.
 template <>
 class PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
                   LPMUpdater &>
     : public PassInfoMixin<
           PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
                       LPMUpdater &>> {
 public:
+  static StringRef name() { return "loop-pass-manager"; }
+
   /// Construct a pass manager.
   ///
   /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
   explicit PassManager(bool DebugLogging = false)
       : DebugLogging(DebugLogging) {}
 
   // FIXME: These are equivalent to the default move constructor/move
   // assignment. However, using = default triggers linker errors due to the
struct RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
     : PassInfoMixin<
           RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
                               LoopStandardAnalysisResults &, LPMUpdater &>> {
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &) {
     (void)AM.template getResult<AnalysisT>(L, AR);
     return PreservedAnalyses::all();
   }
+  static StringRef name() { return "require-analysis"; }
 };
 
 /// An alias template to easily name a require analysis loop pass.
 template <typename AnalysisT>
 using RequireAnalysisLoopPass =
     RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
                         LoopStandardAnalysisResults &, LPMUpdater &>;
 
explicit FunctionToLoopPassAdaptor(std::unique_ptr<PassConceptT> Pass,
     LoopCanonicalizationFPM.addPass(LoopSimplifyPass());
     LoopCanonicalizationFPM.addPass(LCSSAPass());
   }
 
   /// Runs the loop passes across every loop in the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "function-to-loop-adaptor"; }
 
   bool isLoopNestMode() const { return LoopNestMode; }
 
 private:
   std::unique_ptr<PassConceptT> Pass;
 
   FunctionPassManager LoopCanonicalizationFPM;
 
class PrintLoopPass : public PassInfoMixin<PrintLoopPass> {
   std::string Banner;
 
 public:
   PrintLoopPass();
   PrintLoopPass(raw_ostream &OS, const std::string &Banner = "");
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
                         LoopStandardAnalysisResults &, LPMUpdater &);
+
+  static StringRef name() { return "print"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H

llvm/include/llvm/Transforms/Scalar/LoopPredication.h

 
 namespace llvm {
 
 /// Performs Loop Predication Pass.
 class LoopPredicationPass : public PassInfoMixin<LoopPredicationPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-predication"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPPREDICATION_H

llvm/include/llvm/Transforms/Scalar/LoopReroll.h

 namespace llvm {
 
 class Function;
 
 class LoopRerollPass : public PassInfoMixin<LoopRerollPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-reroll"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H

llvm/include/llvm/Transforms/Scalar/LoopRotation.h

 
 /// A simple loop rotation transformation.
 class LoopRotatePass : public PassInfoMixin<LoopRotatePass> {
 public:
   LoopRotatePass(bool EnableHeaderDuplication = true,
                  bool PrepareForLTO = false);
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-rotate"; }
 
 private:
   const bool EnableHeaderDuplication;
   const bool PrepareForLTO;
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPROTATION_H

llvm/include/llvm/Transforms/Scalar/LoopSimplifyCFG.h

 
 namespace llvm {
 
 /// Performs basic CFG simplifications to assist other loop passes.
 class LoopSimplifyCFGPass : public PassInfoMixin<LoopSimplifyCFGPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-simplifycfg"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPSIMPLIFYCFG_H

llvm/include/llvm/Transforms/Scalar/LoopSink.h

 /// A classic example is an extremely cold branch within a loop body.
 ///
 /// We do this as a separate pass so that during normal optimization all
 /// invariant operations can be held outside the loop body to simplify
 /// fundamental analyses and transforms of the loop.
 class LoopSinkPass : public PassInfoMixin<LoopSinkPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  static StringRef name() { return "loop-sink"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPSINK_H

llvm/include/llvm/Transforms/Scalar/LoopStrengthReduce.h

 class Loop;
 class LPMUpdater;
 
 /// Performs Loop Strength Reduce Pass.
 class LoopStrengthReducePass : public PassInfoMixin<LoopStrengthReducePass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-reduce"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPSTRENGTHREDUCE_H

llvm/include/llvm/Transforms/Scalar/LoopUnrollAndJamPass.h

 
 /// A simple loop rotation transformation.
 class LoopUnrollAndJamPass : public PassInfoMixin<LoopUnrollAndJamPass> {
   const int OptLevel;
 
 public:
   explicit LoopUnrollAndJamPass(int OptLevel = 2) : OptLevel(OptLevel) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "loop-unroll-and-jam"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H

llvm/include/llvm/Transforms/Scalar/LoopUnrollPass.h

 public:
   explicit LoopFullUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false,
                               bool ForgetSCEV = false)
       : OptLevel(OptLevel), OnlyWhenForced(OnlyWhenForced),
         ForgetSCEV(ForgetSCEV) {}
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "loop-unroll-full"; }
 };
 
 /// A set of parameters used to control various transforms performed by the
 /// LoopUnroll pass. Each of the boolean parameters can be set to:
 ///      true - enabling the transformation.
 ///      false - disabling the transformation.
 ///      None - relying on a global default.
 ///

 
 public:
   /// This uses the target information (or flags) to control the thresholds for
   /// different unrolling stategies but supports all of them.
   explicit LoopUnrollPass(LoopUnrollOptions UnrollOpts = {})
       : UnrollOpts(UnrollOpts) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "loop-unroll"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLPASS_H

llvm/include/llvm/Transforms/Scalar/LoopVersioningLICM.h

 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
 class LoopVersioningLICMPass : public PassInfoMixin<LoopVersioningLICMPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &LAR, LPMUpdater &U);
+  static StringRef name() { return "loop-versioning-licm"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H

llvm/include/llvm/Transforms/Scalar/LowerAtomic.h

 
 namespace llvm {
 
 /// A pass that lowers atomic intrinsic into non-atomic intrinsics.
 class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
   static bool isRequired() { return true; }
+  static StringRef name() { return "loweratomic"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOWERATOMIC_H

llvm/include/llvm/Transforms/Scalar/LowerConstantIntrinsics.h

public:
   ///
   /// This will lower all remaining 'objectsize' and 'is.constant'`
   /// intrinsic calls in this function, even when the argument has no known
   /// size or is not a constant respectively. The resulting constant is
   /// propagated and conditional branches are resolved where possible.
   /// This complements the Instruction Simplification and
   /// Instruction Combination passes of the optimized pass chain.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+
+  static StringRef name() { return "lower-constant-intrinsics"; }
 };
 
 }
 
 #endif

llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h

struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> {
   /// Run the pass over the function.
   ///
   /// This will lower all of the expect intrinsic calls in this function into
   /// branch weight metadata. That metadata will subsequently feed the analysis
   /// of the probabilities and frequencies of the CFG. After running this pass,
   /// no more expect intrinsics remain, allowing the rest of the optimizer to
   /// ignore them.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "lower-expect"; }
 };
 
 extern cl::opt<uint32_t> LikelyBranchWeight;
 extern cl::opt<uint32_t> UnlikelyBranchWeight;
 }
 
 #endif

llvm/include/llvm/Transforms/Scalar/LowerGuardIntrinsic.h

 #define LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct LowerGuardIntrinsicPass : PassInfoMixin<LowerGuardIntrinsicPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lower-guard-intrinsic"; }
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOWERGUARDINTRINSIC_H

llvm/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h

 class LowerMatrixIntrinsicsPass
     : public PassInfoMixin<LowerMatrixIntrinsicsPass> {
   bool Minimal;
 
 public:
   LowerMatrixIntrinsicsPass(bool Minimal = false) : Minimal(Minimal) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   static bool isRequired() { return true; }
+  static StringRef name() { return "lower-matrix-intrinsics"; }
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Scalar/LowerWidenableCondition.h

 #define LLVM_TRANSFORMS_SCALAR_LOWERWIDENABLECONDITION_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct LowerWidenableConditionPass : PassInfoMixin<LowerWidenableConditionPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lower-widenable-condition"; }
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOWERWIDENABLECONDITION_H

llvm/include/llvm/Transforms/Scalar/MakeGuardsExplicit.h

 #define LLVM_TRANSFORMS_SCALAR_MAKEGUARDSEXPLICIT_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct MakeGuardsExplicitPass : public PassInfoMixin<MakeGuardsExplicitPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "make-guards-explicit"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_MAKEGUARDSEXPLICIT_H

llvm/include/llvm/Transforms/Scalar/MemCpyOptimizer.h

class MemCpyOptPass : public PassInfoMixin<MemCpyOptPass> {
   MemorySSA *MSSA = nullptr;
   MemorySSAUpdater *MSSAU = nullptr;
 
 public:
   MemCpyOptPass() = default;
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "memcpyopt"; }
+
   // Glue for the old PM.
   bool runImpl(Function &F, MemoryDependenceResults *MD, TargetLibraryInfo *TLI,
                AAResults *AA, AssumptionCache *AC, DominatorTree *DT,
                MemorySSA *MSSA);
 
 private:
   // Helper functions
   bool processStore(StoreInst *SI, BasicBlock::iterator &BBI);

llvm/include/llvm/Transforms/Scalar/MergeICmps.h

 
 namespace llvm {
 
 class Function;
 
 struct MergeICmpsPass
     : PassInfoMixin<MergeICmpsPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "mergeicmps"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_MERGEICMPS_H

llvm/include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h

class MergedLoadStoreMotionPass
   MergedLoadStoreMotionOptions Options;
 
 public:
   MergedLoadStoreMotionPass()
       : MergedLoadStoreMotionPass(MergedLoadStoreMotionOptions()) {}
   MergedLoadStoreMotionPass(const MergedLoadStoreMotionOptions &PassOptions)
       : Options(PassOptions) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "mldst-motion"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_MERGEDLOADSTOREMOTION_H

llvm/include/llvm/Transforms/Scalar/NaryReassociate.h

 class TargetTransformInfo;
 class Type;
 class Value;
 
 class NaryReassociatePass : public PassInfoMixin<NaryReassociatePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "nary-reassociate"; }
+
   // Glue for old PM.
   bool runImpl(Function &F, AssumptionCache *AC_, DominatorTree *DT_,
                ScalarEvolution *SE_, TargetLibraryInfo *TLI_,
                TargetTransformInfo *TTI_);
 
 private:
   // Runs only one iteration of the dominator-based algorithm. See the header
   // comments for why we need multiple iterations.

llvm/include/llvm/Transforms/Scalar/NewGVN.h

 namespace llvm {
 
 class Function;
 
 class NewGVNPass : public PassInfoMixin<NewGVNPass> {
 public:
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
+  static StringRef name() { return "newgvn"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_NEWGVN_H
 

llvm/include/llvm/Transforms/Scalar/PartiallyInlineLibCalls.h

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class PartiallyInlineLibCallsPass
     : public PassInfoMixin<PartiallyInlineLibCallsPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "partially-inline-libcalls"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_PARTIALLYINLINELIBCALLS_H

llvm/include/llvm/Transforms/Scalar/Reassociate.h

struct PairMapValue {
     bool isValid() const { return Value1 && Value2; }
   };
   DenseMap<std::pair<Value *, Value *>, PairMapValue> PairMap[NumBinaryOps];
 
   bool MadeChange;
 
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "reassociate"; }
 
 private:
   void BuildRankMap(Function &F, ReversePostOrderTraversal<Function *> &RPOT);
   unsigned getRank(Value *V);
   void canonicalizeOperands(Instruction *I);
   void ReassociateExpression(BinaryOperator *I);
   void RewriteExprTree(BinaryOperator *I,
                        SmallVectorImpl<reassociate::ValueEntry> &Ops);

llvm/include/llvm/Transforms/Scalar/Reg2Mem.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class RegToMemPass : public PassInfoMixin<RegToMemPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "reg2mem"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_REG2MEM_H

llvm/include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h

 class TargetTransformInfo;
 class TargetLibraryInfo;
 
 struct RewriteStatepointsForGC : public PassInfoMixin<RewriteStatepointsForGC> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
   bool runOnFunction(Function &F, DominatorTree &, TargetTransformInfo &,
                      const TargetLibraryInfo &);
+
+  static StringRef name() { return "rewrite-statepoints-for-gc"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_REWRITESTATEPOINTSFORGC_H

llvm/include/llvm/Transforms/Scalar/SCCP.h

 namespace llvm {
 
 class PostDominatorTree;
 
 /// This pass performs function-level constant propagation and merging.
 class SCCPPass : public PassInfoMixin<SCCPPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "sccp"; }
 };
 
 /// Helper struct for bundling up the analysis results per function for IPSCCP.
 struct AnalysisResultsForFn {
   std::unique_ptr<PredicateInfo> PredInfo;
   DominatorTree *DT;
   PostDominatorTree *PDT;
 };
 
 bool runIPSCCP(Module &M, const DataLayout &DL,
                std::function<const TargetLibraryInfo &(Function &)> GetTLI,
                function_ref<AnalysisResultsForFn(Function &)> getAnalysis);
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SCCP_H

llvm/include/llvm/Transforms/Scalar/SROA.h

class SROA : public PassInfoMixin<SROA> {
   SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;
 
 public:
   SROA() = default;
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "sroa"; }
+
 private:
   friend class sroa::AllocaSliceRewriter;
   friend class sroa::SROALegacyPass;
 
   /// Helper used by both the public run method and by the legacy pass.
   PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
                             AssumptionCache &RunAC);
 

llvm/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct ScalarizeMaskedMemIntrinPass
     : public PassInfoMixin<ScalarizeMaskedMemIntrinPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "scalarize-masked-mem-intrin"; }
 };
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Scalar/Scalarizer.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class ScalarizerPass : public PassInfoMixin<ScalarizerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "scalarizer"; }
 };
 
 /// Create a legacy pass manager instance of the Scalarizer pass
 FunctionPass *createScalarizerPass();
 
 }
 
 #endif /* LLVM_TRANSFORMS_SCALAR_SCALARIZER_H */

llvm/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h

 
 class SeparateConstOffsetFromGEPPass
     : public PassInfoMixin<SeparateConstOffsetFromGEPPass> {
   bool LowerGEP;
 
 public:
   SeparateConstOffsetFromGEPPass(bool LowerGEP = false) : LowerGEP(LowerGEP) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "separate-const-offset-from-gep"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H

llvm/include/llvm/Transforms/Scalar/SimpleLoopUnswitch.h

 class SimpleLoopUnswitchPass : public PassInfoMixin<SimpleLoopUnswitchPass> {
   bool NonTrivial;
 
 public:
   SimpleLoopUnswitchPass(bool NonTrivial = false) : NonTrivial(NonTrivial) {}
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "simple-loop-unswitch"; }
 };
 
 /// Create the legacy pass object for the simple loop unswitcher.
 ///
 /// See the documentaion for `SimpleLoopUnswitchPass` for details.
 Pass *createSimpleLoopUnswitchLegacyPass(bool NonTrivial = false);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SIMPLELOOPUNSWITCH_H

llvm/include/llvm/Transforms/Scalar/SimplifyCFG.h

public:
   /// difficult.
   SimplifyCFGPass();
 
   /// Construct a pass with optional optimizations.
   SimplifyCFGPass(const SimplifyCFGOptions &PassOptions);
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "simplifycfg"; }
 };
 
 }
 
 #endif

llvm/include/llvm/Transforms/Scalar/Sink.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Move instructions into successor blocks when possible.
 class SinkingPass : public PassInfoMixin<SinkingPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "sink"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_SINK_H

llvm/include/llvm/Transforms/Scalar/SpeculateAroundPHIs.h

 /// pass, in contrast, is *only* interested in cases where despite no
 /// simplifications to the IR itself, speculation is *faster* to execute. The
 /// result of this is that the cost models which are appropriate to consider
 /// here are relatively simple ones around execution and codesize cost, without
 /// any need to consider simplifications or other transformations.
 struct SpeculateAroundPHIsPass : PassInfoMixin<SpeculateAroundPHIsPass> {
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "spec-phis"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_SPECULATEAROUNDPHIS_H

llvm/include/llvm/Transforms/Scalar/SpeculativeExecution.h

 namespace llvm {
 class SpeculativeExecutionPass
     : public PassInfoMixin<SpeculativeExecutionPass> {
 public:
   SpeculativeExecutionPass(bool OnlyIfDivergentTarget = false);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "speculative-execution"; }
+
   // Glue for old PM
   bool runImpl(Function &F, TargetTransformInfo *TTI);
 
 private:
   bool runOnBasicBlock(BasicBlock &B);
   bool considerHoistingFromTo(BasicBlock &FromBlock, BasicBlock &ToBlock);
 
   // If true, this pass is a nop unless the target architecture has branch
   // divergence.
   const bool OnlyIfDivergentTarget = false;
 
   TargetTransformInfo *TTI = nullptr;
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_SPECULATIVEEXECUTION_H

llvm/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class StraightLineStrengthReducePass
     : public PassInfoMixin<StraightLineStrengthReducePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "slsr"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H

llvm/include/llvm/Transforms/Scalar/StructurizeCFG.h

 //===- StructurizeCFG.h ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
 #define LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct StructurizeCFGPass : PassInfoMixin<StructurizeCFGPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "structurizecfg"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H

llvm/include/llvm/Transforms/Scalar/TailRecursionElimination.h

 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct TailCallElimPass : PassInfoMixin<TailCallElimPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "tailcallelim"; }
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H

llvm/include/llvm/Transforms/Scalar/WarnMissedTransforms.h

 
 // New pass manager boilerplate.
 class WarnMissedTransformationsPass
     : public PassInfoMixin<WarnMissedTransformationsPass> {
 public:
   explicit WarnMissedTransformationsPass() {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static StringRef name() { return "transform-warning"; }
 };
 
 // Legacy pass manager boilerplate.
 Pass *createWarnMissedTransformationsPass();
 void initializeWarnMissedTransformationsLegacyPass(PassRegistry &);
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_WARNMISSEDTRANSFORMS_H

llvm/include/llvm/Transforms/Utils/AddDiscriminators.h

 
 namespace llvm {
 
 class Function;
 
 class AddDiscriminatorsPass : public PassInfoMixin<AddDiscriminatorsPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "add-discriminators"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_ADDDISCRIMINATORS_H

llvm/include/llvm/Transforms/Utils/AssumeBundleBuilder.h

IntrinsicInst *buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge,
                                         Instruction *CtxI,
                                         AssumptionCache *AC = nullptr,
                                         DominatorTree *DT = nullptr);
 
 /// This pass attempts to minimize the number of assume without loosing any
 /// information.
 struct AssumeSimplifyPass : public PassInfoMixin<AssumeSimplifyPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "assume-simplify"; }
 };
 
 FunctionPass *createAssumeSimplifyPass();
 
 /// This pass will try to build an llvm.assume for every instruction in the
 /// function. Its main purpose is testing.
 struct AssumeBuilderPass : public PassInfoMixin<AssumeBuilderPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "assume-builder"; }
 };
 
 /// canonicalize the RetainedKnowledge RK. it is assumed that RK is part of
 /// Assume. This will return an empty RetainedKnowledge if the knowledge is
 /// useless.
 RetainedKnowledge simplifyRetainedKnowledge(CallBase *Assume,
                                             RetainedKnowledge RK,
                                             AssumptionCache *AC,
                                             DominatorTree *DT);
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Utils/BreakCriticalEdges.h

 #define LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct BreakCriticalEdgesPass : public PassInfoMixin<BreakCriticalEdgesPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "break-crit-edges"; }
 };
 } // namespace llvm
 #endif // LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H

llvm/include/llvm/Transforms/Utils/CanonicalizeAliases.h

 namespace llvm {
 
 /// Simple pass that canonicalizes aliases.
 class CanonicalizeAliasesPass : public PassInfoMixin<CanonicalizeAliasesPass> {
 public:
   CanonicalizeAliasesPass() = default;
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "canonicalize-aliases"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_CANONICALIZEALIASES_H

llvm/include/llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h

 class LPMUpdater;
 
 /// A pass that canonicalizes freeze instructions in a loop.
 class CanonicalizeFreezeInLoopsPass
     : public PassInfoMixin<CanonicalizeFreezeInLoopsPass> {
 public:
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "canon-freeze"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_CANONICALIZEFREEZEINLOOPS_H

llvm/include/llvm/Transforms/Utils/Debugify.h

llvm::ModulePass *createDebugifyModulePass(
     DebugInfoPerPassMap *DIPreservationMap = nullptr);
 llvm::FunctionPass *createDebugifyFunctionPass(
     enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
     llvm::StringRef NameOfWrappedPass = "",
     DebugInfoPerPassMap *DIPreservationMap = nullptr);
 
 struct NewPMDebugifyPass : public llvm::PassInfoMixin<NewPMDebugifyPass> {
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
+  static llvm::StringRef name() { return "debugify"; }
 };
 
 /// Track how much `debugify` information (in the `synthetic` mode only)
 /// has been lost.
 struct DebugifyStatistics {
   /// Number of missing dbg.values.
   unsigned NumDbgValuesMissing = 0;
 
llvm::FunctionPass *createCheckDebugifyFunctionPass(
     bool Strip = false, llvm::StringRef NameOfWrappedPass = "",
     DebugifyStatsMap *StatsMap = nullptr,
     enum DebugifyMode Mode = DebugifyMode::SyntheticDebugInfo,
     DebugInfoPerPassMap *DIPreservationMap = nullptr);
 
 struct NewPMCheckDebugifyPass
     : public llvm::PassInfoMixin<NewPMCheckDebugifyPass> {
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
+  static llvm::StringRef name() { return "check-debugify"; }
 };
 
 namespace llvm {
 void exportDebugifyStats(StringRef Path, const DebugifyStatsMap &Map);
 
 struct DebugifyEachInstrumentation {
   DebugifyStatsMap StatsMap;
 

llvm/include/llvm/Transforms/Utils/EntryExitInstrumenter.h

struct EntryExitInstrumenterPass
     : public PassInfoMixin<EntryExitInstrumenterPass> {
   EntryExitInstrumenterPass(bool PostInlining) : PostInlining(PostInlining) {}
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   bool PostInlining;
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "ee-instrument"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_ENTRYEXITINSTRUMENTER_H

llvm/include/llvm/Transforms/Utils/FixIrreducible.h

 //===- FixIrreducible.h - Convert irreducible control-flow into loops -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H
 #define LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct FixIrreduciblePass : PassInfoMixin<FixIrreduciblePass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "fix-irreducible"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_FIXIRREDUCIBLE_H

llvm/include/llvm/Transforms/Utils/HelloWorld.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class HelloWorldPass : public PassInfoMixin<HelloWorldPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "helloworld"; }
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_HELLOWORLD_H

llvm/include/llvm/Transforms/Utils/InjectTLIMappings.h

 
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 
 namespace llvm {
 class InjectTLIMappings : public PassInfoMixin<InjectTLIMappings> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "inject-tli-mappings"; }
 };
 
 // Legacy pass
 class InjectTLIMappingsLegacy : public FunctionPass {
 public:
   static char ID;
   InjectTLIMappingsLegacy() : FunctionPass(ID) {
     initializeInjectTLIMappingsLegacyPass(*PassRegistry::getPassRegistry());
   }
   void getAnalysisUsage(AnalysisUsage &AU) const override;
   bool runOnFunction(Function &F) override;
 };
 
 } // End namespace llvm
 #endif // LLVM_TRANSFORMS_UTILS_INJECTTLIMAPPINGS_H

llvm/include/llvm/Transforms/Utils/InstructionNamer.h

 //===- InstructionNamer.h - Give anonymous instructions names -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H
 #define LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct InstructionNamerPass : PassInfoMixin<InstructionNamerPass> {
   PreservedAnalyses run(Function &, FunctionAnalysisManager &);
+  static StringRef name() { return "instnamer"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_INSTRUCTIONNAMER_H

llvm/include/llvm/Transforms/Utils/LCSSA.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Converts loops into loop-closed SSA form.
 class LCSSAPass : public PassInfoMixin<LCSSAPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lcssa"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LCSSA_H

llvm/include/llvm/Transforms/Utils/LibCallsShrinkWrap.h

 #define LLVM_TRANSFORMS_UTILS_LIBCALLSSHRINKWRAP_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class LibCallsShrinkWrapPass : public PassInfoMixin<LibCallsShrinkWrapPass> {
 public:
-  static StringRef name() { return "LibCallsShrinkWrapPass"; }
-
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+
+  static StringRef name() { return "libcalls-shrinkwrap"; }
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LIBCALLSSHRINKWRAP_H

llvm/include/llvm/Transforms/Utils/LoopSimplify.h

 class LoopInfo;
 class MemorySSAUpdater;
 class ScalarEvolution;
 
 /// This pass is responsible for loop canonicalization.
 class LoopSimplifyPass : public PassInfoMixin<LoopSimplifyPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "loop-simplify"; }
 };
 
 /// Simplify each loop in a loop nest recursively.
 ///
 /// This takes a potentially un-simplified loop L (and its children) and turns
 /// it into a simplified loop nest with preheaders and single backedges. It will
 /// update \c DominatorTree, \c LoopInfo, \c ScalarEvolution and \c MemorySSA
 /// analyses if they're non-null, and LCSSA if \c PreserveLCSSA is true.
 bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE,
                   AssumptionCache *AC, MemorySSAUpdater *MSSAU,
                   bool PreserveLCSSA);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LOOPSIMPLIFY_H

llvm/include/llvm/Transforms/Utils/LoopVersioning.h

 };
 
 /// Expose LoopVersioning as a pass.  Currently this is only used for
 /// unit-testing.  It adds all memchecks necessary to remove all may-aliasing
 /// array accesses from the loop.
 class LoopVersioningPass : public PassInfoMixin<LoopVersioningPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  static StringRef name() { return "loop-versioning"; }
 };
 }
 
 #endif

llvm/include/llvm/Transforms/Utils/LowerInvoke.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class LowerInvokePass : public PassInfoMixin<LowerInvokePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lowerinvoke"; }
 };
 
 }
 
 #endif // LLVM_TRANSFORMS_UTILS_LOWERINVOKE_H

llvm/include/llvm/Transforms/Utils/LowerSwitch.h

 #ifndef LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H
 #define LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct LowerSwitchPass : public PassInfoMixin<LowerSwitchPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "lowerswitch"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LOWERSWITCH_H

llvm/include/llvm/Transforms/Utils/Mem2Reg.h

 
 namespace llvm {
 
 class Function;
 
 class PromotePass : public PassInfoMixin<PromotePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "mem2reg"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_MEM2REG_H

llvm/include/llvm/Transforms/Utils/MetaRenamer.h

 #ifndef LLVM_TRANSFORMS_UTILS_METARENAMER_H
 #define LLVM_TRANSFORMS_UTILS_METARENAMER_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct MetaRenamerPass : PassInfoMixin<MetaRenamerPass> {
   PreservedAnalyses run(Module &, ModuleAnalysisManager &);
+  static StringRef name() { return "metarenamer"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_METARENAMER_H

llvm/include/llvm/Transforms/Utils/NameAnonGlobals.h

 namespace llvm {
 
 /// Simple pass that provides a name to every anonymous globals.
 class NameAnonGlobalPass : public PassInfoMixin<NameAnonGlobalPass> {
 public:
   NameAnonGlobalPass() = default;
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "name-anon-globals"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_NAMEANONGLOBALS_H

llvm/include/llvm/Transforms/Utils/PredicateInfo.h

 /// Printer pass for \c PredicateInfo.
 class PredicateInfoPrinterPass
     : public PassInfoMixin<PredicateInfoPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit PredicateInfoPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "print-predicateinfo"; }
 };
 
 /// Verifier pass for \c PredicateInfo.
 struct PredicateInfoVerifierPass : PassInfoMixin<PredicateInfoVerifierPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H

llvm/include/llvm/Transforms/Utils/StripGCRelocates.h

 
 namespace llvm {
 
 class Function;
 
 class StripGCRelocates : public PassInfoMixin<StripGCRelocates> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "strip-gc-relocates"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_STRIPGCRELOCATES_H

llvm/include/llvm/Transforms/Utils/StripNonLineTableDebugInfo.h

 namespace llvm {
 
 class Module;
 
 class StripNonLineTableDebugInfoPass
     : public PassInfoMixin<StripNonLineTableDebugInfoPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "strip-nonlinetable-debuginfo"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_STRIPNONLINETABLEDEBUGINFO_H

llvm/include/llvm/Transforms/Utils/SymbolRewriter.h

public:
   RewriteSymbolPass() { loadAndParseMapFiles(); }
 
   RewriteSymbolPass(SymbolRewriter::RewriteDescriptorList &DL) {
     Descriptors.splice(Descriptors.begin(), DL);
   }
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
+  static StringRef name() { return "rewrite-symbols"; }
+
   // Glue for old PM
   bool runImpl(Module &M);
 
 private:
   void loadAndParseMapFiles();
 
   SymbolRewriter::RewriteDescriptorList Descriptors;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H

llvm/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h

 };
 
 Pass *createUnifyFunctionExitNodesPass();
 
 class UnifyFunctionExitNodesPass
     : public PassInfoMixin<UnifyFunctionExitNodesPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "mergereturn"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_UNIFYFUNCTIONEXITNODES_H

llvm/include/llvm/Transforms/Utils/UnifyLoopExits.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class UnifyLoopExitsPass : public PassInfoMixin<UnifyLoopExitsPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "unify-loop-exits"; }
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_UNIFYLOOPEXITS_H

llvm/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h

 
 namespace llvm {
 
 /// Simple pass that provides a name to every anonymous globals.
 class UniqueInternalLinkageNamesPass
     : public PassInfoMixin<UniqueInternalLinkageNamesPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "unique-internal-linkage-names"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H

llvm/include/llvm/Transforms/Vectorize/LoadStoreVectorizer.h

 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class LoadStoreVectorizerPass : public PassInfoMixin<LoadStoreVectorizerPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "load-store-vectorizer"; }
 };
 
 /// Create a legacy pass manager instance of the LoadStoreVectorizer pass
 Pass *createLoadStoreVectorizerPass();
 
 }
 
 #endif /* LLVM_TRANSFORMS_VECTORIZE_LOADSTOREVECTORIZER_H */

llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h

public:
   AAResults *AA;
   AssumptionCache *AC;
   std::function<const LoopAccessInfo &(Loop &)> *GetLAA;
   OptimizationRemarkEmitter *ORE;
   ProfileSummaryInfo *PSI;
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "loop-vectorize"; }
+
   // Shim for old PM.
   LoopVectorizeResult
   runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
           TargetTransformInfo &TTI_, DominatorTree &DT_,
           BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_, DemandedBits &DB_,
           AAResults &AA_, AssumptionCache &AC_,
           std::function<const LoopAccessInfo &(Loop &)> &GetLAA_,
           OptimizationRemarkEmitter &ORE_, ProfileSummaryInfo *PSI_);

llvm/include/llvm/Transforms/Vectorize/SLPVectorizer.h

struct SLPVectorizerPass : public PassInfoMixin<SLPVectorizerPass> {
   DominatorTree *DT = nullptr;
   AssumptionCache *AC = nullptr;
   DemandedBits *DB = nullptr;
   const DataLayout *DL = nullptr;
 
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
+  static StringRef name() { return "slp-vectorizer"; }
+
   // Glue for old PM.
   bool runImpl(Function &F, ScalarEvolution *SE_, TargetTransformInfo *TTI_,
                TargetLibraryInfo *TLI_, AAResults *AA_, LoopInfo *LI_,
                DominatorTree *DT_, AssumptionCache *AC_, DemandedBits *DB_,
                OptimizationRemarkEmitter *ORE_);
 
 private:
   /// Collect store and getelementptr instructions and organize them

llvm/include/llvm/Transforms/Vectorize/VectorCombine.h

 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Optimize scalar/vector interactions in IR using target cost models.
 struct VectorCombinePass : public PassInfoMixin<VectorCombinePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+  static StringRef name() { return "vector-combine"; }
 };
 
 }
 #endif // LLVM_TRANSFORMS_VECTORIZE_VECTORCOMBINE_H

llvm/lib/IR/PassInstrumentation.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-void PassInstrumentationCallbacks::addClassToPassName(StringRef ClassName,
-                                                      StringRef PassName) {
-  ClassToPassName[ClassName] = PassName.str();
-}
-
-StringRef
-PassInstrumentationCallbacks::getPassNameForClassName(StringRef ClassName) {
-  return ClassToPassName[ClassName];
-}
-
 AnalysisKey PassInstrumentationAnalysis::Key;
 
 bool isSpecialPass(StringRef PassID, const std::vector<StringRef> &Specials) {
   size_t Pos = PassID.find('<');
   StringRef Prefix = PassID;
   if (Pos != StringRef::npos)
     Prefix = PassID.substr(0, Pos);
   return any_of(Specials, [Prefix](StringRef S) { return Prefix.endswith(S); });
 }
 
 } // namespace llvm

llvm/lib/Passes/PassBuilder.cpp

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 : PassInfoMixin<NoOpModulePass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
     return PreservedAnalyses::all();
   }
 
-  static StringRef name() { return "NoOpModulePass"; }
+  static StringRef name() { return "no-op-module"; }
 };
 
 /// 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"; }
+  static StringRef name() { return "no-op-module"; }
 };
 
 /// No-op CGSCC pass which does nothing.
 struct NoOpCGSCCPass : PassInfoMixin<NoOpCGSCCPass> {
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &,
                         LazyCallGraph &, CGSCCUpdateResult &UR) {
     return PreservedAnalyses::all();
   }
-  static StringRef name() { return "NoOpCGSCCPass"; }
+  static StringRef name() { return "no-op-cgscc"; }
 };
 
 /// 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"; }
+  static StringRef name() { return "no-op-cgscc"; }
 };
 
 /// No-op function pass which does nothing.
 struct NoOpFunctionPass : PassInfoMixin<NoOpFunctionPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
     return PreservedAnalyses::all();
   }
-  static StringRef name() { return "NoOpFunctionPass"; }
+  static StringRef name() { return "no-op-function"; }
 };
 
 /// 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"; }
+  static StringRef name() { return "no-op-function"; }
 };
 
 /// No-op loop pass which does nothing.
 struct NoOpLoopPass : PassInfoMixin<NoOpLoopPass> {
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
                         LoopStandardAnalysisResults &, LPMUpdater &) {
     return PreservedAnalyses::all();
   }
-  static StringRef name() { return "NoOpLoopPass"; }
+  static StringRef name() { return "no-op-loop"; }
 };
 
 /// No-op loop analysis.
 class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
   friend AnalysisInfoMixin<NoOpLoopAnalysis>;
   static AnalysisKey Key;
 
 public:
   struct Result {};
   Result run(Loop &, LoopAnalysisManager &, LoopStandardAnalysisResults &) {
     return Result();
   }
-  static StringRef name() { return "NoOpLoopAnalysis"; }
+  static StringRef name() { return "no-op-loop"; }
 };
 
 AnalysisKey NoOpModuleAnalysis::Key;
 AnalysisKey NoOpCGSCCAnalysis::Key;
 AnalysisKey NoOpFunctionAnalysis::Key;
 AnalysisKey NoOpLoopAnalysis::Key;
 
 /// Whether or not we should populate a PassInstrumentationCallbacks's class to
 /// pass name map.
 ///
 /// This is for optimization purposes so we don't populate it if we never use
 /// it. This should be updated if new pass instrumentation wants to use the map.
 /// We currently only use this for --print-before/after.
-bool shouldPopulateClassToPassNames() {
-  return !printBeforePasses().empty() || !printAfterPasses().empty();
-}
+// bool shouldPopulateClassToPassNames() {
+//   return !printBeforePasses().empty() || !printAfterPasses().empty();
+// }
 
 } // namespace
 
 PassBuilder::PassBuilder(bool DebugLogging, TargetMachine *TM,
                          PipelineTuningOptions PTO, Optional<PGOOptions> PGOOpt,
                          PassInstrumentationCallbacks *PIC)
     : DebugLogging(DebugLogging), TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
   if (TM)
     TM->registerPassBuilderCallbacks(*this, DebugLogging);
-  if (PIC && shouldPopulateClassToPassNames()) {
-#define MODULE_PASS(NAME, CREATE_PASS)                                         \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define LOOP_PASS(NAME, CREATE_PASS)                                           \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define CGSCC_PASS(NAME, CREATE_PASS)                                          \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
-  PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
-#include "PassRegistry.def"
-  }
 }
 
 void PassBuilder::invokePeepholeEPCallbacks(
     FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
   for (auto &C : PeepholeEPCallbacks)
     C(FPM, Level);
 }
 
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
 
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   if (Name == NAME)                                                            \
     return true;
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
-  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
+  if (Name == "require<" + std::string(NAME) + ">" ||                          \
+      Name == "invalidate<" + std::string(NAME) + ">")                         \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
 static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
   // Explicitly handle pass manager names.
   if (Name == "cgscc")
     return true;
   if (Name == "function")
     return true;
 
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
   if (parseDevirtPassName(Name))
     return true;
 
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   if (Name == NAME)                                                            \
     return true;
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
-  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
+  if (Name == "require<" + std::string(NAME) + ">" ||                          \
+      Name == "invalidate<" + std::string(NAME) + ">")                         \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
 static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {

 
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME)                                                            \
     return true;
 #define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)                   \
   if (checkParametrizedPassName(Name, NAME))                                   \
     return true;
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
-  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
+  if (Name == "require<" + std::string(NAME) + ">" ||                          \
+      Name == "invalidate<" + std::string(NAME) + ">")                         \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
 static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks) {
   // Explicitly handle pass manager names.
   if (Name == "loop" || Name == "loop-mssa")
     return true;
 
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
 
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME)                                                            \
     return true;
 #define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)                       \
   if (checkParametrizedPassName(Name, NAME))                                   \
     return true;
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
-  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
+  if (Name == "require<" + std::string(NAME) + ">" ||                          \
+      Name == "invalidate<" + std::string(NAME) + ">")                         \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
 }
 
 Optional<std::vector<PassBuilder::PipelineElement>>
 PassBuilder::parsePipelineText(StringRef Text) {
Error PassBuilder::parseModulePass(ModulePassManager &MPM,
 
   // Finally expand the basic registered passes from the .inc file.
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   if (Name == NAME) {                                                          \
     MPM.addPass(CREATE_PASS);                                                  \
     return Error::success();                                                   \
   }
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
-  if (Name == "require<" NAME ">") {                                           \
+  if (Name == "require<" + std::string(NAME) + ">") {                          \
     MPM.addPass(                                                               \
         RequireAnalysisPass<                                                   \
             std::remove_reference<decltype(CREATE_PASS)>::type, Module>());    \
     return Error::success();                                                   \
   }                                                                            \
-  if (Name == "invalidate<" NAME ">") {                                        \
+  if (Name == "invalidate<" + std::string(NAME) + ">") {                       \
     MPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return Error::success();                                                   \
   }
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   if (Name == NAME) {                                                          \
     MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS));         \
     return Error::success();                                                   \

 
 // Now expand the basic registered passes from the .inc file.
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   if (Name == NAME) {                                                          \
     CGPM.addPass(CREATE_PASS);                                                 \
     return Error::success();                                                   \
   }
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
-  if (Name == "require<" NAME ">") {                                           \
+  if (Name == "require<" + std::string(NAME) + ">") {                          \
     CGPM.addPass(RequireAnalysisPass<                                          \
                  std::remove_reference<decltype(CREATE_PASS)>::type,           \
                  LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &,    \
                  CGSCCUpdateResult &>());                                      \
     return Error::success();                                                   \
   }                                                                            \
-  if (Name == "invalidate<" NAME ">") {                                        \
+  if (Name == "invalidate<" + std::string(NAME) + ">") {                       \
     CGPM.addPass(InvalidateAnalysisPass<                                       \
                  std::remove_reference<decltype(CREATE_PASS)>::type>());       \
     return Error::success();                                                   \
   }
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS));               \
     return Error::success();                                                   \
#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)                   \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     FPM.addPass(CREATE_PASS(Params.get()));                                    \
     return Error::success();                                                   \
   }
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
-  if (Name == "require<" NAME ">") {                                           \
+  if (Name == "require<" + std::string(NAME) + ">") {                          \
     FPM.addPass(                                                               \
         RequireAnalysisPass<                                                   \
             std::remove_reference<decltype(CREATE_PASS)>::type, Function>());  \
     return Error::success();                                                   \
   }                                                                            \
-  if (Name == "invalidate<" NAME ">") {                                        \
+  if (Name == "invalidate<" + std::string(NAME) + ">") {                       \
     FPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return Error::success();                                                   \
   }
 // FIXME: UseMemorySSA is set to false. Maybe we could do things like:
 //        bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
 //                              "guard-widening");
 //        The risk is that it may become obsolete if we're not careful.
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)                       \
   if (checkParametrizedPassName(Name, NAME)) {                                 \
     auto Params = parsePassParameters(PARSER, Name, NAME);                     \
     if (!Params)                                                               \
       return Params.takeError();                                               \
     LPM.addPass(CREATE_PASS(Params.get()));                                    \
     return Error::success();                                                   \
   }
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
-  if (Name == "require<" NAME ">") {                                           \
+  if (Name == "require<" + std::string(NAME) + ">") {                          \
     LPM.addPass(RequireAnalysisPass<                                           \
                 std::remove_reference<decltype(CREATE_PASS)>::type, Loop,      \
                 LoopAnalysisManager, LoopStandardAnalysisResults &,            \
                 LPMUpdater &>());                                              \
     return Error::success();                                                   \
   }                                                                            \
-  if (Name == "invalidate<" NAME ">") {                                        \
+  if (Name == "invalidate<" + std::string(NAME) + ">") {                       \
     LPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return Error::success();                                                   \
   }
 #include "PassRegistry.def"
 
   for (auto &C : LoopPipelineParsingCallbacks)
     if (C(Name, LPM, InnerPipeline))

llvm/lib/Passes/PassRegistry.def

 //
 //===----------------------------------------------------------------------===//
 
 // NOTE: NO INCLUDE GUARD DESIRED!
 
 #ifndef MODULE_ANALYSIS
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
-MODULE_ANALYSIS("callgraph", CallGraphAnalysis())
-MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis())
-MODULE_ANALYSIS("module-summary", ModuleSummaryIndexAnalysis())
-MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
-MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis())
-MODULE_ANALYSIS("stack-safety", StackSafetyGlobalAnalysis())
-MODULE_ANALYSIS("verify", VerifierAnalysis())
+#define MODULE_ANALYSIS_DEFAULT_NAME(CREATE_PASS) MODULE_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+MODULE_ANALYSIS_DEFAULT_NAME(CallGraphAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(LazyCallGraphAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(ModuleSummaryIndexAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(NoOpModuleAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(ProfileSummaryAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(StackSafetyGlobalAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(VerifierAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(ASanGlobalsMetadataAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(InlineAdvisorAnalysis())
+MODULE_ANALYSIS_DEFAULT_NAME(IRSimilarityAnalysis())
 MODULE_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
-MODULE_ANALYSIS("asan-globals-md", ASanGlobalsMetadataAnalysis())
-MODULE_ANALYSIS("inline-advisor", InlineAdvisorAnalysis())
-MODULE_ANALYSIS("ir-similarity", IRSimilarityAnalysis())
+#undef MODULE_ANALYSIS_DEFAULT_NAME
 
 #ifndef MODULE_ALIAS_ANALYSIS
-#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                               \
-  MODULE_ANALYSIS(NAME, CREATE_PASS)
+#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
-MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())
+#define MODULE_ALIAS_ANALYSIS_DEFAULT_NAME(CREATE_PASS) MODULE_ALIAS_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+MODULE_ALIAS_ANALYSIS_DEFAULT_NAME(GlobalsAA())
+#undef MODULE_ALIAS_ANALYSIS_DEFAULT_NAME
 #undef MODULE_ALIAS_ANALYSIS
 #undef MODULE_ANALYSIS
 
 #ifndef MODULE_PASS
 #define MODULE_PASS(NAME, CREATE_PASS)
 #endif
-MODULE_PASS("always-inline", AlwaysInlinerPass())
-MODULE_PASS("attributor", AttributorPass())
-MODULE_PASS("annotation2metadata", Annotation2MetadataPass())
-MODULE_PASS("called-value-propagation", CalledValuePropagationPass())
-MODULE_PASS("canonicalize-aliases", CanonicalizeAliasesPass())
-MODULE_PASS("cg-profile", CGProfilePass())
-MODULE_PASS("constmerge", ConstantMergePass())
-MODULE_PASS("cross-dso-cfi", CrossDSOCFIPass())
-MODULE_PASS("deadargelim", DeadArgumentEliminationPass())
-MODULE_PASS("elim-avail-extern", EliminateAvailableExternallyPass())
-MODULE_PASS("extract-blocks", BlockExtractorPass())
-MODULE_PASS("forceattrs", ForceFunctionAttrsPass())
-MODULE_PASS("function-import", FunctionImportPass())
-MODULE_PASS("globaldce", GlobalDCEPass())
-MODULE_PASS("globalopt", GlobalOptPass())
-MODULE_PASS("globalsplit", GlobalSplitPass())
-MODULE_PASS("hotcoldsplit", HotColdSplittingPass())
-MODULE_PASS("hwasan", HWAddressSanitizerPass(false, false))
+#define MODULE_PASS_DEFAULT_NAME(CREATE_PASS) MODULE_PASS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+MODULE_PASS_DEFAULT_NAME(AlwaysInlinerPass())
+MODULE_PASS_DEFAULT_NAME(AttributorPass())
+MODULE_PASS_DEFAULT_NAME(Annotation2MetadataPass())
+MODULE_PASS_DEFAULT_NAME(CalledValuePropagationPass())
+MODULE_PASS_DEFAULT_NAME(CanonicalizeAliasesPass())
+MODULE_PASS_DEFAULT_NAME(CGProfilePass())
+MODULE_PASS_DEFAULT_NAME(ConstantMergePass())
+MODULE_PASS_DEFAULT_NAME(CrossDSOCFIPass())
+MODULE_PASS_DEFAULT_NAME(DeadArgumentEliminationPass())
+MODULE_PASS_DEFAULT_NAME(EliminateAvailableExternallyPass())
+MODULE_PASS_DEFAULT_NAME(BlockExtractorPass())
+MODULE_PASS_DEFAULT_NAME(ForceFunctionAttrsPass())
+MODULE_PASS_DEFAULT_NAME(FunctionImportPass())
+MODULE_PASS_DEFAULT_NAME(GlobalDCEPass())
+MODULE_PASS_DEFAULT_NAME(GlobalOptPass())
+MODULE_PASS_DEFAULT_NAME(GlobalSplitPass())
+MODULE_PASS_DEFAULT_NAME(HotColdSplittingPass())
+MODULE_PASS_DEFAULT_NAME(InferFunctionAttrsPass())
+MODULE_PASS_DEFAULT_NAME(ModuleInlinerWrapperPass())
+MODULE_PASS_DEFAULT_NAME(GCOVProfilerPass())
+MODULE_PASS_DEFAULT_NAME(InstrOrderFilePass())
+MODULE_PASS_DEFAULT_NAME(InstrProfiling())
+MODULE_PASS_DEFAULT_NAME(InternalizePass())
+MODULE_PASS_DEFAULT_NAME(InvalidateAllAnalysesPass())
+MODULE_PASS_DEFAULT_NAME(IPSCCPPass())
+MODULE_PASS_DEFAULT_NAME(IROutlinerPass())
+MODULE_PASS_DEFAULT_NAME(LoopExtractorPass())
+MODULE_PASS_DEFAULT_NAME(LowerTypeTestsPass())
+MODULE_PASS_DEFAULT_NAME(MetaRenamerPass())
+MODULE_PASS_DEFAULT_NAME(MergeFunctionsPass())
+MODULE_PASS_DEFAULT_NAME(NameAnonGlobalPass())
+MODULE_PASS_DEFAULT_NAME(NoOpModulePass())
+MODULE_PASS_DEFAULT_NAME(ObjCARCAPElimPass())
+MODULE_PASS_DEFAULT_NAME(PartialInlinerPass())
+MODULE_PASS_DEFAULT_NAME(PGOIndirectCallPromotion())
+MODULE_PASS_DEFAULT_NAME(PGOInstrumentationGen())
+MODULE_PASS_DEFAULT_NAME(PGOInstrumentationUse())
+MODULE_PASS_DEFAULT_NAME(RewriteStatepointsForGC())
+MODULE_PASS_DEFAULT_NAME(RewriteSymbolPass())
+MODULE_PASS_DEFAULT_NAME(ReversePostOrderFunctionAttrsPass())
+MODULE_PASS_DEFAULT_NAME(SampleProfileLoaderPass())
+MODULE_PASS_DEFAULT_NAME(StripSymbolsPass())
+MODULE_PASS_DEFAULT_NAME(StripDeadDebugInfoPass())
+MODULE_PASS_DEFAULT_NAME(StripDeadPrototypesPass())
+MODULE_PASS_DEFAULT_NAME(StripDebugDeclarePass())
+MODULE_PASS_DEFAULT_NAME(StripNonDebugSymbolsPass())
+MODULE_PASS_DEFAULT_NAME(StripNonLineTableDebugInfoPass())
+MODULE_PASS_DEFAULT_NAME(SyntheticCountsPropagation())
+MODULE_PASS_DEFAULT_NAME(UniqueInternalLinkageNamesPass())
+MODULE_PASS_DEFAULT_NAME(VerifierPass())
+MODULE_PASS_DEFAULT_NAME(WholeProgramDevirtPass())
+MODULE_PASS_DEFAULT_NAME(DataFlowSanitizerPass())
+MODULE_PASS_DEFAULT_NAME(HWAddressSanitizerPass(false, false))
+MODULE_PASS_DEFAULT_NAME(MemorySanitizerPass({}))
+MODULE_PASS_DEFAULT_NAME(ThreadSanitizerPass())
+MODULE_PASS_DEFAULT_NAME(ModuleSanitizerCoveragePass())
+MODULE_PASS_DEFAULT_NAME(ModuleMemProfilerPass())
+MODULE_PASS_DEFAULT_NAME(PoisonCheckingPass())
+MODULE_PASS_DEFAULT_NAME(PseudoProbeUpdatePass())
 MODULE_PASS("khwasan", HWAddressSanitizerPass(true, true))
-MODULE_PASS("inferattrs", InferFunctionAttrsPass())
-MODULE_PASS("inliner-wrapper", ModuleInlinerWrapperPass())
 MODULE_PASS("inliner-wrapper-no-mandatory-first", ModuleInlinerWrapperPass(
   getInlineParams(), 
   DebugLogging, 
   false))
-MODULE_PASS("insert-gcov-profiling", GCOVProfilerPass())
-MODULE_PASS("instrorderfile", InstrOrderFilePass())
-MODULE_PASS("instrprof", InstrProfiling())
-MODULE_PASS("internalize", InternalizePass())
-MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-MODULE_PASS("ipsccp", IPSCCPPass())
-MODULE_PASS("iroutliner", IROutlinerPass())
 MODULE_PASS("print-ir-similarity", IRSimilarityAnalysisPrinterPass(dbgs()))
-MODULE_PASS("loop-extract", LoopExtractorPass())
-MODULE_PASS("lowertypetests", LowerTypeTestsPass())
-MODULE_PASS("metarenamer", MetaRenamerPass())
-MODULE_PASS("mergefunc", MergeFunctionsPass())
-MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
-MODULE_PASS("no-op-module", NoOpModulePass())
-MODULE_PASS("objc-arc-apelim", ObjCARCAPElimPass())
-MODULE_PASS("partial-inliner", PartialInlinerPass())
-MODULE_PASS("pgo-icall-prom", PGOIndirectCallPromotion())
-MODULE_PASS("pgo-instr-gen", PGOInstrumentationGen())
-MODULE_PASS("pgo-instr-use", PGOInstrumentationUse())
 MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs()))
 MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs()))
 MODULE_PASS("print", PrintModulePass(dbgs()))
 MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
 MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs()))
 MODULE_PASS("print-must-be-executed-contexts", MustBeExecutedContextPrinterPass(dbgs()))
 MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(dbgs()))
 MODULE_PASS("print<module-debuginfo>", ModuleDebugInfoPrinterPass(dbgs()))
-MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC())
-MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
-MODULE_PASS("rpo-function-attrs", ReversePostOrderFunctionAttrsPass())
-MODULE_PASS("sample-profile", SampleProfileLoaderPass())
 MODULE_PASS("scc-oz-module-inliner",
   buildInlinerPipeline(OptimizationLevel::Oz, ThinOrFullLTOPhase::None))
 MODULE_PASS("loop-extract-single", LoopExtractorPass(1))
-MODULE_PASS("strip", StripSymbolsPass())
-MODULE_PASS("strip-dead-debug-info", StripDeadDebugInfoPass())
 MODULE_PASS("pseudo-probe", SampleProfileProbePass(TM))
-MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
-MODULE_PASS("strip-debug-declare", StripDebugDeclarePass())
-MODULE_PASS("strip-nondebug", StripNonDebugSymbolsPass())
-MODULE_PASS("strip-nonlinetable-debuginfo", StripNonLineTableDebugInfoPass())
-MODULE_PASS("synthetic-counts-propagation", SyntheticCountsPropagation())
-MODULE_PASS("unique-internal-linkage-names", UniqueInternalLinkageNamesPass())
-MODULE_PASS("verify", VerifierPass())
-MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass())
-MODULE_PASS("dfsan", DataFlowSanitizerPass())
 MODULE_PASS("asan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/false, false, true, false))
-MODULE_PASS("msan-module", MemorySanitizerPass({}))
-MODULE_PASS("tsan-module", ThreadSanitizerPass())
 MODULE_PASS("kasan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/true, false, true, false))
-MODULE_PASS("sancov-module", ModuleSanitizerCoveragePass())
-MODULE_PASS("memprof-module", ModuleMemProfilerPass())
-MODULE_PASS("poison-checking", PoisonCheckingPass())
-MODULE_PASS("pseudo-probe-update", PseudoProbeUpdatePass())
+#undef MODULE_PASS_DEFAULT_NAME
 #undef MODULE_PASS
 
 #ifndef CGSCC_ANALYSIS
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 #endif
-CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
-CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy())
+#define CGSCC_ANALYSIS_DEFAULT_NAME(CREATE_PASS) CGSCC_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+CGSCC_ANALYSIS_DEFAULT_NAME(NoOpCGSCCAnalysis())
+CGSCC_ANALYSIS_DEFAULT_NAME(FunctionAnalysisManagerCGSCCProxy())
 CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
+#undef CGSCC_ANALYSIS_DEFAULT_NAME
 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
-CGSCC_PASS("argpromotion", ArgumentPromotionPass())
-CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
-CGSCC_PASS("attributor-cgscc", AttributorCGSCCPass())
-CGSCC_PASS("inline", InlinerPass())
-CGSCC_PASS("openmpopt", OpenMPOptPass())
-CGSCC_PASS("coro-split", CoroSplitPass())
-CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
+#define CGSCC_PASS_DEFAULT_NAME(CREATE_PASS) CGSCC_PASS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+CGSCC_PASS_DEFAULT_NAME(ArgumentPromotionPass())
+CGSCC_PASS_DEFAULT_NAME(InvalidateAllAnalysesPass())
+CGSCC_PASS_DEFAULT_NAME(PostOrderFunctionAttrsPass())
+CGSCC_PASS_DEFAULT_NAME(AttributorCGSCCPass())
+CGSCC_PASS_DEFAULT_NAME(InlinerPass())
+CGSCC_PASS_DEFAULT_NAME(OpenMPOptPass())
+CGSCC_PASS_DEFAULT_NAME(CoroSplitPass())
+CGSCC_PASS_DEFAULT_NAME(NoOpCGSCCPass())
+#undef CGSCC_PASS_DEFAULT_NAME
 #undef CGSCC_PASS
 
 #ifndef FUNCTION_ANALYSIS
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 #endif
-FUNCTION_ANALYSIS("aa", AAManager())
-FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())
-FUNCTION_ANALYSIS("block-freq", BlockFrequencyAnalysis())
-FUNCTION_ANALYSIS("branch-prob", BranchProbabilityAnalysis())
-FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
-FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis())
-FUNCTION_ANALYSIS("demanded-bits", DemandedBitsAnalysis())
-FUNCTION_ANALYSIS("domfrontier", DominanceFrontierAnalysis())
-FUNCTION_ANALYSIS("func-properties", FunctionPropertiesAnalysis())
-FUNCTION_ANALYSIS("loops", LoopAnalysis())
-FUNCTION_ANALYSIS("lazy-value-info", LazyValueAnalysis())
-FUNCTION_ANALYSIS("da", DependenceAnalysis())
-FUNCTION_ANALYSIS("inliner-size-estimator", InlineSizeEstimatorAnalysis())
-FUNCTION_ANALYSIS("memdep", MemoryDependenceAnalysis())
-FUNCTION_ANALYSIS("memoryssa", MemorySSAAnalysis())
-FUNCTION_ANALYSIS("phi-values", PhiValuesAnalysis())
-FUNCTION_ANALYSIS("regions", RegionInfoAnalysis())
-FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis())
-FUNCTION_ANALYSIS("opt-remark-emit", OptimizationRemarkEmitterAnalysis())
-FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis())
-FUNCTION_ANALYSIS("stack-safety-local", StackSafetyAnalysis())
-FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
+#define FUNCTION_ANALYSIS_DEFAULT_NAME(CREATE_PASS) FUNCTION_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+FUNCTION_ANALYSIS_DEFAULT_NAME(AAManager())
+FUNCTION_ANALYSIS_DEFAULT_NAME(AssumptionAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(BlockFrequencyAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(BranchProbabilityAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(DominatorTreeAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(PostDominatorTreeAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(DemandedBitsAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(DominanceFrontierAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(FunctionPropertiesAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(LoopAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(LazyValueAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(DependenceAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(InlineSizeEstimatorAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(MemoryDependenceAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(MemorySSAAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(PhiValuesAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(RegionInfoAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(NoOpFunctionAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(OptimizationRemarkEmitterAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(ScalarEvolutionAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(StackSafetyAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(TargetLibraryAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(VerifierAnalysis())
+FUNCTION_ANALYSIS_DEFAULT_NAME(DivergenceAnalysis())
 FUNCTION_ANALYSIS("targetir",
                   TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis())
-FUNCTION_ANALYSIS("verify", VerifierAnalysis())
 FUNCTION_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
-FUNCTION_ANALYSIS("divergence", DivergenceAnalysis())
+#undef FUNCTION_ANALYSIS_DEFAULT_NAME
 
 #ifndef FUNCTION_ALIAS_ANALYSIS
 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)                             \
   FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 #endif
-FUNCTION_ALIAS_ANALYSIS("basic-aa", BasicAA())
-FUNCTION_ALIAS_ANALYSIS("cfl-anders-aa", CFLAndersAA())
-FUNCTION_ALIAS_ANALYSIS("cfl-steens-aa", CFLSteensAA())
-FUNCTION_ALIAS_ANALYSIS("objc-arc-aa", objcarc::ObjCARCAA())
-FUNCTION_ALIAS_ANALYSIS("scev-aa", SCEVAA())
-FUNCTION_ALIAS_ANALYSIS("scoped-noalias-aa", ScopedNoAliasAA())
-FUNCTION_ALIAS_ANALYSIS("tbaa", TypeBasedAA())
+#define FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(CREATE_PASS) FUNCTION_ALIAS_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(BasicAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(CFLAndersAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(CFLSteensAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(objcarc::ObjCARCAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(SCEVAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(ScopedNoAliasAA())
+FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME(TypeBasedAA())
+#undef FUNCTION_ALIAS_ANALYSIS_DEFAULT_NAME
 #undef FUNCTION_ALIAS_ANALYSIS
 #undef FUNCTION_ANALYSIS
 
 #ifndef FUNCTION_PASS
 #define FUNCTION_PASS(NAME, CREATE_PASS)
 #endif
-FUNCTION_PASS("aa-eval", AAEvaluator())
-FUNCTION_PASS("adce", ADCEPass())
-FUNCTION_PASS("add-discriminators", AddDiscriminatorsPass())
-FUNCTION_PASS("aggressive-instcombine", AggressiveInstCombinePass())
-FUNCTION_PASS("assume-builder", AssumeBuilderPass())
-FUNCTION_PASS("assume-simplify", AssumeSimplifyPass())
-FUNCTION_PASS("alignment-from-assumptions", AlignmentFromAssumptionsPass())
-FUNCTION_PASS("annotation-remarks", AnnotationRemarksPass())
-FUNCTION_PASS("bdce", BDCEPass())
-FUNCTION_PASS("bounds-checking", BoundsCheckingPass())
-FUNCTION_PASS("break-crit-edges", BreakCriticalEdgesPass())
-FUNCTION_PASS("callsite-splitting", CallSiteSplittingPass())
-FUNCTION_PASS("consthoist", ConstantHoistingPass())
-FUNCTION_PASS("constraint-elimination", ConstraintEliminationPass())
-FUNCTION_PASS("chr", ControlHeightReductionPass())
-FUNCTION_PASS("coro-early", CoroEarlyPass())
-FUNCTION_PASS("coro-elide", CoroElidePass())
-FUNCTION_PASS("coro-cleanup", CoroCleanupPass())
-FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())
-FUNCTION_PASS("dce", DCEPass())
-FUNCTION_PASS("div-rem-pairs", DivRemPairsPass())
-FUNCTION_PASS("dse", DSEPass())
-FUNCTION_PASS("dot-cfg", CFGPrinterPass())
-FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass())
-FUNCTION_PASS("early-cse", EarlyCSEPass(/*UseMemorySSA=*/false))
+#define FUNCTION_PASS_DEFAULT_NAME(CREATE_PASS) FUNCTION_PASS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+FUNCTION_PASS_DEFAULT_NAME(AAEvaluator())
+FUNCTION_PASS_DEFAULT_NAME(ADCEPass())
+FUNCTION_PASS_DEFAULT_NAME(AddDiscriminatorsPass())
+FUNCTION_PASS_DEFAULT_NAME(AggressiveInstCombinePass())
+FUNCTION_PASS_DEFAULT_NAME(AssumeBuilderPass())
+FUNCTION_PASS_DEFAULT_NAME(AssumeSimplifyPass())
+FUNCTION_PASS_DEFAULT_NAME(AlignmentFromAssumptionsPass())
+FUNCTION_PASS_DEFAULT_NAME(AnnotationRemarksPass())
+FUNCTION_PASS_DEFAULT_NAME(BDCEPass())
+FUNCTION_PASS_DEFAULT_NAME(BoundsCheckingPass())
+FUNCTION_PASS_DEFAULT_NAME(BreakCriticalEdgesPass())
+FUNCTION_PASS_DEFAULT_NAME(CallSiteSplittingPass())
+FUNCTION_PASS_DEFAULT_NAME(ConstantHoistingPass())
+FUNCTION_PASS_DEFAULT_NAME(ConstraintEliminationPass())
+FUNCTION_PASS_DEFAULT_NAME(ControlHeightReductionPass())
+FUNCTION_PASS_DEFAULT_NAME(CoroEarlyPass())
+FUNCTION_PASS_DEFAULT_NAME(CoroElidePass())
+FUNCTION_PASS_DEFAULT_NAME(CoroCleanupPass())
+FUNCTION_PASS_DEFAULT_NAME(CorrelatedValuePropagationPass())
+FUNCTION_PASS_DEFAULT_NAME(DCEPass())
+FUNCTION_PASS_DEFAULT_NAME(DivRemPairsPass())
+FUNCTION_PASS_DEFAULT_NAME(DSEPass())
+FUNCTION_PASS_DEFAULT_NAME(CFGPrinterPass())
+FUNCTION_PASS_DEFAULT_NAME(CFGOnlyPrinterPass())
+FUNCTION_PASS_DEFAULT_NAME(EarlyCSEPass(/*UseMemorySSA=*/false))
+FUNCTION_PASS_DEFAULT_NAME(EntryExitInstrumenterPass(/*PostInlining=*/false))
+FUNCTION_PASS_DEFAULT_NAME(FixIrreduciblePass())
+FUNCTION_PASS_DEFAULT_NAME(MakeGuardsExplicitPass())
+FUNCTION_PASS_DEFAULT_NAME(GVNHoistPass())
+FUNCTION_PASS_DEFAULT_NAME(GVNSinkPass())
+FUNCTION_PASS_DEFAULT_NAME(HelloWorldPass())
+FUNCTION_PASS_DEFAULT_NAME(InferAddressSpacesPass())
+FUNCTION_PASS_DEFAULT_NAME(InstCombinePass())
+FUNCTION_PASS_DEFAULT_NAME(InstCountPass())
+FUNCTION_PASS_DEFAULT_NAME(InstSimplifyPass())
+FUNCTION_PASS_DEFAULT_NAME(InvalidateAllAnalysesPass())
+FUNCTION_PASS_DEFAULT_NAME(IRCEPass())
+FUNCTION_PASS_DEFAULT_NAME(Float2IntPass())
+FUNCTION_PASS_DEFAULT_NAME(NoOpFunctionPass())
+FUNCTION_PASS_DEFAULT_NAME(LibCallsShrinkWrapPass())
+FUNCTION_PASS_DEFAULT_NAME(LintPass())
+FUNCTION_PASS_DEFAULT_NAME(InjectTLIMappings())
+FUNCTION_PASS_DEFAULT_NAME(InstructionNamerPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerAtomicPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerExpectIntrinsicPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerGuardIntrinsicPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerConstantIntrinsicsPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerMatrixIntrinsicsPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerWidenableConditionPass())
+FUNCTION_PASS_DEFAULT_NAME(GuardWideningPass())
+FUNCTION_PASS_DEFAULT_NAME(LoadStoreVectorizerPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopSimplifyPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopSinkPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopUnrollAndJamPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopFlattenPass())
+FUNCTION_PASS_DEFAULT_NAME(LowerInvokePass())
+FUNCTION_PASS_DEFAULT_NAME(LowerSwitchPass())
+FUNCTION_PASS_DEFAULT_NAME(PromotePass())
+FUNCTION_PASS_DEFAULT_NAME(MemCpyOptPass())
+FUNCTION_PASS_DEFAULT_NAME(MergeICmpsPass())
+FUNCTION_PASS_DEFAULT_NAME(UnifyFunctionExitNodesPass())
+FUNCTION_PASS_DEFAULT_NAME(NaryReassociatePass())
+FUNCTION_PASS_DEFAULT_NAME(NewGVNPass())
+FUNCTION_PASS_DEFAULT_NAME(JumpThreadingPass())
+FUNCTION_PASS_DEFAULT_NAME(PartiallyInlineLibCallsPass())
+FUNCTION_PASS_DEFAULT_NAME(LCSSAPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopDataPrefetchPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopLoadEliminationPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopFusePass())
+FUNCTION_PASS_DEFAULT_NAME(LoopDistributePass())
+FUNCTION_PASS_DEFAULT_NAME(LoopVersioningPass())
+FUNCTION_PASS_DEFAULT_NAME(ObjCARCOptPass())
+FUNCTION_PASS_DEFAULT_NAME(ObjCARCContractPass())
+FUNCTION_PASS_DEFAULT_NAME(ObjCARCExpandPass())
+FUNCTION_PASS_DEFAULT_NAME(PGOMemOPSizeOpt())
+FUNCTION_PASS_DEFAULT_NAME(ReassociatePass())
+FUNCTION_PASS_DEFAULT_NAME(RedundantDbgInstEliminationPass())
+FUNCTION_PASS_DEFAULT_NAME(RegToMemPass())
+FUNCTION_PASS_DEFAULT_NAME(ScalarizeMaskedMemIntrinPass())
+FUNCTION_PASS_DEFAULT_NAME(ScalarizerPass())
+FUNCTION_PASS_DEFAULT_NAME(SeparateConstOffsetFromGEPPass())
+FUNCTION_PASS_DEFAULT_NAME(SCCPPass())
+FUNCTION_PASS_DEFAULT_NAME(SimplifyCFGPass())
+FUNCTION_PASS_DEFAULT_NAME(SinkingPass())
+FUNCTION_PASS_DEFAULT_NAME(SLPVectorizerPass())
+FUNCTION_PASS_DEFAULT_NAME(StraightLineStrengthReducePass())
+FUNCTION_PASS_DEFAULT_NAME(SpeculativeExecutionPass())
+FUNCTION_PASS_DEFAULT_NAME(SpeculateAroundPHIsPass())
+FUNCTION_PASS_DEFAULT_NAME(SROA())
+FUNCTION_PASS_DEFAULT_NAME(StripGCRelocates())
+FUNCTION_PASS_DEFAULT_NAME(StructurizeCFGPass())
+FUNCTION_PASS_DEFAULT_NAME(TailCallElimPass())
+FUNCTION_PASS_DEFAULT_NAME(UnifyLoopExitsPass())
+FUNCTION_PASS_DEFAULT_NAME(VectorCombinePass())
+FUNCTION_PASS_DEFAULT_NAME(VerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(DominatorTreeVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(LoopVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(MemorySSAVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(RegionInfoVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(SafepointIRVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(ScalarEvolutionVerifierPass())
+FUNCTION_PASS_DEFAULT_NAME(CFGViewerPass())
+FUNCTION_PASS_DEFAULT_NAME(CFGOnlyViewerPass())
+FUNCTION_PASS_DEFAULT_NAME(WarnMissedTransformationsPass())
+FUNCTION_PASS_DEFAULT_NAME(AddressSanitizerPass(false, false, false))
+FUNCTION_PASS_DEFAULT_NAME(MemorySanitizerPass({}))
+FUNCTION_PASS_DEFAULT_NAME(ThreadSanitizerPass())
+FUNCTION_PASS_DEFAULT_NAME(MemProfilerPass())
 FUNCTION_PASS("early-cse-memssa", EarlyCSEPass(/*UseMemorySSA=*/true))
-FUNCTION_PASS("ee-instrument", EntryExitInstrumenterPass(/*PostInlining=*/false))
-FUNCTION_PASS("fix-irreducible", FixIrreduciblePass())
-FUNCTION_PASS("make-guards-explicit", MakeGuardsExplicitPass())
 FUNCTION_PASS("post-inline-ee-instrument", EntryExitInstrumenterPass(/*PostInlining=*/true))
-FUNCTION_PASS("gvn-hoist", GVNHoistPass())
-FUNCTION_PASS("gvn-sink", GVNSinkPass())
-FUNCTION_PASS("helloworld", HelloWorldPass())
-FUNCTION_PASS("infer-address-spaces", InferAddressSpacesPass())
-FUNCTION_PASS("instcombine", InstCombinePass())
-FUNCTION_PASS("instcount", InstCountPass())
-FUNCTION_PASS("instsimplify", InstSimplifyPass())
-FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-FUNCTION_PASS("irce", IRCEPass())
-FUNCTION_PASS("float2int", Float2IntPass())
-FUNCTION_PASS("no-op-function", NoOpFunctionPass())
-FUNCTION_PASS("libcalls-shrinkwrap", LibCallsShrinkWrapPass())
-FUNCTION_PASS("lint", LintPass())
-FUNCTION_PASS("inject-tli-mappings", InjectTLIMappings())
-FUNCTION_PASS("instnamer", InstructionNamerPass())
-FUNCTION_PASS("loweratomic", LowerAtomicPass())
-FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
-FUNCTION_PASS("lower-guard-intrinsic", LowerGuardIntrinsicPass())
-FUNCTION_PASS("lower-constant-intrinsics", LowerConstantIntrinsicsPass())
-FUNCTION_PASS("lower-matrix-intrinsics", LowerMatrixIntrinsicsPass())
 FUNCTION_PASS("lower-matrix-intrinsics-minimal", LowerMatrixIntrinsicsPass(true))
-FUNCTION_PASS("lower-widenable-condition", LowerWidenableConditionPass())
-FUNCTION_PASS("guard-widening", GuardWideningPass())
-FUNCTION_PASS("load-store-vectorizer", LoadStoreVectorizerPass())
-FUNCTION_PASS("loop-simplify", LoopSimplifyPass())
-FUNCTION_PASS("loop-sink", LoopSinkPass())
-FUNCTION_PASS("loop-unroll-and-jam", LoopUnrollAndJamPass())
-FUNCTION_PASS("loop-flatten", LoopFlattenPass())
-FUNCTION_PASS("lowerinvoke", LowerInvokePass())
-FUNCTION_PASS("lowerswitch", LowerSwitchPass())
-FUNCTION_PASS("mem2reg", PromotePass())
-FUNCTION_PASS("memcpyopt", MemCpyOptPass())
-FUNCTION_PASS("mergeicmps", MergeICmpsPass())
-FUNCTION_PASS("mergereturn", UnifyFunctionExitNodesPass())
-FUNCTION_PASS("nary-reassociate", NaryReassociatePass())
-FUNCTION_PASS("newgvn", NewGVNPass())
-FUNCTION_PASS("jump-threading", JumpThreadingPass())
-FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass())
-FUNCTION_PASS("lcssa", LCSSAPass())
-FUNCTION_PASS("loop-data-prefetch", LoopDataPrefetchPass())
-FUNCTION_PASS("loop-load-elim", LoopLoadEliminationPass())
-FUNCTION_PASS("loop-fusion", LoopFusePass())
-FUNCTION_PASS("loop-distribute", LoopDistributePass())
-FUNCTION_PASS("loop-versioning", LoopVersioningPass())
-FUNCTION_PASS("objc-arc", ObjCARCOptPass())
-FUNCTION_PASS("objc-arc-contract", ObjCARCContractPass())
-FUNCTION_PASS("objc-arc-expand", ObjCARCExpandPass())
-FUNCTION_PASS("pgo-memop-opt", PGOMemOPSizeOpt())
 FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<block-freq>", BlockFrequencyPrinterPass(dbgs()))
 FUNCTION_PASS("print<branch-prob>", BranchProbabilityPrinterPass(dbgs()))
 FUNCTION_PASS("print<da>", DependenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<divergence>", DivergenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))

 FUNCTION_PASS("print<regions>", RegionInfoPrinterPass(dbgs()))
 FUNCTION_PASS("print<scalar-evolution>", ScalarEvolutionPrinterPass(dbgs()))
 FUNCTION_PASS("print<stack-safety-local>", StackSafetyPrinterPass(dbgs()))
 // TODO: rename to print<foo> after NPM switch
 FUNCTION_PASS("print-alias-sets", AliasSetsPrinterPass(dbgs()))
 FUNCTION_PASS("print-predicateinfo", PredicateInfoPrinterPass(dbgs()))
 FUNCTION_PASS("print-mustexecute", MustExecutePrinterPass(dbgs()))
 FUNCTION_PASS("print-memderefs", MemDerefPrinterPass(dbgs()))
-FUNCTION_PASS("reassociate", ReassociatePass())
-FUNCTION_PASS("redundant-dbg-inst-elim", RedundantDbgInstEliminationPass())
-FUNCTION_PASS("reg2mem", RegToMemPass())
-FUNCTION_PASS("scalarize-masked-mem-intrin", ScalarizeMaskedMemIntrinPass())
-FUNCTION_PASS("scalarizer", ScalarizerPass())
-FUNCTION_PASS("separate-const-offset-from-gep", SeparateConstOffsetFromGEPPass())
-FUNCTION_PASS("sccp", SCCPPass())
-FUNCTION_PASS("simplifycfg", SimplifyCFGPass())
-FUNCTION_PASS("sink", SinkingPass())
-FUNCTION_PASS("slp-vectorizer", SLPVectorizerPass())
-FUNCTION_PASS("slsr", StraightLineStrengthReducePass())
-FUNCTION_PASS("speculative-execution", SpeculativeExecutionPass())
-FUNCTION_PASS("spec-phis", SpeculateAroundPHIsPass())
-FUNCTION_PASS("sroa", SROA())
-FUNCTION_PASS("strip-gc-relocates", StripGCRelocates())
-FUNCTION_PASS("structurizecfg", StructurizeCFGPass())
-FUNCTION_PASS("tailcallelim", TailCallElimPass())
-FUNCTION_PASS("unify-loop-exits", UnifyLoopExitsPass())
-FUNCTION_PASS("vector-combine", VectorCombinePass())
-FUNCTION_PASS("verify", VerifierPass())
-FUNCTION_PASS("verify<domtree>", DominatorTreeVerifierPass())
-FUNCTION_PASS("verify<loops>", LoopVerifierPass())
-FUNCTION_PASS("verify<memoryssa>", MemorySSAVerifierPass())
-FUNCTION_PASS("verify<regions>", RegionInfoVerifierPass())
-FUNCTION_PASS("verify<safepoint-ir>", SafepointIRVerifierPass())
-FUNCTION_PASS("verify<scalar-evolution>", ScalarEvolutionVerifierPass())
-FUNCTION_PASS("view-cfg", CFGViewerPass())
-FUNCTION_PASS("view-cfg-only", CFGOnlyViewerPass())
-FUNCTION_PASS("transform-warning", WarnMissedTransformationsPass())
-FUNCTION_PASS("asan", AddressSanitizerPass(false, false, false))
 FUNCTION_PASS("kasan", AddressSanitizerPass(true, false, false))
-FUNCTION_PASS("msan", MemorySanitizerPass({}))
 FUNCTION_PASS("kmsan", MemorySanitizerPass({0, false, /*Kernel=*/true}))
-FUNCTION_PASS("tsan", ThreadSanitizerPass())
-FUNCTION_PASS("memprof", MemProfilerPass())
+#undef FUNCTION_PASS_DEFAULT_NAME
 #undef FUNCTION_PASS
 
 #ifndef FUNCTION_PASS_WITH_PARAMS
 #define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 #endif
 FUNCTION_PASS_WITH_PARAMS("loop-unroll",
                            [](LoopUnrollOptions Opts) {
                              return LoopUnrollPass(Opts);
FUNCTION_PASS_WITH_PARAMS("print<stack-lifetime>",
                              return StackLifetimePrinterPass(dbgs(), Type);
                            },
                            parseStackLifetimeOptions)
 #undef FUNCTION_PASS_WITH_PARAMS
 
 #ifndef LOOP_ANALYSIS
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)
 #endif
-LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis())
-LOOP_ANALYSIS("access-info", LoopAccessAnalysis())
-LOOP_ANALYSIS("ddg", DDGAnalysis())
-LOOP_ANALYSIS("iv-users", IVUsersAnalysis())
+#define LOOP_ANALYSIS_DEFAULT_NAME(CREATE_PASS) LOOP_ANALYSIS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+LOOP_ANALYSIS_DEFAULT_NAME(NoOpLoopAnalysis())
+LOOP_ANALYSIS_DEFAULT_NAME(LoopAccessAnalysis())
+LOOP_ANALYSIS_DEFAULT_NAME(DDGAnalysis())
+LOOP_ANALYSIS_DEFAULT_NAME(IVUsersAnalysis())
 LOOP_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
+#undef LOOP_ANALYSIS_DEFAULT_NAME
 #undef LOOP_ANALYSIS
 
 #ifndef LOOP_PASS
 #define LOOP_PASS(NAME, CREATE_PASS)
 #endif
-LOOP_PASS("canon-freeze", CanonicalizeFreezeInLoopsPass())
-LOOP_PASS("dot-ddg", DDGDotPrinterPass())
-LOOP_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-LOOP_PASS("licm", LICMPass())
-LOOP_PASS("loop-idiom", LoopIdiomRecognizePass())
-LOOP_PASS("loop-instsimplify", LoopInstSimplifyPass())
-LOOP_PASS("loop-interchange", LoopInterchangePass())
-LOOP_PASS("loop-rotate", LoopRotatePass())
-LOOP_PASS("no-op-loop", NoOpLoopPass())
+#define LOOP_PASS_DEFAULT_NAME(CREATE_PASS) LOOP_PASS(decltype(CREATE_PASS)::name(), CREATE_PASS)
+LOOP_PASS_DEFAULT_NAME(CanonicalizeFreezeInLoopsPass())
+LOOP_PASS_DEFAULT_NAME(DDGDotPrinterPass())
+LOOP_PASS_DEFAULT_NAME(InvalidateAllAnalysesPass())
+LOOP_PASS_DEFAULT_NAME(LICMPass())
+LOOP_PASS_DEFAULT_NAME(LoopIdiomRecognizePass())
+LOOP_PASS_DEFAULT_NAME(LoopInstSimplifyPass())
+LOOP_PASS_DEFAULT_NAME(LoopInterchangePass())
+LOOP_PASS_DEFAULT_NAME(LoopRotatePass())
+LOOP_PASS_DEFAULT_NAME(NoOpLoopPass())
+LOOP_PASS_DEFAULT_NAME(LoopDeletionPass())
+LOOP_PASS_DEFAULT_NAME(LoopSimplifyCFGPass())
+LOOP_PASS_DEFAULT_NAME(LoopStrengthReducePass())
+LOOP_PASS_DEFAULT_NAME(IndVarSimplifyPass())
+LOOP_PASS_DEFAULT_NAME(LoopFullUnrollPass())
+LOOP_PASS_DEFAULT_NAME(LoopPredicationPass())
+LOOP_PASS_DEFAULT_NAME(GuardWideningPass())
+LOOP_PASS_DEFAULT_NAME(SimpleLoopUnswitchPass())
+LOOP_PASS_DEFAULT_NAME(LoopRerollPass())
+LOOP_PASS_DEFAULT_NAME(LoopVersioningLICMPass())
 LOOP_PASS("print", PrintLoopPass(dbgs()))
-LOOP_PASS("loop-deletion", LoopDeletionPass())
-LOOP_PASS("loop-simplifycfg", LoopSimplifyCFGPass())
-LOOP_PASS("loop-reduce", LoopStrengthReducePass())
-LOOP_PASS("indvars", IndVarSimplifyPass())
-LOOP_PASS("loop-unroll-full", LoopFullUnrollPass())
 LOOP_PASS("print-access-info", LoopAccessInfoPrinterPass(dbgs()))
 LOOP_PASS("print<ddg>", DDGAnalysisPrinterPass(dbgs()))
 LOOP_PASS("print<iv-users>", IVUsersPrinterPass(dbgs()))
 LOOP_PASS("print<loopnest>", LoopNestPrinterPass(dbgs()))
 LOOP_PASS("print<loop-cache-cost>", LoopCachePrinterPass(dbgs()))
-LOOP_PASS("loop-predication", LoopPredicationPass())
-LOOP_PASS("guard-widening", GuardWideningPass())
-LOOP_PASS("simple-loop-unswitch", SimpleLoopUnswitchPass())
-LOOP_PASS("loop-reroll", LoopRerollPass())
-LOOP_PASS("loop-versioning-licm", LoopVersioningLICMPass())
+#undef LOOP_PASS_DEFAULT_NAME
 #undef LOOP_PASS
 
 #ifndef LOOP_PASS_WITH_PARAMS
 #define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 #endif
 LOOP_PASS_WITH_PARAMS("unswitch",
                            [](bool NonTrivial) {
                              return SimpleLoopUnswitchPass(NonTrivial);
                            },
                            parseLoopUnswitchOptions)
 #undef LOOP_PASS_WITH_PARAMS

llvm/lib/Passes/StandardInstrumentations.cpp

void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
   if (StoreModuleDesc)
     popModuleDesc(PassID);
 
   SmallString<20> Banner = formatv("*** IR Dump After {0} ***", PassID);
   unwrapAndPrint(dbgs(), IR, Banner, forcePrintModuleIR());
 }
 
 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
-  StringRef PassName = PIC->getPassNameForClassName(PassID);
-  if (!StoreModuleDesc || !shouldPrintAfterPass(PassName))
+  if (!StoreModuleDesc || !shouldPrintAfterPass(PassID))
     return;
 
   if (isIgnored(PassID))
     return;
 
   const Module *M;
   std::string Extra;
   StringRef StoredPassID;
   std::tie(M, Extra, StoredPassID) = popModuleDesc(PassID);
   // Additional filtering (e.g. -filter-print-func) can lead to module
   // printing being skipped.
   if (!M)
     return;
 
   SmallString<20> Banner =
       formatv("*** IR Dump After {0} *** invalidated: ", PassID);
   printIR(dbgs(), M, Banner, Extra);
 }
 
 bool PrintIRInstrumentation::shouldPrintBeforePass(StringRef PassID) {
   if (shouldPrintBeforeAll())
     return true;
 
-  StringRef PassName = PIC->getPassNameForClassName(PassID);
-  return llvm::is_contained(printBeforePasses(), PassName);
+  return llvm::is_contained(printBeforePasses(), PassID);
 }
 
 bool PrintIRInstrumentation::shouldPrintAfterPass(StringRef PassID) {
   if (shouldPrintAfterAll())
     return true;
 
-  StringRef PassName = PIC->getPassNameForClassName(PassID);
-  return llvm::is_contained(printAfterPasses(), PassName);
+  return llvm::is_contained(printAfterPasses(), PassID);
 }
 
 void PrintIRInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   this->PIC = &PIC;
 
   // BeforePass callback is not just for printing, it also saves a Module
   // for later use in AfterPassInvalidated.

llvm/lib/Target/AMDGPU/AMDGPU.h

 FunctionPass *createAMDGPUPropagateAttributesEarlyPass(const TargetMachine *);
 ModulePass *createAMDGPUPropagateAttributesLatePass(const TargetMachine *);
 FunctionPass *createAMDGPURewriteOutArgumentsPass();
 FunctionPass *createSIModeRegisterPass();
 
 struct AMDGPUSimplifyLibCallsPass : PassInfoMixin<AMDGPUSimplifyLibCallsPass> {
   AMDGPUSimplifyLibCallsPass(TargetMachine &TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-simplifylib"; }
 
 private:
   TargetMachine &TM;
 };
 
 struct AMDGPUUseNativeCallsPass : PassInfoMixin<AMDGPUUseNativeCallsPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-usenative"; }
 };
 
 void initializeAMDGPUDAGToDAGISelPass(PassRegistry&);
 
 void initializeAMDGPUMachineCFGStructurizerPass(PassRegistry&);
 extern char &AMDGPUMachineCFGStructurizerID;
 
 void initializeAMDGPUAlwaysInlinePass(PassRegistry&);

 
 ModulePass *createAMDGPULowerKernelAttributesPass();
 void initializeAMDGPULowerKernelAttributesPass(PassRegistry &);
 extern char &AMDGPULowerKernelAttributesID;
 
 struct AMDGPULowerKernelAttributesPass
     : PassInfoMixin<AMDGPULowerKernelAttributesPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-lower-kernel-attributes"; }
 };
 
 void initializeAMDGPUPropagateAttributesEarlyPass(PassRegistry &);
 extern char &AMDGPUPropagateAttributesEarlyID;
 
 struct AMDGPUPropagateAttributesEarlyPass
     : PassInfoMixin<AMDGPUPropagateAttributesEarlyPass> {
   AMDGPUPropagateAttributesEarlyPass(TargetMachine &TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-propagate-attributes-early"; }
 
 private:
   TargetMachine &TM;
 };
 
 void initializeAMDGPUPropagateAttributesLatePass(PassRegistry &);
 extern char &AMDGPUPropagateAttributesLateID;
 
 struct AMDGPUPropagateAttributesLatePass
     : PassInfoMixin<AMDGPUPropagateAttributesLatePass> {
   AMDGPUPropagateAttributesLatePass(TargetMachine &TM) : TM(TM) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-propagate-attributes-late"; }
 
 private:
   TargetMachine &TM;
 };
 
 void initializeAMDGPURewriteOutArgumentsPass(PassRegistry &);
 extern char &AMDGPURewriteOutArgumentsID;
 

 
 FunctionPass *createAMDGPUPromoteAllocaToVector();
 void initializeAMDGPUPromoteAllocaToVectorPass(PassRegistry&);
 extern char &AMDGPUPromoteAllocaToVectorID;
 
 struct AMDGPUPromoteAllocaPass : PassInfoMixin<AMDGPUPromoteAllocaPass> {
   AMDGPUPromoteAllocaPass(TargetMachine &TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-promote-alloca"; }
 
 private:
   TargetMachine &TM;
 };
 
 struct AMDGPUPromoteAllocaToVectorPass
     : PassInfoMixin<AMDGPUPromoteAllocaToVectorPass> {
   AMDGPUPromoteAllocaToVectorPass(TargetMachine &TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-promote-alloca-to-vector"; }
 
 private:
   TargetMachine &TM;
 };
 
 Pass *createAMDGPUStructurizeCFGPass();
 FunctionPass *createAMDGPUISelDag(
   TargetMachine *TM = nullptr,
   CodeGenOpt::Level OptLevel = CodeGenOpt::Default);
 ModulePass *createAMDGPUAlwaysInlinePass(bool GlobalOpt = true);
 
 struct AMDGPUAlwaysInlinePass : PassInfoMixin<AMDGPUAlwaysInlinePass> {
   AMDGPUAlwaysInlinePass(bool GlobalOpt = true) : GlobalOpt(GlobalOpt) {}
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-always-inline"; }
 
 private:
   bool GlobalOpt;
 };
 
 ModulePass *createR600OpenCLImageTypeLoweringPass();
 FunctionPass *createAMDGPUAnnotateUniformValues();
 
 ModulePass *createAMDGPUPrintfRuntimeBinding();
 void initializeAMDGPUPrintfRuntimeBindingPass(PassRegistry&);
 extern char &AMDGPUPrintfRuntimeBindingID;
 
 struct AMDGPUPrintfRuntimeBindingPass
     : PassInfoMixin<AMDGPUPrintfRuntimeBindingPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-printf-runtime-binding"; }
 };
 
 ModulePass* createAMDGPUUnifyMetadataPass();
 void initializeAMDGPUUnifyMetadataPass(PassRegistry&);
 extern char &AMDGPUUnifyMetadataID;
 
 struct AMDGPUUnifyMetadataPass : PassInfoMixin<AMDGPUUnifyMetadataPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "amdgpu-unify-metadata"; }
 };
 
 void initializeSIOptimizeExecMaskingPreRAPass(PassRegistry&);
 extern char &SIOptimizeExecMaskingPreRAID;
 
 void initializeAMDGPUAnnotateUniformValuesPass(PassRegistry&);
 extern char &AMDGPUAnnotateUniformValuesPassID;
 

llvm/lib/Target/AMDGPU/AMDGPUAliasAnalysis.h

class AMDGPUAA : public AnalysisInfoMixin<AMDGPUAA> {
   static AnalysisKey Key;
 
 public:
   using Result = AMDGPUAAResult;
 
   AMDGPUAAResult run(Function &F, AnalysisManager<Function> &AM) {
     return AMDGPUAAResult(F.getParent()->getDataLayout());
   }
+
+  static StringRef name() { return "amdgpu-aa"; }
 };
 
 /// Legacy wrapper pass to provide the AMDGPUAAResult object.
 class AMDGPUAAWrapperPass : public ImmutablePass {
   std::unique_ptr<AMDGPUAAResult> Result;
 
 public:
   static char ID;

llvm/lib/Target/BPF/BPF.h

class BPFAbstractMemberAccessPass
     : public PassInfoMixin<BPFAbstractMemberAccessPass> {
   BPFTargetMachine *TM;
 
 public:
   BPFAbstractMemberAccessPass(BPFTargetMachine *TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "bpf-abstract-member-access"; }
 };
 
 class BPFPreserveDITypePass : public PassInfoMixin<BPFPreserveDITypePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   static bool isRequired() { return true; }
+  static StringRef name() { return "bpf-preserve-di-type"; }
 };
 
 class BPFAdjustOptPass : public PassInfoMixin<BPFAdjustOptPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+  static StringRef name() { return "bpf-adjust-opt"; }
 };
 } // namespace llvm
 
 #endif

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.h

 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 
 namespace llvm {
 
 struct HexagonLoopIdiomRecognitionPass
     : PassInfoMixin<HexagonLoopIdiomRecognitionPass> {
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "hexagon-loop-idiom"; }
 };
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONLOOPIDIOMRECOGNITION_H

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.h

 /// Hexagon Vector Loop Carried Reuse Pass
 struct HexagonVectorLoopCarriedReusePass
     : public PassInfoMixin<HexagonVectorLoopCarriedReusePass> {
   HexagonVectorLoopCarriedReusePass() {}
 
   /// Run pass over the Loop.
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &LAM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
+  static StringRef name() { return "hexagon-vlcr"; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONVLCR_H

llvm/lib/Target/NVPTX/NVPTX.h

 FunctionPass *createNVPTXLowerAllocaPass();
 MachineFunctionPass *createNVPTXPeephole();
 MachineFunctionPass *createNVPTXProxyRegErasurePass();
 
 struct NVVMIntrRangePass : PassInfoMixin<NVVMIntrRangePass> {
   NVVMIntrRangePass();
   NVVMIntrRangePass(unsigned SmVersion) : SmVersion(SmVersion) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "nvvm-intr-range"; }
 
 private:
   unsigned SmVersion;
 };
 
 struct NVVMReflectPass : PassInfoMixin<NVVMReflectPass> {
   NVVMReflectPass();
   NVVMReflectPass(unsigned SmVersion) : SmVersion(SmVersion) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+  static StringRef name() { return "nvvm-reflect"; }
 
 private:
   unsigned SmVersion;
 };
 
 namespace NVPTX {
 enum DrvInterface {
   NVCL,