POC. [PassBuilder] introduce a separate pass-pipeline parsing API

[fedor.sergeev]

Summary

Separating all the parsing APIs into PipelineParser. For now just a proof-of-concept.

[fedor.sergeev]

This is not yet complete (in particular parseAA is still in PassBuilder atm).
However I would like to get a feedback on overall organization.
Right now:

• PipelineParser is a nested class in PassBuilder
• it is created for a single text-pipeline-parsing query
• text is processed into a pipeline vector and kept in the parser
• callbacks still reside in pass builder, accessed through a reference to pass builder kept in the parser
• callbacks take both Parser and array of Elements

[philip.pfaffe]

IMO it makes sense to separate parsing of the pipeline text and the pipeline tree more. Parsing the pipeline string into the tree of pipeline elements is an operation that happens once and as the very first thing, after which the string is not needed anymore. The PassBuilder could do that part, and then call the PipelineParser to further parse the tree. Otherwise this looks great!

llvm/include/llvm/Passes/PassBuilder.h

85

Inner classes are auto-friends, are they not?

[philip.pfaffe]

To clarify that: Currently clients are offered two APIs to populate a PassManager: One that consumes PipelineElements and one that consumes a string. When you have a PipelineElement in hand, you could use both, because it's mostly just a StringRef! I'd like to avoid that ambiguity.

llvm/include/llvm/Passes/PassBuilder.h

 /// of the built-in passes, and those may reference these members during
 /// construction.
 class PassBuilder {
   TargetMachine *TM;
   Optional<PGOOptions> PGOOpt;
   PassInstrumentationCallbacks *PIC;
 
 public:
+  /// This class performs all the tasks related to parsing of the textual
+  /// representation for the pass pipeline.
+  class PipelineParser {
+
+    friend class PassBuilder;
+
+    PipelineParser(PassBuilder &PB, StringRef PipelineText = StringRef())
+        : PB(PB), PipelineText(PipelineText) {}
+
+    ~PipelineParser() = default;
+
+  public:
     /// A struct to capture parsed pass pipeline names.
     ///
     /// A pipeline is defined as a series of names, each of which may in itself
-  /// recursively contain a nested pipeline. A name is either the name of a pass
-  /// (e.g. "instcombine") or the name of a pipeline type (e.g. "cgscc"). If the
-  /// name is the name of a pass, the InnerPipeline is empty, since passes
-  /// cannot contain inner pipelines. See parsePassPipeline() for a more
-  /// detailed description of the textual pipeline format.
+    /// recursively contain a nested pipeline. A name is either the name of a
+    /// pass (e.g. "instcombine") or the name of a pipeline type (e.g. "cgscc").
+    /// If the name is the name of a pass, the InnerPipeline is empty, since
+    /// passes cannot contain inner pipelines. See parsePassPipeline() for a
+    /// more detailed description of the textual pipeline format.
     struct PipelineElement {
       StringRef Name;
       std::vector<PipelineElement> InnerPipeline;
     };
 
+    /// Individual pipeline element parsing methods.
+    Error parseLoopPassPipeline(LoopPassManager &LPM,
+                                ArrayRef<PipelineElement> Pipeline,
+                                bool VerifyEachPass, bool DebugLogging) const;
+    Error parseFunctionPassPipeline(FunctionPassManager &FPM,
+                                    ArrayRef<PipelineElement> Pipeline,
+                                    bool VerifyEachPass,
+                                    bool DebugLogging) const;
+    Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
+                                 ArrayRef<PipelineElement> Pipeline,
+                                 bool VerifyEachPass, bool DebugLogging) const;
+    Error parseModulePassPipeline(ModulePassManager &MPM,
+                                  ArrayRef<PipelineElement> Pipeline,
+                                  bool VerifyEachPass, bool DebugLogging) const;
+
+    /// This utility template takes care of adding require<> and invalidate<>
+    /// passes for an analysis to a given \c PassManager. It is intended to be
+    /// used during parsing of a pass pipeline when parsing a single
+    /// PipelineName. When registering a new function analysis FancyAnalysis
+    /// with the pass pipeline name "fancy-analysis", a matching
+    /// ParsePipelineCallback could look like this:
+    ///
+    /// static bool parseFunctionPipeline(StringRef Name, FunctionPassManager
+    /// &FPM,
+    ///                                   PipelineParser Parser,
+    ///                                   ArrayRef<PipelineElement> P) {
+    ///   if (Parser.parseAnalysisUtilityPasses<FancyAnalysis>(
+    ///            "fancy-analysis", Name, FPM))
+    ///     return true;
+    ///   return false;
+    /// }
+    template <typename AnalysisT, typename IRUnitT, typename AnalysisManagerT,
+              typename... ExtraArgTs>
+    bool parseAnalysisUtilityPasses(
+        StringRef AnalysisName, StringRef PipelineName,
+        PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) const {
+      if (!PipelineName.endswith(">"))
+        return false;
+      // See if this is an invalidate<> pass name
+      if (PipelineName.startswith("invalidate<")) {
+        PipelineName = PipelineName.substr(11, PipelineName.size() - 12);
+        if (PipelineName != AnalysisName)
+          return false;
+        PM.addPass(InvalidateAnalysisPass<AnalysisT>());
+        return true;
+      }
+
+      // See if this is a require<> pass name
+      if (PipelineName.startswith("require<")) {
+        PipelineName = PipelineName.substr(8, PipelineName.size() - 9);
+        if (PipelineName != AnalysisName)
+          return false;
+        PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
+                                       ExtraArgTs...>());
+        return true;
+      }
+
+      return false;
+    }
+
+    Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
+                          bool VerifyEachPass, bool DebugLogging) const;
+    Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
+                         bool VerifyEachPass, bool DebugLogging) const;
+    Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
+                            bool VerifyEachPass, bool DebugLogging) const;
+    Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
+                        bool VerifyEachPass, bool DebugLogging) const;
+
+  public:
+    /// Implementation of PassBuilder::parsePassPipeline methods.
+    /// They perform parsing of the pipeline-elements tree already populated
+    /// from text representation.
+    Error parsePassPipeline(ModulePassManager &MPM, bool VerifyEachPass = true,
+                            bool DebugLogging = false);
+    Error parsePassPipeline(CGSCCPassManager &CGPM, bool VerifyEachPass = true,
+                            bool DebugLogging = false);
+    Error parsePassPipeline(FunctionPassManager &FPM,
+                            bool VerifyEachPass = true,
+                            bool DebugLogging = false);
+    Error parsePassPipeline(LoopPassManager &LPM, bool VerifyEachPass = true,
+                            bool DebugLogging = false);
+
+  private:
+    template <typename PassManagerT, typename CallbacksT>
+    static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks);
+    template <typename CallbacksT>
+    static bool isModulePassName(StringRef Name, CallbacksT &Callbacks);
+    template <typename CallbacksT>
+    static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks);
+    template <typename CallbacksT>
+    static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks);
+    template <typename CallbacksT>
+    static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks);
+
+    /// Utility that performs initial parsing of the pipeline text.
+    /// Produces a tree of pipeline elements.
+    static Optional<std::vector<PipelineElement>>
+    parsePipelineText(StringRef Text);
+
+    PassBuilder &PB;
+    StringRef PipelineText;
+    Optional<std::vector<PipelineElement>> Pipeline = None;
+  };
+
   /// ThinLTO phase.
   ///
   /// This enumerates the LLVM ThinLTO optimization phases.
   enum class ThinLTOPhase {
     /// No ThinLTO behavior needed.
     None,
     // ThinLTO prelink (summary) phase.
     PreLink,
public:
   ///
   /// This shortcut is especially useful for debugging and testing small pass
   /// combinations. Note that these shortcuts don't introduce any other magic.
   /// If the sequence of passes aren't all the exact same kind of pass, it will
   /// be an error. You cannot mix different levels implicitly, you must
   /// explicitly form a pass manager in which to nest passes.
   Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
                           bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+                          bool DebugLogging = false) {
+    return PipelineParser(*this, PipelineText)
+        .parsePassPipeline(MPM, VerifyEachPass, DebugLogging);
+  }
 
   /// {{@ Parse a textual pass pipeline description into a specific PassManager
   ///
   /// Automatic deduction of an appropriate pass manager stack is not supported.
   /// For example, to insert a loop pass 'lpass' into a FunctinoPassManager,
   /// this is the valid pipeline text:
   ///
   ///   function(lpass)
   Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText,
                           bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+                          bool DebugLogging = false) {
+    return PipelineParser(*this, PipelineText)
+        .parsePassPipeline(CGPM, VerifyEachPass, DebugLogging);
+  }
   Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText,
                           bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+                          bool DebugLogging = false) {
+    return PipelineParser(*this, PipelineText)
+        .parsePassPipeline(FPM, VerifyEachPass, DebugLogging);
+  }
   Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText,
                           bool VerifyEachPass = true,
