Support providing pass schedule to new passmanager as a YAML input

[serge-sans-paille]

Summary

In addition to the existing textual representation, offer the ability to use a YAML file to provide pass schedule specification.
Using a standard format for which LLVM has a parser would make integration with other tools easier.

One could also envision a world were -On configuration would be stored as .yml file within llvm, and a world where clang would load a custom config from a user-provided config file.

As a side effect, if the temporary schedule structure were saved has a class member, we could dump it back for free.

[serge-sans-paille]

@chandlerc up!

[serge-sans-paille]

Up!

[serge-sans-paille]

@chandlerc any chance you could have a look at this?

include/llvm/Passes/PassBuilder.h

 #include <vector>
 
 namespace llvm {
 class StringRef;
 class AAManager;
 class TargetMachine;
 class ModuleSummaryIndex;
 
+namespace yaml {
+class Input;
+}
+
 /// A struct capturing PGO tunables.
 struct PGOOptions {
   enum PGOAction { NoAction, IRInstr, IRUse, SampleUse };
   enum CSPGOAction { NoCSAction, CSIRInstr, CSIRUse };
   PGOOptions(std::string ProfileFile = "", std::string CSProfileGenFile = "",
              std::string ProfileRemappingFile = "", PGOAction Action = NoAction,
              CSPGOAction CSAction = NoCSAction, bool SamplePGOSupport = false)
       : ProfileFile(ProfileFile), CSProfileGenFile(CSProfileGenFile),
public:
   /// combinations. Note that these shortcuts don't introduce any other magic.
   /// If the sequence of passes aren't all the exact same kind of pass, it will
   /// be an error. You cannot mix different levels implicitly, you must
   /// explicitly form a pass manager in which to nest passes.
   Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
                           bool VerifyEachPass = true,
                           bool DebugLogging = false);
 
+  /// This is equivalent to parsePassPipeline, but using a YAML input structured
+  /// as followed:
+  /// - name: module:
+  ///   elements:
+  ///     - name: function
+  ///       elements:
+  ///         - name: fpass1
+  ///         - name: fpass2
+  ///         - name: fpass3
+  /// - name: module:
+  ///   elements:
+  ///     - name: cgscc
+  ///       elements:
+  ///         - name: cgpass1
+  ///         - name: cgpass2
+  ///         - name: cgpass3
+  /// - name: module:
+  ///   elements:
+  ///     - name: function
+  ///       elements:
+  ///         - name: loop:
+  ///           elements:
+  ///             - name: lpass1
+  ///             - name: lpass2
+  ///             - name: lpass3
+  Error parsePassPipeline(ModulePassManager &MPM, yaml::Input &PipelineYAML,
+                          bool VerifyEachPass = true,
+                          bool DebugLogging = false);
+
   /// {{@ Parse a textual pass pipeline description into a specific PassManager
   ///
   /// Automatic deduction of an appropriate pass manager stack is not supported.
   /// For example, to insert a loop pass 'lpass' into a FunctinoPassManager,
   /// this is the valid pipeline text:
   ///
   ///   function(lpass)
   Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText,
void registerParseTopLevelPipelineCallback(
                                bool VerifyEachPass, bool DebugLogging)> &C) {
     TopLevelPipelineParsingCallbacks.push_back(C);
   }
 
 private:
   static Optional<std::vector<PipelineElement>>
   parsePipelineText(StringRef Text);
 
+  static Optional<std::vector<PipelineElement>>
+  parsePipelineYAML(yaml::Input &Yin);
+
+  Error normalizeAndParseModulePassPipleline(
+      ModulePassManager &MPM,
+      std::vector<PassBuilder::PipelineElement> &&Pipeline, bool VerifyEachPass,
+      bool DebugLogging);
   Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
                         bool VerifyEachPass, bool DebugLogging);
   Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
                        bool VerifyEachPass, bool DebugLogging);
   Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
                           bool VerifyEachPass, bool DebugLogging);
   Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
                       bool VerifyEachPass, bool DebugLogging);

