Rollup merge of rust-lang#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 rust-lang#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 rust-lang#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

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 });