-                          bool DebugLogging = false);
+                          bool DebugLogging = false) {
+    return PipelineParser(*this, PipelineText)
+        .parsePassPipeline(LPM, VerifyEachPass, DebugLogging);
+  }
   /// @}}
 
   /// Parse a textual alias analysis pipeline into the provided AA manager.
   ///
   /// The format of the textual AA pipeline is a comma separated list of AA
   /// pass names:
   ///
   ///   basic-aa,globals-aa,...
public:
   /// @}}
 
   /// {{@ Register pipeline parsing callbacks with this pass builder instance.
   /// Using these callbacks, callers can parse both a single pass name, as well
   /// as entire sub-pipelines, and populate the PassManager instance
   /// accordingly.
   void registerPipelineParsingCallback(
       const std::function<bool(StringRef Name, CGSCCPassManager &,
-                               ArrayRef<PipelineElement>)> &C) {
+                               const PipelineParser &Parser,
+                               ArrayRef<PipelineParser::PipelineElement>)> &C) {
     CGSCCPipelineParsingCallbacks.push_back(C);
   }
   void registerPipelineParsingCallback(
       const std::function<bool(StringRef Name, FunctionPassManager &,
-                               ArrayRef<PipelineElement>)> &C) {
+                               const PipelineParser &Parser,
+                               ArrayRef<PipelineParser::PipelineElement>)> &C) {
     FunctionPipelineParsingCallbacks.push_back(C);
   }
   void registerPipelineParsingCallback(
       const std::function<bool(StringRef Name, LoopPassManager &,
-                               ArrayRef<PipelineElement>)> &C) {
+                               const PipelineParser &Parser,
+                               ArrayRef<PipelineParser::PipelineElement>)> &C) {
     LoopPipelineParsingCallbacks.push_back(C);
   }
   void registerPipelineParsingCallback(
       const std::function<bool(StringRef Name, ModulePassManager &,
-                               ArrayRef<PipelineElement>)> &C) {
+                               const PipelineParser &Parser,
+                               ArrayRef<PipelineParser::PipelineElement>)> &C) {
     ModulePipelineParsingCallbacks.push_back(C);
   }
   /// @}}
 
   /// Register a callback for a top-level pipeline entry.
   ///
   /// If the PassManager type is not given at the top level of the pipeline
   /// text, this Callback should be used to determine the appropriate stack of
   /// PassManagers and populate the passed ModulePassManager.
   void registerParseTopLevelPipelineCallback(
-      const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
+      const std::function<bool(ModulePassManager &, const PipelineParser &,
+                               ArrayRef<PipelineParser::PipelineElement>,
                                bool VerifyEachPass, bool DebugLogging)> &C) {
     TopLevelPipelineParsingCallbacks.push_back(C);
   }
 
 private:
