[mlir] Remove uses of LLVM's legacy pass manager

[aeubanks]

Summary

Use the new pass manager.

This also removes the ability to run arbitrary sets of passes. Not sure if this functionality is used, but it doesn't seem to be tested.

No need to initialize passes outside of constructing the PassBuilder with the new pass manager.

[mehdi_amini]

Pre-merge checks are failing:

mlir-cpu-runner: /var/lib/buildkite-agent/builds/llvm-project/llvm/lib/Passes/PassBuilderPipelines.cpp:1286: llvm::ModulePassManager llvm::PassBuilder::buildPerModuleDefaultPipeline(llvm::OptimizationLevel, bool): Assertion `Level != OptimizationLevel::O0 && "Must request optimizations for the default pipeline!"' failed.

[aeubanks]

fix -O0

[aeubanks]

check optLevel in JitRunner.cpp

mlir/include/mlir/ExecutionEngine/OptUtils.h

 //===- OptUtils.h - MLIR Execution Engine opt pass utilities ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the utility functions to trigger LLVM optimizations from
 // MLIR Execution Engine.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_OPTUTILS_H
 #define MLIR_EXECUTIONENGINE_OPTUTILS_H
 
-#include "llvm/Pass.h"
-
 #include <functional>
 #include <string>
 
 namespace llvm {
 class Module;
 class Error;
 class TargetMachine;
 } // namespace llvm
 
 namespace mlir {
 
-/// Initialize LLVM passes that can be used when running MLIR code using
-/// ExecutionEngine.
-void initializeLLVMPasses();
-
 /// Create a module transformer function for MLIR ExecutionEngine that runs
 /// LLVM IR passes corresponding to the given speed and size optimization
 /// levels (e.g. -O2 or -Os). If not null, `targetMachine` is used to
 /// initialize passes that provide target-specific information to the LLVM
 /// optimizer. `targetMachine` must outlive the returned std::function.
 std::function<llvm::Error(llvm::Module *)>
 makeOptimizingTransformer(unsigned optLevel, unsigned sizeLevel,
                           llvm::TargetMachine *targetMachine);
 
-/// Create a module transformer function for MLIR ExecutionEngine that runs
-/// LLVM IR passes explicitly specified, plus an optional optimization level,
-/// Any optimization passes, if present, will be inserted before the pass at
-/// position optPassesInsertPos. If not null, `targetMachine` is used to
-/// initialize passes that provide target-specific information to the LLVM
-/// optimizer. `targetMachine` must outlive the returned std::function.
-std::function<llvm::Error(llvm::Module *)>
-makeLLVMPassesTransformer(llvm::ArrayRef<const llvm::PassInfo *> llvmPasses,
-                          llvm::Optional<unsigned> mbOptLevel,
-                          llvm::TargetMachine *targetMachine,
-                          unsigned optPassesInsertPos = 0);
-
 } // namespace mlir
 
 #endif // MLIR_EXECUTIONENGINE_OPTUTILS_H

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

mlirExecutionEngineCreate(MlirModule op, int optLevel, int numPaths,
 
   SmallVector<StringRef> libPaths;
   for (unsigned i = 0; i < static_cast<unsigned>(numPaths); ++i)
     libPaths.push_back(sharedLibPaths[i].data);
 
   // Create a transformer to run all LLVM optimization passes at the
   // specified optimization level.
   auto llvmOptLevel = static_cast<llvm::CodeGenOpt::Level>(optLevel);
-  auto transformer = mlir::makeLLVMPassesTransformer(
-      /*passes=*/{}, llvmOptLevel, /*targetMachine=*/tmOrError->get());
+  auto transformer = mlir::makeOptimizingTransformer(
+      llvmOptLevel, /*sizeLevel=*/0, /*targetMachine=*/tmOrError->get());
   ExecutionEngineOptions jitOptions;
   jitOptions.transformer = transformer;
   jitOptions.jitCodeGenOptLevel = llvmOptLevel;
   jitOptions.sharedLibPaths = libPaths;
   auto jitOrError = ExecutionEngine::create(unwrap(op), jitOptions);
   if (!jitOrError) {
     consumeError(jitOrError.takeError());
     return MlirExecutionEngine{nullptr};

mlir/lib/ExecutionEngine/JitRunner.cpp

llvm::cl::opt<std::string> mainFuncName{
       llvm::cl::value_desc("<function name>"), llvm::cl::init("main")};
   llvm::cl::opt<std::string> mainFuncType{
       "entry-point-result",
       llvm::cl::desc("Textual description of the function type to be called"),
       llvm::cl::value_desc("f32 | i32 | i64 | void"), llvm::cl::init("f32")};
 
   llvm::cl::OptionCategory optFlags{"opt-like flags"};
 
-  // CLI list of pass information
-  llvm::cl::list<const llvm::PassInfo *, bool, llvm::PassNameParser> llvmPasses{
-      llvm::cl::desc("LLVM optimizing passes to run"), llvm::cl::cat(optFlags)};
-
   // CLI variables for -On options.
   llvm::cl::opt<bool> optO0{"O0",
                             llvm::cl::desc("Run opt passes and codegen at O0"),
                             llvm::cl::cat(optFlags)};
   llvm::cl::opt<bool> optO1{"O1",
                             llvm::cl::desc("Run opt passes and codegen at O1"),
                             llvm::cl::cat(optFlags)};
   llvm::cl::opt<bool> optO2{"O2",
int mlir::JitRunnerMain(int argc, char **argv, const DialectRegistry &registry,
   // Create the options struct containing the command line options for the
   // runner. This must come before the command line options are parsed.
   Options options;
   llvm::cl::ParseCommandLineOptions(argc, argv, "MLIR CPU execution driver\n");
 
   Optional<unsigned> optLevel = getCommandLineOptLevel(options);
   SmallVector<std::reference_wrapper<llvm::cl::opt<bool>>, 4> optFlags{
       options.optO0, options.optO1, options.optO2, options.optO3};
-  unsigned optCLIPosition = 0;
-  // Determine if there is an optimization flag present, and its CLI position
-  // (optCLIPosition).
-  for (unsigned j = 0; j < 4; ++j) {
-    auto &flag = optFlags[j].get();
-    if (flag) {
-      optCLIPosition = flag.getPosition();
-      break;
-    }
-  }
-  // Generate vector of pass information, plus the index at which we should
-  // insert any optimization passes in that vector (optPosition).
-  SmallVector<const llvm::PassInfo *, 4> passes;
-  unsigned optPosition = 0;
-  for (unsigned i = 0, e = options.llvmPasses.size(); i < e; ++i) {
-    passes.push_back(options.llvmPasses[i]);
-    if (optCLIPosition < options.llvmPasses.getPosition(i)) {
-      optPosition = i;
-      optCLIPosition = UINT_MAX; // To ensure we never insert again
-    }
-  }
 
   MLIRContext context(registry);
 
   auto m = parseMLIRInput(options.inputFilename, &context);
   if (!m) {
     llvm::errs() << "could not parse the input IR\n";
     return 1;
   }
 
   if (config.mlirTransformer)
     if (failed(config.mlirTransformer(m.get())))
       return EXIT_FAILURE;
 
   auto tmBuilderOrError = llvm::orc::JITTargetMachineBuilder::detectHost();
   if (!tmBuilderOrError) {
     llvm::errs() << "Failed to create a JITTargetMachineBuilder for the host\n";
     return EXIT_FAILURE;
   }
   auto tmOrError = tmBuilderOrError->createTargetMachine();
   if (!tmOrError) {
     llvm::errs() << "Failed to create a TargetMachine for the host\n";
     return EXIT_FAILURE;
   }
 
-  auto transformer = mlir::makeLLVMPassesTransformer(
-      passes, optLevel, /*targetMachine=*/tmOrError->get(), optPosition);
-
   CompileAndExecuteConfig compileAndExecuteConfig;
-  compileAndExecuteConfig.transformer = transformer;
+  if (optLevel) {
+    compileAndExecuteConfig.transformer = mlir::makeOptimizingTransformer(
+        *optLevel, /*sizeLevel=*/0, /*targetMachine=*/tmOrError->get());
+  }
   compileAndExecuteConfig.llvmModuleBuilder = config.llvmModuleBuilder;
   compileAndExecuteConfig.runtimeSymbolMap = config.runtimesymbolMap;
 
   // Get the function used to compile and execute the module.
   using CompileAndExecuteFnT =
       Error (*)(Options &, ModuleOp, StringRef, CompileAndExecuteConfig);
   auto compileAndExecuteFn =
       StringSwitch<CompileAndExecuteFnT>(options.mainFuncType.getValue())

mlir/lib/ExecutionEngine/OptUtils.cpp

 //===- OptUtils.cpp - MLIR Execution Engine optimization pass utilities ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the utility functions to trigger LLVM optimizations from
 // MLIR Execution Engine.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/OptUtils.h"
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/IR/LegacyPassManager.h"
-#include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Passes/OptimizationLevel.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/StringSaver.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Transforms/Coroutines.h"
-#include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
-#include <climits>
-#include <mutex>
-
-// Run the module and function passes managed by the module manager.
-static void runPasses(llvm::legacy::PassManager &modulePM,
-                      llvm::legacy::FunctionPassManager &funcPM,
-                      llvm::Module &m) {
-  funcPM.doInitialization();
-  for (auto &func : m) {
-    funcPM.run(func);
-  }
-  funcPM.doFinalization();
-  modulePM.run(m);
-}
 
-// Initialize basic LLVM transformation passes under lock.
-void mlir::initializeLLVMPasses() {
-  static std::mutex mutex;
-  std::lock_guard<std::mutex> lock(mutex);
-
-  auto &registry = *llvm::PassRegistry::getPassRegistry();
-  llvm::initializeCore(registry);
-  llvm::initializeTransformUtils(registry);
-  llvm::initializeScalarOpts(registry);
-  llvm::initializeIPO(registry);
-  llvm::initializeInstCombine(registry);
-  llvm::initializeAggressiveInstCombine(registry);
-  llvm::initializeAnalysis(registry);
-  llvm::initializeVectorization(registry);
-  llvm::initializeCoroutines(registry);
-}
+using namespace llvm;
 
-// Populate pass managers according to the optimization and size levels.
-// This behaves similarly to LLVM opt.
-static void populatePassManagers(llvm::legacy::PassManager &modulePM,
-                                 llvm::legacy::FunctionPassManager &funcPM,
-                                 unsigned optLevel, unsigned sizeLevel,
-                                 llvm::TargetMachine *targetMachine) {
-  llvm::PassManagerBuilder builder;
-  builder.OptLevel = optLevel;
-  builder.SizeLevel = sizeLevel;
-  builder.Inliner = llvm::createFunctionInliningPass(
-      optLevel, sizeLevel, /*DisableInlineHotCallSite=*/false);
-  builder.LoopVectorize = optLevel > 1 && sizeLevel < 2;
-  builder.SLPVectorize = optLevel > 1 && sizeLevel < 2;
-  builder.DisableUnrollLoops = (optLevel == 0);
-
-  // Add all coroutine passes to the builder.
-  addCoroutinePassesToExtensionPoints(builder);
-
-  if (targetMachine) {
-    // Add pass to initialize TTI for this specific target. Otherwise, TTI will
-    // be initialized to NoTTIImpl by default.
-    modulePM.add(createTargetTransformInfoWrapperPass(
-        targetMachine->getTargetIRAnalysis()));
-    funcPM.add(createTargetTransformInfoWrapperPass(
-        targetMachine->getTargetIRAnalysis()));
-  }
+static Optional<OptimizationLevel> mapToLevel(unsigned optLevel,
+                                              unsigned sizeLevel) {
+  switch (optLevel) {
+  case 0:
+    return OptimizationLevel::O0;
 
-  builder.populateModulePassManager(modulePM);
-  builder.populateFunctionPassManager(funcPM);
-}
+  case 1:
+    return OptimizationLevel::O1;
 
-// Create and return a lambda that uses LLVM pass manager builder to set up
-// optimizations based on the given level.
-std::function<llvm::Error(llvm::Module *)>
-mlir::makeOptimizingTransformer(unsigned optLevel, unsigned sizeLevel,
-                                llvm::TargetMachine *targetMachine) {
-  return [optLevel, sizeLevel, targetMachine](llvm::Module *m) -> llvm::Error {
-    llvm::legacy::PassManager modulePM;
-    llvm::legacy::FunctionPassManager funcPM(m);
-    populatePassManagers(modulePM, funcPM, optLevel, sizeLevel, targetMachine);
-    runPasses(modulePM, funcPM, *m);
+  case 2:
+    switch (sizeLevel) {
+    case 0:
+      return OptimizationLevel::O2;
 
-    return llvm::Error::success();
-  };
-}
+    case 1:
+      return OptimizationLevel::Os;
 
-// Create and return a lambda that is given a set of passes to run, plus an
-// optional optimization level to pre-populate the pass manager.
-std::function<llvm::Error(llvm::Module *)> mlir::makeLLVMPassesTransformer(
-    llvm::ArrayRef<const llvm::PassInfo *> llvmPasses,
-    llvm::Optional<unsigned> mbOptLevel, llvm::TargetMachine *targetMachine,
-    unsigned optPassesInsertPos) {
-  return [llvmPasses, mbOptLevel, optPassesInsertPos,
-          targetMachine](llvm::Module *m) -> llvm::Error {
-    llvm::legacy::PassManager modulePM;
-    llvm::legacy::FunctionPassManager funcPM(m);
-
-    bool insertOptPasses = mbOptLevel.hasValue();
-    for (unsigned i = 0, e = llvmPasses.size(); i < e; ++i) {
-      const auto *passInfo = llvmPasses[i];
-      if (!passInfo->getNormalCtor())
-        continue;
-
-      if (insertOptPasses && optPassesInsertPos == i) {
-        populatePassManagers(modulePM, funcPM, mbOptLevel.getValue(), 0,
-                             targetMachine);
-        insertOptPasses = false;
-      }
+    case 2:
+      return OptimizationLevel::Oz;
 
-      auto *pass = passInfo->createPass();
-      if (!pass)
-        return llvm::make_error<llvm::StringError>(
-            "could not create pass " + passInfo->getPassName(),
-            llvm::inconvertibleErrorCode());
-      modulePM.add(pass);
-    }
+  case 3:
+    return OptimizationLevel::O3;
+  return None;
+}
+// Create and return a lambda that uses LLVM pass manager builder to set up
+// optimizations based on the given level.
+std::function<Error(Module *)>
+mlir::makeOptimizingTransformer(unsigned optLevel, unsigned sizeLevel,
+                                TargetMachine *targetMachine) {
+  return [optLevel, sizeLevel, targetMachine](Module *m) -> Error {
+    Optional<OptimizationLevel> ol = mapToLevel(optLevel, sizeLevel);
+    if (!ol) {
+      return make_error<StringError>(
+          formatv("invalid optimization/size level {0}/{1}", optLevel,
+                  sizeLevel)
+              .str(),
+          inconvertibleErrorCode());
+    }
+    LoopAnalysisManager lam;
+    FunctionAnalysisManager fam;
+    CGSCCAnalysisManager cgam;
+    ModuleAnalysisManager mam;
+
+    PassBuilder pb(targetMachine);
+
+    pb.registerModuleAnalyses(mam);
+    pb.registerCGSCCAnalyses(cgam);
+    pb.registerFunctionAnalyses(fam);
+    pb.registerLoopAnalyses(lam);
+    pb.crossRegisterProxies(lam, fam, cgam, mam);
+
+    ModulePassManager mpm;
+    if (*ol == OptimizationLevel::O0)
+      mpm.addPass(pb.buildO0DefaultPipeline(*ol));
+    else
+      mpm.addPass(pb.buildPerModuleDefaultPipeline(*ol));
 
-    if (insertOptPasses)
-      populatePassManagers(modulePM, funcPM, mbOptLevel.getValue(), 0,
-                           targetMachine);
-
-    runPasses(modulePM, funcPM, *m);
-    return llvm::Error::success();
+    mpm.run(*m, mam);
+    return Error::success();
   };
 }

mlir/tools/mlir-cpu-runner/mlir-cpu-runner.cpp

 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 
 int main(int argc, char **argv) {
   llvm::InitLLVM y(argc, argv);
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
   llvm::InitializeNativeTargetAsmParser();
-  mlir::initializeLLVMPasses();
 
   mlir::DialectRegistry registry;
   mlir::registerAllToLLVMIRTranslations(registry);
 
   return mlir::JitRunnerMain(argc, argv, registry);
 }

mlir/tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp

static LogicalResult runMLIRPasses(ModuleOp module) {
   return passManager.run(module);
 }
 
 int main(int argc, char **argv) {
   llvm::InitLLVM y(argc, argv);
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
-  mlir::initializeLLVMPasses();
 
   mlir::JitRunnerConfig jitRunnerConfig;
   jitRunnerConfig.mlirTransformer = runMLIRPasses;
   jitRunnerConfig.llvmModuleBuilder = convertMLIRModule;
 
   mlir::DialectRegistry registry;
   registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect,
                   mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
                   mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
   mlir::registerLLVMDialectTranslation(registry);
 
   return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig);
 }

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

 
 int main(int argc, char **argv) {
   llvm::llvm_shutdown_obj x;
   registerPassManagerCLOptions();
 
   llvm::InitLLVM y(argc, argv);
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
-  mlir::initializeLLVMPasses();
 
   mlir::JitRunnerConfig jitRunnerConfig;
   jitRunnerConfig.mlirTransformer = runMLIRPasses;
 
   mlir::DialectRegistry registry;
   registry.insert<mlir::arith::ArithmeticDialect, mlir::LLVM::LLVMDialect,
                   mlir::gpu::GPUDialect, mlir::spirv::SPIRVDialect,
                   mlir::func::FuncDialect, mlir::memref::MemRefDialect>();
   mlir::registerLLVMDialectTranslation(registry);
 
   return mlir::JitRunnerMain(argc, argv, registry, jitRunnerConfig);
 }