lib/Passes/PassBuilder.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/SafepointIRVerifier.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
+#include "llvm/Support/YAMLTraits.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
 #include "llvm/Transforms/IPO/AlwaysInliner.h"
 #include "llvm/Transforms/IPO/ArgumentPromotion.h"
 #include "llvm/Transforms/IPO/CalledValuePropagation.h"
 #include "llvm/Transforms/IPO/ConstantMerge.h"
 #include "llvm/Transforms/IPO/CrossDSOCFI.h"
 #include "llvm/Transforms/IPO/DeadArgumentElimination.h"
if (PipelineStack.size() > 1)
     // Unbalanced paretheses.
     return None;
 
   assert(PipelineStack.back() == &ResultPipeline &&
          "Wrong pipeline at the bottom of the stack!");
   return {std::move(ResultPipeline)};
 }
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(PassBuilder::PipelineElement)
+
+template <> struct yaml::MappingTraits<PassBuilder::PipelineElement> {
+  static void mapping(yaml::IO &io, PassBuilder::PipelineElement &PE) {
+    io.mapRequired("name", PE.Name);
+    io.mapOptional("elements", PE.InnerPipeline);
+  }
+};
+
+Optional<std::vector<PassBuilder::PipelineElement>>
+PassBuilder::parsePipelineYAML(yaml::Input &Yin) {
+  std::vector<PipelineElement> Yang;
+  Yin >> Yang;
+  if (Yin.error())
+    return None;
+  return {std::move(Yang)};
+}
+
 Error PassBuilder::parseModulePass(ModulePassManager &MPM,
                                    const PipelineElement &E,
                                    bool VerifyEachPass, bool DebugLogging) {
   auto &Name = E.Name;
   auto &InnerPipeline = E.InnerPipeline;
 
   // First handle complex passes like the pass managers which carry pipelines.
   if (!InnerPipeline.empty()) {
for (const auto &Element : Pipeline) {
     if (auto Err = parseModulePass(MPM, Element, VerifyEachPass, DebugLogging))
       return Err;
     if (VerifyEachPass)
       MPM.addPass(VerifierPass());
   }
   return Error::success();
 }
 
-// Primary pass pipeline description parsing routine for a \c ModulePassManager
-// FIXME: Should this routine accept a TargetMachine or require the caller to
-// pre-populate the analysis managers with target-specific stuff?
-Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
-                                     StringRef PipelineText,
-                                     bool VerifyEachPass, bool DebugLogging) {
-  auto Pipeline = parsePipelineText(PipelineText);
-  if (!Pipeline || Pipeline->empty())
-    return make_error<StringError>(
-        formatv("invalid pipeline '{0}'", PipelineText).str(),
-        inconvertibleErrorCode());
-
+Error PassBuilder::normalizeAndParseModulePassPipleline(
+    ModulePassManager &MPM,
+    std::vector<PassBuilder::PipelineElement> &&Pipeline, bool VerifyEachPass,
+    bool DebugLogging) {
   // If the first name isn't at the module layer, wrap the pipeline up
   // automatically.
-  StringRef FirstName = Pipeline->front().Name;
+  StringRef FirstName = Pipeline.front().Name;
 
   if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
     if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
-      Pipeline = {{"cgscc", std::move(*Pipeline)}};
+      Pipeline = {{"cgscc", std::move(Pipeline)}};
     } else if (isFunctionPassName(FirstName,
                                   FunctionPipelineParsingCallbacks)) {
-      Pipeline = {{"function", std::move(*Pipeline)}};
+      Pipeline = {{"function", std::move(Pipeline)}};
     } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks)) {
-      Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}};
+      Pipeline = {{"function", {{"loop", std::move(Pipeline)}}}};
     } else {
       for (auto &C : TopLevelPipelineParsingCallbacks)
-        if (C(MPM, *Pipeline, VerifyEachPass, DebugLogging))
+        if (C(MPM, Pipeline, VerifyEachPass, DebugLogging))
           return Error::success();
 
       // Unknown pass or pipeline name!
-      auto &InnerPipeline = Pipeline->front().InnerPipeline;
+      auto &InnerPipeline = Pipeline.front().InnerPipeline;
       return make_error<StringError>(
           formatv("unknown {0} name '{1}'",
                   (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
               .str(),
           inconvertibleErrorCode());
     }
   }
 
   if (auto Err =
-          parseModulePassPipeline(MPM, *Pipeline, VerifyEachPass, DebugLogging))
+          parseModulePassPipeline(MPM, Pipeline, VerifyEachPass, DebugLogging))
     return Err;
   return Error::success();
 }
 
