Auto merge of #67954 - nikic:new-pm, r=<try>

[WIP] Support new LLVM pass manager

This is a prototype to add support for the new LLVM pass manager. For now this is only for the optimization phase.

Closes #64289.

r? @ghost

Author: bors

src/librustc_codegen_llvm/back/write.rs

@@ -111,6 +111,18 @@ pub fn to_llvm_opt_settings(
     }
 }
 
+pub fn to_pass_builder_opt_level(cfg: config::OptLevel) -> llvm::PassBuilderOptLevel {
+    use config::OptLevel::*;
+    match cfg {
+        No => llvm::PassBuilderOptLevel::O0,
+        Less => llvm::PassBuilderOptLevel::O1,
+        Default => llvm::PassBuilderOptLevel::O2,
+        Aggressive => llvm::PassBuilderOptLevel::O3,
+        Size => llvm::PassBuilderOptLevel::Os,
+        SizeMin => llvm::PassBuilderOptLevel::Oz,
+    }
+}
+
 // If find_features is true this won't access `sess.crate_types` by assuming
 // that `is_pie_binary` is false. When we discover LLVM target features
 // `sess.crate_types` is uninitialized so we cannot access it.
@@ -327,6 +339,58 @@ pub(crate) unsafe fn optimize(
     }
 
     if let Some(opt_level) = config.opt_level {
+        if config.new_llvm_pass_manager {
+            let unroll_loops =
+                opt_level != config::OptLevel::Size && opt_level != config::OptLevel::SizeMin;
+            let prepare_for_thin_lto = cgcx.lto == Lto::Thin
+                || cgcx.lto == Lto::ThinLocal
+                || (cgcx.lto != Lto::Fat && cgcx.opts.cg.linker_plugin_lto.enabled());
+            let using_thin_buffers = prepare_for_thin_lto || config.bitcode_needed();
+
+            let pgo_gen_path = match config.pgo_gen {
+                SwitchWithOptPath::Enabled(ref opt_dir_path) => {
+                    let path = if let Some(dir_path) = opt_dir_path {
+                        dir_path.join("default_%m.profraw")
+                    } else {
+                        PathBuf::from("default_%m.profraw")
+                    };
+
+                    Some(CString::new(format!("{}", path.display())).unwrap())
+                }
+                SwitchWithOptPath::Disabled => None,
+            };
+            let pgo_use_path = config
+                .pgo_use
+                .as_ref()
+                .map(|path_buf| CString::new(path_buf.to_string_lossy().as_bytes()).unwrap());
+
+            // FIXME: NewPM doesn't seem to have a facility to provide custom InlineParams.
+            // FIXME: Support extra passes.
+            llvm::LLVMRustOptimizeWithNewPassManager(
+                llmod,
+                tm,
+                to_pass_builder_opt_level(opt_level),
+                config.no_prepopulate_passes,
+                config.verify_llvm_ir,
+                prepare_for_thin_lto,
+                /* prepare_for_lto */ false, // FIXME: Actually differentiate this?
+                using_thin_buffers,
+                config.merge_functions,
+                unroll_loops,
+                config.vectorize_slp,
+                config.vectorize_loop,
+                config.no_builtins,
+                Some(Sanitizer::Memory) == config.sanitizer,
+                Some(Sanitizer::Thread) == config.sanitizer,
+                Some(Sanitizer::Address) == config.sanitizer,
+                config.sanitizer.as_ref().map_or(false, |s| config.sanitizer_recover.contains(s)),
+                config.sanitizer_memory_track_origins as c_int,
+                pgo_gen_path.as_ref().map_or(std::ptr::null(), |s| s.as_ptr()),
+                pgo_use_path.as_ref().map_or(std::ptr::null(), |s| s.as_ptr()),
+            );
+            return Ok(());
+        }
+
         // Create the two optimizing pass managers. These mirror what clang
         // does, and are by populated by LLVM's default PassManagerBuilder.
         // Each manager has a different set of passes, but they also share
@@ -346,8 +410,6 @@ pub(crate) unsafe fn optimize(
             }
 
             let mut extra_passes = Vec::new();
-            let mut have_name_anon_globals_pass = false;
-
             for pass_name in &config.passes {
                 if pass_name == "lint" {
                     // Linting should also be performed early, directly on the generated IR.
@@ -360,10 +422,6 @@ pub(crate) unsafe fn optimize(
                 } else {
                     diag_handler.warn(&format!("unknown pass `{}`, ignoring", pass_name));
                 }
-
-                if pass_name == "name-anon-globals" {
-                    have_name_anon_globals_pass = true;
-                }
             }
 
             add_sanitizer_passes(config, &mut extra_passes);
@@ -389,33 +447,17 @@ pub(crate) unsafe fn optimize(
                     llvm::LLVMPassManagerBuilderPopulateModulePassManager(b, mpm);
                 });
 
-                have_name_anon_globals_pass = have_name_anon_globals_pass || prepare_for_thin_lto;
                 if using_thin_buffers && !prepare_for_thin_lto {
                     llvm::LLVMRustAddPass(mpm, find_pass("name-anon-globals").unwrap());
-                    have_name_anon_globals_pass = true;
                 }
             } else {
                 // If we don't use the standard pipeline, directly populate the MPM
                 // with the extra passes.
                 for pass in extra_passes {
                     llvm::LLVMRustAddPass(mpm, pass);
                 }
-            }
-
-            if using_thin_buffers && !have_name_anon_globals_pass {
-                // As described above, this will probably cause an error in LLVM
-                if config.no_prepopulate_passes {
-                    diag_handler.err(
-                        "The current compilation is going to use thin LTO buffers \
-                                      without running LLVM's NameAnonGlobals pass. \
-                                      This will likely cause errors in LLVM. Consider adding \
-                                      -C passes=name-anon-globals to the compiler command line.",
-                    );
-                } else {
-                    bug!(
-                        "We are using thin LTO buffers without running the NameAnonGlobals pass. \
-                          This will likely cause errors in LLVM and should never happen."
-                    );
+                if using_thin_buffers {
+                    llvm::LLVMRustAddPass(mpm, find_pass("name-anon-globals").unwrap());
                 }
             }
         }

