Add rest of test fixes

Sa4dUs · Sa4dUs · commit 43efce85802a · 2025-07-25T17:38:26.000Z
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -276,7 +276,7 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
     //  %0 = fmul double %x, %x
     //  ret double %0
     // }
-    // ```
+    //
     // define double @dsquare(double %x) {
     //  return 0.0;
     // }
diff --git a/tests/codegen-llvm/autodiff/generic.rs b/tests/codegen-llvm/autodiff/generic.rs
@@ -11,23 +11,23 @@ fn square<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T {
     *x * *x
 }
 
-// Ensure that `d_square::<f64>` code is generated even if `square::<f64>` was never called
+// Ensure that `d_square::<f32>` code is generated
 //
 // CHECK: ; generic::square
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define internal {{.*}} double
+// CHECK-NEXT: ; Function Attrs: {{.*}}
+// CHECK-NEXT: define internal {{.*}} float
 // CHECK-NEXT: start:
 // CHECK-NOT: ret
-// CHECK: fmul double
+// CHECK: fmul float
 
-// Ensure that `d_square::<f32>` code is generated
+// Ensure that `d_square::<f64>` code is generated even if `square::<f64>` was never called
 //
 // CHECK: ; generic::square
-// CHECK-NEXT: ; Function Attrs: {{.*}}
-// CHECK-NEXT: define internal {{.*}} float
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define internal {{.*}} double
 // CHECK-NEXT: start:
 // CHECK-NOT: ret
-// CHECK: fmul float
+// CHECK: fmul double
 
 fn main() {
     let xf32: f32 = std::hint::black_box(3.0);
diff --git a/tests/codegen-llvm/autodiff/identical_fnc.rs b/tests/codegen-llvm/autodiff/identical_fnc.rs
@@ -26,12 +26,12 @@ fn square2(x: &f64) -> f64 {
 
 // CHECK:; identical_fnc::main
 // CHECK-NEXT:; Function Attrs:
-// CHECK-NEXT:define internal void @_ZN13identical_fnc4main17hf4dbc69c8d2f9130E()
+// CHECK-NEXT:define internal void @_ZN13identical_fnc4main17h6009e4f751bf9407E()
 // CHECK-NEXT:start:
 // CHECK-NOT:br
 // CHECK-NOT:ret
-// CHECK:call fastcc void @diffe_ZN13identical_fnc6square17hdfa1c645848284b7E(double %x.val, ptr %dx1)
-// CHECK-NEXT:call fastcc void @diffe_ZN13identical_fnc6square17hdfa1c645848284b7E(double %x.val, ptr %dx2)
+// CHECK:call fastcc void @diffe_ZN13identical_fnc6square17h67c6eccd3051fb4cE(double %x.val, ptr %dx1)
+// CHECK-NEXT:call fastcc void @diffe_ZN13identical_fnc6square17h67c6eccd3051fb4cE(double %x.val, ptr %dx2)
 
 fn main() {
     let x = std::hint::black_box(3.0);
diff --git a/tests/codegen-llvm/autodiff/inline.rs b/tests/codegen-llvm/autodiff/inline.rs
diff --git a/tests/codegen-llvm/autodiffv2.rs b/tests/codegen-llvm/autodiffv2.rs
@@ -25,13 +25,15 @@
 // in our frontend and in the llvm backend to avoid these issues.
 
 #![feature(autodiff)]
+#![feature(core_intrinsics)]
 
-use std::autodiff::autodiff;
+use std::autodiff::autodiff_forward;
 
+// CHECK: ;
 #[no_mangle]
 //#[autodiff(d_square1, Forward, Dual, Dual)]
-#[autodiff(d_square2, Forward, 4, Dualv, Dualv)]
-#[autodiff(d_square3, Forward, 4, Dual, Dual)]
+#[autodiff_forward(d_square2, 4, Dualv, Dualv)]
+#[autodiff_forward(d_square3, 4, Dual, Dual)]
 fn square(x: &[f32], y: &mut [f32]) {
     assert!(x.len() >= 4);
     assert!(y.len() >= 5);
diff --git a/tests/pretty/autodiff/autodiff_forward.pp b/tests/pretty/autodiff/autodiff_forward.pp
@@ -3,7 +3,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
@@ -37,92 +37,105 @@
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Dual)]
-#[rustc_intrinsic]
-pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64);
+pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {
+    std::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, bx_0, y))
+}
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f2(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
-#[rustc_intrinsic]
-pub fn df2(x: &[f64], bx_0: &[f64], y: f64) -> f64;
+pub fn df2(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f2::<>, df2::<>, (x, bx_0, y))
+}
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f3(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
-#[rustc_intrinsic]
-pub fn df3(x: &[f64], bx_0: &[f64], y: f64) -> f64;
+pub fn df3(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, bx_0, y))
+}
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f4() {}
 #[rustc_autodiff(Forward, 1, None)]
