Add LLVM compiler-rt/profile in bootstrap

Author: bogon-right

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1144,23 +1144,46 @@ fn add_sanitizer_libraries(sess: &Session, crate_type: CrateType, linker: &mut d
     }
 }
 
-fn link_sanitizer_runtime(sess: &Session, linker: &mut dyn Linker, name: &str) {
-    fn find_sanitizer_runtime(sess: &Session, filename: &str) -> PathBuf {
-        let session_tlib =
-            filesearch::make_target_lib_path(&sess.sysroot, sess.opts.target_triple.triple());
-        let path = session_tlib.join(filename);
-        if path.exists() {
-            return session_tlib;
-        } else {
-            let default_sysroot = filesearch::get_or_default_sysroot();
-            let default_tlib = filesearch::make_target_lib_path(
-                &default_sysroot,
-                sess.opts.target_triple.triple(),
-            );
-            return default_tlib;
-        }
+fn add_profiler_libraries(sess: &Session, crate_type: CrateType, linker: &mut dyn Linker) {
+    let needs_runtime = match crate_type {
+        CrateType::Executable => true,
+        CrateType::Dylib
+        | CrateType::Cdylib
+        | CrateType::ProcMacro
+        | CrateType::Rlib
+        | CrateType::Staticlib => false,
+    };
+
+    if !needs_runtime {
+        return;
+    }
+
+    if !sess.opts.unstable_opts.no_profiler_runtime
+        && (sess.instrument_coverage()
+            || sess.opts.unstable_opts.profile
+            || sess.opts.cg.profile_generate.enabled())
+        // If user doesn't provide custom profiler runtime, link default llvm profiler.
+        && sess.opts.unstable_opts.profiler_runtime == "profiler_builtins"
+    {
+        link_profiler_runtime(sess, linker);
+    }
+}
+
+fn find_compiler_rt(sess: &Session, filename: &str) -> PathBuf {
+    let session_tlib =
+        filesearch::make_target_lib_path(&sess.sysroot, sess.opts.target_triple.triple());
+    let path = session_tlib.join(filename);
+    if path.exists() {
+        return session_tlib;
+    } else {
+        let default_sysroot = filesearch::get_or_default_sysroot();
+        let default_tlib =
+            filesearch::make_target_lib_path(&default_sysroot, sess.opts.target_triple.triple());
+        return default_tlib;
     }
+}
 
+fn link_sanitizer_runtime(sess: &Session, linker: &mut dyn Linker, name: &str) {
     let channel = option_env!("CFG_RELEASE_CHANNEL")
         .map(|channel| format!("-{}", channel))
         .unwrap_or_default();
@@ -1171,17 +1194,27 @@ fn link_sanitizer_runtime(sess: &Session, linker: &mut dyn Linker, name: &str) {
         // rpath to the library as well (the rpath should be absolute, see
         // PR #41352 for details).
         let filename = format!("rustc{}_rt.{}", channel, name);
-        let path = find_sanitizer_runtime(&sess, &filename);
+        let path = find_compiler_rt(&sess, &filename);
         let rpath = path.to_str().expect("non-utf8 component in path");
         linker.args(&["-Wl,-rpath", "-Xlinker", rpath]);
         linker.link_dylib(&filename, false, true);
     } else {
         let filename = format!("librustc{}_rt.{}.a", channel, name);
-        let path = find_sanitizer_runtime(&sess, &filename).join(&filename);
+        let path = find_compiler_rt(&sess, &filename).join(&filename);
         linker.link_whole_rlib(&path);
     }
 }
 
+fn link_profiler_runtime(sess: &Session, linker: &mut dyn Linker) {
+    let channel = option_env!("CFG_RELEASE_CHANNEL")
+        .map(|channel| format!("-{}", channel))
+        .unwrap_or_default();
+
+    let filename = format!("librustc{}_rt.profile.a", channel);
+    let path = find_compiler_rt(&sess, &filename).join(&filename);
+    linker.link_whole_rlib(&path);
+}
+
 /// Returns a boolean indicating whether the specified crate should be ignored
 /// during LTO.
 ///
@@ -1997,6 +2030,9 @@ fn linker_with_args<'a>(
     // Sanitizer libraries.
     add_sanitizer_libraries(sess, crate_type, cmd);
 
+    // Profiler libraries.
+    add_profiler_libraries(sess, crate_type, cmd);
+
     // Object code from the current crate.
     // Take careful note of the ordering of the arguments we pass to the linker
     // here. Linkers will assume that things on the left depend on things to the

src/bootstrap/builder.rs

@@ -608,6 +608,7 @@ impl<'a> Builder<'a> {
                 tool::CargoClippy,
                 native::Llvm,
                 native::Sanitizers,
+                native::Profiler,
                 tool::Rustfmt,
                 tool::Miri,
                 tool::CargoMiri,

src/bootstrap/compile.rs

@@ -205,6 +205,14 @@ fn copy_third_party_objects(
         );
     }
 
+    if builder.config.profiler_enabled(target) && compiler.stage != 0 {
+        // The profiler are only copied in stage1 or above,
+        // to avoid creating dependency on LLVM.
+        if let Some(profiler_path) = copy_profiler(builder, &compiler, target) {
+            target_deps.push((profiler_path, DependencyType::Target));
+        }
+    }
+
     if target == "x86_64-fortanix-unknown-sgx"
         || target.contains("pc-windows-gnullvm")
         || builder.config.llvm_libunwind(target) == LlvmLibunwind::InTree
@@ -444,6 +452,24 @@ impl Step for StdLink {
     }
 }
 
+/// Copies profiler runtime library into target libdir.
+fn copy_profiler(
+    builder: &Builder<'_>,
+    compiler: &Compiler,
+    target: TargetSelection,
+) -> Option<PathBuf> {
+    let runtime: native::ProfilerRuntime = builder.ensure(native::Profiler { target })?;
+
+    if builder.config.dry_run {
+        return None;
+    }
+
+    let destination = builder.sysroot_libdir(*compiler, target).join(&runtime.name);
+    builder.copy(&runtime.path, &destination);
+
+    Some(destination)
+}
+
 /// Copies sanitizer runtime libraries into target libdir.
 fn copy_sanitizers(
     builder: &Builder<'_>,

src/bootstrap/native.rs

@@ -1182,6 +1182,131 @@ fn supported_sanitizers(
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Profiler {
+    pub target: TargetSelection,
+}
+
+impl Step for Profiler {
+    type Output = Option<ProfilerRuntime>;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.alias("profiler")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(Profiler { target: run.target });
+    }
+
+    /// Builds sanitizer runtime libraries.
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
+        let compiler_rt_dir = builder.src.join("src/llvm-project/compiler-rt");
+        if !compiler_rt_dir.exists() {
+            return None;
+        }
+
+        let out_dir = builder.native_dir(self.target).join("profiler");
+        let runtime = supported_profilers(&out_dir, self.target, &builder.config.channel)?;
+
+        let llvm_config = builder.ensure(Llvm { target: builder.config.build });
+        if builder.config.dry_run {
+            return Some(runtime);
+        }
+
+        let stamp = out_dir.join("profiler-finished-building");
+        let stamp = HashStamp::new(stamp, builder.in_tree_llvm_info.sha());
+
+        if stamp.is_done() {
+            if stamp.hash.is_none() {
+                builder.info(&format!(
+                    "Rebuild profiler by removing the file `{}`",
+                    stamp.path.display()
+                ));
+            }
+            return Some(runtime);
+        }
+
+        builder.info(&format!("Building profiler for {}", self.target));
+        t!(stamp.remove());
+        let _time = util::timeit(&builder);
+
+        let mut cfg = cmake::Config::new(&compiler_rt_dir);
+        cfg.profile("Release");
+        cfg.define("CMAKE_C_COMPILER_TARGET", self.target.triple);
+        cfg.define("COMPILER_RT_BUILD_BUILTINS", "OFF");
+        cfg.define("COMPILER_RT_BUILD_CRT", "OFF");
+        cfg.define("COMPILER_RT_BUILD_LIBFUZZER", "OFF");
+        cfg.define("COMPILER_RT_BUILD_PROFILE", "ON");
+        cfg.define("COMPILER_RT_BUILD_SANITIZERS", "OFF");
+        cfg.define("COMPILER_RT_BUILD_XRAY", "OFF");
+        cfg.define("COMPILER_RT_DEFAULT_TARGET_ONLY", "ON");
+        cfg.define("COMPILER_RT_USE_LIBCXX", "OFF");
+        cfg.define("LLVM_CONFIG_PATH", &llvm_config);
+
+        configure_cmake(builder, self.target, &mut cfg, true, LdFlags::default());
+
+        t!(fs::create_dir_all(&out_dir));
+        cfg.out_dir(out_dir);
+        cfg.build_target(&runtime.cmake_target);
+        cfg.build();
+        t!(stamp.write());
+
+        Some(runtime)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ProfilerRuntime {
+    /// CMake target used to build the runtime.
+    pub cmake_target: String,
+    /// Path to the built runtime library.
+    pub path: PathBuf,
+    /// Library filename that will be used rustc.
+    pub name: String,
+}
+
+/// Returns sanitizers available on a given target.
+fn supported_profilers(
+    out_dir: &Path,
+    target: TargetSelection,
+    channel: &str,
+) -> Option<ProfilerRuntime> {
+    // LLVM's compile-rt has a special taste on target naming. :D
+    //
+    // compiler runtime's name seems to be a chaos:
+    // <https://chromium.googlesource.com/chromium/src/tools/clang/+/refs/heads/main/scripts/package.py>
+    let darwin_libs = || -> Option<ProfilerRuntime> {
+        Some(ProfilerRuntime {
+            cmake_target: format!("clang_rt.profile_osx"),
+            path: out_dir.join(&format!("build/lib/darwin/libclang_rt.profile_osx.a")),
+            name: format!("librustc-{}_rt.profile.a", channel),
+        })
+    };
+
+    let common_libs = |os: &str, arch: &str| -> Option<ProfilerRuntime> {
+        Some(ProfilerRuntime {
+            cmake_target: format!("clang_rt.profile-{}", arch),
+            path: out_dir.join(&format!("build/lib/{}/libclang_rt.profile-{}.a", os, arch)),
+            name: format!("librustc-{}_rt.profile.a", channel),
+        })
+    };
+
+    match &*target.triple {
+        "aarch64-apple-darwin" => darwin_libs(),
+        "aarch64-fuchsia" => common_libs("fuchsia", "aarch64"),
+        "aarch64-unknown-linux-gnu" => common_libs("linux", "aarch64"),
+        "x86_64-apple-darwin" => darwin_libs(),
+        "x86_64-fuchsia" => common_libs("fuchsia", "x86_64"),
+        "x86_64-unknown-freebsd" => common_libs("freebsd", "x86_64"),
+        "x86_64-unknown-netbsd" => common_libs("netbsd", "x86_64"),
+        "x86_64-unknown-illumos" => common_libs("illumos", "x86_64"),
+        "x86_64-pc-solaris" => common_libs("solaris", "x86_64"),
+        "x86_64-unknown-linux-gnu" => common_libs("linux", "x86_64"),
+        "x86_64-unknown-linux-musl" => common_libs("linux", "x86_64"),
+        _ => None,
+    }
+}
+
 struct HashStamp {
     path: PathBuf,
     hash: Option<Vec<u8>>,