[llvm-c] Add convenience method for running a default optimization pipeline

[aeubanks]

Summary

So people don't have to worry about the exact syntax of pipelines like "default<O3>".

llvm/docs/ReleaseNotes.rst

 --------------------
 
 * ``LLVMContextSetOpaquePointers``, a temporary API to pin to legacy typed
   pointer, has been removed.
 * Functions for adding legacy passes like ``LLVMAddInstructionCombiningPass``
   have been removed.
 * Removed ``LLVMPassManagerBuilderRef`` and functions interacting with it.
   These belonged to the no longer supported legacy pass manager.
+* ``LLVMRunOptimizationPipeline`` was added as a convenience method to run a
+  default optimization pipeline.
 * As part of the opaque pointer transition, ``LLVMGetElementType`` no longer
   gives the pointee type of a pointer type.
 
 Changes to the FastISel infrastructure
 --------------------------------------
 
 * ...
 

llvm/include/llvm-c/Transforms/PassBuilder.h

  * pipelines may also be invoked using `default<O3>` and friends. See opt for
  * full reference of the Passes format.
  */
 LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes,
                            LLVMTargetMachineRef TM,
                            LLVMPassBuilderOptionsRef Options);
 
 /**
+ * Construct and run an optimization pipeline over a module.
+ *
+ * This is a convenience method equivalent to
+ * `LLVMRunPasses(..., "default<On>", ...)`.
+ */
+LLVMErrorRef LLVMRunOptimizationPipeline(LLVMModuleRef M, int SpeedLevel,
+                                         int SizeLevel, LLVMTargetMachineRef TM,
+                                         LLVMPassBuilderOptionsRef Options);
+
+/**
  * Create a new set of options for a PassBuilder
  *
  * Ownership of the returned instance is given to the client, and they are
  * responsible for it. The client should call LLVMDisposePassBuilderOptions
  * to free the pass builder options.
  */
 LLVMPassBuilderOptionsRef LLVMCreatePassBuilderOptions(void);
 

llvm/include/llvm/Passes/OptimizationLevel.h

 /// Each level has a specific goal and rationale.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASSES_OPTIMIZATIONLEVEL_H
 #define LLVM_PASSES_OPTIMIZATIONLEVEL_H
 
 #include <assert.h>
+#include <optional>
 
 namespace llvm {
 
 class OptimizationLevel final {
   unsigned SpeedLevel = 2;
   unsigned SizeLevel = 0;
   OptimizationLevel(unsigned SpeedLevel, unsigned SizeLevel)
       : SpeedLevel(SpeedLevel), SizeLevel(SizeLevel) {
public:
   }
   bool operator!=(const OptimizationLevel &Other) const {
     return SizeLevel != Other.SizeLevel || SpeedLevel != Other.SpeedLevel;
   }
 
   unsigned getSpeedupLevel() const { return SpeedLevel; }
 
   unsigned getSizeLevel() const { return SizeLevel; }
+
+  static std::optional<OptimizationLevel> fromSpeedAndSizeLevel(unsigned Speed,
+                                                                unsigned Size);
 };
 } // namespace llvm
 
 #endif

llvm/lib/Passes/OptimizationLevel.cpp

const OptimizationLevel OptimizationLevel::O3 = {
     /*SpeedLevel*/ 3,
     /*SizeLevel*/ 0};
 const OptimizationLevel OptimizationLevel::Os = {
     /*SpeedLevel*/ 2,
     /*SizeLevel*/ 1};
 const OptimizationLevel OptimizationLevel::Oz = {
     /*SpeedLevel*/ 2,
     /*SizeLevel*/ 2};
+
+std::optional<OptimizationLevel>
+OptimizationLevel::fromSpeedAndSizeLevel(unsigned Speed, unsigned Size) {
+  if (Speed == 0 && Size == 0)
+    return O0;
+  if (Speed == 1 && Size == 0)
+    return O1;
+  if (Speed == 2 && Size == 0)
+    return O2;
+  if (Speed == 3 && Size == 0)
+    return O3;
+  if (Speed == 2 && Size == 1)
+    return Os;
+  if (Speed == 2 && Size == 2)
+    return Oz;
+  return std::nullopt;
+}

