Rollup of 7 pull requests

Cargo.lock

@@ -1713,9 +1713,9 @@ checksum = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
 
 [[package]]
 name = "libc"
-version = "0.2.62"
+version = "0.2.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba"
+checksum = "74dfca3d9957906e8d1e6a0b641dc9a59848e793f1da2165889fd4f62d10d79c"
 dependencies = [
  "rustc-std-workspace-core",
 ]
@@ -3388,17 +3388,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "rustc_asan"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "build_helper",
- "cmake",
- "compiler_builtins",
- "core",
-]
-
 [[package]]
 name = "rustc_codegen_llvm"
 version = "0.0.0"
@@ -3595,17 +3584,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "rustc_lsan"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "build_helper",
- "cmake",
- "compiler_builtins",
- "core",
-]
-
 [[package]]
 name = "rustc_macros"
 version = "0.1.0"
@@ -3660,17 +3638,6 @@ dependencies = [
  "syntax_pos",
 ]
 
-[[package]]
-name = "rustc_msan"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "build_helper",
- "cmake",
- "compiler_builtins",
- "core",
-]
-
 [[package]]
 name = "rustc_passes"
 version = "0.0.0"
@@ -3785,17 +3752,6 @@ dependencies = [
  "syntax_pos",
 ]
 
-[[package]]
-name = "rustc_tsan"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "build_helper",
- "cmake",
- "compiler_builtins",
- "core",
-]
-
 [[package]]
 name = "rustc_typeck"
 version = "0.0.0"
@@ -4150,10 +4106,6 @@ dependencies = [
  "panic_unwind",
  "profiler_builtins",
  "rand 0.7.0",
- "rustc_asan",
- "rustc_lsan",
- "rustc_msan",
- "rustc_tsan",
  "unwind",
  "wasi",
 ]

src/bootstrap/check.rs

