passing some enzyme tests

Author: ZuseZ4

compiler/rustc_codegen_llvm/Cargo.toml

@@ -14,6 +14,7 @@ bitflags = "2.4.1"
 gimli = "0.31"
 itertools = "0.12"
 libc = "0.2"
+libloading = "0.8.8"
 measureme = "12.0.1"
 object = { version = "0.37.0", default-features = false, features = ["std", "read"] }
 rustc-demangle = "0.1.21"

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -665,6 +665,22 @@ pub(crate) unsafe fn llvm_optimize(
 
     let llvm_plugins = config.llvm_plugins.join(",");
 
+    fn call_dynamic() -> Result<*const c_void, Box<dyn std::error::Error>> {
+        unsafe {
+            let lib = libloading::Library::new("/home/manuel/prog/rust/build/x86_64-unknown-linux-gnu/enzyme/lib/libEnzyme-21.so")?;
+            let func: libloading::Symbol<'_, c_void> = lib.get(b"registerEnzymeAndPassPipeline")?;
+            let func = func.try_as_raw_ptr().unwrap();
+            dbg!(func);
+            Ok(func as *const c_void)
+        }
+    }
+    let enzyme_fn = if cfg!(llvm_enzyme) && run_enzyme {
+        call_dynamic().unwrap_or(std::ptr::null())
+    } else {
+       std::ptr::null()
+    };
+
+
     let result = unsafe {
         llvm::LLVMRustOptimize(
             module.module_llvm.llmod(),
@@ -684,7 +700,8 @@ pub(crate) unsafe fn llvm_optimize(
             vectorize_loop,
             config.no_builtins,
             config.emit_lifetime_markers,
-            run_enzyme,
+            enzyme_fn,
+            //run_enzyme,
             print_before_enzyme,
             print_after_enzyme,
             print_passes,

compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs

@@ -59,10 +59,10 @@ pub(crate) enum LLVMRustVerifierFailureAction {
     LLVMReturnStatusAction = 2,
 }
 
-#[cfg(llvm_enzyme)]
+#[cfg(not(llvm_enzyme))]
 pub(crate) use self::Enzyme_AD::*;
 
-#[cfg(llvm_enzyme)]
+#[cfg(not(llvm_enzyme))]
 pub(crate) mod Enzyme_AD {
     use std::ffi::{CString, c_char};
 
@@ -134,38 +134,38 @@ pub(crate) mod Enzyme_AD {
     }
 }
 
-#[cfg(not(llvm_enzyme))]
+#[cfg(llvm_enzyme)]
 pub(crate) use self::Fallback_AD::*;
 
-#[cfg(not(llvm_enzyme))]
+#[cfg(llvm_enzyme)]
 pub(crate) mod Fallback_AD {
     #![allow(unused_variables)]
 
     pub(crate) fn set_inline(val: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_print_perf(print: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_print_activity(print: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_print_type(print: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_print_type_fun(fun_name: &str) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_print(print: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_strict_aliasing(strict: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_loose_types(loose: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
     pub(crate) fn set_rust_rules(val: bool) {
-        unimplemented!()
+        //unimplemented!()
     }
 }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2518,7 +2518,8 @@ unsafe extern "C" {
         LoopVectorize: bool,
         DisableSimplifyLibCalls: bool,
         EmitLifetimeMarkers: bool,
-        RunEnzyme: bool,
+        RunEnzyme: *const c_void,
+        //RunEnzyme: bool,
         PrintBeforeEnzyme: bool,
         PrintAfterEnzyme: bool,
         PrintPasses: bool,

compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp

@@ -704,19 +704,21 @@ struct LLVMRustSanitizerOptions {
 extern "C" void registerEnzymeAndPassPipeline(llvm::PassBuilder &PB,
                                               /* augmentPassBuilder */ bool);
 
-extern "C" {
-extern llvm::cl::opt<std::string> EnzymeFunctionToAnalyze;
-}
+//extern "C" {
+//extern llvm::cl::opt<std::string> EnzymeFunctionToAnalyze;
+//}
 #endif
 
+extern "C" typedef void (*registerEnzymeAndPassPipelineFn)(llvm::PassBuilder &PB, bool augment);
+
 extern "C" LLVMRustResult LLVMRustOptimize(
     LLVMModuleRef ModuleRef, LLVMTargetMachineRef TMRef,
     LLVMRustPassBuilderOptLevel OptLevelRust, LLVMRustOptStage OptStage,
     bool IsLinkerPluginLTO, bool NoPrepopulatePasses, bool VerifyIR,
     bool LintIR, LLVMRustThinLTOBuffer **ThinLTOBufferRef, bool EmitThinLTO,
     bool EmitThinLTOSummary, bool MergeFunctions, bool UnrollLoops,
     bool SLPVectorize, bool LoopVectorize, bool DisableSimplifyLibCalls,
-    bool EmitLifetimeMarkers, bool RunEnzyme, bool PrintBeforeEnzyme,
+    bool EmitLifetimeMarkers, registerEnzymeAndPassPipelineFn EnzymePtr, bool PrintBeforeEnzyme,
     bool PrintAfterEnzyme, bool PrintPasses,
     LLVMRustSanitizerOptions *SanitizerOptions, const char *PGOGenPath,
     const char *PGOUsePath, bool InstrumentCoverage,
@@ -1061,29 +1063,30 @@ extern "C" LLVMRustResult LLVMRustOptimize(
 
   // now load "-enzyme" pass:
 #ifdef ENZYME
-  if (RunEnzyme) {
+  if (EnzymePtr) {
 
     if (PrintBeforeEnzyme) {
       // Handle the Rust flag `-Zautodiff=PrintModBefore`.
       std::string Banner = "Module before EnzymeNewPM";
       MPM.addPass(PrintModulePass(outs(), Banner, true, false));
     }
 
-    registerEnzymeAndPassPipeline(PB, false);
+    EnzymePtr(PB, false);
+    //registerEnzymeAndPassPipeline(PB, false);
     if (auto Err = PB.parsePassPipeline(MPM, "enzyme")) {
       std::string ErrMsg = toString(std::move(Err));
       LLVMRustSetLastError(ErrMsg.c_str());
       return LLVMRustResult::Failure;
     }
 
     // Check if PrintTAFn was used and add type analysis pass if needed
-    if (!EnzymeFunctionToAnalyze.empty()) {
-      if (auto Err = PB.parsePassPipeline(MPM, "print-type-analysis")) {
-        std::string ErrMsg = toString(std::move(Err));
-        LLVMRustSetLastError(ErrMsg.c_str());
-        return LLVMRustResult::Failure;
-      }
-    }
+    //if (!EnzymeFunctionToAnalyze.empty()) {
+    //  if (auto Err = PB.parsePassPipeline(MPM, "print-type-analysis")) {
+    //    std::string ErrMsg = toString(std::move(Err));
+    //    LLVMRustSetLastError(ErrMsg.c_str());
+    //    return LLVMRustResult::Failure;
+    //  }
+    //}
 
     if (PrintAfterEnzyme) {
       // Handle the Rust flag `-Zautodiff=PrintModAfter`.

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

@@ -1205,14 +1205,14 @@ pub fn rustc_cargo(
     // We want to link against registerEnzyme and in the future we want to use additional
     // functionality from Enzyme core. For that we need to link against Enzyme.
     if builder.config.llvm_enzyme {
-        let arch = builder.build.host_target;
-        let enzyme_dir = builder.build.out.join(arch).join("enzyme").join("lib");
-        cargo.rustflag("-L").rustflag(enzyme_dir.to_str().expect("Invalid path"));
-
-        if let Some(llvm_config) = builder.llvm_config(builder.config.host_target) {
-            let llvm_version_major = llvm::get_llvm_version_major(builder, &llvm_config);
-            cargo.rustflag("-l").rustflag(&format!("Enzyme-{llvm_version_major}"));
-        }
+        //let arch = builder.build.host_target;
+        //let enzyme_dir = builder.build.out.join(arch).join("enzyme").join("lib");
+        //cargo.rustflag("-L").rustflag(enzyme_dir.to_str().expect("Invalid path"));
+
+        //if let Some(llvm_config) = builder.llvm_config(builder.config.host_target) {
+        //    let llvm_version_major = llvm::get_llvm_version_major(builder, &llvm_config);
+        //    cargo.rustflag("-l").rustflag(&format!("Enzyme-{llvm_version_major}"));
+        //}
     }
 
     // Building with protected visibility reduces the number of dynamic relocations needed, giving