Auto merge of #65241 - tmiasko:no-std-san, r=nikomatsakis

build-std compatible sanitizer support

### Motivation

When using `-Z sanitizer=*` feature it is essential that both user code and
standard library is instrumented. Otherwise the utility of sanitizer will be
limited, or its use will be impractical like in the case of memory sanitizer.

The recently introduced cargo feature build-std makes it possible to rebuild
standard library with arbitrary rustc flags. Unfortunately, those changes alone
do not make it easy to rebuild standard library with sanitizers, since runtimes
are dependencies of std that have to be build in specific environment,
generally not available outside rustbuild process. Additionally rebuilding them
requires presence of llvm-config and compiler-rt sources.

The goal of changes proposed here is to make it possible to avoid rebuilding
sanitizer runtimes when rebuilding the std, thus making it possible to
instrument standard library for use with sanitizer with simple, although
verbose command:

```
env CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS=-Zsanitizer=thread cargo test -Zbuild-std --target x86_64-unknown-linux-gnu
```

### Implementation

* Sanitizer runtimes are no long packed into crates. Instead, libraries build
  from compiler-rt are used as is, after renaming them into `librusc_rt.*`.
* rustc obtains runtimes from target libdir for default sysroot, so that
  they are not required in custom build sysroots created with build-std.
* The runtimes are only linked-in into executables to address issue #64629.
  (in previous design it was hard to avoid linking runtimes into static
  libraries produced by rustc as demonstrated by sanitizer-staticlib-link
  test, which still passes despite changes made in #64780).
* When custom llvm-config is specified during build process, the sanitizer
  runtimes will be obtained from there instead of begin rebuilding from sources
  in src/llvm-project/compiler-rt. This should be preferable since runtimes
  used should match instrumentation passes. For example there have been nine
  version of address sanitizer ABI.

Note this marked as a draft PR, because it is currently untested on OS X (I
would appreciate any help there).

cc @kennytm, @japaric, @Firstyear, @choller

Author: bors

Cargo.lock

@@ -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"
@@ -3596,17 +3585,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"
@@ -3661,17 +3639,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"
@@ -3786,17 +3753,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"
@@ -4151,10 +4107,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,21 +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,
-            });
-            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"));
@@ -273,30 +257,98 @@ 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,
+    });
+
+    if builder.config.dry_run {
+        return;
+    }
+
+    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

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

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