[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

479–485

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?

509–516

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

479–485

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

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

509–516

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

479–485

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

479–485

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

304–307

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

304–307

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/Target/TargetMachine.h

protected: // Can only create subclasses.
 
   unsigned RequireStructuredCFG : 1;
   unsigned O0WantsFastISel : 1;
 
 public:
   const TargetOptions DefaultOptions;
   mutable TargetOptions Options;
 
+  /// Provide a generic way to handle the Start/Stop After/Before
+  /// parameters of addPassesToEmitFile.
+  /// @{
+  /// Name of the commandline option to set the StartAfter parameter.
+  static const char *StartAfterOptName;
+  /// Name of the commandline option to set the StartAfter parameter.
+  static const char *StartBeforeOptName;
+  /// Name of the commandline option to set the StopAfter parameter.
+  static const char *StopAfterOptName;
+  /// Name of the commandline option to set the StopBefore parameter.
+  static const char *StopBeforeOptName;
+
+  /// Enum of the different options available to control the pipeline
+  /// when emitting a file (addPassesToEmitFile).
+  enum PipelineControlOption {
+    StartAfter,
+    StartBefore,
+    StopAfter,
+    StopBefore,
+    LastPipelineControlOption = StopBefore
+  };
+
+  /// Helper method to get the pass ID of the Start/Stop After/Before
+  /// passes from the generic options.
+  /// \p Kind defines which pass ID we look for.
+  ///
+  /// This uses getPassID with the value of the related option as
+  /// PassName. In other words, \see getPassID for the usage of
+  /// \p AbortIfNotRegistered.
+  static AnalysisID getPassIDForOption(PipelineControlOption Kind,
+                                       bool AbortIfNotRegistered = true);
+
+  /// Helper method to get the pass ID of \p PassName.
+  /// This is a simple wrapper around getPassInfo.
+  static AnalysisID getPassID(StringRef PassName,
+                              bool AbortIfNotRegistered = true);
+
+  /// Helper method to get the pass ID of the StartAfter generic option.
+  /// \see getPassIDForOption.
+  static AnalysisID getStartAfterID(bool AbortIfNotRegistered = true) {
+    return getPassIDForOption(TargetMachine::StartAfter, AbortIfNotRegistered);
+  }
+
+  /// Helper method to get the pass ID of the StartBefore generic option.
+  /// \see getPassIDForOption.
+  static AnalysisID getStartBeforeID(bool AbortIfNotRegistered = true) {
+    return getPassIDForOption(TargetMachine::StartBefore, AbortIfNotRegistered);
+  }
+
+  /// Helper method to get the pass ID of the StopAfter generic option.
+  /// \see getPassIDForOption.
+  static AnalysisID getStopAfterID(bool AbortIfNotRegistered = true) {
+    return getPassIDForOption(TargetMachine::StopAfter, AbortIfNotRegistered);
+  }
+
+  /// Helper method to get the pass ID of the StopBefore generic option.
+  /// \see getPassIDForOption.
+  static AnalysisID getStopBeforeID(bool AbortIfNotRegistered = true) {
+    return getPassIDForOption(TargetMachine::StopBefore, AbortIfNotRegistered);
+  }
+
+  /// Helper method to get the PassInfo of \p PassName
+  /// \p AbortIfNotRegistered will abort the process if the name of
+  /// the pass specified with the related option hasn't been found.
+  /// This parameter has no effect if the option was not set.
+  ///
+  /// \pre The pass registry has been initialized.
+  ///
+  /// \return The PassInfo of \p PassName or nullptr if PassName is empty
+  /// or this pass does not exist.
+  static const PassInfo *getPassInfo(StringRef PassName,
+                                     bool AbortIfNotRegistered = true);
+  /// @}
+
   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; }
public:
   };
 
   /// 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,
+      bool /*DisableVerify*/ = true,
+      AnalysisID StartBefore = getStartBeforeID(),
+      AnalysisID StartAfter = getStartAfterID(),
+      AnalysisID StopBefore = getStopBeforeID(),
+      AnalysisID StopAfter = getStopAfterID(),
       MachineFunctionInitializer * /*MFInitializer*/ = 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.
   ///
public:
   /// 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,
+      bool DisableVerify = true, AnalysisID StartBefore = getStartBeforeID(),
+      AnalysisID StartAfter = getStartAfterID(),
+      AnalysisID StopBefore = getStopBeforeID(),
+      AnalysisID StopAfter = getStopAfterID(),
       MachineFunctionInitializer *MFInitializer = 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;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TARGET_TARGETMACHINE_H

lib/Target/TargetMachine.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
 