-  static Optional<std::vector<PipelineElement>>
-  parsePipelineText(StringRef Text);
-
-  Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
-                        bool VerifyEachPass, bool DebugLogging);
-  Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
-                       bool VerifyEachPass, bool DebugLogging);
-  Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
-                          bool VerifyEachPass, bool DebugLogging);
-  Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
-                      bool VerifyEachPass, bool DebugLogging);
-  bool parseAAPassName(AAManager &AA, StringRef Name);
-
-  Error parseLoopPassPipeline(LoopPassManager &LPM,
-                              ArrayRef<PipelineElement> Pipeline,
-                              bool VerifyEachPass, bool DebugLogging);
-  Error parseFunctionPassPipeline(FunctionPassManager &FPM,
-                                  ArrayRef<PipelineElement> Pipeline,
-                                  bool VerifyEachPass, bool DebugLogging);
-  Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
-                               ArrayRef<PipelineElement> Pipeline,
-                               bool VerifyEachPass, bool DebugLogging);
-  Error parseModulePassPipeline(ModulePassManager &MPM,
-                                ArrayRef<PipelineElement> Pipeline,
-                                bool VerifyEachPass, bool DebugLogging);
 
   void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
                          OptimizationLevel Level, bool RunProfileGen, bool IsCS,
                          std::string ProfileFile,
                          std::string ProfileRemappingFile);
+  bool parseAAPassName(AAManager &AA, StringRef Name);
 
   void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);
 
   // Extension Point callbacks
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       PeepholeEPCallbacks;
   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
       LateLoopOptimizationsEPCallbacks;
   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
       LoopOptimizerEndEPCallbacks;
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       ScalarOptimizerLateEPCallbacks;
   SmallVector<std::function<void(CGSCCPassManager &, OptimizationLevel)>, 2>
       CGSCCOptimizerLateEPCallbacks;
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       VectorizerStartEPCallbacks;
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       OptimizerLastEPCallbacks;
   // Module callbacks
   SmallVector<std::function<void(ModulePassManager &)>, 2>
       PipelineStartEPCallbacks;
   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
       ModuleAnalysisRegistrationCallbacks;
-  SmallVector<std::function<bool(StringRef, ModulePassManager &,
-                                 ArrayRef<PipelineElement>)>,
-              2>
+  SmallVector<
+      std::function<bool(StringRef, ModulePassManager &, const PipelineParser &,
+                         ArrayRef<PipelineParser::PipelineElement>)>,
       ModulePipelineParsingCallbacks;
-  SmallVector<std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
+  SmallVector<std::function<bool(ModulePassManager &, const PipelineParser &,
+                                 ArrayRef<PipelineParser::PipelineElement>,
                                  bool VerifyEachPass, bool DebugLogging)>,
               2>
       TopLevelPipelineParsingCallbacks;
   // CGSCC callbacks
   SmallVector<std::function<void(CGSCCAnalysisManager &)>, 2>
       CGSCCAnalysisRegistrationCallbacks;
-  SmallVector<std::function<bool(StringRef, CGSCCPassManager &,
-                                 ArrayRef<PipelineElement>)>,
-              2>
+  SmallVector<
+      std::function<bool(StringRef, CGSCCPassManager &, const PipelineParser &,
+                         ArrayRef<PipelineParser::PipelineElement>)>,
       CGSCCPipelineParsingCallbacks;
   // Function callbacks
   SmallVector<std::function<void(FunctionAnalysisManager &)>, 2>
       FunctionAnalysisRegistrationCallbacks;
   SmallVector<std::function<bool(StringRef, FunctionPassManager &,
-                                 ArrayRef<PipelineElement>)>,
+                                 const PipelineParser &,
+                                 ArrayRef<PipelineParser::PipelineElement>)>,
               2>
       FunctionPipelineParsingCallbacks;
   // Loop callbacks
   SmallVector<std::function<void(LoopAnalysisManager &)>, 2>
       LoopAnalysisRegistrationCallbacks;
-  SmallVector<std::function<bool(StringRef, LoopPassManager &,
-                                 ArrayRef<PipelineElement>)>,
-              2>
+  SmallVector<
+      std::function<bool(StringRef, LoopPassManager &, const PipelineParser &,
+                         ArrayRef<PipelineParser::PipelineElement>)>,
       LoopPipelineParsingCallbacks;
   // AA callbacks
   SmallVector<std::function<bool(StringRef Name, AAManager &AA)>, 2>
       AAParsingCallbacks;
 };
 
