Allow llc to run passes under the new pass manager one at a time.

[arsenm]

llvm/tools/llc/llc.cpp

60

This header should be renamed to match the new pass name

209

-run-pass-new would be a slightly less confusing name

[czhang]

rebase & run-new-pass > run-pass-new & clang-format

[probinson]

llvm/tools/llc/llc.cpp

62

Is there some reason these includes aren't in order with the others above?

[czhang]

Rebase

[czhang]

llvm/tools/llc/llc.cpp

62

Yes, these are only needed for the included new pass manager registry. This diff is only meant to hack up llc to actually use the new pass manager, so I thought it would be better to keep these includes visually separate for now.

llvm/tools/llc/llc.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/CodeGen/CommandFlags.inc"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/PassManager.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/RemarkStreamer.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <memory>
+
+#include <llvm/CodeGen/FinalizeISel.h>
+#include <llvm/CodeGen/MIRPrintingPass.h>
+#include <llvm/CodeGen/MachineCSE.h>
+#include <llvm/CodeGen/MachineCopyPropagation.h>
+#include <llvm/CodeGen/MachineDominators.h>
 using namespace llvm;
 
 // General options for llc.  Other pass-specific options are specified
 // within the corresponding llc passes, and target-specific options
 // and back-end code generation options are specified with the target machine.
 //
 static cl::opt<std::string>
 InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));

 static cl::opt<std::string> RemarksFormat(
     "pass-remarks-format",
     cl::desc("The format used for serializing remarks (default: YAML)"),
     cl::value_desc("format"), cl::init("yaml"));
 
 namespace {
 static ManagedStatic<std::vector<std::string>> RunPassNames;
 
+static ManagedStatic<std::vector<std::string>> RunPassNewNames;
+
 struct RunPassOption {
   void operator=(const std::string &Val) const {
     if (Val.empty())
       return;
     SmallVector<StringRef, 8> PassNames;
     StringRef(Val).split(PassNames, ',', -1, false);
     for (auto PassName : PassNames)
       RunPassNames->push_back(PassName);
   }
 };
+
+struct RunPassNewOption {
+  void operator=(const std::string &Val) const {
+    if (Val.empty())
+      return;
+    SmallVector<StringRef, 8> PassNames;
+    StringRef(Val).split(PassNames, ',', -1, false);
+    for (auto PassName : PassNames)
+      RunPassNewNames->push_back(PassName);
+  }
+};
 }
 
 static RunPassOption RunPassOpt;
 
 static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
     "run-pass",
     cl::desc("Run compiler only for specified passes (comma separated list)"),
     cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
 