+const char *TargetMachine::StartAfterOptName = "start-after";
+const char *TargetMachine::StartBeforeOptName = "start-before";
+const char *TargetMachine::StopAfterOptName = "stop-after";
+const char *TargetMachine::StopBeforeOptName = "stop-before";
+
+static cl::opt<std::string>
+    StartAfterOpt(StringRef(TargetMachine::StartAfterOptName),
+                  cl::desc("Resume compilation after a specific pass"),
+                  cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StartBeforeOpt(StringRef(TargetMachine::StartBeforeOptName),
+                   cl::desc("Resume compilation before a specific pass"),
+                   cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StopAfterOpt(StringRef(TargetMachine::StopAfterOptName),
+                 cl::desc("Stop compilation after a specific pass"),
+                 cl::value_desc("pass-name"), cl::init(""));
+
+static cl::opt<std::string>
+    StopBeforeOpt(StringRef(TargetMachine::StopBeforeOptName),
+                  cl::desc("Stop compilation before a specific pass"),
+                  cl::value_desc("pass-name"), cl::init(""));
+
 cl::opt<bool> EnableIPRA("enable-ipra", cl::init(false), cl::Hidden,
                          cl::desc("Enable interprocedural register allocation "
                                   "to reduce load/store at procedure calls."));
 
 //---------------------------------------------------------------------------
 // TargetMachine Class
 //
 

 
 TargetMachine::~TargetMachine() {
   delete AsmInfo;
   delete MRI;
   delete MII;
   delete STI;
 }
 
+AnalysisID TargetMachine::getPassIDForOption(PipelineControlOption Kind,
+                                             bool AbortIfNotRegistered) {
+  static cl::opt<std::string> *PassNames[] = {&StartAfterOpt, &StartBeforeOpt,
+                                              &StopAfterOpt, &StopBeforeOpt};
+#define CHECK_OPT(OPTNAME)                                                     \
+  assert(PassNames[TargetMachine::OPTNAME] == &OPTNAME##Opt &&                 \
+         "Static array is messed up for " #OPTNAME);
+  CHECK_OPT(StartAfter);
+  CHECK_OPT(StartBefore);
+  CHECK_OPT(StopAfter);
+  CHECK_OPT(StopBefore);
+  static_assert(LastPipelineControlOption == 3,
+                "The check before needs to be updated");
+  return getPassID(*PassNames[Kind], AbortIfNotRegistered);
+}
+
+const PassInfo *TargetMachine::getPassInfo(StringRef PassName,
+                                           bool AbortIfNotRegistered) {
+  if (PassName.empty())
+    return nullptr;
+
+  const PassRegistry &PR = *PassRegistry::getPassRegistry();
+  const PassInfo *PI = PR.getPassInfo(PassName);
+  if (!PI && AbortIfNotRegistered) {
+    errs() << "\"" << PassName << "\" pass is not registered.\n";
+    exit(1);
+  }
+  return PI;
+}
+
+AnalysisID TargetMachine::getPassID(StringRef PassName,
+                                    bool AbortIfNotRegistered) {
+  const PassInfo *PI = getPassInfo(PassName, AbortIfNotRegistered);
+  return PI ? PI->getTypeInfo() : nullptr;
+}
+
 bool TargetMachine::isPositionIndependent() const {
   return getRelocationModel() == Reloc::PIC_;
 }
 
 /// \brief Reset the target options based on the function's attributes.
 // FIXME: This function needs to go away for a number of reasons:
 // a) global state on the TargetMachine is terrible in general,
 // b) these target options should be passed only on the function

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!

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<std::string>
int main(int argc, char **argv) {
 
   if (YamlFile)
     YamlFile->keep();
   return 0;
 }
 
 static bool addPass(PassManagerBase &PM, const char *argv0,
                     StringRef PassName, TargetPassConfig &TPC) {
-  if (PassName == "none")
+  if (PassName.empty() || PassName == "none")
     return false;
 
-  const PassRegistry *PR = PassRegistry::getPassRegistry();
-  const PassInfo *PI = PR->getPassInfo(PassName);
-  if (!PI) {
-    errs() << argv0 << ": run-pass " << PassName << " is not registered.\n";
-    return true;
-  }
+  const PassInfo *PI =
+      TargetMachine::getPassInfo(PassName, /*AbortIfNotRegistered=*/true);
+  assert(PI && "We should have aborted in the previous call in that case");
 
   Pass *P;
   if (PI->getTargetMachineCtor())
     P = PI->getTargetMachineCtor()(&TPC.getTM<TargetMachine>());
   else if (PI->getNormalCtor())
     P = PI->getNormalCtor()();
   else {
     errs() << argv0 << ": cannot create pass: " << PI->getPassName() << "\n";
     return true;
   }
   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();
     }
 
+    AnalysisID StartBeforeID = TargetMachine::getStartBeforeID();
+    AnalysisID StartAfterID = TargetMachine::getStartAfterID();
+    AnalysisID StopAfterID = TargetMachine::getStopAfterID();
+    AnalysisID StopBeforeID = TargetMachine::getStopBeforeID();
+
     if (!RunPassNames->empty()) {
-      if (!StartAfter.empty() || !StopAfter.empty() || !StartBefore.empty() ||
-          !StopBefore.empty()) {
+      if (StartAfterID || StopAfterID || StartBeforeID || StopBeforeID) {
         errs() << argv[0] << ": start-after and/or stop-after passes are "
                              "redundant when run-pass is specified.\n";
         return 1;
       }
       if (!MIR) {
         errs() << argv[0] << ": run-pass needs a .mir input.\n";
         return 1;
       }
       LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine&>(*Target);
       TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
       PM.add(&TPC);
       MachineModuleInfo *MMI = new MachineModuleInfo(&LLVMTM);
       MMI->setMachineFunctionInitializer(MIR.get());
       PM.add(MMI);
       TPC.printAndVerify("");
 
       for (const std::string &RunPassName : *RunPassNames) {
         if (addPass(PM, argv[0], RunPassName, TPC))
           return 1;
       }
       PM.add(createPrintMIRPass(*OS));
     } else {
-      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() << argv[0] << ": -start-before and -start-after specified!\n";
         return 1;
       }
       if (StopBeforeID && StopAfterID) {
         errs() << argv[0] << ": -stop-before and -stop-after specified!\n";
         return 1;
       }
 
       // Ask the target to add backend passes as necessary.
       if (Target->addPassesToEmitFile(PM, *OS, FileType, NoVerify,
                                       StartBeforeID, StartAfterID, StopBeforeID,
                                       StopAfterID, MIR.get())) {
         errs() << argv[0] << ": target does not support generation of this"
                << " file type!\n";
         return 1;