Use the existing llvm-plugins option for both legacy and new pm registration

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -470,7 +470,7 @@ pub(crate) unsafe fn optimize_with_new_llvm_pass_manager(
 
     let extra_passes = config.passes.join(",");
 
-    let pass_plugins = config.pass_plugins.join(" ");
+    let llvm_plugins = config.llvm_plugins.join(",");
 
     // FIXME: NewPM doesn't provide a facility to pass custom InlineParams.
     // We would have to add upstream support for this first, before we can support
@@ -501,8 +501,8 @@ pub(crate) unsafe fn optimize_with_new_llvm_pass_manager(
         selfprofile_after_pass_callback,
         extra_passes.as_ptr().cast(),
         extra_passes.len(),
-        pass_plugins.as_ptr().cast(),
-        pass_plugins.len(),
+        llvm_plugins.as_ptr().cast(),
+        llvm_plugins.len(),
     );
     result.into_result().map_err(|()| llvm_err(diag_handler, "failed to run LLVM passes"))
 }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2304,8 +2304,8 @@ extern "C" {
         end_callback: SelfProfileAfterPassCallback,
         ExtraPasses: *const c_char,
         ExtraPassesLen: size_t,
-        PassPlugins: *const c_char,
-        PassPluginsLen: size_t,
+        LLVMPlugins: *const c_char,
+        LLVMPluginsLen: size_t,
     ) -> LLVMRustResult;
     pub fn LLVMRustPrintModule(
         M: &'a Module,

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -119,14 +119,20 @@ unsafe fn configure_llvm(sess: &Session) {
 
     llvm::LLVMInitializePasses();
 
-    // Register LLVM plugins by loading them into the compiler process.
-    for plugin in &sess.opts.debugging_opts.llvm_plugins {
-        let lib = Library::new(plugin).unwrap_or_else(|e| bug!("couldn't load plugin: {}", e));
-        debug!("LLVM plugin loaded successfully {:?} ({})", lib, plugin);
+    let use_new_llvm_pm_plugin_register =
+        sess.opts.debugging_opts.new_llvm_pass_manager.unwrap_or(false);
 
-        // Intentionally leak the dynamic library. We can't ever unload it
-        // since the library can make things that will live arbitrarily long.
-        mem::forget(lib);
+    // Use the legacy pm registration if the new_llvm_pass_manager option isn't explicitly enabled
+    if use_new_llvm_pm_plugin_register {
+        // Register LLVM plugins by loading them into the compiler process.
+        for plugin in &sess.opts.debugging_opts.llvm_plugins {
+            let lib = Library::new(plugin).unwrap_or_else(|e| bug!("couldn't load plugin: {}", e));
+            debug!("LLVM plugin loaded successfully {:?} ({})", lib, plugin);
+
+            // Intentionally leak the dynamic library. We can't ever unload it
+            // since the library can make things that will live arbitrarily long.
+            mem::forget(lib);
+        }
     }
 
     rustc_llvm::initialize_available_targets();

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -74,8 +74,6 @@ pub enum BitcodeSection {
 pub struct ModuleConfig {
     /// Names of additional optimization passes to run.
     pub passes: Vec<String>,
-    /// Paths of LLVM pass plugins to load.
-    pub pass_plugins: Vec<String>,
     /// Some(level) to optimize at a certain level, or None to run
     /// absolutely no optimizations (used for the metadata module).
     pub opt_level: Option<config::OptLevel>,
@@ -115,6 +113,7 @@ pub struct ModuleConfig {
     pub inline_threshold: Option<u32>,
     pub new_llvm_pass_manager: Option<bool>,
     pub emit_lifetime_markers: bool,
+    pub llvm_plugins: Vec<String>,
 }
 
 impl ModuleConfig {
@@ -172,8 +171,6 @@ impl ModuleConfig {
         ModuleConfig {
             passes: if_regular!(sess.opts.cg.passes.clone(), vec![]),
 
-            pass_plugins: if_regular!(sess.opts.cg.pass_plugins.clone(), vec![]),
-
             opt_level: opt_level_and_size,
             opt_size: opt_level_and_size,
 
@@ -264,6 +261,7 @@ impl ModuleConfig {
             inline_threshold: sess.opts.cg.inline_threshold,
             new_llvm_pass_manager: sess.opts.debugging_opts.new_llvm_pass_manager,
             emit_lifetime_markers: sess.emit_lifetime_markers(),
+            llvm_plugins: if_regular!(sess.opts.debugging_opts.llvm_plugins.clone(), vec![]),
         }
     }
 

compiler/rustc_interface/src/tests.rs

@@ -587,7 +587,6 @@ fn test_codegen_options_tracking_hash() {
     tracked!(overflow_checks, Some(true));
     tracked!(panic, Some(PanicStrategy::Abort));
     tracked!(passes, vec![String::from("1"), String::from("2")]);
-    tracked!(pass_plugins, vec![String::from("1"), String::from("2")]);
     tracked!(prefer_dynamic, true);
     tracked!(profile_generate, SwitchWithOptPath::Enabled(None));
     tracked!(profile_use, Some(PathBuf::from("abc")));

compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp

@@ -755,7 +755,7 @@ LLVMRustOptimizeWithNewPassManager(
     LLVMRustSelfProfileBeforePassCallback BeforePassCallback,
     LLVMRustSelfProfileAfterPassCallback AfterPassCallback,
     const char *ExtraPasses, size_t ExtraPassesLen,
-    const char *PassPlugins, size_t PassPluginsLen) {
+    const char *LLVMPlugins, size_t LLVMPluginsLen) {
   Module *TheModule = unwrap(ModuleRef);
   TargetMachine *TM = unwrap(TMRef);
   OptimizationLevel OptLevel = fromRust(OptLevelRust);
@@ -926,10 +926,10 @@ LLVMRustOptimizeWithNewPassManager(
     }
   }
 
-  if (PassPluginsLen) {
-    auto PluginsStr = StringRef(PassPlugins, PassPluginsLen);
+  if (LLVMPluginsLen) {
+    auto PluginsStr = StringRef(LLVMPlugins, LLVMPluginsLen);
     SmallVector<StringRef> Plugins;
-    PluginsStr.split(Plugins, ' ', -1, false);
+    PluginsStr.split(Plugins, ',', -1, false);
     for (auto PluginPath: Plugins) {
       auto Plugin = PassPlugin::Load(PluginPath.str());
       if (!Plugin) {

compiler/rustc_session/src/options.rs

@@ -1033,8 +1033,6 @@ options! {
         "panic strategy to compile crate with"),
     passes: Vec<String> = (Vec::new(), parse_list, [TRACKED],
         "a list of extra LLVM passes to run (space separated)"),
-    pass_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
-        "a list of LLVM pass plugins to load (space separated)"),
     prefer_dynamic: bool = (false, parse_bool, [TRACKED],
         "prefer dynamic linking to static linking (default: no)"),
     profile_generate: SwitchWithOptPath = (SwitchWithOptPath::Disabled,