-/// This utility template takes care of adding require<> and invalidate<>
-/// passes for an analysis to a given \c PassManager. It is intended to be used
-/// during parsing of a pass pipeline when parsing a single PipelineName.
-/// When registering a new function analysis FancyAnalysis with the pass
-/// pipeline name "fancy-analysis", a matching ParsePipelineCallback could look
-/// like this:
-///
-/// static bool parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
-///                                   ArrayRef<PipelineElement> P) {
-///   if (parseAnalysisUtilityPasses<FancyAnalysis>("fancy-analysis", Name,
-///                                                 FPM))
-///     return true;
-///   return false;
-/// }
-template <typename AnalysisT, typename IRUnitT, typename AnalysisManagerT,
-          typename... ExtraArgTs>
-bool parseAnalysisUtilityPasses(
-    StringRef AnalysisName, StringRef PipelineName,
-    PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) {
-  if (!PipelineName.endswith(">"))
-    return false;
-  // See if this is an invalidate<> pass name
-  if (PipelineName.startswith("invalidate<")) {
-    PipelineName = PipelineName.substr(11, PipelineName.size() - 12);
-    if (PipelineName != AnalysisName)
-      return false;
-    PM.addPass(InvalidateAnalysisPass<AnalysisT>());
-    return true;
-  }
-
-  // See if this is a require<> pass name
-  if (PipelineName.startswith("require<")) {
-    PipelineName = PipelineName.substr(8, PipelineName.size() - 9);
-    if (PipelineName != AnalysisName)
-      return false;
-    PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
-                                   ExtraArgTs...>());
-    return true;
-  }
-
-  return false;
-}
 }
 
 #endif

llvm/lib/Passes/PassBuilder.cpp

 ///
 /// When parsing a pipeline text, the type of the outermost pipeline may be
 /// omitted, in which case the type is automatically determined from the first
 /// pass name in the text. This may be a name that is handled through one of the
 /// callbacks. We check this through the oridinary parsing callbacks by setting
 /// up a dummy PassManager in order to not force the client to also handle this
 /// type of query.
 template <typename PassManagerT, typename CallbacksT>
-static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
+bool PassBuilder::PipelineParser::callbacksAcceptPassName(
+    StringRef Name, CallbacksT &Callbacks) {
   if (!Callbacks.empty()) {
     PassManagerT DummyPM;
+    PassBuilder DummyPB;
+    PipelineParser DummyParser(DummyPB);
     for (auto &CB : Callbacks)
-      if (CB(Name, DummyPM, {}))
+      if (CB(Name, DummyPM, DummyParser, {}))
         return true;
   }
   return false;
 }
 
 template <typename CallbacksT>
-static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
+bool PassBuilder::PipelineParser::isModulePassName(StringRef Name,
+                                                   CallbacksT &Callbacks) {
   // Manually handle aliases for pre-configured pipeline fragments.
   if (startsWithDefaultPipelineAliasPrefix(Name))
     return DefaultAliasRegex.match(Name);
 
   // Explicitly handle pass manager names.
   if (Name == "module")
     return true;
   if (Name == "cgscc")
#define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
-static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
+bool PassBuilder::PipelineParser::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 ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
-static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
+bool PassBuilder::PipelineParser::isFunctionPassName(StringRef Name,
+                                                     CallbacksT &Callbacks) {
   // Explicitly handle pass manager names.
   if (Name == "function")
     return true;
   if (Name == "loop")
     return true;
 
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
 }
 
 template <typename CallbacksT>
-static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks) {
+bool PassBuilder::PipelineParser::isLoopPassName(StringRef Name,
+                                                 CallbacksT &Callbacks) {
   // Explicitly handle pass manager names.
   if (Name == "loop")
     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_ANALYSIS(NAME, CREATE_PASS)                                       \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
 }
 
-Optional<std::vector<PassBuilder::PipelineElement>>
-PassBuilder::parsePipelineText(StringRef Text) {
+Optional<std::vector<PassBuilder::PipelineParser::PipelineElement>>
+PassBuilder::PipelineParser::parsePipelineText(StringRef Text) {
+  if (Text.empty())
+    return None;
+
   std::vector<PipelineElement> ResultPipeline;
 
   SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
       &ResultPipeline};
   for (;;) {
     std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
     size_t Pos = Text.find_first_of(",()");
     Pipeline.push_back({Text.substr(0, Pos), {}});
if (PipelineStack.size() > 1)
     // Unbalanced paretheses.
     return None;
 
   assert(PipelineStack.back() == &ResultPipeline &&
          "Wrong pipeline at the bottom of the stack!");
   return {std::move(ResultPipeline)};
 }
 
-Error PassBuilder::parseModulePass(ModulePassManager &MPM,
+Error PassBuilder::PipelineParser::parseModulePass(ModulePassManager &MPM,
                                                    const PipelineElement &E,
-                                   bool VerifyEachPass, bool DebugLogging) {
+                                                   bool VerifyEachPass,
+                                                   bool DebugLogging) const {
   auto &Name = E.Name;
   auto &InnerPipeline = E.InnerPipeline;
 
   // First handle complex passes like the pass managers which carry pipelines.
   if (!InnerPipeline.empty()) {
     if (Name == "module") {
       ModulePassManager NestedMPM(DebugLogging);
       if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline,
if (auto Count = parseRepeatPassName(Name)) {
       ModulePassManager NestedMPM(DebugLogging);
       if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline,
                                              VerifyEachPass, DebugLogging))
         return Err;
       MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
       return Error::success();
     }
 
-    for (auto &C : ModulePipelineParsingCallbacks)
-      if (C(Name, MPM, InnerPipeline))
+    for (auto &C : PB.ModulePipelineParsingCallbacks)
+      if (C(Name, MPM, *this, InnerPipeline))
         return Error::success();
 
     // Normal passes can't have pipelines.
     return make_error<StringError>(
         formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
         inconvertibleErrorCode());
     ;
   }
OptimizationLevel L = StringSwitch<OptimizationLevel>(Matches[2])
                               .Case("O3", O3)
                               .Case("Os", Os)
                               .Case("Oz", Oz);
     if (L == O0)
       // At O0 we do nothing at all!
       return Error::success();
 
     if (Matches[1] == "default") {
-      MPM.addPass(buildPerModuleDefaultPipeline(L, DebugLogging));
+      MPM.addPass(PB.buildPerModuleDefaultPipeline(L, DebugLogging));
     } else if (Matches[1] == "thinlto-pre-link") {
-      MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L, DebugLogging));
+      MPM.addPass(PB.buildThinLTOPreLinkDefaultPipeline(L, DebugLogging));
     } else if (Matches[1] == "thinlto") {
-      MPM.addPass(buildThinLTODefaultPipeline(L, DebugLogging, nullptr));
+      MPM.addPass(PB.buildThinLTODefaultPipeline(L, DebugLogging, nullptr));
     } else if (Matches[1] == "lto-pre-link") {
-      MPM.addPass(buildLTOPreLinkDefaultPipeline(L, DebugLogging));
+      MPM.addPass(PB.buildLTOPreLinkDefaultPipeline(L, DebugLogging));
     } else {
       assert(Matches[1] == "lto" && "Not one of the matched options!");
-      MPM.addPass(buildLTODefaultPipeline(L, DebugLogging, nullptr));
+      MPM.addPass(PB.buildLTODefaultPipeline(L, DebugLogging, nullptr));
     }
     return Error::success();
   }
 
   // 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 ">") {                                           \
     MPM.addPass(                                                               \
         RequireAnalysisPass<                                                   \
             std::remove_reference<decltype(CREATE_PASS)>::type, Module>());    \
     return Error::success();                                                   \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     MPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return Error::success();                                                   \
   }
 #include "PassRegistry.def"
 
