AS, allow only RA passes

Author: optimisan

llvm/include/llvm/Passes/CodeGenPassBuilder.h

@@ -610,7 +610,7 @@ Error CodeGenPassBuilder<Derived, TargetMachineT>::buildPipeline(
 
   if (!Opt.RegAllocPipeline.empty())
     return make_error<StringError>(
-        "Extra passes in regalloc pipeline: " + Opt.RegAllocPipeline,
+        "extra passes in regalloc pipeline: " + Opt.RegAllocPipeline,
         std::make_error_code(std::errc::invalid_argument));
 
   return verifyStartStop(*StartStopInfo);
@@ -1125,8 +1125,7 @@ bool CodeGenPassBuilder<Derived, TargetMachineT>::addRegAllocPassFromOpt(
     StringRef PassOpt;
     std::tie(PassOpt, Opt.RegAllocPipeline) = Opt.RegAllocPipeline.split(',');
     // Reuse the registered parser to parse the pass name.
-#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER,    \
-                                          PARAMS)                              \
+#define RA_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)          \
   if (PB.checkParametrizedPassName(PassOpt, NAME)) {                           \
     auto Params = PB.parsePassParameters(PARSER, PassOpt, NAME,                \
                                          const_cast<const PassBuilder &>(PB)); \
@@ -1136,17 +1135,17 @@ bool CodeGenPassBuilder<Derived, TargetMachineT>::addRegAllocPassFromOpt(
     }                                                                          \
     if (!MatchPassTo.empty()) {                                                \
       if (MatchPassTo != CLASS)                                                \
-        report_fatal_error("Expected " +                                       \
+        report_fatal_error("expected " +                                       \
                                PIC->getPassNameForClassName(MatchPassTo) +     \
-                               " in option -regalloc-npm",                     \
+                               " in option --regalloc-npm",                    \
                            false);                                             \
     }                                                                          \
     addPass(CREATE_PASS(Params.get()));                                        \
     return true;                                                               \
   }
 #include "llvm/Passes/MachinePassRegistry.def"
     if (PassOpt != "default") {
-      report_fatal_error("Unknown register allocator pass: " + PassOpt, false);
+      report_fatal_error("unknown register allocator pass: " + PassOpt, false);
     }
   }
   // If user did not give a specific pass, use the default provided.

llvm/include/llvm/Passes/MachinePassRegistry.def

@@ -239,7 +239,15 @@ MACHINE_FUNCTION_PASS_WITH_PARAMS(
     },
     parseMachineSinkingPassOptions, "enable-sink-fold")
 
