[NFC] Feature generic options to setup start/stop-after/before

[qcolombet]

Summary

Hi,

This patch refactors the code used in llc such that all the users of the addPassesToEmitFile API have access to a homogeneous way of handling start/stop-after/before options right out of the box.

Previously each user would have needed to duplicate this logic and set up its own options.

Note:
I am not super happy about the error reporting. I would have preferred this to be handled by the caller of the getPassXXX methods. However, since I wanted to have the start/stop-after/before options working out-of-the-box, that's not possible. Indeed that would mean that every user of the getPassXXX API would need to have code to unbox/treat the error case. Thus, I settle for a direct reporting. Given this is more of a developer capability, I thought it would be good enough.

Moreover, the current patch loses the prefix "llc: " or "stop-after" in the error message. I initially thought about passing an additional prefix to the error message (with a default "LLVM: "), but again I thought given the usage of that stuff, this was not worth the effort/complexity.

What do people think?

Cheers,
-Quentin

[MatzeB]

Looks good in general. But I think this can be done a bit more aggressively with less public API.

include/llvm/Target/TargetMachine.h

100

We prefer \{ doxygen commands in llvm instead of @{. And from what I remember (though I may be wrong here) you have to use something like \defgroup in front for \{ to have any sensible effect.

101–108

Why not just hardcode these names?
(You should be able to use OptionName.ArgStr if you want to reference the name later)

120–169

Do we really need all of this API? I think this would work just as well if you just put it inside TargetMachine.cpp now (possibly with a single hasLimitedPpipelineOption() call (see below) but not more.

tools/llc/llc.cpp

509–515

Maybe keep it simple and move all of this into TargetMachine and just keep a TargetMachine::hasLimitedPipelineOption() or so to check for the start/stop with run-pass error?

534–536

You should probably move this error checking into TargetMachine as well now.

[qcolombet]

Hi Matthias,

Thanks for the quick review.
I'm not sure I got the hasLimitedPipelineOption suggestion. See the inline comment.

Cheers,
-Quentin

include/llvm/Target/TargetMachine.h

100

All three are in use at the moment.
A quick look (grep -c), showed up that @{ is the most used, followed by \{ and then \defgroup.
Honestly I don't care which one we use, but I'd like to be consistent.

The coding standard list @{ though:
http://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

101–108

I thought it was easier for someone to look them up.
That being said, given I can't put the initializer in the header, that's probably not super useful.
I'll get rid of it.

tools/llc/llc.cpp

509–515

You mean something like:
getRunPass(StringRef PassName, bool AbortIfNotRegistered, bool HasLimitedPipelineOption)

And going farther, having the AbortXX and HasLimitedXX being field member?

534–536

I'll update getStartXXID for that.

[MatzeB]

include/llvm/Target/TargetMachine.h

100

Odd that we use @{ but not @param then. Anyway I don't care too much either. \defgroup is needed so doxygen knows what it is you are grouping together with @{. Looking at example it looks like \name works as well, so use that instead of \defgroup.

tools/llc/llc.cpp

509–515

What I was getting at:

• Currently you expose 7 function and an enum type as API for something that looks like a few commandline options that we should be able to handle inside of TargetMachine.cpp entirely.
• However when you move everything into TargetMachine.cpp we obviously cannot do the if (StartAfterID || StopAfterID || StartBeforeID || StopBeforeID) { here anymore. That's why I suggested to expose a single function in the API which looks similar to this: class TargetMachine { ... bool hasLimitedPipeline() { return StartAfterID || StopAfterID || StartBeforeID || StopBeforeID; } ... } you could use that here and at that point do not need the {Start|Stop}XXXID variables and all the API to access them anymore.

[qcolombet]

Hi Matthias,

Thanks for the clarifications.
I am ok moving some more error checking within the TargetMachine class, but I have one more question regarding not exposing the API for the options, see my inline comment.

Cheers,
-Quentin

tools/llc/llc.cpp

509–515

Ok, but how do we set the default arguments for this API then?

TargetMachine ::addPassesToEmitFile

Should we just get rid of those arguments and all do that internally?
(Note: I am not a fan of changing the pipeline behind the developer back.)

[qcolombet]

• Move all the logic to handle the options in TargetPassConfig
• Refactor llc code to avoid code duplication, now only the run-pass pipeline is custom made
• Add MMI output parameter to be able to parse the module and populate the MachineModuleInfo after creating the pipeline

[MatzeB]

Suggestion for different style below, but I don't really care deeply one way or the other.
Either way this is fine by me to go in; LGTM.

[tstellar]

It would be nice to get this into the 5.0 release, there have been a few times I've needed this functionality for debugging.

[MatzeB]

Looks like whatever I wrote went missing here it is again:

include/llvm/Target/TargetMachine.h

228–231

I wonder if instead of setting an external MachineModuleInfo **MMI you could instead use whatever the user passes in and make this a MachineModuleInfo *MMI.

[MatzeB]

In D30913#823248, @tstellar wrote:

It would be nice to get this into the 5.0 release, there have been a few times I've needed this functionality for debugging.

Note that in the current form it's not magically working for any frontend like you would expect: The MIR printing and verification at the end of a pipeline or loading a MIR file at the beginning of a pipeline is still done in llc even with this patch and would need to replicate that code in other frontends.
(If you're gonna adapt your frontends anyway, then you can do that even without this pass :)

[MatzeB]

In D30913#823281, @MatzeB wrote:

In D30913#823248, @tstellar wrote:

It would be nice to get this into the 5.0 release, there have been a few times I've needed this functionality for debugging.

Note that in the current form it's not magically working for any frontend like you would expect: The MIR printing and verification at the end of a pipeline or loading a MIR file at the beginning of a pipeline is still done in llc even with this patch and would need to replicate that code in other frontends.
(If you're gonna adapt your frontends anyway, then you can do that even without this pass :)

Just reread the code and actually the MIR printing at the end of the pipeline (in -stop-xxx mode) is there.

[qcolombet]

include/llvm/Target/TargetMachine.h

228–231

That would mean that if the users create the information, we won't have a way to get back them something they can use.
Concretely, that would mean we would need to always create the MachineModuleInfo in llc, which is fine.

I don't care either way either :).

That said, I like the fact that this API will make it clear that if you pass something it is used. I'll update and coming hopefully shortly.

include/llvm/CodeGen/TargetPassConfig.h

private:
   AnalysisID StartBefore = nullptr;
   AnalysisID StartAfter = nullptr;
   AnalysisID StopBefore = nullptr;
   AnalysisID StopAfter = nullptr;
   bool Started = true;
   bool Stopped = false;
   bool AddingMachinePasses = false;
 
+  /// Set the StartAfter, StartBefore and StopAfter passes to allow running only
+  /// a portion of the normal code-gen pass sequence.
+  ///
+  /// If the StartAfter and StartBefore pass ID is zero, then compilation will
+  /// begin at the normal point; otherwise, clear the Started flag to indicate
+  /// that passes should not be added until the starting pass is seen.  If the
+  /// Stop pass ID is zero, then compilation will continue to the end.
+  ///
+  /// This function expects that at least one of the StartAfter or the
+  /// StartBefore pass IDs is null.
+  void setStartStopPasses();
+
 protected:
   LLVMTargetMachine *TM;
   PassConfigImpl *Impl = nullptr; // Internal data structures
   bool Initialized = false; // Flagged after all passes are configured.
 
   // Target Pass Options
   // Targets provide a default setting, user flags override.
   bool DisableVerify = false;
template<typename TMC> TMC &getTM() const {
     return *static_cast<TMC*>(TM);
   }
 
   //
   void setInitialized() { Initialized = true; }
 
   CodeGenOpt::Level getOptLevel() const;
 
-  /// Set the StartAfter, StartBefore and StopAfter passes to allow running only
-  /// a portion of the normal code-gen pass sequence.
-  ///
-  /// If the StartAfter and StartBefore pass ID is zero, then compilation will
-  /// begin at the normal point; otherwise, clear the Started flag to indicate
-  /// that passes should not be added until the starting pass is seen.  If the
-  /// Stop pass ID is zero, then compilation will continue to the end.
-  ///
-  /// This function expects that at least one of the StartAfter or the
-  /// StartBefore pass IDs is null.
-  void setStartStopPasses(AnalysisID StartBefore, AnalysisID StartAfter,
-                          AnalysisID StopBefore, AnalysisID StopAfter) {
-    assert(!(StartBefore && StartAfter) &&
-           "Start after and start before passes are given");
-    assert(!(StopBefore && StopAfter) &&
-           "Stop after and stop before passed are given");
-    this->StartBefore = StartBefore;
-    this->StartAfter = StartAfter;
-    this->StopBefore = StopBefore;
-    this->StopAfter = StopAfter;
-    Started = (StartAfter == nullptr) && (StartBefore == nullptr);
+  /// Describe the status of the codegen
+  /// pipeline set by this target pass config.
+  /// Having a limited codegen pipeline means that options
+  /// have been used to restrict what codegen is doing.
+  /// In particular, that means that codegen won't emit
+  /// assembly code.
+  bool hasLimitedCodeGenPipeline() const;
+
+  /// If hasLimitedCodeGenPipeline is true, this method
+  /// returns a string with the name of the options, separated
+  /// by \p Separator that caused this pipeline to be limited.
+  std::string
+  getLimitedCodeGenPipelineReason(const char *Separator = "/") const;
+
+  /// Check if the codegen pipeline is limited in such a way that it
+  /// won't be complete. When the codegen pipeline is not complete,
+  /// this means it may not be possible to generate assembly from it.
+  bool willCompleteCodeGenPipeline() const {
+    return !hasLimitedCodeGenPipeline() || (!StopAfter && !StopBefore);
   }
 
   void setDisableVerify(bool Disable) { setOpt(DisableVerify, Disable); }
 
   bool getEnableTailMerge() const { return EnableTailMerge; }
   void setEnableTailMerge(bool Enable) { setOpt(EnableTailMerge, Enable); }
 
   bool requiresCodeGenSCCOrder() const { return RequireCodeGenSCCOrder; }

include/llvm/Target/TargetMachine.h

 #include "llvm/Pass.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 
 namespace llvm {
 
 class GlobalValue;
+class MachineModuleInfo;
 class Mangler;
 class MCAsmInfo;
 class MCContext;
 class MCInstrInfo;
 class MCRegisterInfo;
 class MCSubtargetInfo;
 class MCSymbol;
 class raw_pwrite_stream;
protected: // Can only create subclasses.
   unsigned O0WantsFastISel : 1;
 
 public:
   const TargetOptions DefaultOptions;
   mutable TargetOptions Options;
 
   TargetMachine(const TargetMachine &) = delete;
   void operator=(const TargetMachine &) = delete;
   virtual ~TargetMachine();
 
   const Target &getTarget() const { return TheTarget; }
 
   const Triple &getTargetTriple() const { return TargetTriple; }
   StringRef getTargetCPU() const { return TargetCPU; }
   StringRef getTargetFeatureString() const { return TargetFS; }
 
   /// Virtual method implemented by subclasses that returns a reference to that
   /// target's TargetSubtargetInfo-derived member variable.
   virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const {
     return nullptr;
   }
   virtual TargetLoweringObjectFile *getObjFileLowering() const {
     return nullptr;
   }
 
   /// This method returns a pointer to the specified type of
   /// TargetSubtargetInfo.  In debug builds, it verifies that the object being
   /// returned is of the correct type.
   template <typename STC> const STC &getSubtarget(const Function &F) const {
     return *static_cast<const STC*>(getSubtargetImpl(F));
   }
 
   /// Create a DataLayout.
   const DataLayout createDataLayout() const { return DL; }
 
   /// Test if a DataLayout if compatible with the CodeGen for this target.
   ///
   /// The LLVM Module owns a DataLayout that is used for the target independent
   /// optimizations and code generation. This hook provides a target specific
   /// check on the validity of this DataLayout.
   bool isCompatibleDataLayout(const DataLayout &Candidate) const {
     return DL == Candidate;
   }
 
   /// Get the pointer size for this target.
   ///
   /// This is the only time the DataLayout in the TargetMachine is used.
   unsigned getPointerSize() const { return DL.getPointerSize(); }
 
   /// \brief Reset the target options based on the function's attributes.
   // FIXME: Remove TargetOptions that affect per-function code generation
   // from TargetMachine.
   void resetTargetOptions(const Function &F) const;
 
   /// Return target specific asm information.
   const MCAsmInfo *getMCAsmInfo() const { return AsmInfo; }
 
   const MCRegisterInfo *getMCRegisterInfo() const { return MRI; }
   const MCInstrInfo *getMCInstrInfo() const { return MII; }
   const MCSubtargetInfo *getMCSubtargetInfo() const { return STI; }
 
   /// If intrinsic information is available, return it.  If not, return null.
   virtual const TargetIntrinsicInfo *getIntrinsicInfo() const {
     return nullptr;
   }
 
   bool requiresStructuredCFG() const { return RequireStructuredCFG; }
   void setRequiresStructuredCFG(bool Value) { RequireStructuredCFG = Value; }
 
   /// Returns the code generation relocation model. The choices are static, PIC,
   /// and dynamic-no-pic, and target default.
   Reloc::Model getRelocationModel() const;
 
   /// Returns the code model. The choices are small, kernel, medium, large, and
   /// target default.
   CodeModel::Model getCodeModel() const;
 
   bool isPositionIndependent() const;
 
   bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
 
   /// Returns the TLS model which should be used for the given global variable.
   TLSModel::Model getTLSModel(const GlobalValue *GV) const;
 
   /// Returns the optimization level: None, Less, Default, or Aggressive.
   CodeGenOpt::Level getOptLevel() const;
enum CodeGenFileType {
     CGFT_ObjectFile,
     CGFT_Null         // Do not emit any output.
   };
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
   /// This method should return true if emission of this file type is not
   /// supported, or false on success.
-  virtual bool addPassesToEmitFile(
-      PassManagerBase &, raw_pwrite_stream &, CodeGenFileType,
-      bool /*DisableVerify*/ = true, AnalysisID /*StartBefore*/ = nullptr,
-      AnalysisID /*StartAfter*/ = nullptr, AnalysisID /*StopBefore*/ = nullptr,
-      AnalysisID /*StopAfter*/ = nullptr) {
+  /// \p MMISave is an optional parameter that, if set to non-nullptr,
+  /// will contain the MachineModuloInfo created for this PM.
+  virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &,
+                                   CodeGenFileType,
+                                   bool /*DisableVerify*/ = true,
+                                   MachineModuleInfo **MMI = nullptr) {
     return true;
   }
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported. It
   /// fills the MCContext Ctx pointer which can be used to build custom
   /// MCStreamer.
   ///

 class LLVMTargetMachine : public TargetMachine {
 protected: // Can only create subclasses.
   LLVMTargetMachine(const Target &T, StringRef DataLayoutString,
                     const Triple &TargetTriple, StringRef CPU, StringRef FS,
                     const TargetOptions &Options, Reloc::Model RM,
                     CodeModel::Model CM, CodeGenOpt::Level OL);
 
   void initAsmInfo();
+
 public:
   /// \brief Get a TargetIRAnalysis implementation for the target.
   ///
   /// This analysis will produce a TTI result which uses the common code
   /// generator to answer queries about the IR.
   TargetIRAnalysis getTargetIRAnalysis() override;
 
   /// Create a pass configuration object to be used by addPassToEmitX methods
   /// for generating a pipeline of CodeGen passes.
   virtual TargetPassConfig *createPassConfig(PassManagerBase &PM);
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
-  bool addPassesToEmitFile(
-      PassManagerBase &PM, raw_pwrite_stream &Out, CodeGenFileType FileType,
-      bool DisableVerify = true, AnalysisID StartBefore = nullptr,
-      AnalysisID StartAfter = nullptr, AnalysisID StopBefore = nullptr,
-      AnalysisID StopAfter = nullptr) override;
+  /// \p MMISave is an optional parameter that, if set to non-nullptr,
+  /// will contain the MachineModuloInfo created for this PM.
+  bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
+                           CodeGenFileType FileType, bool DisableVerify = true,
+                           MachineModuleInfo **MMISave = nullptr) override;
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported. It
   /// fills the MCContext Ctx pointer which can be used to build custom
   /// MCStreamer.
   bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
                          raw_pwrite_stream &OS,
                          bool DisableVerify = true) override;

lib/CodeGen/LLVMTargetMachine.cpp

TargetIRAnalysis LLVMTargetMachine::getTargetIRAnalysis() {
   return TargetIRAnalysis([this](const Function &F) {
     return TargetTransformInfo(BasicTTIImpl(this, F));
   });
 }
 
 /// addPassesToX helper drives creation and initialization of TargetPassConfig.
 static MCContext *
 addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM,
-                        bool DisableVerify, AnalysisID StartBefore,
-                        AnalysisID StartAfter, AnalysisID StopBefore,
-                        AnalysisID StopAfter) {
+                        bool DisableVerify, bool &WillCompleteCodeGenPipeline,
+                        raw_pwrite_stream &Out, MachineModuleInfo **MMISave) {
   // Targets may override createPassConfig to provide a target-specific
   // subclass.
   TargetPassConfig *PassConfig = TM->createPassConfig(PM);
-  PassConfig->setStartStopPasses(StartBefore, StartAfter, StopBefore,
-                                 StopAfter);
   // Set PassConfig options provided by TargetMachine.
   PassConfig->setDisableVerify(DisableVerify);
+  WillCompleteCodeGenPipeline = PassConfig->willCompleteCodeGenPipeline();
   PM.add(PassConfig);
   MachineModuleInfo *MMI = new MachineModuleInfo(TM);
+  if (MMISave)
+    *MMISave = MMI;
   PM.add(MMI);
 
   if (PassConfig->addISelPasses())
     return nullptr;
   PassConfig->addMachinePasses();
   PassConfig->setInitialized();
+  if (!WillCompleteCodeGenPipeline)
+    PM.add(createPrintMIRPass(Out));
 
   return &MMI->getContext();
 }
 
 bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
     raw_pwrite_stream &Out, CodeGenFileType FileType,
     MCContext &Context) {
   if (Options.MCOptions.MCSaveTempLabels)
FunctionPass *Printer =
       getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
   if (!Printer)
     return true;
 
   PM.add(Printer);
   return false;
 }
 
-bool LLVMTargetMachine::addPassesToEmitFile(
-    PassManagerBase &PM, raw_pwrite_stream &Out, CodeGenFileType FileType,
-    bool DisableVerify, AnalysisID StartBefore, AnalysisID StartAfter,
-    AnalysisID StopBefore, AnalysisID StopAfter) {
+bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
+                                            raw_pwrite_stream &Out,
+                                            CodeGenFileType FileType,
+                                            bool DisableVerify,
+                                            MachineModuleInfo **MMI) {
   // Add common CodeGen passes.
-  MCContext *Context =
-      addPassesToGenerateCode(this, PM, DisableVerify, StartBefore, StartAfter,
-                              StopBefore, StopAfter);
+  bool WillCompleteCodeGenPipeline = true;
+  MCContext *Context = addPassesToGenerateCode(
+      this, PM, DisableVerify, WillCompleteCodeGenPipeline, Out, MMI);
   if (!Context)
     return true;
 
-  if (StopBefore || StopAfter) {
-    PM.add(createPrintMIRPass(Out));
-  } else {
-    if (addAsmPrinter(PM, Out, FileType, *Context))
-      return true;
-  }
+  if (WillCompleteCodeGenPipeline && addAsmPrinter(PM, Out, FileType, *Context))
 
   PM.add(createFreeMachineFunctionPass());
   return false;
 }
 
 /// addPassesToEmitMC - Add passes to the specified pass manager to get
 /// machine code emitted with the MCJIT. This method returns true if machine
 /// code is not supported. It fills the MCContext Ctx pointer which can be
 /// used to build custom MCStreamer.
 ///
 bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
                                           raw_pwrite_stream &Out,
                                           bool DisableVerify) {
   // Add common CodeGen passes.
-  Ctx = addPassesToGenerateCode(this, PM, DisableVerify, nullptr, nullptr,
-                                nullptr, nullptr);
+  bool WillCompleteCodeGenPipeline = true;
+  Ctx = addPassesToGenerateCode(this, PM, DisableVerify,
+                                WillCompleteCodeGenPipeline, Out,
+                                /*MachineModuleInfo*/ nullptr);
   if (!Ctx)
     return true;
+  assert(WillCompleteCodeGenPipeline && "CodeGen pipeline has been altered");
 
   if (Options.MCOptions.MCSaveTempLabels)
     Ctx->setAllowTemporaryLabels(false);
 
   // Create the code emitter for the target if it exists.  If not, .o file
   // emission fails.
   const MCRegisterInfo &MRI = *getMCRegisterInfo();
   MCCodeEmitter *MCE =

lib/CodeGen/TargetPassConfig.cpp

static cl::opt<CFLAAType> UseCFLAA(
     cl::values(clEnumValN(CFLAAType::None, "none", "Disable CFL-AA"),
                clEnumValN(CFLAAType::Steensgaard, "steens",
                           "Enable unification-based CFL-AA"),
                clEnumValN(CFLAAType::Andersen, "anders",
                           "Enable inclusion-based CFL-AA"),
                clEnumValN(CFLAAType::Both, "both", 
                           "Enable both variants of CFL-AA")));
 
+/// Option names for limiting the codegen pipeline.
+/// Those are used in error reporting and we didn't want
+/// to duplicate their names all over the place.
+const char *StartAfterOptName = "start-after";
+const char *StartBeforeOptName = "start-before";
+const char *StopAfterOptName = "stop-after";
+const char *StopBeforeOptName = "stop-before";
+
+static cl::opt<std::string>
+    StartAfterOpt(StringRef(StartAfterOptName),
+                  cl::desc("Resume compilation after a specific pass"),
+                  cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StartBeforeOpt(StringRef(StartBeforeOptName),
+                   cl::desc("Resume compilation before a specific pass"),
+                   cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StopAfterOpt(StringRef(StopAfterOptName),
+                 cl::desc("Stop compilation after a specific pass"),
+                 cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StopBeforeOpt(StringRef(StopBeforeOptName),
+                  cl::desc("Stop compilation before a specific pass"),
+                  cl::value_desc("pass-name"), cl::init(""));
+
 /// Allow standard passes to be disabled by command line options. This supports
 /// simple binary flags that either suppress the pass or do nothing.
 /// i.e. -disable-mypass=false has no effect.
 /// These should be converted to boolOrDefault in order to use applyOverride.
 static IdentifyingPassPtr applyDisable(IdentifyingPassPtr PassID,
                                        bool Override) {
   if (Override)
     return IdentifyingPassPtr();

 
 } // end namespace llvm
 
 // Out of line virtual method.
 TargetPassConfig::~TargetPassConfig() {
   delete Impl;
 }
 
+static const PassInfo *getPassInfo(StringRef PassName) {
+  if (PassName.empty())
+    return nullptr;
+
+  const PassRegistry &PR = *PassRegistry::getPassRegistry();
+  const PassInfo *PI = PR.getPassInfo(PassName);
+  if (!PI)
+    report_fatal_error(Twine('\"') + Twine(PassName) +
+                       Twine("\" pass is not registered."));
+  return PI;
+}
+
+static AnalysisID getPassIDFromName(StringRef PassName) {
+  const PassInfo *PI = getPassInfo(PassName);
+  return PI ? PI->getTypeInfo() : nullptr;
+}
+
+void TargetPassConfig::setStartStopPasses() {
+  StartBefore = getPassIDFromName(StartBeforeOpt);
+  StartAfter = getPassIDFromName(StartAfterOpt);
+  StopBefore = getPassIDFromName(StopBeforeOpt);
+  StopAfter = getPassIDFromName(StopAfterOpt);
+  if (StartBefore && StartAfter)
+    report_fatal_error(Twine(StartBeforeOptName) + Twine(" and ") +
+                       Twine(StartAfterOptName) + Twine(" specified!"));
+  if (StopBefore && StopAfter)
+    report_fatal_error(Twine(StopBeforeOptName) + Twine(" and ") +
+                       Twine(StopAfterOptName) + Twine(" specified!"));
+  Started = (StartAfter == nullptr) && (StartBefore == nullptr);
+}
+
 // Out of line constructor provides default values for pass options and
 // registers all common codegen passes.
 TargetPassConfig::TargetPassConfig(LLVMTargetMachine &TM, PassManagerBase &pm)
     : ImmutablePass(ID), PM(&pm), TM(&TM) {
   Impl = new PassConfigImpl();
 
   // Register all target independent codegen passes to activate their PassIDs,
   // including this pass itself.
   initializeCodeGen(*PassRegistry::getPassRegistry());
 
   // Also register alias analysis passes required by codegen passes.
   initializeBasicAAWrapperPassPass(*PassRegistry::getPassRegistry());
   initializeAAResultsWrapperPassPass(*PassRegistry::getPassRegistry());
 
   // Substitute Pseudo Pass IDs for real ones.
   substitutePass(&EarlyTailDuplicateID, &TailDuplicateID);
   substitutePass(&PostRAMachineLICMID, &MachineLICMID);
 
   if (StringRef(PrintMachineInstrs.getValue()).equals(""))
     TM.Options.PrintMachineCode = true;
 
   if (TM.Options.EnableIPRA)
     setRequiresCodeGenSCCOrder();
+
+  setStartStopPasses();
 }
 
 CodeGenOpt::Level TargetPassConfig::getOptLevel() const {
   return TM->getOptLevel();
 }
 
 /// Insert InsertedPassID pass after TargetPassID.
 void TargetPassConfig::insertPass(AnalysisID TargetPassID,

 
 TargetPassConfig::TargetPassConfig()
   : ImmutablePass(ID) {
   report_fatal_error("Trying to construct TargetPassConfig without a target "
                      "machine. Scheduling a CodeGen pass without a target "
                      "triple set?");
 }
 
+bool TargetPassConfig::hasLimitedCodeGenPipeline() const {
+  return StartBefore || StartAfter || StopBefore || StopAfter;
+}
+
+std::string
+TargetPassConfig::getLimitedCodeGenPipelineReason(const char *Separator) const {
+  if (!hasLimitedCodeGenPipeline())
+    return std::string();
+  std::string Res;
+  static cl::opt<std::string> *PassNames[] = {&StartAfterOpt, &StartBeforeOpt,
+                                              &StopAfterOpt, &StopBeforeOpt};
+  static const char *OptNames[] = {StartAfterOptName, StartBeforeOptName,
+                                   StopAfterOptName, StopBeforeOptName};
+  bool IsFirst = true;
+  for (int Idx = 0; Idx < 4; ++Idx)
+    if (!PassNames[Idx]->empty()) {
+      if (!IsFirst)
+        Res += Separator;
+      IsFirst = false;
+      Res += OptNames[Idx];
+    }
+  return Res;
+}
+
 // Helper to verify the analysis is really immutable.
 void TargetPassConfig::setOpt(bool &Opt, bool Val) {
   assert(!Initialized && "PassConfig is immutable");
   Opt = Val;
 }
 
 void TargetPassConfig::substitutePass(AnalysisID StandardID,
                                       IdentifyingPassPtr TargetID) {

test/CodeGen/Generic/llc-start-stop.ll

 ; START-BEFORE: FunctionPass Manager
 ; START-BEFORE: Loop Strength Reduction
 ; START-BEFORE-NEXT: Lower Garbage Collection Instructions
 
 ; RUN: not llc < %s -start-before=nonexistent -o /dev/null 2>&1 | FileCheck %s -check-prefix=NONEXISTENT-START-BEFORE
 ; RUN: not llc < %s -stop-before=nonexistent -o /dev/null 2>&1 | FileCheck %s -check-prefix=NONEXISTENT-STOP-BEFORE
 ; RUN: not llc < %s -start-after=nonexistent -o /dev/null 2>&1 | FileCheck %s -check-prefix=NONEXISTENT-START-AFTER
 ; RUN: not llc < %s -stop-after=nonexistent -o /dev/null 2>&1 | FileCheck %s -check-prefix=NONEXISTENT-STOP-AFTER
-; NONEXISTENT-START-BEFORE: start-before pass is not registered.
-; NONEXISTENT-STOP-BEFORE: stop-before pass is not registered.
-; NONEXISTENT-START-AFTER: start-after pass is not registered.
-; NONEXISTENT-STOP-AFTER: stop-after pass is not registered.
+; NONEXISTENT-START-BEFORE: "nonexistent" pass is not registered.
+; NONEXISTENT-STOP-BEFORE: "nonexistent" pass is not registered.
+; NONEXISTENT-START-AFTER: "nonexistent" pass is not registered.
+; NONEXISTENT-STOP-AFTER: "nonexistent" pass is not registered.
 
 ; RUN: not llc < %s -start-before=loop-reduce -start-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=DOUBLE-START
 ; RUN: not llc < %s -stop-before=loop-reduce -stop-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=DOUBLE-STOP
-; DOUBLE-START: -start-before and -start-after specified!
-; DOUBLE-STOP: -stop-before and -stop-after specified!
+; DOUBLE-START: start-before and start-after specified!
+; DOUBLE-STOP: stop-before and stop-after specified!

tools/llc/llc.cpp

CompileTwice("compile-twice", cl::Hidden,
                           "manager and verify the result is the same."),
                  cl::init(false));
 
 static cl::opt<bool> DiscardValueNames(
     "discard-value-names",
     cl::desc("Discard names from Value (other than GlobalValue)."),
     cl::init(false), cl::Hidden);
 
-static cl::opt<std::string> StopBefore("stop-before",
-    cl::desc("Stop compilation before a specific pass"),
-    cl::value_desc("pass-name"), cl::init(""));
-
-static cl::opt<std::string> StopAfter("stop-after",
-    cl::desc("Stop compilation after a specific pass"),
-    cl::value_desc("pass-name"), cl::init(""));
-
-static cl::opt<std::string> StartBefore("start-before",
-    cl::desc("Resume compilation before a specific pass"),
-    cl::value_desc("pass-name"), cl::init(""));
-
-static cl::opt<std::string> StartAfter("start-after",
-    cl::desc("Resume compilation after a specific pass"),
-    cl::value_desc("pass-name"), cl::init(""));
-
 static cl::list<std::string> IncludeDirs("I", cl::desc("include search path"));
 
 static cl::opt<bool> PassRemarksWithHotness(
     "pass-remarks-with-hotness",
     cl::desc("With PGO, include profile count in optimization remarks"),
     cl::Hidden);
 
 static cl::opt<unsigned> PassRemarksHotnessThreshold(
static bool addPass(PassManagerBase &PM, const char *argv0,
   }
   std::string Banner = std::string("After ") + std::string(P->getPassName());
   PM.add(P);
   TPC.printAndVerify(Banner);
 
   return false;
 }
 
-static AnalysisID getPassID(const char *argv0, const char *OptionName,
-                            StringRef PassName) {
-  if (PassName.empty())
-    return nullptr;
-
-  const PassRegistry &PR = *PassRegistry::getPassRegistry();
-  const PassInfo *PI = PR.getPassInfo(PassName);
-  if (!PI) {
-    errs() << argv0 << ": " << OptionName << " pass is not registered.\n";
-    exit(1);
-  }
-  return PI->getTypeInfo();
-}
-
 static int compileModule(char **argv, LLVMContext &Context) {
   // Load the module to be compiled...
   SMDiagnostic Err;
   std::unique_ptr<Module> M;
   std::unique_ptr<MIRParser> MIR;
   Triple TheTriple;
 
   bool SkipModule = MCPU == "help" ||
if (RelaxAll.getNumOccurrences() > 0 &&
     std::unique_ptr<raw_svector_ostream> BOS;
     if ((FileType != TargetMachine::CGFT_AssemblyFile &&
          !Out->os().supportsSeeking()) ||
         CompileTwice) {
       BOS = make_unique<raw_svector_ostream>(Buffer);
       OS = BOS.get();
     }
 
     const char *argv0 = argv[0];
-    AnalysisID StartBeforeID = getPassID(argv0, "start-before", StartBefore);
-    AnalysisID StartAfterID = getPassID(argv0, "start-after", StartAfter);
-    AnalysisID StopAfterID = getPassID(argv0, "stop-after", StopAfter);
-    AnalysisID StopBeforeID = getPassID(argv0, "stop-before", StopBefore);
-    if (StartBeforeID && StartAfterID) {
-      errs() << argv0 << ": -start-before and -start-after specified!\n";
-      return 1;
-    }
-    if (StopBeforeID && StopAfterID) {
-      errs() << argv0 << ": -stop-before and -stop-after specified!\n";
-      return 1;
-    }
+    MachineModuleInfo *MMI = nullptr;
 
-    if (MIR) {
-      // Construct a custom pass pipeline that starts after instruction
-      // selection.
+    if (!RunPassNames->empty()) {
+      if (!MIR) {
+        errs() << argv0 << ": run-pass is for .mir file only.\n";
+        return 1;
+      }
       LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine&>(*Target);
       TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
+      if (TPC.hasLimitedCodeGenPipeline()) {
+        errs() << argv0 << ": run-pass cannot be used with "
+               << TPC.getLimitedCodeGenPipelineReason(" and ") << ".\n";
+        return 1;
+      }
+
       TPC.setDisableVerify(NoVerify);
       PM.add(&TPC);
-      MachineModuleInfo *MMI = new MachineModuleInfo(&LLVMTM);
-      if (MIR->parseMachineFunctions(*M, *MMI))
-        return 1;
+      MMI = new MachineModuleInfo(&LLVMTM);
       PM.add(MMI);
       TPC.printAndVerify("");
-
-      if (!RunPassNames->empty()) {
-        if (!StartAfter.empty() || !StopAfter.empty() || !StartBefore.empty() ||
-            !StopBefore.empty()) {
-          errs() << argv0 << ": start-after and/or stop-after passes are "
-                               "redundant when run-pass is specified.\n";
-          return 1;
-        }
-
-        for (const std::string &RunPassName : *RunPassNames) {
-          if (addPass(PM, argv0, RunPassName, TPC))
-            return 1;
-        }
-      } else {
-        TPC.setStartStopPasses(StartBeforeID, StartAfterID, StopBeforeID,
-                               StopAfterID);
-        TPC.addISelPasses();
-        TPC.addMachinePasses();
-      }
       TPC.setInitialized();
-
-      if (!StopBefore.empty() || !StopAfter.empty() || !RunPassNames->empty()) {
-        PM.add(createPrintMIRPass(*OS));
-      } else if (LLVMTM.addAsmPrinter(PM, *OS, FileType, MMI->getContext())) {
-        errs() << argv0 << ": target does not support generation of this"
-               << " file type!\n";
-        return 1;
-      }
-      PM.add(createFreeMachineFunctionPass());
-    } else if (Target->addPassesToEmitFile(PM, *OS, FileType, NoVerify,
-                                           StartBeforeID, StartAfterID,
-                                           StopBeforeID, StopAfterID)) {
-      errs() << argv0 << ": target does not support generation of this"
-        << " file type!\n";
+      PM.add(createFreeMachineFunctionPass());
+    } else if (Target->addPassesToEmitFile(PM, *OS, FileType, NoVerify, &MMI)) {
+
+    if (MIR) {
+      assert(MMI && "addPassesToEmitFile didn't set MMI");
+      if (MIR->parseMachineFunctions(*M, *MMI))
         return 1;
     }
 
     // Before executing passes, print the final values of the LLVM options.
     cl::PrintOptionValues();
 
     // If requested, run the pass manager over the same module again,
     // to catch any bugs due to persistent state in the passes. Note that
     // opt has the same functionality, so it may be worth abstracting this out