src/librustc_codegen_llvm/builder.rs

@@ -780,13 +780,18 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         align: Align,
         flags: MemFlags,
     ) {
-        let ptr_width = &self.sess().target.target.target_pointer_width;
-        let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
-        let llintrinsicfn = self.get_intrinsic(&intrinsic_key);
+        let is_volatile = flags.contains(MemFlags::VOLATILE);
         let ptr = self.pointercast(ptr, self.type_i8p());
-        let align = self.const_u32(align.bytes() as u32);
-        let volatile = self.const_bool(flags.contains(MemFlags::VOLATILE));
-        self.call(llintrinsicfn, &[ptr, fill_byte, size, align, volatile], None);
+        unsafe {
+            llvm::LLVMRustBuildMemSet(
+                self.llbuilder,
+                ptr,
+                align.bytes() as c_uint,
+                fill_byte,
+                size,
+                is_volatile,
+            );
+        }
     }
 
     fn select(
@@ -984,11 +989,11 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     fn lifetime_start(&mut self, ptr: &'ll Value, size: Size) {
-        self.call_lifetime_intrinsic("llvm.lifetime.start", ptr, size);
+        self.call_lifetime_intrinsic("llvm.lifetime.start.p0i8", ptr, size);
     }
 
     fn lifetime_end(&mut self, ptr: &'ll Value, size: Size) {
-        self.call_lifetime_intrinsic("llvm.lifetime.end", ptr, size);
+        self.call_lifetime_intrinsic("llvm.lifetime.end.p0i8", ptr, size);
     }
 
     fn call(

src/librustc_codegen_llvm/context.rs

@@ -543,10 +543,6 @@ impl CodegenCx<'b, 'tcx> {
             t_v8f64: t_f64, 8;
         }
 
-        ifn!("llvm.memset.p0i8.i16", fn(i8p, t_i8, t_i16, t_i32, i1) -> void);
-        ifn!("llvm.memset.p0i8.i32", fn(i8p, t_i8, t_i32, t_i32, i1) -> void);
-        ifn!("llvm.memset.p0i8.i64", fn(i8p, t_i8, t_i64, t_i32, i1) -> void);
-
         ifn!("llvm.trap", fn() -> void);
         ifn!("llvm.debugtrap", fn() -> void);
         ifn!("llvm.frameaddress", fn(t_i32) -> i8p);
@@ -811,8 +807,8 @@ impl CodegenCx<'b, 'tcx> {
         ifn!("llvm.usub.sat.i64", fn(t_i64, t_i64) -> t_i64);
         ifn!("llvm.usub.sat.i128", fn(t_i128, t_i128) -> t_i128);
 
-        ifn!("llvm.lifetime.start", fn(t_i64, i8p) -> void);
-        ifn!("llvm.lifetime.end", fn(t_i64, i8p) -> void);
+        ifn!("llvm.lifetime.start.p0i8", fn(t_i64, i8p) -> void);
+        ifn!("llvm.lifetime.end.p0i8", fn(t_i64, i8p) -> void);
 
         ifn!("llvm.expect.i1", fn(i1, i1) -> i1);
         ifn!("llvm.eh.typeid.for", fn(i8p) -> t_i32);

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -402,6 +402,17 @@ pub enum CodeGenOptLevel {
     Aggressive,
 }
 
+/// LLVMPassBuilderOptLevel
+#[repr(C)]
+pub enum PassBuilderOptLevel {
+    O0,
+    O1,
+    O2,
+    O3,
+    Os,
+    Oz,
+}
+
 /// LLVMRelocMode
 #[derive(Copy, Clone, PartialEq)]
 #[repr(C)]
@@ -1317,6 +1328,14 @@ extern "C" {
         Size: &'a Value,
         IsVolatile: bool,
     ) -> &'a Value;
+    pub fn LLVMRustBuildMemSet(
+        B: &Builder<'a>,
+        Dst: &'a Value,
+        DstAlign: c_uint,
+        Val: &'a Value,
+        Size: &'a Value,
+        IsVolatile: bool,
+    ) -> &'a Value;
     pub fn LLVMBuildSelect(
         B: &Builder<'a>,
         If: &'a Value,
@@ -1886,6 +1905,28 @@ extern "C" {
         Output: *const c_char,
         FileType: FileType,
     ) -> LLVMRustResult;
+    pub fn LLVMRustOptimizeWithNewPassManager(
+        M: &'a Module,
+        TM: &'a TargetMachine,
+        OptLevel: PassBuilderOptLevel,
+        NoPrepopulatePasses: bool,
+        VerifyIR: bool,
+        PrepareForThinLTO: bool,
+        PrepareForLTO: bool,
+        UseThinLTOBuffers: bool,
+        MergeFunctions: bool,
+        UnrollLoops: bool,
+        SLPVectorize: bool,
+        LoopVectorize: bool,
+        DisableSimplifyLibCalls: bool,
+        SanitizeMemory: bool,
+        SanitizeThread: bool,
+        SanitizeAddress: bool,
+        SanitizeRecover: bool,
+        SanitizeMemoryTrackOrigins: c_int,
+        PGOGenPath: *const c_char,
+        PGOUsePath: *const c_char,
+    );
     pub fn LLVMRustPrintModule(
         M: &'a Module,
         Output: *const c_char,

src/librustc_codegen_ssa/back/write.rs

@@ -85,6 +85,7 @@ pub struct ModuleConfig {
     pub vectorize_slp: bool,
     pub merge_functions: bool,
     pub inline_threshold: Option<usize>,
+    pub new_llvm_pass_manager: bool,
     // Instead of creating an object file by doing LLVM codegen, just
     // make the object file bitcode. Provides easy compatibility with
     // emscripten's ecc compiler, when used as the linker.
@@ -129,6 +130,7 @@ impl ModuleConfig {
             vectorize_slp: false,
             merge_functions: false,
             inline_threshold: None,
+            new_llvm_pass_manager: false,
         }
     }
 
@@ -137,6 +139,7 @@ impl ModuleConfig {
         self.no_prepopulate_passes = sess.opts.cg.no_prepopulate_passes;
         self.no_builtins = no_builtins || sess.target.target.options.no_builtins;
         self.inline_threshold = sess.opts.cg.inline_threshold;
+        self.new_llvm_pass_manager = sess.opts.debugging_opts.new_llvm_pass_manager;
         self.obj_is_bitcode =
             sess.target.target.options.obj_is_bitcode || sess.opts.cg.linker_plugin_lto.enabled();
         let embed_bitcode =

src/librustc_session/options.rs

@@ -948,4 +948,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
          (such as entering an empty infinite loop) by inserting llvm.sideeffect"),
     deduplicate_diagnostics: Option<bool> = (None, parse_opt_bool, [UNTRACKED],
         "deduplicate identical diagnostics"),
+    new_llvm_pass_manager: bool = (true, parse_bool, [TRACKED],
+        "use new LLVM pass manager"),
 }