[LegacyPM] Rename and deprecate populateModulePassManager

[MaskRay]

Summary

Using LLVM's legacy PM for optimization pipeline was deprecated in
13.0.0
and some rarely used pieces are being removed.

populateModulePassManager is a main API indicating legacy usage. Rename
and deprecate it to make users aware. Use a function attribute instead
of LLVM_ATTRIBUTE_DEPRECATED to allow warning suppression with #pragma
without worrying about MSVC.

[nikic]

Please do not change names in the FFI API at least. It's okay to drop it entirely, but renaming is unnecessarily hostile for FFI APIs.

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

95

This seems like an easy usage to replace?

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

72

Let's not promise any specific timeline. IMHO we should drop this as soon as there are no in-tree users anymore.

llvm/unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

317

This also looks like an easy usage to remove.

[MaskRay]

In D124063#3461133, @nikic wrote:

Please do not change names in the FFI API at least. It's okay to drop it entirely, but renaming is unnecessarily hostile for FFI APIs.

Why?

[nikic]

In D124063#3461171, @MaskRay wrote:

In D124063#3461133, @nikic wrote:

Please do not change names in the FFI API at least. It's okay to drop it entirely, but renaming is unnecessarily hostile for FFI APIs.

Why?

Users of the FFI interface generally target multiple LLVM versions, so they need to introduce checks to use one or the other API -- if lucky only compile-time checks, if not lucky it requires switching the code to use dlsym. This may be unavoidable if an API is removed, but it's an unnecessary complication for a rename.

[MaskRay]

I still do not see the argument about C API, but I just drop that changes.

[aeubanks]

I'd first fix up as many in-tree users as nikic pointed out

(I'll work on bugpoint soonish since that requires a bit more work)

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

72

can we use llvm/include/llvm-c/Deprecated.h for the C API here? looks like we only have on in-tree user in llvm/unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp that we should be able to clean up

[jberdine]

Apologies if this isn't directly related to this patch in particular, but is there a more informative message that could be given than "Migrate to new pass manager"? In particular, for non-C language bindings that currently call LLVMPassManagerBuilderPopulateModulePassManager, any pointers to what functions in the C API should be used instead would be very helpful.

[nikic]

@jberdine See https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm-c/Transforms/PassBuilder.h for C bindings for the new pass manager.

[MaskRay]

So nobody has managed to fix all the in-tree usage. I think having this for the upcoming release/15.x will be nice...

[aeubanks]

polly and clang-fuzzer both call populateModulePassManager just to optimize IR, they should be easily migrated to use the new PM

bugpoint is still an issue, I just haven't found time to work on it yet

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

static void AddOptimizationPasses(legacy::PassManagerBase &MPM,
                                   CodeGenOpt::Level OptLevel,
                                   unsigned SizeLevel) {
   // Create and initialize a PassManagerBuilder
   PassManagerBuilder Builder;
   Builder.OptLevel = OptLevel;
   Builder.SizeLevel = SizeLevel;
   Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel, false);
   Builder.LoopVectorize = true;
-  Builder.populateModulePassManager(MPM);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+  Builder.populateModulePassManagerLegacy(MPM);
 }
 
 // Mimics the opt tool to run an optimization pass over the provided IR
 static std::string OptLLVM(const std::string &IR, CodeGenOpt::Level OLvl) {
   // Create a module that will run the optimization passes
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseIR(MemoryBufferRef(IR, "IR"), Err, Context);

llvm/bindings/ocaml/transforms/passmgr_builder/llvm_passmgr_builder.mli

 external use_inliner_with_threshold : int -> t -> unit
   = "llvm_pmbuilder_use_inliner_with_threshold"
 
 (** See the [llvm::PassManagerBuilder::populateFunctionPassManager] function. *)
 external populate_function_pass_manager
   : [ `Function ] Llvm.PassManager.t -> t -> unit
   = "llvm_pmbuilder_populate_function_pass_manager"
 
-(** See the [llvm::PassManagerBuilder::populateModulePassManager] function. *)
+(** See the [llvm::PassManagerBuilder::populateModulePassManagerLegacy] function. *)
 external populate_module_pass_manager
   : [ `Module ] Llvm.PassManager.t -> t -> unit
   = "llvm_pmbuilder_populate_module_pass_manager"

llvm/bindings/ocaml/transforms/passmgr_builder/passmgr_builder_ocaml.c

value llvm_pmbuilder_populate_function_pass_manager(LLVMPassManagerRef PM,
                                                     value PMB) {
   LLVMPassManagerBuilderPopulateFunctionPassManager(PMBuilder_val(PMB), PM);
   return Val_unit;
 }
 
 /* [ `Module ] Llvm.PassManager.t -> t -> unit */
 value llvm_pmbuilder_populate_module_pass_manager(LLVMPassManagerRef PM,
                                                   value PMB) {
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
   LLVMPassManagerBuilderPopulateModulePassManager(PMBuilder_val(PMB), PM);
   return Val_unit;
 }

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

 LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
                                               unsigned Threshold);
 
 /** See llvm::PassManagerBuilder::populateFunctionPassManager. */
 void
 LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
                                                   LLVMPassManagerRef PM);
 
