wip, fixing ci

Author: KMJ-007

compiler/rustc_codegen_gcc/src/builder.rs

@@ -1384,27 +1384,19 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         _src_align: Align,
         size: RValue<'gcc>,
         flags: MemFlags,
-        tt: Option<FncTree>,
+        _tt: Option<FncTree>,
     ) {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memcpy not supported");
         let size = self.intcast(size, self.type_size_t(), false);
         let _is_volatile = flags.contains(MemFlags::VOLATILE);
         let dst = self.pointercast(dst, self.type_i8p());
         let src = self.pointercast(src, self.type_ptr_to(self.type_void()));
         let memcpy = self.context.get_builtin_function("memcpy");
-
-        // Create the memcpy call
-        let call = self.context.new_call(self.location, memcpy, &[dst, src, size]);
-
-        // TypeTree metadata for memcpy: when Enzyme encounters a memcpy during autodiff,
-        if let Some(_tt) = tt {
-            // TODO(KMJ-007): implement TypeTree support for gcc backend
-            // For now, we just ignore the TypeTree since gcc backend doesn't support autodiff yet
-            // When autodiff support is added to gcc backend, this should attach TypeTree information
-            // as function attributes similar to how LLVM backend does it.
-        }
         // TODO(antoyo): handle aligns and is_volatile.
-        self.block.add_eval(self.location, call);
+        self.block.add_eval(
+            self.location,
+            self.context.new_call(self.location, memcpy, &[dst, src, size]),
+        );
     }
 
     fn memmove(

compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs

@@ -1,11 +1,32 @@
 #![expect(dead_code)]
 
-use libc::{c_char, c_uint};
+use libc::{c_char, c_uint, size_t};
 
 use super::MetadataKindId;
-use super::ffi::{AttributeKind, BasicBlock, Metadata, Module, Type, Value};
+use super::ffi::{AttributeKind, BasicBlock, Context, Metadata, Module, Type, Value};
 use crate::llvm::{Bool, Builder};
 
+// TypeTree types
+pub(crate) type CTypeTreeRef = *mut EnzymeTypeTree;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct EnzymeTypeTree {
+    _unused: [u8; 0],
+}
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub(crate) enum CConcreteType {
+    DT_Anything = 0,
+    DT_Integer = 1,
+    DT_Pointer = 2,
+    DT_Half = 3,
+    DT_Float = 4,
+    DT_Double = 5,
+    DT_Unknown = 6,
+}
+
 #[link(name = "llvm-wrapper", kind = "static")]
 unsafe extern "C" {
     // Enzyme
@@ -66,12 +87,35 @@ pub(crate) use self::Enzyme_AD::*;
 pub(crate) mod Enzyme_AD {
     use std::ffi::{CString, c_char};
 
-    use libc::c_void;
+    use libc::{c_void, size_t};
+
+    use super::{CConcreteType, CTypeTreeRef, Context};
 
     unsafe extern "C" {
         pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
         pub(crate) fn EnzymeSetCLString(arg1: *mut ::std::os::raw::c_void, arg2: *const c_char);
     }
+    
+    // TypeTree functions
+    unsafe extern "C" {
+        pub(crate) fn EnzymeNewTypeTree() -> CTypeTreeRef;
+        pub(crate) fn EnzymeNewTypeTreeCT(arg1: CConcreteType, ctx: &Context) -> CTypeTreeRef;
+        pub(crate) fn EnzymeNewTypeTreeTR(arg1: CTypeTreeRef) -> CTypeTreeRef;
+        pub(crate) fn EnzymeFreeTypeTree(CTT: CTypeTreeRef);
+        pub(crate) fn EnzymeMergeTypeTree(arg1: CTypeTreeRef, arg2: CTypeTreeRef) -> bool;
+        pub(crate) fn EnzymeTypeTreeOnlyEq(arg1: CTypeTreeRef, pos: i64);
+        pub(crate) fn EnzymeTypeTreeData0Eq(arg1: CTypeTreeRef);
+        pub(crate) fn EnzymeTypeTreeShiftIndiciesEq(
+            arg1: CTypeTreeRef,
+            data_layout: *const c_char,
+            offset: i64,
+            max_size: i64,
+            add_offset: u64,
+        );
+        pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
+        pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
+    }
+    
     unsafe extern "C" {
         static mut EnzymePrintPerf: c_void;
         static mut EnzymePrintActivity: c_void;
@@ -140,6 +184,56 @@ pub(crate) use self::Fallback_AD::*;
 #[cfg(not(llvm_enzyme))]
 pub(crate) mod Fallback_AD {
     #![allow(unused_variables)]
+    
+    use super::{CConcreteType, CTypeTreeRef, Context};
+    use libc::c_char;
+
+    // TypeTree function fallbacks
+    pub(crate) fn EnzymeNewTypeTree() -> CTypeTreeRef {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeNewTypeTreeCT(arg1: CConcreteType, ctx: &Context) -> CTypeTreeRef {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeNewTypeTreeTR(arg1: CTypeTreeRef) -> CTypeTreeRef {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeFreeTypeTree(CTT: CTypeTreeRef) {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeMergeTypeTree(arg1: CTypeTreeRef, arg2: CTypeTreeRef) -> bool {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeTypeTreeOnlyEq(arg1: CTypeTreeRef, pos: i64) {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeTypeTreeData0Eq(arg1: CTypeTreeRef) {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeTypeTreeShiftIndiciesEq(
+        arg1: CTypeTreeRef,
+        data_layout: *const c_char,
+        offset: i64,
+        max_size: i64,
+        add_offset: u64,
+    ) {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char {
+        unimplemented!()
+    }
+    
+    pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char) {
+        unimplemented!()
+    }
 
     pub(crate) fn set_inline(val: bool) {
         unimplemented!()

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2680,27 +2680,36 @@ unsafe extern "C" {
 
     // ========== ENZYME AUTODIFF FFI FUNCTIONS ==========
 
+    #[cfg(llvm_enzyme)]
     // Enzyme Type Tree Functions (minimal set for TypeTree support)
     pub(crate) fn EnzymeNewTypeTree() -> CTypeTreeRef;
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeFreeTypeTree(CTT: CTypeTreeRef);
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeNewTypeTreeCT(arg1: CConcreteType, ctx: &Context) -> CTypeTreeRef;
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeNewTypeTreeTR(arg1: CTypeTreeRef) -> CTypeTreeRef;
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeMergeTypeTree(arg1: CTypeTreeRef, arg2: CTypeTreeRef);
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeTypeTreeShiftIndiciesEq(
         arg1: CTypeTreeRef,
         data_layout: *const c_char,
         offset: i64,
         max_size: i64,
         add_offset: u64,
     );
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
+    #[cfg(llvm_enzyme)]
     pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
 }
 
 // ========== ENZYME TYPES AND ENUMS ==========
 
 // Type Tree Support for Autodiff
 
+#[cfg(llvm_enzyme)]
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub(crate) enum CConcreteType {
@@ -2713,19 +2722,23 @@ pub(crate) enum CConcreteType {
     DT_Unknown = 6,
 }
 
+#[cfg(llvm_enzyme)]
 pub(crate) type CTypeTreeRef = *mut EnzymeTypeTree;
 
+#[cfg(llvm_enzyme)]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct EnzymeTypeTree {
     _unused: [u8; 0],
 }
 
 // TypeTree wrapper for Rust-side type safety and memory management
+#[cfg(llvm_enzyme)]
 pub(crate) struct TypeTree {
     pub(crate) inner: CTypeTreeRef,
 }
 
+#[cfg(llvm_enzyme)]
 impl TypeTree {
     pub(crate) fn new() -> TypeTree {
         let inner = unsafe { EnzymeNewTypeTree() };
@@ -2769,13 +2782,15 @@ impl TypeTree {
     }
 }
 
+#[cfg(llvm_enzyme)]
 impl Clone for TypeTree {
     fn clone(&self) -> Self {
         let inner = unsafe { EnzymeNewTypeTreeTR(self.inner) };
         TypeTree { inner }
     }
 }
 
+#[cfg(llvm_enzyme)]
 impl std::fmt::Display for TypeTree {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let ptr = unsafe { EnzymeTypeTreeToString(self.inner) };
@@ -2792,12 +2807,14 @@ impl std::fmt::Display for TypeTree {
     }
 }
 
+#[cfg(llvm_enzyme)]
 impl std::fmt::Debug for TypeTree {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         <Self as std::fmt::Display>::fmt(self, f)
     }
 }
 
+#[cfg(llvm_enzyme)]
 impl Drop for TypeTree {
     fn drop(&mut self) {
         unsafe { EnzymeFreeTypeTree(self.inner) }

tests/run-make/autodiff/type-trees/type-analysis/memcpy/memcpy.check

@@ -0,0 +1,9 @@
+CHECK: test_memcpy - {[-1]:Float@double} |{[-1]:Pointer, [-1,0]:Float@double, [-1,8]:Float@double, [-1,16]:Float@double, [-1,24]:Float@double, [-1,32]:Float@double, [-1,40]:Float@double, [-1,48]:Float@double, [-1,56]:Float@double}:{}
+
+CHECK-DAG: call void @llvm.memcpy{{.*}}!enzyme_type
+
+CHECK-DAG: load double{{.*}}: {[-1]:Float@double}
+
+CHECK-DAG: fmul double{{.*}}: {[-1]:Float@double}
+
+CHECK-DAG: fadd double{{.*}}: {[-1]:Float@double} 

tests/run-make/autodiff/type-trees/type-analysis/memcpy/memcpy.rs

@@ -0,0 +1,31 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+use std::ptr;
+
+#[autodiff_reverse(d_test_memcpy, Duplicated, Active)]
+#[no_mangle]
+fn test_memcpy(input: &[f64; 8]) -> f64 {
+    let mut local_data = [0.0f64; 8];
+    
+    unsafe {
+        ptr::copy_nonoverlapping(input.as_ptr(), local_data.as_mut_ptr(), 8);
+    }
+    
+    let mut result = 0.0;
+    for i in 0..8 {
+        result += local_data[i] * local_data[i];
+    }
+    
+    result
+}
+
+fn main() {
+    let input = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+    let mut d_input = [0.0; 8];
+    let result = test_memcpy(&input);
+    let result_d = d_test_memcpy(&input, &mut d_input, 1.0);
+    
+    assert_eq!(result, result_d);
+    println!("Memcpy test passed: result = {}", result);
+} 

tests/run-make/autodiff/type-trees/type-analysis/memcpy/rmake.rs

@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("memcpy.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=test_memcpy")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("memcpy.stdout", stdout);
+    rfs::write("memcpy.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("memcpy.check").stdin_buf(rfs::read("memcpy.stdout")).run();
+}