-  for (auto &C : ModulePipelineParsingCallbacks)
-    if (C(Name, MPM, InnerPipeline))
+  for (auto &C : PB.ModulePipelineParsingCallbacks)
+    if (C(Name, MPM, *this, InnerPipeline))
       return Error::success();
   return make_error<StringError>(
       formatv("unknown module pass '{0}'", Name).str(),
       inconvertibleErrorCode());
 }
 
-Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
-                                  const PipelineElement &E, bool VerifyEachPass,
-                                  bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseCGSCCPass(CGSCCPassManager &CGPM,
+                                                  const PipelineElement &E,
+                                                  bool VerifyEachPass,
+                                                  bool DebugLogging) const {
   auto &Name = E.Name;
   auto &InnerPipeline = E.InnerPipeline;
 
   // First handle complex passes like the pass managers which carry pipelines.
   if (!InnerPipeline.empty()) {
     if (Name == "cgscc") {
       CGSCCPassManager NestedCGPM(DebugLogging);
       if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline,
if (auto MaxRepetitions = parseDevirtPassName(Name)) {
       if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline,
                                             VerifyEachPass, DebugLogging))
         return Err;
       CGPM.addPass(
           createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
       return Error::success();
     }
 
-    for (auto &C : CGSCCPipelineParsingCallbacks)
-      if (C(Name, CGPM, InnerPipeline))
+    for (auto &C : PB.CGSCCPipelineParsingCallbacks)
+      if (C(Name, CGPM, *this, InnerPipeline))
         return Error::success();
 
     // Normal passes can't have pipelines.
     return make_error<StringError>(
         formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
         inconvertibleErrorCode());
   }
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     CGPM.addPass(InvalidateAnalysisPass<                                       \
                  std::remove_reference<decltype(CREATE_PASS)>::type>());       \
     return Error::success();                                                   \
   }
 #include "PassRegistry.def"
 
-  for (auto &C : CGSCCPipelineParsingCallbacks)
-    if (C(Name, CGPM, InnerPipeline))
+  for (auto &C : PB.CGSCCPipelineParsingCallbacks)
+    if (C(Name, CGPM, *this, InnerPipeline))
       return Error::success();
   return make_error<StringError>(
       formatv("unknown cgscc pass '{0}'", Name).str(),
       inconvertibleErrorCode());
 }
 
-Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
+Error PassBuilder::PipelineParser::parseFunctionPass(FunctionPassManager &FPM,
                                                      const PipelineElement &E,
-                                     bool VerifyEachPass, bool DebugLogging) {
+                                                     bool VerifyEachPass,
+                                                     bool DebugLogging) const {
   auto &Name = E.Name;
   auto &InnerPipeline = E.InnerPipeline;
 
   // First handle complex passes like the pass managers which carry pipelines.
   if (!InnerPipeline.empty()) {
     if (Name == "function") {
       FunctionPassManager NestedFPM(DebugLogging);
       if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline,
if (auto Count = parseRepeatPassName(Name)) {
       FunctionPassManager NestedFPM(DebugLogging);
       if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline,
                                                VerifyEachPass, DebugLogging))
         return Err;
       FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
       return Error::success();
     }
 
-    for (auto &C : FunctionPipelineParsingCallbacks)
-      if (C(Name, FPM, InnerPipeline))
+    for (auto &C : PB.FunctionPipelineParsingCallbacks)
+      if (C(Name, FPM, *this, InnerPipeline))
         return Error::success();
 
     // Normal passes can't have pipelines.
     return make_error<StringError>(
         formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
         inconvertibleErrorCode());
   }
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     FPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return Error::success();                                                   \
   }
 #include "PassRegistry.def"
 
-  for (auto &C : FunctionPipelineParsingCallbacks)
-    if (C(Name, FPM, InnerPipeline))
+  for (auto &C : PB.FunctionPipelineParsingCallbacks)
+    if (C(Name, FPM, *this, InnerPipeline))
       return Error::success();
   return make_error<StringError>(
       formatv("unknown function pass '{0}'", Name).str(),
       inconvertibleErrorCode());
 }
 
-Error PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
-                                 bool VerifyEachPass, bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseLoopPass(LoopPassManager &LPM,
+                                                 const PipelineElement &E,
+                                                 bool VerifyEachPass,
+                                                 bool DebugLogging) const {
   StringRef Name = E.Name;
   auto &InnerPipeline = E.InnerPipeline;
 
   // First handle complex passes like the pass managers which carry pipelines.
   if (!InnerPipeline.empty()) {
     if (Name == "loop") {
       LoopPassManager NestedLPM(DebugLogging);
       if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline,
                                            VerifyEachPass, DebugLogging))
         return Err;
       // Add the nested pass manager with the appropriate adaptor.
       LPM.addPass(std::move(NestedLPM));
       return Error::success();
     }
     if (auto Count = parseRepeatPassName(Name)) {
       LoopPassManager NestedLPM(DebugLogging);
       if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline,
                                            VerifyEachPass, DebugLogging))
         return Err;
       LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
       return Error::success();
     }
 
-    for (auto &C : LoopPipelineParsingCallbacks)
-      if (C(Name, LPM, InnerPipeline))
+    for (auto &C : PB.LoopPipelineParsingCallbacks)
+      if (C(Name, LPM, *this, InnerPipeline))
         return Error::success();
 
     // Normal passes can't have pipelines.
     return make_error<StringError>(
         formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
         inconvertibleErrorCode());
   }
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   }                                                                            \
   if (Name == "invalidate<" 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))
+  for (auto &C : PB.LoopPipelineParsingCallbacks)
+    if (C(Name, LPM, *this, InnerPipeline))
       return Error::success();
   return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
                                  inconvertibleErrorCode());
 }
 
 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                               \
   if (Name == NAME) {                                                          \

 #include "PassRegistry.def"
 
   for (auto &C : AAParsingCallbacks)
     if (C(Name, AA))
       return true;
   return false;
 }
 
-Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
-                                         ArrayRef<PipelineElement> Pipeline,
-                                         bool VerifyEachPass,
-                                         bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseLoopPassPipeline(
+    LoopPassManager &LPM, ArrayRef<PipelineElement> Pipeline,
+    bool VerifyEachPass, bool DebugLogging) const {
   for (const auto &Element : Pipeline) {
     if (auto Err = parseLoopPass(LPM, Element, VerifyEachPass, DebugLogging))
       return Err;
     // FIXME: No verifier support for Loop passes!
   }
   return Error::success();
 }
 
-Error PassBuilder::parseFunctionPassPipeline(FunctionPassManager &FPM,
-                                             ArrayRef<PipelineElement> Pipeline,
-                                             bool VerifyEachPass,
-                                             bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseFunctionPassPipeline(
+    FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline,
+    bool VerifyEachPass, bool DebugLogging) const {
   for (const auto &Element : Pipeline) {
     if (auto Err =
             parseFunctionPass(FPM, Element, VerifyEachPass, DebugLogging))
       return Err;
     if (VerifyEachPass)
       FPM.addPass(VerifierPass());
   }
   return Error::success();
 }
 
-Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
-                                          ArrayRef<PipelineElement> Pipeline,
-                                          bool VerifyEachPass,
-                                          bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseCGSCCPassPipeline(
+    CGSCCPassManager &CGPM, ArrayRef<PipelineElement> Pipeline,
+    bool VerifyEachPass, bool DebugLogging) const {
   for (const auto &Element : Pipeline) {
     if (auto Err = parseCGSCCPass(CGPM, Element, VerifyEachPass, DebugLogging))
       return Err;
     // FIXME: No verifier support for CGSCC passes!
   }
   return Error::success();
 }
 
 void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
                                        FunctionAnalysisManager &FAM,
                                        CGSCCAnalysisManager &CGAM,
                                        ModuleAnalysisManager &MAM) {
   MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
   MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
   CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
   FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
   FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
   FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
   LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
 }
 
-Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
-                                           ArrayRef<PipelineElement> Pipeline,
-                                           bool VerifyEachPass,
-                                           bool DebugLogging) {
+Error PassBuilder::PipelineParser::parseModulePassPipeline(
+    ModulePassManager &MPM, ArrayRef<PipelineElement> Pipeline,
+    bool VerifyEachPass, bool DebugLogging) const {
   for (const auto &Element : Pipeline) {
     if (auto Err = parseModulePass(MPM, Element, VerifyEachPass, DebugLogging))
       return Err;
     if (VerifyEachPass)
       MPM.addPass(VerifierPass());
   }
   return Error::success();
 }
 
 // Primary pass pipeline description parsing routine for a \c ModulePassManager
 // FIXME: Should this routine accept a TargetMachine or require the caller to
 // pre-populate the analysis managers with target-specific stuff?
-Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
-                                     StringRef PipelineText,
-                                     bool VerifyEachPass, bool DebugLogging) {
-  auto Pipeline = parsePipelineText(PipelineText);
+Error PassBuilder::PipelineParser::parsePassPipeline(ModulePassManager &MPM,
+                                                     bool VerifyEachPass,
+                                                     bool DebugLogging) {
+  Pipeline = parsePipelineText(PipelineText);
   if (!Pipeline || Pipeline->empty())
     return make_error<StringError>(
         formatv("invalid pipeline '{0}'", PipelineText).str(),
         inconvertibleErrorCode());
 
   // If the first name isn't at the module layer, wrap the pipeline up
   // automatically.
   StringRef FirstName = Pipeline->front().Name;
 
-  if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
-    if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
+  if (!isModulePassName(FirstName, PB.ModulePipelineParsingCallbacks)) {
+    if (isCGSCCPassName(FirstName, PB.CGSCCPipelineParsingCallbacks)) {
       Pipeline = {{"cgscc", std::move(*Pipeline)}};
     } else if (isFunctionPassName(FirstName,
-                                  FunctionPipelineParsingCallbacks)) {
+                                  PB.FunctionPipelineParsingCallbacks)) {
       Pipeline = {{"function", std::move(*Pipeline)}};
-    } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks)) {
+    } else if (isLoopPassName(FirstName, PB.LoopPipelineParsingCallbacks)) {
       Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}};
     } else {
-      for (auto &C : TopLevelPipelineParsingCallbacks)
-        if (C(MPM, *Pipeline, VerifyEachPass, DebugLogging))
+      for (auto &C : PB.TopLevelPipelineParsingCallbacks)
+        if (C(MPM, *this, *Pipeline, VerifyEachPass, DebugLogging))
           return Error::success();
 
       // Unknown pass or pipeline name!
       auto &InnerPipeline = Pipeline->front().InnerPipeline;
       return make_error<StringError>(
           formatv("unknown {0} name '{1}'",
                   (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
               .str(),
           inconvertibleErrorCode());
     }
   }
 
   if (auto Err =
           parseModulePassPipeline(MPM, *Pipeline, VerifyEachPass, DebugLogging))
     return Err;
   return Error::success();
 }
 
 // Primary pass pipeline description parsing routine for a \c CGSCCPassManager
-Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
-                                     StringRef PipelineText,
-                                     bool VerifyEachPass, bool DebugLogging) {
-  auto Pipeline = parsePipelineText(PipelineText);
+Error PassBuilder::PipelineParser::parsePassPipeline(CGSCCPassManager &CGPM,
+                                                     bool VerifyEachPass,
+                                                     bool DebugLogging) {
+  Pipeline = parsePipelineText(PipelineText);
   if (!Pipeline || Pipeline->empty())
     return make_error<StringError>(
         formatv("invalid pipeline '{0}'", PipelineText).str(),
         inconvertibleErrorCode());
 
   StringRef FirstName = Pipeline->front().Name;
-  if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
+  if (!isCGSCCPassName(FirstName, PB.CGSCCPipelineParsingCallbacks))
     return make_error<StringError>(
         formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
                 PipelineText)
             .str(),
         inconvertibleErrorCode());
 
   if (auto Err =
           parseCGSCCPassPipeline(CGPM, *Pipeline, VerifyEachPass, DebugLogging))
     return Err;
   return Error::success();
 }
 
 // Primary pass pipeline description parsing routine for a \c
 // FunctionPassManager
-Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
-                                     StringRef PipelineText,
-                                     bool VerifyEachPass, bool DebugLogging) {
-  auto Pipeline = parsePipelineText(PipelineText);
+Error PassBuilder::PipelineParser::parsePassPipeline(FunctionPassManager &FPM,
+                                                     bool VerifyEachPass,
+                                                     bool DebugLogging) {
+  Pipeline = parsePipelineText(PipelineText);
   if (!Pipeline || Pipeline->empty())
     return make_error<StringError>(
         formatv("invalid pipeline '{0}'", PipelineText).str(),
         inconvertibleErrorCode());
 
   StringRef FirstName = Pipeline->front().Name;
-  if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
+  if (!isFunctionPassName(FirstName, PB.FunctionPipelineParsingCallbacks))
     return make_error<StringError>(
         formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
                 PipelineText)
             .str(),
         inconvertibleErrorCode());
 
   if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline, VerifyEachPass,
                                            DebugLogging))
     return Err;
   return Error::success();
 }
 
 // Primary pass pipeline description parsing routine for a \c LoopPassManager
-Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
-                                     StringRef PipelineText,
-                                     bool VerifyEachPass, bool DebugLogging) {
-  auto Pipeline = parsePipelineText(PipelineText);
+Error PassBuilder::PipelineParser::parsePassPipeline(LoopPassManager &CGPM,
+                                                     bool VerifyEachPass,
+                                                     bool DebugLogging) {
+  Pipeline = parsePipelineText(PipelineText);
   if (!Pipeline || Pipeline->empty())
     return make_error<StringError>(
         formatv("invalid pipeline '{0}'", PipelineText).str(),
         inconvertibleErrorCode());
 
   if (auto Err =
           parseLoopPassPipeline(CGPM, *Pipeline, VerifyEachPass, DebugLogging))
     return Err;

llvm/tools/opt/NewPMDriver.cpp

for (auto &PluginFN : PassPlugins) {
     }
 
     PassPlugin->registerPassBuilderCallbacks(PB);
   }
 
   // Register a callback that creates the debugify passes as needed.
   PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &MPM,
-         ArrayRef<PassBuilder::PipelineElement>) {
+         const PassBuilder::PipelineParser &Parser,
+         ArrayRef<PassBuilder::PipelineParser::PipelineElement>) {
         if (Name == "debugify") {
           MPM.addPass(NewPMDebugifyPass());
           return true;
         } else if (Name == "check-debugify") {
           MPM.addPass(NewPMCheckDebugifyPass());
           return true;
         }
         return false;

llvm/unittests/IR/PassBuilderCallbacksTest.cpp

PassBuilderCallbacksTest()
     /// Register a callback for pipeline parsing.
     ///
     /// During parsing of a textual pipeline, the PassBuilder will call these
     /// callbacks for each encountered pass name that it does not know. This
     /// includes both simple pass names as well as names of sub-pipelines. In
     /// the latter case, the InnerPipeline is not empty.
     PB.registerPipelineParsingCallback(
         [this](StringRef Name, PassManagerT &PM,
-               ArrayRef<PassBuilder::PipelineElement> InnerPipeline) {
+               const PassBuilder::PipelineParser &Parser,
+               ArrayRef<PassBuilder::PipelineParser::PipelineElement>
+                   InnerPipeline) {
           /// Handle parsing of the names of analysis utilities such as
           /// require<test-analysis> and invalidate<test-analysis> for our
           /// analysis mock handle
-          if (parseAnalysisUtilityPasses<AnalysisT>("test-analysis", Name, PM))
+          if (Parser.parseAnalysisUtilityPasses<AnalysisT>("test-analysis",
+                                                           Name, PM))
             return true;
 
           /// Parse the name of our pass mock handle
           if (Name == "test-transform") {
             PM.addPass(PassHandle.getPass());
             return true;
           }
           return false;

 /// Test parsing of the top-level pipeline.
 ///
 /// The ParseTopLevelPipeline callback takes over parsing of the entire pipeline
 /// from PassBuilder if it encounters an unknown pipeline entry at the top level
 /// (i.e., the first entry on the pipeline).
 /// This test parses a pipeline named 'another-pipeline', whose only elements
 /// may be the test-transform pass or the analysis utilities
 TEST_F(ModuleCallbacksTest, ParseTopLevelPipeline) {
-  PB.registerParseTopLevelPipelineCallback([this](
-      ModulePassManager &MPM, ArrayRef<PassBuilder::PipelineElement> Pipeline,
+  PB.registerParseTopLevelPipelineCallback(
+      [this](ModulePassManager &MPM, const PassBuilder::PipelineParser &Parser,
+             ArrayRef<PassBuilder::PipelineParser::PipelineElement> Pipeline,
              bool VerifyEachPass, bool DebugLogging) {
         auto &FirstName = Pipeline.front().Name;
         auto &InnerPipeline = Pipeline.front().InnerPipeline;
         if (FirstName == "another-pipeline") {
           for (auto &E : InnerPipeline) {
-        if (parseAnalysisUtilityPasses<AnalysisT>("test-analysis", E.Name, PM))
+            if (Parser.parseAnalysisUtilityPasses<AnalysisT>("test-analysis",
+                                                             E.Name, PM))
               continue;
 
             if (E.Name == "test-transform") {
               PM.addPass(PassHandle.getPass());
               continue;
             }
             return false;
           }
         }
         return true;
       });
 
   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
       .WillOnce(Invoke(getAnalysisResult));
   EXPECT_CALL(AnalysisHandle, invalidate(HasName("<string>"), _, _));
 
   StringRef PipelineText =
       "another-pipeline(test-transform,invalidate<test-analysis>)";

llvm/unittests/Passes/TestPlugin.cpp

struct TestModulePass : public PassInfoMixin<TestModulePass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM) {
     return PreservedAnalyses::all();
   }
 };
 
 void registerCallbacks(PassBuilder &PB) {
   PB.registerPipelineParsingCallback(
       [](StringRef Name, ModulePassManager &PM,
-         ArrayRef<PassBuilder::PipelineElement> InnerPipeline) {
+         const PassBuilder::PipelineParser &Parser,
+         ArrayRef<PassBuilder::PipelineParser::PipelineElement> InnerPipeline) {
         if (Name == "plugin-pass") {
           PM.addPass(TestModulePass());
           return true;
         }
         return false;
       });
 }
 
 extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK
 llvmGetPassPluginInfo() {
   return {LLVM_PLUGIN_API_VERSION, TEST_PLUGIN_NAME, TEST_PLUGIN_VERSION,
           registerCallbacks};
 }