-/** See llvm::PassManagerBuilder::populateModulePassManager. */
-void
-LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
-                                                LLVMPassManagerRef PM);
+/** See llvm::PassManagerBuilder::populateModulePassManagerLegacy. */
+#ifdef __GNUC__
+__attribute__((deprecated("Migrate to new pass manager for optimization pipeline. This header will be removed soon.")))
+#endif
+void LLVMPassManagerBuilderPopulateModulePassManager(
+    LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM);
 
 /**
  * @}
  */
 
 LLVM_C_EXTERN_C_END
 
 #endif

llvm/include/llvm/Transforms/IPO/PassManagerBuilder.h

 
 /// PassManagerBuilder - This class is used to set up a standard optimization
 /// sequence for languages like C and C++, allowing some APIs to customize the
 /// pass sequence in various ways. A simple example of using it would be:
 ///
 ///  PassManagerBuilder Builder;
 ///  Builder.OptLevel = 2;
 ///  Builder.populateFunctionPassManager(FPM);
-///  Builder.populateModulePassManager(MPM);
+///  Builder.populateModulePassManagerLegacy(MPM);
 ///
 /// In addition to setting up the basic passes, PassManagerBuilder allows
 /// frontends to vend a plugin API, where plugins are allowed to add extensions
 /// to the default pass manager.  They do this by specifying where in the pass
 /// pipeline they want to be added, along with a callback function that adds
 /// the pass(es).  For example, a plugin that wanted to add a loop optimization
 /// could do something like this:
 ///
private:
   void addVectorPasses(legacy::PassManagerBase &PM, bool IsFullLTO);
 
 public:
   /// populateFunctionPassManager - This fills in the function pass manager,
   /// which is expected to be run on each function immediately as it is
   /// generated.  The idea is to reduce the size of the IR in memory.
   void populateFunctionPassManager(legacy::FunctionPassManager &FPM);
 