-MACHINE_FUNCTION_PASS_WITH_PARAMS(
+#ifndef RA_PASS_WITH_PARAMS
+// Define MachineFunction passes that are register allocators.
+// This is to differentiate them from other MachineFunction passes
+// to be used in the --regalloc-npm option.
+#define RA_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)          \
+  MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
+#endif
+
+RA_PASS_WITH_PARAMS(
     "regallocfast", "RegAllocFastPass",
     [](RegAllocFastPass::Options Opts) { return RegAllocFastPass(Opts); },
     [](StringRef Params, const PassBuilder &PB) {
@@ -248,13 +256,15 @@ MACHINE_FUNCTION_PASS_WITH_PARAMS(
     "filter=reg-filter;no-clear-vregs")
 
 // 'all' is the default filter.
-MACHINE_FUNCTION_PASS_WITH_PARAMS(
+RA_PASS_WITH_PARAMS(
     "greedy", "RAGreedyPass",
     [](RAGreedyPass::Options Opts) { return RAGreedyPass(Opts); },
     [](StringRef Params, const PassBuilder &PB) {
       return parseRegAllocGreedyFilterFunc(PB, Params);
-    }, "reg-filter"
-)
+    },
+    "reg-filter")
+
+#undef RA_PASS_WITH_PARAMS
 #undef MACHINE_FUNCTION_PASS_WITH_PARAMS
 
 // After a pass is converted to new pass manager, its entry should be moved from

llvm/include/llvm/Target/CGPassBuilderOption.h

@@ -21,22 +21,6 @@
 namespace llvm {
 
 enum class RunOutliner { TargetDefault, AlwaysOutline, NeverOutline };
-enum class RegAllocType { Unset, Default, Basic, Fast, Greedy, PBQP };
-
-class RegAllocTypeParser : public cl::parser<RegAllocType> {
-public:
-  RegAllocTypeParser(cl::Option &O) : cl::parser<RegAllocType>(O) {}
-  void initialize() {
-    cl::parser<RegAllocType>::initialize();
-    addLiteralOption("default", RegAllocType::Default,
-                     "Default register allocator");
-    addLiteralOption("pbqp", RegAllocType::PBQP, "PBQP register allocator");
-    addLiteralOption("fast", RegAllocType::Fast, "Fast register allocator");
-    addLiteralOption("basic", RegAllocType::Basic, "Basic register allocator");
-    addLiteralOption("greedy", RegAllocType::Greedy,
-                     "Greedy register allocator");
-  }
-};
 
 // Not one-on-one but mostly corresponding to commandline options in
 // TargetPassConfig.cpp.

llvm/test/tools/llc/new-pm/x86_64-regalloc-pipeline.mir

@@ -11,13 +11,18 @@
 # attempts to insert an extraneous pass.
 # RUN: not llc -mtriple=x86_64-unknown-linux-gnu -enable-new-pm -O3 -regalloc-npm='default,default,basic' 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
 
-# RUN: not llc -mtriple=x86_64-unknown-linux-gnu -enable-new-pm -O3 -regalloc-npm='invalidpass' -print-pipeline-passes %s -o - 2>&1 | FileCheck %s --check-prefix=CHECK-INVALID
+# RUN: not llc -mtriple=x86_64-unknown-linux-gnu -enable-new-pm -O3 -regalloc-npm='machine-cp' -print-pipeline-passes %s -o - 2>&1 | FileCheck %s --check-prefix=CHECK-INVALID
+# RUN: not llc -mtriple=x86_64-unknown-linux-gnu -enable-new-pm -passes='machine-sink' -regalloc-npm='greedy' -print-pipeline-passes %s -o - 2>&1 | FileCheck %s --check-prefix=CHECK-BOTH-INVALID
+
+# RUN: not llc -mtriple=x86_64-unknown-linux-gnu -enable-new-pm -O0 -regalloc-npm='greedy' -print-pipeline-passes %s -o - 2>&1 | FileCheck %s --check-prefix=CHECK-ONLY-FAST
 
 # CHECK: greedy<tile-reg>
 # CHECK: greedy<all>
 
 # CHECK-FAST: regallocfast
 # CHECK-GREEDY: greedy<all>
 # CHECK-GREEDY-FILTER: greedy<tile-reg>
-# CHECK-ERROR: Extra passes in regalloc pipeline: basic
-# CHECK-INVALID: Unknown register allocator pass: invalidpass
+# CHECK-ERROR: extra passes in regalloc pipeline: basic
+# CHECK-INVALID: unknown register allocator pass: machine-cp
+# CHECK-BOTH-INVALID: --passes and --regalloc-npm cannot be used together
+# CHECK-ONLY-FAST: expected regallocfast in option --regalloc-npm

llvm/tools/llc/NewPMDriver.cpp

@@ -49,9 +49,9 @@
 using namespace llvm;
 
 static cl::opt<std::string>
-    RegAlloc("regalloc-npm",
-             cl::desc("Register allocator to use for new pass manager"),
-             cl::Hidden);
+    RegAllocPasses("regalloc-npm",
+                   cl::desc("Register allocator to use for new pass manager"),
+                   cl::Hidden);
 
 static cl::opt<bool>
     DebugPM("debug-pass-manager", cl::Hidden,
@@ -98,14 +98,19 @@ int llvm::compileModuleWithNewPM(
         << TargetPassConfig::getLimitedCodeGenPipelineReason() << ".\n";
     return 1;
   }
+  if (!PassPipeline.empty() && !RegAllocPasses.empty()) {
+    WithColor::error(errs(), Arg0)
+        << "--passes and --regalloc-npm cannot be used together.\n";
+    return 1;
+  }
 
   raw_pwrite_stream *OS = &Out->os();
 
   // Fetch options from TargetPassConfig
   CGPassBuilderOption Opt = getCGPassBuilderOption();
   Opt.DisableVerify = VK != VerifierKind::InputOutput;
   Opt.DebugPM = DebugPM;
-  Opt.RegAllocPipeline = RegAlloc;
+  Opt.RegAllocPipeline = RegAllocPasses;
 
   MachineModuleInfo MMI(Target.get());