@@ -48,7 +48,7 @@ impl Step for Std {
         let compiler = builder.compiler(0, builder.config.build);
 
         let mut cargo = builder.cargo(compiler, Mode::Std, target, cargo_subcommand(builder.kind));
-        std_cargo(builder, &compiler, target, &mut cargo);
+        std_cargo(builder, target, &mut cargo);
 
         builder.info(&format!("Checking std artifacts ({} -> {})", &compiler.host, target));
         run_cargo(builder,

src/bootstrap/compile.rs

@@ -94,7 +94,7 @@ impl Step for Std {
         copy_third_party_objects(builder, &compiler, target);
 
         let mut cargo = builder.cargo(compiler, Mode::Std, target, "build");
-        std_cargo(builder, &compiler, target, &mut cargo);
+        std_cargo(builder, target, &mut cargo);
 
         builder.info(&format!("Building stage{} std artifacts ({} -> {})", compiler.stage,
                 &compiler.host, target));
@@ -155,7 +155,6 @@ fn copy_third_party_objects(builder: &Builder<'_>, compiler: &Compiler, target:
 /// Configure cargo to compile the standard library, adding appropriate env vars
 /// and such.
 pub fn std_cargo(builder: &Builder<'_>,
-                 compiler: &Compiler,
                  target: Interned<String>,
                  cargo: &mut Cargo) {
     if let Some(target) = env::var_os("MACOSX_STD_DEPLOYMENT_TARGET") {
@@ -200,22 +199,6 @@ pub fn std_cargo(builder: &Builder<'_>,
         let mut features = builder.std_features();
         features.push_str(&compiler_builtins_c_feature);
 
-        if compiler.stage != 0 && builder.config.sanitizers {
-            // This variable is used by the sanitizer runtime crates, e.g.
-            // rustc_lsan, to build the sanitizer runtime from C code
-            // When this variable is missing, those crates won't compile the C code,
-            // so we don't set this variable during stage0 where llvm-config is
-            // missing
-            // We also only build the runtimes when --enable-sanitizers (or its
-            // config.toml equivalent) is used
-            let llvm_config = builder.ensure(native::Llvm {
-                target: builder.config.build,
-                emscripten: false,
-            });
-            cargo.env("LLVM_CONFIG", llvm_config);
-            cargo.env("RUSTC_BUILD_SANITIZERS", "1");
-        }
-
         cargo.arg("--features").arg(features)
             .arg("--manifest-path")
             .arg(builder.src.join("src/libtest/Cargo.toml"));
@@ -274,30 +257,95 @@ impl Step for StdLink {
         let hostdir = builder.sysroot_libdir(target_compiler, compiler.host);
         add_to_sysroot(builder, &libdir, &hostdir, &libstd_stamp(builder, compiler, target));
 
-        if builder.config.sanitizers && compiler.stage != 0 && target == "x86_64-apple-darwin" {
-            // The sanitizers are only built in stage1 or above, so the dylibs will
-            // be missing in stage0 and causes panic. See the `std()` function above
-            // for reason why the sanitizers are not built in stage0.
-            copy_apple_sanitizer_dylibs(builder, &builder.native_dir(target), "osx", &libdir);
+        if builder.config.sanitizers && target_compiler.stage != 0 {
+            // The sanitizers are only copied in stage1 or above,
+            // to avoid creating dependency on LLVM.
+            copy_sanitizers(builder, &target_compiler, target);
         }
     }
 }
 
-fn copy_apple_sanitizer_dylibs(
-    builder: &Builder<'_>,
-    native_dir: &Path,
-    platform: &str,
-    into: &Path,
-) {
-    for &sanitizer in &["asan", "tsan"] {
-        let filename = format!("lib__rustc__clang_rt.{}_{}_dynamic.dylib", sanitizer, platform);
-        let mut src_path = native_dir.join(sanitizer);
-        src_path.push("build");
-        src_path.push("lib");
-        src_path.push("darwin");
-        src_path.push(&filename);
-        builder.copy(&src_path, &into.join(filename));
+/// Copies sanitizer runtime libraries into target libdir.
+fn copy_sanitizers(builder: &Builder<'_>, compiler: &Compiler, target: Interned<String>) {
+    let llvm_config = builder.ensure(native::Llvm {
+        target,
+        emscripten: false,
+    });
+
+    let llvm_version = output(Command::new(&llvm_config).arg("--version"));
+    let llvm_version = llvm_version.trim();
+
+    // The compiler-rt uses CLANG_VERSION as a part of COMPILER_RT_INSTALL_PATH.
+    // The CLANG_VERSION is based on LLVM_VERSION but it does not not include
+    // LLVM_VERSION_SUFFIX. On the other hand value returned from llvm-config
+    // --version does include it, so lets strip it to obtain CLANG_VERSION.
+    let mut non_digits = 0;
+    let mut third_non_digit = llvm_version.len();
+    for (i, c) in llvm_version.char_indices() {
+        if !c.is_digit(10) {
+            non_digits += 1;
+            if non_digits == 3 {
+                third_non_digit = i;
+                break;
+            }
+        }
+    }
+    let llvm_version = &llvm_version[..third_non_digit];
+
+    let llvm_libdir = output(Command::new(&llvm_config).arg("--libdir"));
+    let llvm_libdir = PathBuf::from(llvm_libdir.trim());
+
+    let clang_resourcedir = llvm_libdir.join("clang").join(&llvm_version);
+    let sanitizers = supported_sanitizers(&clang_resourcedir, target);
+    let libdir = builder.sysroot_libdir(*compiler, target);
+
+    for (src, name) in &sanitizers {
+        let dst = libdir.join(name);
+        if !src.exists() {
+            println!("Ignoring missing runtime: {}", src.display());
+            continue;
+        }
+        builder.copy(&src, &dst);
+
+        if target == "x86_64-apple-darwin" {
+            // Update the library install name reflect the fact it has been renamed.
+            let status = Command::new("install_name_tool")
+                .arg("-id")
+                .arg(format!("@rpath/{}", name))
+                .arg(&dst)
+                .status()
+                .expect("failed to execute `install_name_tool`");
+            assert!(status.success());
+        }
+    }
+}
+
+/// Returns a list of paths to sanitizer libraries supported on given target,
+/// and corresponding names we plan to give them when placed in target libdir.
+fn supported_sanitizers(resourcedir: &Path, target: Interned<String>) -> Vec<(PathBuf, String)> {
+    let sanitizers = &["asan", "lsan", "msan", "tsan"];
+    let mut result = Vec::new();
+    match &*target {
+        "x86_64-apple-darwin" => {
+            let srcdir = resourcedir.join("lib/darwin");
+            for s in sanitizers {
+                let src = format!("libclang_rt.{}_osx_dynamic.dylib", s);
+                let dst = format!("librustc_rt.{}.dylib", s);
+                result.push((srcdir.join(src), dst));
+             }
+
+        }
+        "x86_64-unknown-linux-gnu" => {
+            let srcdir = resourcedir.join("lib/linux");
+            for s in sanitizers {
+                let src = format!("libclang_rt.{}-x86_64.a", s);
+                let dst = format!("librustc_rt.{}.a", s);
+                result.push((srcdir.join(src), dst));
+            }
+        }
+        _ => {}
     }
+    result
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]

src/bootstrap/dist.rs

@@ -901,10 +901,6 @@ impl Step for Src {
             "src/libcore",
             "src/libpanic_abort",
             "src/libpanic_unwind",
-            "src/librustc_asan",
-            "src/librustc_lsan",
-            "src/librustc_msan",
-            "src/librustc_tsan",
             "src/libstd",
             "src/libunwind",
             "src/libtest",

src/bootstrap/doc.rs

@@ -458,7 +458,7 @@ impl Step for Std {
 
         let run_cargo_rustdoc_for = |package: &str| {
             let mut cargo = builder.cargo(compiler, Mode::Std, target, "rustdoc");
-            compile::std_cargo(builder, &compiler, target, &mut cargo);
+            compile::std_cargo(builder, target, &mut cargo);
 
             // Keep a whitelist so we do not build internal stdlib crates, these will be
             // build by the rustc step later if enabled.

src/bootstrap/native.rs

@@ -209,6 +209,13 @@ impl Step for Llvm {
             enabled_llvm_projects.push("compiler-rt");
         }
 
+        if builder.config.sanitizers {
+            enabled_llvm_projects.push("compiler-rt");
+            cfg.define("COMPILER_RT_BUILD_SANITIZERS", "ON");
+            // Avoids building instrumented version of libcxx.
+            cfg.define("COMPILER_RT_USE_LIBCXX", "OFF");
+        }
+
         if want_lldb {
             enabled_llvm_projects.push("clang");
             enabled_llvm_projects.push("lldb");

src/bootstrap/test.rs

@@ -1760,7 +1760,7 @@ impl Step for Crate {
         let mut cargo = builder.cargo(compiler, mode, target, test_kind.subcommand());
         match mode {
             Mode::Std => {
-                compile::std_cargo(builder, &compiler, target, &mut cargo);
+                compile::std_cargo(builder, target, &mut cargo);
             }
             Mode::Rustc => {
                 builder.ensure(compile::Rustc { compiler, target });