-  /// populateModulePassManager - This sets up the primary pass manager.
-  void populateModulePassManager(legacy::PassManagerBase &MPM);
+  /// Set up the primary pass manager.
+#ifdef __GNUC__
+  [[deprecated(
+      "Migrate to new pass manager for "
+      "optimization pipeline. This class will be removed in LLVM 16.")]]
+#endif
+  void
+  populateModulePassManagerLegacy(legacy::PassManagerBase &MPM);
 };
 
 /// Registers a function for adding a standard set of passes.  This should be
 /// used by optimizer plugins to allow all front ends to transparently use
 /// them.  Create a static instance of this class in your plugin, providing a
 /// private function that the PassManagerBuilder can use to add your passes.
 class RegisterStandardPasses {
   PassManagerBuilder::GlobalExtensionID ExtensionID;

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::addVectorPasses(legacy::PassManagerBase &PM,
   // After vectorization and unrolling, assume intrinsics may tell us more
   // about pointer alignments.
   PM.add(createAlignmentFromAssumptionsPass());
 
   if (IsFullLTO)
     PM.add(createInstructionCombiningPass());
 }
 
-void PassManagerBuilder::populateModulePassManager(
+void PassManagerBuilder::populateModulePassManagerLegacy(
     legacy::PassManagerBase &MPM) {
   MPM.add(createAnnotation2MetadataLegacyPass());
 
   if (!PGOSampleUse.empty()) {
     MPM.add(createPruneEHPass());
     // In ThinLTO mode, when flattened profile is used, all the available
     // profile information will be annotated in PreLink phase so there is
     // no need to load the profile again in PostLink.

 void
 LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
                                                   LLVMPassManagerRef PM) {
   PassManagerBuilder *Builder = unwrap(PMB);
   legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
   Builder->populateFunctionPassManager(*FPM);
 }
 
-void
-LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
-                                                LLVMPassManagerRef PM) {
+void LLVMPassManagerBuilderPopulateModulePassManager(
+    LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM) {
   PassManagerBuilder *Builder = unwrap(PMB);
   legacy::PassManagerBase *MPM = unwrap(PM);
-  Builder->populateModulePassManager(*MPM);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+  Builder->populateModulePassManagerLegacy(*MPM);
 }

llvm/tools/bugpoint/bugpoint.cpp

static void AddOptimizationPasses(legacy::FunctionPassManager &FPM,
   Builder.SizeLevel = SizeLevel;
 
   if (OptLevel > 1)
     Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel, false);
   else
     Builder.Inliner = createAlwaysInlinerLegacyPass();
 
   Builder.populateFunctionPassManager(FPM);
-  Builder.populateModulePassManager(FPM);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+  Builder.populateModulePassManagerLegacy(FPM);
 }
 
 #define HANDLE_EXTENSION(Ext)                                                  \
   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 #include "llvm/Support/Extension.def"
 
 int main(int argc, char **argv) {
 #ifndef DEBUG_BUGPOINT

llvm/tools/opt/opt.cpp

static void AddOptimizationPasses(legacy::PassManagerBase &MPM,
   case CSInstrUse:
     Builder.EnablePGOCSInstrUse = true;
     break;
   default:
     break;
   }
 
   Builder.populateFunctionPassManager(FPM);
-  Builder.populateModulePassManager(MPM);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+  Builder.populateModulePassManagerLegacy(MPM);
 }
 
 //===----------------------------------------------------------------------===//
 // CodeGen-related helper functions.
 //
 
 static CodeGenOpt::Level GetCodeGenOptLevel() {
   if (CodeGenOptLevel.getNumOccurrences())

llvm/unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

void buildAndRunOptPasses() {
     
     LLVMPassManagerRef functionPasses =
       LLVMCreateFunctionPassManagerForModule(Module);
     LLVMPassManagerRef modulePasses =
       LLVMCreatePassManager();
     
     LLVMPassManagerBuilderPopulateFunctionPassManager(passBuilder,
                                                       functionPasses);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
     LLVMPassManagerBuilderPopulateModulePassManager(passBuilder, modulePasses);
-    
     LLVMPassManagerBuilderDispose(passBuilder);
     
     LLVMInitializeFunctionPassManager(functionPasses);
     for (LLVMValueRef value = LLVMGetFirstFunction(Module);
          value; value = LLVMGetNextFunction(value))
       LLVMRunFunctionPassManager(functionPasses, value);
     LLVMFinalizeFunctionPassManager(functionPasses);
     
     LLVMRunPassManager(modulePasses, Module);
     
     LLVMDisposePassManager(functionPasses);
     LLVMDisposePassManager(modulePasses);

polly/lib/CodeGen/PPCGCodeGeneration.cpp

if (DumpKernelIR)
     outs() << *GPUModule << "\n";
 
   if (Arch != GPUArch::SPIR32 && Arch != GPUArch::SPIR64) {
     // Optimize module.
     llvm::legacy::PassManager OptPasses;
     PassManagerBuilder PassBuilder;
     PassBuilder.OptLevel = 3;
     PassBuilder.SizeLevel = 0;
-    PassBuilder.populateModulePassManager(OptPasses);
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+    PassBuilder.populateModulePassManagerLegacy(OptPasses);
     OptPasses.run(*GPUModule);
   }
 
   std::string Assembly = createKernelASM();
 
   if (DumpKernelASM)
     outs() << Assembly << "\n";