-#[rustc_intrinsic]
-pub fn df4() -> ();
+pub fn df4() -> () { std::intrinsics::enzyme_autodiff(f4::<>, df4::<>, ()) }
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f5(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Const, Dual, Const)]
-#[rustc_intrinsic]
-pub fn df5_y(x: &[f64], y: f64, by_0: f64) -> f64;
+pub fn df5_y(x: &[f64], y: f64, by_0: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f5::<>, df5_y::<>, (x, y, by_0))
+}
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
-#[rustc_intrinsic]
-pub fn df5_x(x: &[f64], bx_0: &[f64], y: f64) -> f64;
+pub fn df5_x(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f5::<>, df5_x::<>, (x, bx_0, y))
+}
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
-#[rustc_intrinsic]
-pub fn df5_rev(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64;
+pub fn df5_rev(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f5::<>, df5_rev::<>, (x, dx_0, y, dret))
+}
 struct DoesNotImplDefault;
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f6() -> DoesNotImplDefault {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Const)]
-#[rustc_intrinsic]
-pub fn df6() -> DoesNotImplDefault;
+pub fn df6() -> DoesNotImplDefault {
+    std::intrinsics::enzyme_autodiff(f6::<>, df6::<>, ())
+}
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f7(x: f32) -> () {}
 #[rustc_autodiff(Forward, 1, Const, None)]
-#[rustc_intrinsic]
-pub fn df7(x: f32) -> ();
+pub fn df7(x: f32) -> () {
+    std::intrinsics::enzyme_autodiff(f7::<>, df7::<>, (x,))
+}
 #[no_mangle]
 #[rustc_autodiff]
 #[inline(never)]
 fn f8(x: &f32) -> f32 { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Forward, 4, Dual, Dual)]
-#[rustc_intrinsic]
 fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
--> [f32; 5usize];
+    -> [f32; 5usize] {
+    std::intrinsics::enzyme_autodiff(f8::<>, f8_3::<>,
+        (x, bx_0, bx_1, bx_2, bx_3))
+}
 #[rustc_autodiff(Forward, 4, Dual, DualOnly)]
-#[rustc_intrinsic]
 fn f8_2(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
--> [f32; 4usize];
+    -> [f32; 4usize] {
+    std::intrinsics::enzyme_autodiff(f8::<>, f8_2::<>,
+        (x, bx_0, bx_1, bx_2, bx_3))
+}
 #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
-#[rustc_intrinsic]
-fn f8_1(x: &f32, bx_0: &f32) -> f32;
+fn f8_1(x: &f32, bx_0: &f32) -> f32 {
+    std::intrinsics::enzyme_autodiff(f8::<>, f8_1::<>, (x, bx_0))
+}
 pub fn f9() {
     #[rustc_autodiff]
     #[inline(never)]
     fn inner(x: f32) -> f32 { x * x }
     #[rustc_autodiff(Forward, 1, Dual, Dual)]
-    #[rustc_intrinsic]
-    fn d_inner_2(x: f32, bx_0: f32)
-    -> (f32, f32);
+    fn d_inner_2(x: f32, bx_0: f32) -> (f32, f32) {
+        std::intrinsics::enzyme_autodiff(inner::<>, d_inner_2::<>, (x, bx_0))
+    }
     #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
-    #[rustc_intrinsic]
-    fn d_inner_1(x: f32, bx_0: f32)
-    -> f32;
+    fn d_inner_1(x: f32, bx_0: f32) -> f32 {
+        std::intrinsics::enzyme_autodiff(inner::<>, d_inner_1::<>, (x, bx_0))
+    }
 }
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f10<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T { *x * *x }
 #[rustc_autodiff(Reverse, 1, Duplicated, Active)]
-#[rustc_intrinsic]
 pub fn d_square<T: std::ops::Mul<Output = T> +
-Copy>(x: &T, dx_0: &mut T, dret: T) -> T;
+    Copy>(x: &T, dx_0: &mut T, dret: T) -> T {
+    std::intrinsics::enzyme_autodiff(f10::<T>, d_square::<T>, (x, dx_0, dret))
+}
 fn main() {}
diff --git a/tests/pretty/autodiff/autodiff_forward.rs b/tests/pretty/autodiff/autodiff_forward.rs
@@ -1,7 +1,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 //@ pretty-mode:expanded
 //@ pretty-compare-only
 //@ pp-exact:autodiff_forward.pp
diff --git a/tests/pretty/autodiff/autodiff_reverse.pp b/tests/pretty/autodiff/autodiff_reverse.pp
@@ -3,7 +3,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
@@ -30,36 +30,37 @@
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
-#[rustc_intrinsic]
-pub fn df1(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64;
+pub fn df1(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, dx_0, y, dret))
+}
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f2() {}
 #[rustc_autodiff(Reverse, 1, None)]