llvm/lib/Passes/PassBuilderBindings.cpp

 //===-------------- PassBuilder bindings for LLVM-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
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the C bindings to the new pass manager
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/Transforms/PassBuilder.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/Error.h"
 
 using namespace llvm;
 
 namespace llvm {
 /// Helper struct for holding a set of builder options for LLVMRunPasses. This
 /// structure is used to keep LLVMRunPasses backwards compatible with future
 /// versions in case we modify the options the new Pass Manager utilizes.
 class LLVMPassBuilderOptions {
LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes,
   if (auto Err = PB.parsePassPipeline(MPM, Passes)) {
     return wrap(std::move(Err));
   }
 
   MPM.run(*Mod, MAM);
   return LLVMErrorSuccess;
 }
 
+LLVMErrorRef LLVMRunOptimizationPipeline(LLVMModuleRef M, int SpeedLevel,
+                                         int SizeLevel, LLVMTargetMachineRef TM,
+                                         LLVMPassBuilderOptionsRef Options) {
+  std::optional<OptimizationLevel> OL =
+      OptimizationLevel::fromSpeedAndSizeLevel(SpeedLevel, SizeLevel);
+  if (!OL) {
+    return wrap(make_error<StringError>(
+        formatv("invalid speed/size level combination: {0} {1}", SpeedLevel,
+                SizeLevel)
+            .str(),
+        inconvertibleErrorCode()));
+  }
+  TargetMachine *Machine = unwrap(TM);
+  LLVMPassBuilderOptions *PassOpts = unwrap(Options);
+  bool Debug = PassOpts->DebugLogging;
+  bool VerifyEach = PassOpts->VerifyEach;
+
+  Module *Mod = unwrap(M);
+  PassInstrumentationCallbacks PIC;
+  PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC);
+
+  LoopAnalysisManager LAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModuleAnalysisManager MAM;
+  PB.registerLoopAnalyses(LAM);
+  PB.registerFunctionAnalyses(FAM);
+  PB.registerCGSCCAnalyses(CGAM);
+  PB.registerModuleAnalyses(MAM);
+  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+  StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach);
+  SI.registerCallbacks(PIC, &FAM);
+  ModulePassManager MPM;
+  if (VerifyEach)
+    MPM.addPass(VerifierPass());
+  if (*OL == OptimizationLevel::O0)
+    MPM.addPass(PB.buildO0DefaultPipeline(*OL));
+  else
+    MPM.addPass(PB.buildPerModuleDefaultPipeline(*OL));
+
+  MPM.run(*Mod, MAM);
+  return LLVMErrorSuccess;
+}
+
 LLVMPassBuilderOptionsRef LLVMCreatePassBuilderOptions() {
   return wrap(new LLVMPassBuilderOptions());
 }
 
 void LLVMPassBuilderOptionsSetVerifyEach(LLVMPassBuilderOptionsRef Options,
                                          LLVMBool VerifyEach) {
   unwrap(Options)->VerifyEach = VerifyEach;
 }

llvm/unittests/Passes/PassBuilderBindings/PassBuilderBindingsTest.cpp

if (LLVMErrorRef E = LLVMRunPasses(Module, "default<O2>", TM, Options)) {
     char *Msg = LLVMGetErrorMessage(E);
     LLVMConsumeError(E);
     LLVMDisposePassBuilderOptions(Options);
     FAIL() << "Failed to run passes: " << Msg;
   }
   LLVMDisposePassBuilderOptions(Options);
 }
 
+TEST_F(PassBuilderCTest, Pipeline) {
+  LLVMPassBuilderOptionsRef Options = LLVMCreatePassBuilderOptions();
+  LLVMPassBuilderOptionsSetLoopUnrolling(Options, 1);
+  LLVMPassBuilderOptionsSetVerifyEach(Options, 1);
+  LLVMPassBuilderOptionsSetDebugLogging(Options, 0);
+  if (LLVMErrorRef E = LLVMRunOptimizationPipeline(Module, 2, 0, TM, Options)) {
+    char *Msg = LLVMGetErrorMessage(E);
+    LLVMConsumeError(E);
+    FAIL() << "Failed to run passes: " << Msg;
+  }
+  LLVMDisposePassBuilderOptions(Options);
+}
+
+TEST_F(PassBuilderCTest, O0Pipeline) {
+  LLVMPassBuilderOptionsRef Options = LLVMCreatePassBuilderOptions();
+  LLVMPassBuilderOptionsSetLoopUnrolling(Options, 1);
+  LLVMPassBuilderOptionsSetVerifyEach(Options, 1);
+  LLVMPassBuilderOptionsSetDebugLogging(Options, 0);
+  if (LLVMErrorRef E = LLVMRunOptimizationPipeline(Module, 0, 0, TM, Options)) {
+    char *Msg = LLVMGetErrorMessage(E);
+    LLVMConsumeError(E);
+    FAIL() << "Failed to run passes: " << Msg;
+  }
+  LLVMDisposePassBuilderOptions(Options);
+}
+
+TEST_F(PassBuilderCTest, BadPipeline) {
+  LLVMPassBuilderOptionsRef Options = LLVMCreatePassBuilderOptions();
+  LLVMPassBuilderOptionsSetLoopUnrolling(Options, 1);
+  LLVMPassBuilderOptionsSetVerifyEach(Options, 1);
+  LLVMPassBuilderOptionsSetDebugLogging(Options, 0);
+  if (LLVMErrorRef E = LLVMRunOptimizationPipeline(Module, 3, 1, TM, Options)) {
+    LLVMConsumeError(E);
+  } else {
+    FAIL() << "Unexpectedly passed";
+  }
+  LLVMDisposePassBuilderOptions(Options);
+}
+
 TEST_F(PassBuilderCTest, InvalidPassIsError) {
   LLVMPassBuilderOptionsRef Options = LLVMCreatePassBuilderOptions();
   LLVMErrorRef E1 = LLVMRunPasses(Module, "", TM, Options);
   LLVMErrorRef E2 = LLVMRunPasses(Module, "does-not-exist-pass", TM, Options);
   ASSERT_TRUE(E1);
   ASSERT_TRUE(E2);
   LLVMConsumeError(E1);
   LLVMConsumeError(E2);
   LLVMDisposePassBuilderOptions(Options);
 }