+static RunPassNewOption RunPassNewOpt;
+
+static cl::opt<RunPassNewOption, true, cl::parser<std::string>> RunPassNew(
+    "run-pass-new",
+    cl::desc(
+        "Run compiler only for specified new passes (comma separated list)"),
+    cl::value_desc("new-pass-name"), cl::ZeroOrMore,
+    cl::location(RunPassNewOpt));
+
 static int compileModule(char **, LLVMContext &);
 
 static std::unique_ptr<ToolOutputFile> GetOutputStream(const char *TargetName,
                                                        Triple::OSType OS,
                                                        const char *ProgName) {
   // If we don't yet have an output filename, make one.
   if (OutputFilename.empty()) {
     if (InputFilename == "-")
for (unsigned I = TimeCompilations; I; --I)
     if (int RetVal = compileModule(argv, Context))
       return RetVal;
 
   if (RemarksFile)
     RemarksFile->keep();
   return 0;
 }
 
+static bool addNewPass(ModulePassManager &PM, MachineFunctionPassManager &MFPM,
+                       const char *argv0, StringRef PassName,
+                       TargetPassConfig &TPC) {
+#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)                               \
+  if (PassName == NAME)                                                        \
+    MFPM.addPass(CREATE_PASS);
+#include "../../lib/Passes/PassRegistry.def"
+  std::string Banner = std::string("After ") + std::string("machine-cp");
+  TPC.printAndVerify(Banner);
+  return false;
+}
+
 static bool addPass(PassManagerBase &PM, const char *argv0,
                     StringRef PassName, TargetPassConfig &TPC) {
   if (PassName == "none")
     return false;
 
   const PassRegistry *PR = PassRegistry::getPassRegistry();
   const PassInfo *PI = PR->getPassInfo(PassName);
   if (!PI) {
if (EC) {
       WithColor::error(errs(), argv[0]) << EC.message() << '\n';
       return 1;
     }
   }
 
   // Build up all of the passes that we want to do to the module.
   legacy::PassManager PM;
 
+  LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine &>(*Target);
+
+  PassInstrumentationCallbacks PIC;
+  PassBuilder PB(TheTarget->createTargetMachine(
+      TheTriple.getTriple(), CPUStr, FeaturesStr, Options, getRelocModel(),
+      getCodeModel(), OLvl));
+  AAManager AA = PB.buildDefaultAAPipeline();
+  MachineFunctionAnalysisManager MFAM;
+  FunctionAnalysisManager FAM;
+  ModuleAnalysisManager MAM;
+
+  PB.registerModuleAnalyses(MAM);
+  PB.registerFunctionAnalyses(FAM);
+  MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
+  FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
+  FAM.registerPass(
+      [&] { return MachineFunctionAnalysisManagerFunctionProxy(MFAM); });
+  FAM.registerPass([&] { return AA; });
+  MFAM.registerPass(
+      [&] { return FunctionAnalysisManagerMachineFunctionProxy(FAM); });
+#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)                           \
+  MFAM.registerPass([&] { return CREATE_PASS; });
+
+  MAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
+  FAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
+  MFAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
+
+#include "../../lib/Passes/PassRegistry.def"
+
+  ModulePassManager MPM;
+  MachineFunctionPassManager MFPM;
+
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(Triple(M->getTargetTriple()));
 
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   PM.add(new TargetLibraryInfoWrapperPass(TLII));
 
+  FAM.registerPass([&] { return TargetLibraryAnalysis(TLII); });
+  MAM.registerPass([&] { return TargetLibraryAnalysis(TLII); });
+
+  MAM.registerPass([&] { return MachineModuleAnalysis(&LLVMTM); });
+
   // Add the target data from the target machine, if it exists, or the module.
   M->setDataLayout(Target->createDataLayout());
 
   // This needs to be done after setting datalayout since it calls verifier
   // to check debug info whereas verifier relies on correct datalayout.
   UpgradeDebugInfo(*M);
 
   // Verify module immediately to catch problems before doInitialization() is
if ((FileType != TargetMachine::CGFT_AssemblyFile &&
       BOS = make_unique<raw_svector_ostream>(Buffer);
       OS = BOS.get();
     }
 
     const char *argv0 = argv[0];
     MachineModuleInfoWrapperPass *MMIWP =
         new MachineModuleInfoWrapperPass(&LLVMTM);
 
+    const bool UsingNewPM = !RunPassNewNames->empty();
+
     // Construct a custom pass pipeline that starts after instruction
     // selection.
     if (!RunPassNames->empty()) {
       if (!MIR) {
         WithColor::warning(errs(), argv[0])
             << "run-pass is for .mir file only.\n";
         return 1;
       }
       TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
       if (TPC.hasLimitedCodeGenPipeline()) {
         WithColor::warning(errs(), argv[0])
             << "run-pass cannot be used with "
             << TPC.getLimitedCodeGenPipelineReason(" and ") << ".\n";
         return 1;
       }
 
       TPC.setDisableVerify(NoVerify);
       PM.add(&TPC);
-      PM.add(MMI);
+      PM.add(MMIWP);
       TPC.printAndVerify("");
       for (const std::string &RunPassName : *RunPassNames) {
         if (addPass(PM, argv0, RunPassName, TPC))
           return 1;
       }
+      for (const std::string &RunPassName : *RunPassNewNames) {
+        if (addNewPass(MPM, MFPM, argv0, RunPassName, TPC))
+          return 1;
+      }
       TPC.setInitialized();
+
+      if (UsingNewPM)
+        MPM.addPass(createModuleToFunctionPassAdaptor(
+            createFunctionToMachineFunctionPassAdaptor(std::move(MFPM))));
+
+      if (UsingNewPM)
+        MPM.addPass(MIRPrintingPass(*OS));
+      else
         PM.add(createPrintMIRPass(*OS));
       PM.add(createFreeMachineFunctionPass());
     } else if (Target->addPassesToEmitFile(PM, *OS,
                                            DwoOut ? &DwoOut->os() : nullptr,
-                                           FileType, NoVerify, MMI)) {
+                                           FileType, NoVerify, MMIWP)) {
       WithColor::warning(errs(), argv[0])
           << "target does not support generation of this"
           << " file type!\n";
       return 1;
     }
 
     if (MIR) {
       assert(MMIWP && "Forgot to create MMIWP?");
-          if (MIR->parseMachineFunctions(*M, MMIWP->getMMI()))
+      if (UsingNewPM) {
+        if (MIR->parseMachineFunctions(
+                *M, MAM.getResult<MachineModuleAnalysis>(*M)))
+          return 1;
+      } else if (MIR->parseMachineFunctions(*M, MMIWP->getMMI()))
         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
     // in the future.
     SmallVector<char, 0> CompileTwiceBuffer;
     if (CompileTwice) {
       std::unique_ptr<Module> M2(llvm::CloneModule(*M));
       PM.run(*M2);
       CompileTwiceBuffer = Buffer;
       Buffer.clear();
     }
 
+    // Now that we have all of the passes ready, run them.
+    {
+      PrettyStackTraceString CrashInfo("Optimizer");
+      MPM.run(*M, MAM);
+    }
+
     PM.run(*M);
 
     auto HasError =
         ((const LLCDiagnosticHandler *)(Context.getDiagHandlerPtr()))->HasError;
     if (*HasError)
       return 1;
 
     // Compare the two outputs and make sure they're the same