-#[rustc_intrinsic]
-pub fn df2();
+pub fn df2() { std::intrinsics::enzyme_autodiff(f2::<>, df2::<>, ()) }
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f3(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
-#[rustc_intrinsic]
-pub fn df3(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64;
+pub fn df3(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
+    std::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, dx_0, y, dret))
+}
 enum Foo { Reverse, }
 use Foo::Reverse;
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f4(x: f32) { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Reverse, 1, Const, None)]
-#[rustc_intrinsic]
-pub fn df4(x: f32);
+pub fn df4(x: f32) { std::intrinsics::enzyme_autodiff(f4::<>, df4::<>, (x,)) }
 #[rustc_autodiff]
 #[inline(never)]
 pub fn f5(x: *const f32, y: &f32) {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, DuplicatedOnly, Duplicated, None)]
-#[rustc_intrinsic]
-pub unsafe fn df5(x: *const f32, dx_0: *mut f32, y: &f32, dy_0: &mut f32);
+pub unsafe fn df5(x: *const f32, dx_0: *mut f32, y: &f32, dy_0: &mut f32) {
+    std::intrinsics::enzyme_autodiff(f5::<>, df5::<>, (x, dx_0, y, dy_0))
+}
 fn main() {}
diff --git a/tests/pretty/autodiff/autodiff_reverse.rs b/tests/pretty/autodiff/autodiff_reverse.rs
@@ -1,7 +1,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 //@ pretty-mode:expanded
 //@ pretty-compare-only
 //@ pp-exact:autodiff_reverse.pp
diff --git a/tests/pretty/autodiff/inherent_impl.pp b/tests/pretty/autodiff/inherent_impl.pp
@@ -3,7 +3,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 #[prelude_import]
 use ::std::prelude::rust_2015::*;
 #[macro_use]
@@ -32,11 +32,8 @@
         self.a * 0.25 * (x * x - 1.0 - 2.0 * x.ln())
     }
     #[rustc_autodiff(Reverse, 1, Const, Active, Active)]
-    #[rustc_intrinsic]
     fn df(&self, x: f64, dret: f64) -> (f64, f64) {
-        unsafe { asm!("NOP", options(pure, nomem)); };
-        ::core::hint::black_box(self.f(x));
-        ::core::hint::black_box((dret,));
-        ::core::hint::black_box((self.f(x), f64::default()))
+        std::intrinsics::enzyme_autodiff(Self::f::<>, Self::df::<>,
+            (self, x, dret))
     }
 }
diff --git a/tests/pretty/autodiff/inherent_impl.rs b/tests/pretty/autodiff/inherent_impl.rs
@@ -1,7 +1,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 //@ pretty-mode:expanded
 //@ pretty-compare-only
 //@ pp-exact:inherent_impl.pp
diff --git a/tests/ui/autodiff/autodiff_illegal.rs b/tests/ui/autodiff/autodiff_illegal.rs
@@ -1,6 +1,7 @@
 //@ needs-enzyme
 
 #![feature(autodiff)]
+#![feature(core_intrinsics)]
 //@ pretty-mode:expanded
 //@ pretty-compare-only
 //@ pp-exact:autodiff_illegal.pp
