Switch to dynamically linked BDWGC

This works by ensuring that the bootstrap phase puts libgc.so inside the
sysroot, where the librustc-driver and libtest objects are already
given to search at load time in their RPATH.

Author: jacob-hughes

.buildbot.config.toml

@@ -1,5 +1,6 @@
 [alloy]
 bdwgc-assertions = true
+bdwgc-link-shared = true
 
 [rust]
 codegen-units = 0           # Use many compilation units.

.buildbot.sh

@@ -28,7 +28,7 @@ sh rustup.sh --default-host x86_64-unknown-linux-gnu \
 	-y
 export PATH=$(pwd)/.cargo/bin/:$PATH
 
-rustup toolchain link alloy build/x86_64-unknown-linux-gnu/stage1
+rustup toolchain link alloy build/x86_64-unknown-linux-gnu/stage2
 
 # Build and test yksom
 git clone --recursive https://github.com/softdevteam/yksom

.buildbot_dockerfile_debian

@@ -2,7 +2,8 @@ FROM debian:latest
 ARG CI_UID
 RUN useradd -m -u ${CI_UID} ci
 RUN apt-get update && \
-    apt-get -y install build-essential curl cmake python3 git ninja-build time autoconf libtool libssl-dev pkg-config
+    apt-get -y install build-essential curl cmake python3 git ninja-build \
+    time autoconf libclang-dev libtool libssl-dev pkg-config
 WORKDIR /ci
 RUN chown ${CI_UID}:${CI_UID} .
 COPY --chown=${CI_UID}:${CI_UID} . .

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1318,6 +1318,12 @@ fn link_sanitizer_runtime(
     }
 }
 
+fn add_bdwgc(sess: &Session, linker: &mut dyn Linker) {
+    let sysroot = sess.sysroot.clone();
+    linker.link_args(&["-rpath", &sysroot.join("lib").to_str().unwrap()]);
+    linker.link_dylib_by_name("gc", false, false);
+}
+
 /// Returns a boolean indicating whether the specified crate should be ignored
 /// during LTO.
 ///
