Build and link Enzyme durin bootstrap

Author: ZuseZ4

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

@@ -1576,6 +1576,7 @@ pub struct Assemble {
     pub target_compiler: Compiler,
 }
 
+#[allow(unreachable_code)]
 impl Step for Assemble {
     type Output = Compiler;
     const ONLY_HOSTS: bool = true;
@@ -1636,6 +1637,26 @@ impl Step for Assemble {
             return target_compiler;
         }
 
+        // Build enzyme
+        let enzyme_install =
+            Some(builder.ensure(llvm::Enzyme { target: build_compiler.host }));
+        //let enzyme_install = if builder.config.llvm_enzyme {
+        //    Some(builder.ensure(llvm::Enzyme { target: build_compiler.host }))
+        //} else {
+        //    None
+        //};
+
+        if let Some(enzyme_install) = enzyme_install {
+            let src_lib = enzyme_install.join("build/Enzyme/LLVMEnzyme-17.so");
+
+            let libdir = builder.sysroot_libdir(build_compiler, build_compiler.host);
+            let target_libdir = builder.sysroot_libdir(target_compiler, target_compiler.host);
+            let dst_lib = libdir.join("libLLVMEnzyme-17.so");
+            let target_dst_lib = target_libdir.join("libLLVMEnzyme-17.so");
+            builder.copy(&src_lib, &dst_lib);
+            builder.copy(&src_lib, &target_dst_lib);
+        }
+
         // Build the libraries for this compiler to link to (i.e., the libraries
         // it uses at runtime). NOTE: Crates the target compiler compiles don't
         // link to these. (FIXME: Is that correct? It seems to be correct most

src/bootstrap/src/core/build_steps/llvm.rs

@@ -817,6 +817,72 @@ fn get_var(var_base: &str, host: &str, target: &str) -> Option<OsString> {
         .or_else(|| env::var_os(var_base))
 }
 
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Enzyme {
+    pub target: TargetSelection,
+}
+
+impl Step for Enzyme {
+    type Output = PathBuf;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("src/tools/enzyme/enzyme")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(Enzyme { target: run.target });
+    }
+
+    /// Compile Enzyme for `target`.
+    fn run(self, builder: &Builder<'_>) -> PathBuf {
+        if builder.config.dry_run() {
+            let out_dir = builder.enzyme_out(self.target);
+            return out_dir;
+        }
+        let target = self.target;
+
+        let LlvmResult { llvm_config, .. } = builder.ensure(Llvm { target: self.target });
+
+        let out_dir = builder.enzyme_out(target);
+        let done_stamp = out_dir.join("enzyme-finished-building");
+        if done_stamp.exists() {
+            return out_dir;
+        }
+
+        builder.info(&format!("Building Enzyme for {}", target));
+        let _time = helpers::timeit(&builder);
+        t!(fs::create_dir_all(&out_dir));
+
+        builder.update_submodule(&Path::new("src").join("tools").join("enzyme"));
+        let mut cfg = cmake::Config::new(builder.src.join("src/tools/enzyme/enzyme/"));
+        // TODO: Find a nicer way to use Enzyme Debug builds
+        //cfg.profile("Debug");
+        //cfg.define("CMAKE_BUILD_TYPE", "Debug");
+        configure_cmake(builder, target, &mut cfg, true, LdFlags::default(), &[]);
+
+        // Re-use the same flags as llvm to control the level of debug information
+        // generated for lld.
+        let profile = match (builder.config.llvm_optimize, builder.config.llvm_release_debuginfo) {
+            (false, _) => "Debug",
+            (true, false) => "Release",
+            (true, true) => "RelWithDebInfo",
+        };
+
+        cfg.out_dir(&out_dir)
+            .profile(profile)
+            .env("LLVM_CONFIG_REAL", &llvm_config)
+            .define("LLVM_ENABLE_ASSERTIONS", "ON")
+            .define("ENZYME_EXTERNAL_SHARED_LIB", "OFF")
+            .define("LLVM_DIR", builder.llvm_out(target));
+
+        cfg.build();
+
+        t!(File::create(&done_stamp));
+        out_dir
+    }
+}
+
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct Lld {
     pub target: TargetSelection,

src/bootstrap/src/core/builder.rs

@@ -1416,6 +1416,10 @@ impl<'a> Builder<'a> {
             rustflags.arg(sysroot_str);
         }
 
+        // https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/.E2.9C.94.20link.20new.20library.20into.20stage1.2Frustc
+        rustflags.arg("-l");
+        rustflags.arg("LLVMEnzyme-17");
+
         let use_new_symbol_mangling = match self.config.rust_new_symbol_mangling {
             Some(setting) => {
                 // If an explicit setting is given, use that

src/bootstrap/src/lib.rs

@@ -799,6 +799,10 @@ impl Build {
         self.out.join(&*target.triple).join("lld")
     }
 
+    fn enzyme_out(&self, target: TargetSelection) -> PathBuf {
+        self.out.join(&*target.triple).join("enzyme")
+    }
+
     /// Output directory for all documentation for a target
     fn doc_out(&self, target: TargetSelection) -> PathBuf {
         self.out.join(&*target.triple).join("doc")