[llvm] [CodeGen][NPM] Support generic regalloc-npm option (PR #172485)

[Matt Arsenault via llvm-commits]

================
@@ -1135,32 +1155,76 @@ void CodeGenPassBuilder<Derived, TargetMachineT>::addTargetRegisterAllocator(
     addMachineFunctionPass(RegAllocFastPass(), PMW);
 }
 
+template <typename Derived, typename TargetMachineT>
+template <typename RegAllocPassBuilderT>
+void CodeGenPassBuilder<Derived, TargetMachineT>::addRegAllocPassOrOpt(
+    PassManagerWrapper &PMW, RegAllocPassBuilderT PassBuilder) const {
+  if (auto Err = addRegAllocPassFromOpt(PMW)) {
+    report_fatal_error(std::move(Err));
+  }
+  if (Opt.RegAllocPipeline.empty())
+    addMachineFunctionPass(std::move(PassBuilder()), PMW);
+}
+
+template <typename Derived, typename TargetMachineT>
+Error CodeGenPassBuilder<Derived, TargetMachineT>::addRegAllocPassFromOpt(
+    PassManagerWrapper &PMW, StringRef MatchPassTo) const {
+  StringRef Pipeline = Opt.RegAllocPipeline;
+  if (Pipeline.empty())
+    return Error::success();
+
+  StringRef PassOpt;
+  std::tie(PassOpt, Opt.RegAllocPipeline) = Pipeline.split(',');
+
+  if (PassOpt == "default")
+    return Error::success();
+
+  bool Matched = false;
+  // Reuse the registered parser to parse the pass name.
+#define RA_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)          \
+  if (PassBuilder::checkParametrizedPassName(PassOpt, NAME)) {                 \
+    if (!MatchPassTo.empty() && MatchPassTo != CLASS) {                        \
+      return make_error<StringError>(                                          \
+          Twine("expected ") + PIC->getPassNameForClassName(MatchPassTo) +     \
+              " in option --regalloc-npm",                                     \
+          inconvertibleErrorCode());                                           \
+    }                                                                          \
+    auto Params = PassBuilder::parsePassParameters(PARSER, PassOpt, NAME, PB); \
+    if (!Params)                                                               \
+      return Params.takeError();                                               \
+    addMachineFunctionPass(CREATE_PASS(*Params), PMW);                         \
+    Matched = true;                                                            \
+  }
+#include "llvm/Passes/MachinePassRegistry.def"
+
+  if (!Matched)
+    return make_error<StringError>(Twine("unknown register allocator pass: ") +
+                                       PassOpt,
+                                   inconvertibleErrorCode());
+
+  return Error::success();
+}
+
 /// Find and instantiate the register allocation pass requested by this target
 /// at the current optimization level.  Different register allocators are
 /// defined as separate passes because they may require different analysis.
 ///
-/// This helper ensures that the -regalloc-npm= option is always available,
-/// even for targets that override the default allocator.
+/// This helper ensures that the -regalloc-npm-pipeline= option is always
+/// available, even for targets that override the default allocator.
 template <typename Derived, typename TargetMachineT>
 void CodeGenPassBuilder<Derived, TargetMachineT>::addRegAllocPass(
     PassManagerWrapper &PMW, bool Optimized) const {
-  // Use the specified -regalloc-npm={basic|greedy|fast|pbqp}
-  if (Opt.RegAlloc > RegAllocType::Default) {
-    switch (Opt.RegAlloc) {
-    case RegAllocType::Fast:
-      addMachineFunctionPass(RegAllocFastPass(), PMW);
-      break;
-    case RegAllocType::Greedy:
-      addMachineFunctionPass(RAGreedyPass(), PMW);
-      break;
-    default:
-      reportFatalUsageError("register allocator not supported yet");
-    }
-    return;
+  // At O0 (not optimized), only regallocfast is allowed
+  StringRef MatchPassTo = Optimized ? StringRef{} : "RegAllocFastPass";
+
+  // Use the specified -regalloc-npm-pipeline= option if provided
+  if (auto Err = addRegAllocPassFromOpt(PMW, MatchPassTo)) {
+    report_fatal_error(std::move(Err));
----------------
arsenm wrote:

```suggestion
    reportFatalUsageError(std::move(Err));
```
Ditto

https://github.com/llvm/llvm-project/pull/172485