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