Rollup of 7 pull requests

Cargo.lock

@@ -3412,17 +3412,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"
@@ -3620,17 +3609,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"
@@ -3685,17 +3663,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"
@@ -3809,17 +3776,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"
@@ -4175,10 +4131,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 {
         target_deps.extend(copy_third_party_objects(builder, &compiler, target).into_iter());
 
         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));
@@ -157,13 +157,18 @@ fn copy_third_party_objects(builder: &Builder<'_>, compiler: &Compiler, target:
         copy_and_stamp(Path::new(&src), "libunwind.a");
     }
 
+    if builder.config.sanitizers && compiler.stage != 0 {
+        // The sanitizers are only copied in stage1 or above,
+        // to avoid creating dependency on LLVM.
+        target_deps.extend(copy_sanitizers(builder, &compiler, target));
+    }
+
     target_deps
 }
 
 /// 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") {
@@ -208,21 +213,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,
-            });
-            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"));
@@ -280,31 +270,108 @@ impl Step for StdLink {
         let libdir = builder.sysroot_libdir(target_compiler, target);
         let hostdir = builder.sysroot_libdir(target_compiler, compiler.host);
         add_to_sysroot(builder, &libdir, &hostdir, &libstd_stamp(builder, compiler, target));
+    }
+}
+
+/// Copies sanitizer runtime libraries into target libdir.
+fn copy_sanitizers(builder: &Builder<'_>,
+                   compiler: &Compiler,
+                   target: Interned<String>) -> Vec<PathBuf> {
+    let mut target_deps = Vec::new();
+
+    let sanitizers = supported_sanitizers(target);
+    if sanitizers.is_empty() {
+        return target_deps;
+    }
+
+    let llvm_config: PathBuf = builder.ensure(native::Llvm {
+        target: compiler.host,
+    });
+    if builder.config.dry_run {
+        return target_deps;
+    }
+
+    // The compiler-rt installs sanitizer runtimes into clang resource directory.
+    let clang_resourcedir = clang_resourcedir(&llvm_config);
+    let libdir = builder.sysroot_libdir(*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);
+    for (path, name) in &sanitizers {
+        let src = clang_resourcedir.join(path);
+        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());
+        }
+
+        target_deps.push(dst);
     }
+
+    target_deps
 }
 
-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));
+/// Returns path to clang's resource directory.
+fn clang_resourcedir(llvm_config: &Path) -> PathBuf {
+    let llvm_version = output(Command::new(&llvm_config).arg("--version"));
+    let llvm_version = llvm_version.trim();
+    let llvm_libdir = output(Command::new(&llvm_config).arg("--libdir"));
+    let llvm_libdir = PathBuf::from(llvm_libdir.trim());
+
+    // Determine CLANG_VERSION by stripping LLVM_VERSION_SUFFIX from LLVM_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 clang_version = &llvm_version[..third_non_digit];
+    llvm_libdir.join("clang").join(&clang_version)
+}
+
+/// 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.
+///
+/// Returned paths are relative to clang's resource directory.
+fn supported_sanitizers(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 = Path::new("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 = Path::new("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

@@ -960,10 +960,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

@@ -186,6 +186,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 builder.config.lldb_enabled {
             enabled_llvm_projects.push("clang");
             enabled_llvm_projects.push("lldb");

src/bootstrap/test.rs

@@ -1764,7 +1764,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 });