+// Primary pass pipeline description parsing routine for a \c ModulePassManager
+// FIXME: Should this routine accept a TargetMachine or require the caller to
+// pre-populate the analysis managers with target-specific stuff?
+Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
+                                     StringRef PipelineText,
+                                     bool VerifyEachPass, bool DebugLogging) {
+  auto Pipeline = parsePipelineText(PipelineText);
+  if (!Pipeline || Pipeline->empty())
+    return make_error<StringError>(
+        formatv("invalid pipeline '{0}'", PipelineText).str(),
+        inconvertibleErrorCode());
+
+  return normalizeAndParseModulePassPipleline(MPM, std::move(*Pipeline),
+                                              VerifyEachPass, DebugLogging);
+}
+
+Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
+                                     yaml::Input &PipelineYAML,
+                                     bool VerifyEachPass, bool DebugLogging) {
+  auto Pipeline = parsePipelineYAML(PipelineYAML);
+  if (!Pipeline || Pipeline->empty())
+    return make_error<StringError>("invalid YAML pipeline '{0}'",
+                                   inconvertibleErrorCode());
+  return normalizeAndParseModulePassPipleline(MPM, std::move(*Pipeline),
+                                              VerifyEachPass, DebugLogging);
+}
+
 // Primary pass pipeline description parsing routine for a \c CGSCCPassManager
 Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
                                      StringRef PipelineText,
                                      bool VerifyEachPass, bool DebugLogging) {
   auto Pipeline = parsePipelineText(PipelineText);
   if (!Pipeline || Pipeline->empty())
     return make_error<StringError>(
         formatv("invalid pipeline '{0}'", PipelineText).str(),

test/MC/X86/intel-syntax-2.s

 fsub
 // CHECK: fsubp %st, %st(1)
 fsubr
 // CHECK: fsubrp %st, %st(1)
 fdiv
 // CHECK: fdivp %st, %st(1)
 fdivr
 // CHECK: fdivrp %st, %st(1)
+
+_test4:
+.intel_syntax
+// CHECK: movl $26, -4(%rsp)
+  mov  DWORD PTR [RSP - 4], 1ah

unittests/IR/PassBuilderCallbacksTest.cpp

 #include <llvm/Analysis/LoopAnalysisManager.h>
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/PassInstrumentation.h>
 #include <llvm/IR/PassManager.h>
 #include <llvm/Passes/PassBuilder.h>
 #include <llvm/Support/Regex.h>
 #include <llvm/Support/SourceMgr.h>
+#include <llvm/Support/YAMLTraits.h>
 #include <llvm/Transforms/Scalar/LoopPassManager.h>
 
 using namespace llvm;
 
 namespace {
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::DoDefault;
ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Succeeded())
       << "Pipeline was: " << PipelineText;
   PM.run(*M, AM);
 
   /// Test the negative case
   PipelineText = "another-pipeline(instcombine)";
   ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, PipelineText, true), Failed())
       << "Pipeline was: " << PipelineText;
 }
+
+TEST_F(ModuleCallbacksTest, YAMLSimplePipelineTest) {
+  StringRef PipelineYAML = R"(
+- name: test-transform
+)";
+  yaml::Input Yin{PipelineYAML};
+  ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, Yin, true), Succeeded())
+      << "Pipeline was: " << PipelineYAML;
+}
+
+TEST_F(ModuleCallbacksTest, YAMLPipelineWithElementsTest) {
+  StringRef PipelineYAML = R"(
+- name: module
+  elements:
+    - name: test-transform
+    - name: invalidate<test-analysis>
+)";
+
+  yaml::Input Yin{PipelineYAML};
+  ASSERT_THAT_ERROR(PB.parsePassPipeline(PM, Yin, true), Succeeded())
+      << "Pipeline was: " << PipelineYAML;
+}
+
 } // end anonymous namespace