@@ -2254,6 +2260,8 @@ fn linker_with_args(
     // Sanitizer libraries.
     add_sanitizer_libraries(sess, flavor, crate_type, cmd);
 
+    add_bdwgc(sess, cmd);
+
     // Object code from the current crate.
     // Take careful note of the ordering of the arguments we pass to the linker
     // here. Linkers will assume that things on the left depend on things to the

library/Cargo.lock

@@ -409,6 +409,7 @@ dependencies = [
 name = "sysroot"
 version = "0.0.0"
 dependencies = [
+ "bdwgc",
  "proc_macro",
  "profiler_builtins",
  "std",

library/bdwgc/build.rs

@@ -4,50 +4,6 @@ use std::process::Command;
 #[cfg(not(all(target_pointer_width = "64", target_arch = "x86_64")))]
 compile_error!("Requires x86_64 with 64 bit pointer width.");
 
-#[cfg(not(feature = "link-shared"))]
-fn build_bdwgc() {
-    use std::env;
-    use std::path::PathBuf;
-    use std::process::Command;
-
-    const BDWGC_REPO: &str = "../../src/bdwgc";
-    const BDWGC_BUILD_DIR: &str = "lib";
-
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let bdwgc_src = PathBuf::from(BDWGC_REPO);
-
-    if bdwgc_src.read_dir().unwrap().count() == 0 {
-        Command::new("git")
-            .args(["submodule", "update", "--init", BDWGC_REPO])
-            .output()
-            .expect("Failed to clone BDWGC repo");
-    }
-
-    let mut build_dir = PathBuf::from(&out_dir);
-    build_dir.push(BDWGC_BUILD_DIR);
-
-    let mut build = cmake::Config::new(&bdwgc_src);
-    build
-        .pic(true)
-        .define("BUILD_SHARED_LIBS", "OFF")
-        .define("enable_parallel_mark", "Off")
-        .cflag("-DGC_ALWAYS_MULTITHREADED");
-
-    #[cfg(feature = "gc-assertions")]
-    build.define("enable_gc_assertions", "ON");
-
-    #[cfg(not(feature = "gc-debug"))]
-    build.profile("Release");
-
-    #[cfg(feature = "gc-debug")]
-    build.profile("Debug");
-
-    build.build();
-
-    println!("cargo:rustc-link-search=native={}", &build_dir.display());
-    println!("cargo:rustc-link-lib=static=gc");
-}
-
 fn main() {
     let cwd = env::var("CARGO_MANIFEST_DIR").unwrap();
     let header = Path::new(&cwd)
@@ -64,6 +20,8 @@ fn main() {
     let out = Path::new(&env::var("OUT_DIR").unwrap()).join("bindings.rs");
     let status = Command::new(bindgen)
         .args(&[
+            "--ctypes-prefix",
+            "libc",
             "--use-core",
             "-o",
             out.to_str().unwrap(),
@@ -77,8 +35,5 @@ fn main() {
     if !status.success() {
         panic!("bindgen failed with status: {:?}", status);
     }
-    #[cfg(not(feature = "link-shared"))]
-    build_bdwgc();
-    #[cfg(feature = "link-shared")]
-    println!("cargo:rustc-link-lib=dylib=gc");
+    println!("cargo::rustc-link-lib=dylib=gc");
 }

library/sysroot/Cargo.toml

@@ -11,6 +11,7 @@ proc_macro = { path = "../proc_macro", public = true }
 profiler_builtins = { path = "../profiler_builtins", optional = true }
 std = { path = "../std", public = true }
 test = { path = "../test", public = true }
+bdwgc = { path = "../bdwgc", public = true }
 
 # Forward features to the `std` crate as necessary
 [features]

rustfmt.toml

@@ -38,6 +38,7 @@ ignore = [
     "src/doc/rust-by-example",
     "src/doc/rustc-dev-guide",
     "src/llvm-project",
+    "src/tools/bindgen",
     "src/tools/cargo",
     "src/tools/clippy",
     "src/tools/enzyme",

src/bootstrap/src/core/build_steps/bdwgc.rs

@@ -0,0 +1,107 @@
+//! Compilation of native BDWGC
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+
+#[cfg(feature = "tracing")]
+use tracing::instrument;
+
+use crate::core::build_steps::llvm;
+use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
+use crate::core::config::TargetSelection;
+use crate::trace;
+use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
+use crate::utils::helpers::{self, t};
+
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Bdwgc {
+    pub target: TargetSelection,
+}
+
+fn libgc_built_path(out_dir: &Path) -> PathBuf {
+    out_dir.join("lib")
+}
+
+impl Step for Bdwgc {
+    type Output = PathBuf;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("src/bdwgc")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(Bdwgc { target: run.target });
+    }
+
+    fn run(self, builder: &Builder<'_>) -> PathBuf {
+        builder.require_submodule("src/bdwgc", None);
+        let target = self.target;
+        let out_dir = builder.bdwgc_out(target);
+        let libgc = libgc_built_path(&out_dir);
+        if builder.config.dry_run() {
+            return libgc;
+        }
+
+        static STAMP_HASH_MEMO: OnceLock<String> = OnceLock::new();
+        let smart_stamp_hash = STAMP_HASH_MEMO.get_or_init(|| {
+            generate_smart_stamp_hash(
+                builder,
+                &builder.config.src.join("src/bdwgc"),
+                builder.bdwgc_info.sha().unwrap_or_default(),
+            )
+        });
+
+        let stamp = BuildStamp::new(&out_dir).add_stamp(smart_stamp_hash);
+
+        trace!("checking build stamp to see if we need to rebuild BDWGC artifacts");
+        if stamp.is_up_to_date() {
+            trace!(?out_dir, "bdwgc build artifacts are up to date");
+            if stamp.stamp().is_empty() {
+                builder.info(
+                    "Could not determine the BDWGC submodule commit hash. \
+                     Assuming that an BDWGC rebuild is necessary.",
+                );
+            } else {
+                builder.info(&format!(
+                    "To force BDWGC to rebuild, remove the file `{}`",
+                    stamp.path().display()
+                ));
+                return libgc;
+            }
+        }
+
+        trace!(?target, "(re)building BDWGC artifacts");
+        builder.info(&format!("Building BDWGC for {}", target));
+        t!(stamp.remove());
+        let _time = helpers::timeit(builder);
+        t!(fs::create_dir_all(&out_dir));
+
+        builder.config.update_submodule(Path::new("src").join("bdwgc").to_str().unwrap());
+        let mut cfg = cmake::Config::new(builder.src.join("src/bdwgc"));
+        llvm::configure_cmake(builder, target, &mut cfg, true, llvm::LdFlags::default(), &[]);
+
+        let profile = match (builder.config.bdwgc_debug, builder.config.bdwgc_assertions) {
+            (true, _) => "Debug",
+            (false, false) => "Release",
+            (false, true) => "RelWithDebInfo",
+        };
+        trace!(?profile);
+
+        let assertions = if builder.config.bdwgc_assertions { "ON" } else { "OFF" };
+        let shared = if builder.config.bdwgc_link_shared { "ON" } else { "OFF" };
+
+        cfg.out_dir(&out_dir)
+            .pic(true)
+            .profile(profile)
+            .define("BUILD_SHARED_LIBS", shared)
+            .define("enable_parallel_mark", "OFF")
+            .define("enable_gc_assertions", assertions)
+            .cflag("-DGC_ALWAYS_MULTITHREADED");
+
+        cfg.build();
+
+        t!(stamp.write());
+        libgc
+    }
+}

src/bootstrap/src/core/build_steps/compile.rs

@@ -21,7 +21,7 @@ use tracing::{instrument, span};
 
 use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::tool::{Bindgen, SourceType};
-use crate::core::build_steps::{dist, llvm};
+use crate::core::build_steps::{bdwgc, dist, llvm};
 use crate::core::builder;
 use crate::core::builder::{
     Builder, Cargo, Kind, PathSet, RunConfig, ShouldRun, Step, TaskPath, crate_description,
@@ -283,6 +283,8 @@ impl Step for Std {
             }
             cargo
         };
+        let bindgen = builder.ensure(Bindgen { target });
+        cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
 
         // See src/bootstrap/synthetic_targets.rs
         if target.is_synthetic() {
@@ -292,7 +294,7 @@ impl Step for Std {
             cargo.rustflag(rustflag);
         }
 
-        let bindgen = builder.ensure(Bindgen { compiler, target });
+        let bindgen = builder.ensure(Bindgen { target });
         cargo.env("RUSTC_BINDGEN", bindgen.tool_path);
 
         let _guard = builder.msg(
@@ -333,6 +335,33 @@ fn copy_and_stamp(
     target_deps.push((target, dependency_type));
 }
 
+fn copy_libgc(
+    builder: &Builder<'_>,
+    target: TargetSelection,
+    libdir: &Path,
+) -> Vec<(PathBuf, DependencyType)> {
+    let mut v = Vec::new();
+    let install_dir = builder.ensure(bdwgc::Bdwgc { target });
+    if !install_dir.exists() {
+        return v;
+    }
+    for obj in fs::read_dir(install_dir).unwrap() {
+        let p = obj.unwrap().path();
+        if !p.file_name().unwrap().to_str().unwrap().starts_with("libgc") {
+            continue;
+        }
+        if p.is_symlink() {
+            builder.install(&t!(fs::canonicalize(&p)), &libdir, 0o644);
+            let full_dest = libdir.join(p.file_name().unwrap());
+            builder.copy_link(&p, &full_dest);
+        } else {
+            builder.install(&p, &libdir, 0o644);
+        }
+        v.push((p, DependencyType::Target));
+    }
+    v
+}
+
 fn copy_llvm_libunwind(builder: &Builder<'_>, target: TargetSelection, libdir: &Path) -> PathBuf {
     let libunwind_path = builder.ensure(llvm::Libunwind { target });
     let libunwind_source = libunwind_path.join("libunwind.a");
@@ -368,6 +397,11 @@ fn copy_third_party_objects(
         target_deps.push((libunwind_path, DependencyType::Target));
     }
 
+    if builder.config.bdwgc_link_shared {
+        let libgc_objs = copy_libgc(builder, target, &builder.rustc_libdir(*compiler));
+        target_deps.extend(libgc_objs)
+    }
+
     target_deps
 }
 
@@ -537,6 +571,8 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
             cargo.env("MACOSX_DEPLOYMENT_TARGET", target);
         }
     }
+    let bindgen = builder.ensure(Bindgen { target });
+    cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
 
     // Paths needed by `library/profiler_builtins/build.rs`.
     if let Some(path) = builder.config.profiler_path(target) {
@@ -549,6 +585,12 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
         cargo.env("RUST_COMPILER_RT_FOR_PROFILER", compiler_rt);
     }
 
+    // Evenutally we stick libgc.so in the current compiler stage's sysroot where the linker will
+    // find it. But first, we must explicitly link the build directory because of bootstrap
+    // ordering: the first thing rust does is build library/std with stage 0 which doesn't yet know
+    // about libgc.
+    cargo.rustflag("-L").rustflag(builder.bdwgc_out(target).join("lib").to_str().unwrap());
+
     // Determine if we're going to compile in optimized C intrinsics to
     // the `compiler-builtins` crate. These intrinsics live in LLVM's
     // `compiler-rt` repository.
@@ -1191,6 +1233,9 @@ pub fn rustc_cargo(
         }
     }
 
+    let bindgen = builder.ensure(Bindgen { target });
+    cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
+
     // Building with protected visibility reduces the number of dynamic relocations needed, giving
     // us a faster startup time. However GNU ld < 2.40 will error if we try to link a shared object
     // with direct references to protected symbols, so for now we only use protected symbols if
@@ -1351,6 +1396,9 @@ pub fn rustc_cargo_env(
         }
     }
 
+    // Paths needed by `library/bdwgc/build.rs`.
+    let bindgen = builder.ensure(Bindgen { target });
+    cargo.env("RUSTC_BINDGEN", &bindgen.tool_path);
     // Build jemalloc on AArch64 with support for page sizes up to 64K
     // See: https://github.com/rust-lang/rust/pull/135081
     if builder.config.jemalloc(target)