Rename intrinsic from enzyme_autodiff to autodiff

Author: Sa4dUs

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -197,7 +197,7 @@ mod llvm_enzyme {
     /// }
     /// #[rustc_autodiff(Reverse, Duplicated, Active)]
     /// fn cos_box(x: &Box<f32>, dx: &mut Box<f32>, dret: f32) -> f32 {
-    ///     std::intrinsics::enzyme_autodiff(sin::<>, cos_box::<>, (x, dx, dret))
+    ///     std::intrinsics::autodiff(sin::<>, cos_box::<>, (x, dx, dret))
     /// }
     /// ```
     /// FIXME(ZuseZ4): Once autodiff is enabled by default, make this a doc comment which is checked
@@ -493,11 +493,11 @@ mod llvm_enzyme {
         ty
     }
 
-    // Generate `enzyme_autodiff` intrinsic call
+    // Generate `autodiff` intrinsic call
     // ```
-    // std::intrinsics::enzyme_autodiff(source, diff, (args))
+    // std::intrinsics::autodiff(source, diff, (args))
     // ```
-    fn call_enzyme_autodiff(
+    fn call_autodiff(
         ecx: &ExtCtxt<'_>,
         primal: Ident,
         diff: Ident,
@@ -523,7 +523,7 @@ mod llvm_enzyme {
                 .into(),
         );
 
-        let enzyme_path_idents = ecx.std_path(&[sym::intrinsics, sym::enzyme_autodiff]);
+        let enzyme_path_idents = ecx.std_path(&[sym::intrinsics, sym::autodiff]);
         let enzyme_path = ecx.path(span, enzyme_path_idents);
         let call_expr = ecx.expr_call(
             span,
@@ -603,10 +603,10 @@ mod llvm_enzyme {
         let new_decl_span = d_sig.span;
 
         // Add a call to the primal function to prevent it from being inlined
-        // and call `enzyme_autodiff` intrinsic (this also covers the return type)
+        // and call `autodiff` intrinsic (this also covers the return type)
         let body = ecx.block(
             span,
-            thin_vec![call_enzyme_autodiff(
+            thin_vec![call_autodiff(
                 ecx,
                 primal,
                 diff_ident,

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -194,8 +194,8 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     &[ptr, args[1].immediate()],
                 )
             }
-            sym::enzyme_autodiff => {
-                codegen_enzyme_autodiff(self, tcx, instance, args, result);
+            sym::autodiff => {
+                codegen_autodiff(self, tcx, instance, args, result);
                 return Ok(());
             }
             sym::is_val_statically_known => {
@@ -1122,7 +1122,7 @@ fn get_rust_try_fn<'a, 'll, 'tcx>(
     rust_try
 }
 
-fn codegen_enzyme_autodiff<'ll, 'tcx>(
+fn codegen_autodiff<'ll, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     tcx: TyCtxt<'tcx>,
     instance: ty::Instance<'tcx>,

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -135,7 +135,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::round_ties_even_f32
         | sym::round_ties_even_f64
         | sym::round_ties_even_f128
-        | sym::enzyme_autodiff
+        | sym::autodiff
         | sym::const_eval_select => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
     };
@@ -199,7 +199,7 @@ pub(crate) fn check_intrinsic_type(
     let safety = intrinsic_operation_unsafety(tcx, intrinsic_id);
     let n_lts = 0;
     let (n_tps, n_cts, inputs, output) = match intrinsic_name {
-        sym::enzyme_autodiff => (4, 0, vec![param(0), param(1), param(2)], param(3)),
+        sym::autodiff => (4, 0, vec![param(0), param(1), param(2)], param(3)),
         sym::abort => (0, 0, vec![], tcx.types.never),
         sym::unreachable => (0, 0, vec![], tcx.types.never),
         sym::breakpoint => (0, 0, vec![], tcx.types.unit),

compiler/rustc_monomorphize/src/collector.rs

@@ -237,7 +237,7 @@ use rustc_span::source_map::{Spanned, dummy_spanned, respan};
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument, trace};
 
-use crate::collector::autodiff::collect_enzyme_autodiff_fn;
+use crate::collector::autodiff::collect_autodiff_fn;
 use crate::errors::{
     self, EncounteredErrorWhileInstantiating, EncounteredErrorWhileInstantiatingGlobalAsm,
     NoOptimizedMir, RecursionLimit,
@@ -914,7 +914,7 @@ fn visit_instance_use<'tcx>(
         return;
     }
     if let Some(intrinsic) = tcx.intrinsic(instance.def_id()) {
-        collect_enzyme_autodiff_fn(tcx, instance, intrinsic, output);
+        collect_autodiff_fn(tcx, instance, intrinsic, output);
 
         if let Some(_requirement) = ValidityRequirement::from_intrinsic(intrinsic.name) {
             // The intrinsics assert_inhabited, assert_zero_valid, and assert_mem_uninitialized_valid will

compiler/rustc_monomorphize/src/collector/autodiff.rs

@@ -4,16 +4,16 @@ use rustc_middle::ty::{self, GenericArg, IntrinsicDef, TyCtxt};
 use crate::collector::{MonoItems, create_fn_mono_item};
 
 // Here, we force both primal and diff function to be collected in
-// mono so this does not interfere in `enzyme_autodiff` intrinsics
+// mono so this does not interfere in `autodiff` intrinsics
 // codegen process. If they are unused, they will be removed later and
 // won't be present at LLVM-IR.
-pub(crate) fn collect_enzyme_autodiff_fn<'tcx>(
+pub(crate) fn collect_autodiff_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: ty::Instance<'tcx>,
     intrinsic: IntrinsicDef,
     output: &mut MonoItems<'tcx>,
 ) {
-    if intrinsic.name != rustc_span::sym::enzyme_autodiff {
+    if intrinsic.name != rustc_span::sym::autodiff {
         return;
     };
 

compiler/rustc_span/src/symbol.rs

@@ -917,7 +917,7 @@ symbols! {
         enumerate_method,
         env,
         env_CFG_RELEASE: env!("CFG_RELEASE"),
-        enzyme_autodiff,
+        autodiff,
         eprint_macro,
         eprintln_macro,
         eq,

library/core/src/intrinsics/mod.rs

@@ -3169,7 +3169,7 @@ pub const unsafe fn copysignf128(x: f128, y: f128) -> f128;
 /// - `T`: A tuple of arguments passed to `df`.
 /// - `R`: The return type of the derivative function.
 ///
-/// This shows where the `enzyme_autodiff` intrinsic is used during macro expansion:
+/// This shows where the `autodiff` intrinsic is used during macro expansion:
 ///
 /// ```rust,ignore (macro example)
 /// #[autodiff_forward(df1, Dual, Const, Dual)]
@@ -3188,12 +3188,12 @@ pub const unsafe fn copysignf128(x: f128, y: f128) -> f128;
 /// }
 /// #[rustc_autodiff(Forward, 1, Dual, Const, Dual)]
 /// pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {
-///     ::core::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, bx_0, y))
+///     ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, bx_0, y))
 /// }
 /// ```
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const fn enzyme_autodiff<F, G, T: crate::marker::Tuple, R>(f: F, df: G, args: T) -> R;
+pub const fn autodiff<F, G, T: crate::marker::Tuple, R>(f: F, df: G, args: T) -> R;
 
 /// Inform Miri that a given pointer definitely has a certain alignment.
 #[cfg(miri)]

tests/pretty/autodiff/autodiff_forward.pp

@@ -36,46 +36,43 @@
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Dual)]
 pub fn df1(x: &[f64], bx_0: &[f64], y: f64) -> (f64, f64) {
-    ::core::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f2(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df2(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f2::<>, df2::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f2::<>, df2::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f3(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df3(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f3::<>, df3::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
 pub fn f4() {}
 #[rustc_autodiff(Forward, 1, None)]
-pub fn df4() -> () {
-    ::core::intrinsics::enzyme_autodiff(f4::<>, df4::<>, ())
-}
+pub fn df4() -> () { ::core::intrinsics::autodiff(f4::<>, df4::<>, ()) }
 #[rustc_autodiff]
 pub fn f5(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Forward, 1, Const, Dual, Const)]
 pub fn df5_y(x: &[f64], y: f64, by_0: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f5::<>, df5_y::<>, (x, y, by_0))
+    ::core::intrinsics::autodiff(f5::<>, df5_y::<>, (x, y, by_0))
 }
 #[rustc_autodiff(Forward, 1, Dual, Const, Const)]
 pub fn df5_x(x: &[f64], bx_0: &[f64], y: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f5::<>, df5_x::<>, (x, bx_0, y))
+    ::core::intrinsics::autodiff(f5::<>, df5_x::<>, (x, bx_0, y))
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df5_rev(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f5::<>, df5_rev::<>,
-        (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f5::<>, df5_rev::<>, (x, dx_0, y, dret))
 }
 struct DoesNotImplDefault;
 #[rustc_autodiff]
@@ -84,53 +81,50 @@
 }
 #[rustc_autodiff(Forward, 1, Const)]
 pub fn df6() -> DoesNotImplDefault {
-    ::core::intrinsics::enzyme_autodiff(f6::<>, df6::<>, ())
+    ::core::intrinsics::autodiff(f6::<>, df6::<>, ())
 }
 #[rustc_autodiff]
 pub fn f7(x: f32) -> () {}
 #[rustc_autodiff(Forward, 1, Const, None)]
 pub fn df7(x: f32) -> () {
-    ::core::intrinsics::enzyme_autodiff(f7::<>, df7::<>, (x,))
+    ::core::intrinsics::autodiff(f7::<>, df7::<>, (x,))
 }
 #[no_mangle]
 #[rustc_autodiff]
 fn f8(x: &f32) -> f32 { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Forward, 4, Dual, Dual)]
 fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
     -> [f32; 5usize] {
-    ::core::intrinsics::enzyme_autodiff(f8::<>, f8_3::<>,
+    ::core::intrinsics::autodiff(f8::<>, f8_3::<>,
         (x, bx_0, bx_1, bx_2, bx_3))
 }
 #[rustc_autodiff(Forward, 4, Dual, DualOnly)]
 fn f8_2(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
     -> [f32; 4usize] {
-    ::core::intrinsics::enzyme_autodiff(f8::<>, f8_2::<>,
+    ::core::intrinsics::autodiff(f8::<>, f8_2::<>,
         (x, bx_0, bx_1, bx_2, bx_3))
 }
 #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
 fn f8_1(x: &f32, bx_0: &f32) -> f32 {
-    ::core::intrinsics::enzyme_autodiff(f8::<>, f8_1::<>, (x, bx_0))
+    ::core::intrinsics::autodiff(f8::<>, f8_1::<>, (x, bx_0))
 }
 pub fn f9() {
     #[rustc_autodiff]
     fn inner(x: f32) -> f32 { x * x }
     #[rustc_autodiff(Forward, 1, Dual, Dual)]
     fn d_inner_2(x: f32, bx_0: f32) -> (f32, f32) {
-        ::core::intrinsics::enzyme_autodiff(inner::<>, d_inner_2::<>,
-            (x, bx_0))
+        ::core::intrinsics::autodiff(inner::<>, d_inner_2::<>, (x, bx_0))
     }
     #[rustc_autodiff(Forward, 1, Dual, DualOnly)]
     fn d_inner_1(x: f32, bx_0: f32) -> f32 {
-        ::core::intrinsics::enzyme_autodiff(inner::<>, d_inner_1::<>,
-            (x, bx_0))
+        ::core::intrinsics::autodiff(inner::<>, d_inner_1::<>, (x, bx_0))
     }
 }
 #[rustc_autodiff]
 pub fn f10<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T { *x * *x }
 #[rustc_autodiff(Reverse, 1, Duplicated, Active)]
 pub fn d_square<T: std::ops::Mul<Output = T> +
     Copy>(x: &T, dx_0: &mut T, dret: T) -> T {
-    ::core::intrinsics::enzyme_autodiff(f10::<T>, d_square::<T>,
-        (x, dx_0, dret))
+    ::core::intrinsics::autodiff(f10::<T>, d_square::<T>, (x, dx_0, dret))
 }
 fn main() {}

tests/pretty/autodiff/autodiff_reverse.pp

@@ -29,34 +29,32 @@
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df1(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f1::<>, df1::<>, (x, dx_0, y, dret))
 }
 #[rustc_autodiff]
 pub fn f2() {}
 #[rustc_autodiff(Reverse, 1, None)]
-pub fn df2() { ::core::intrinsics::enzyme_autodiff(f2::<>, df2::<>, ()) }
+pub fn df2() { ::core::intrinsics::autodiff(f2::<>, df2::<>, ()) }
 #[rustc_autodiff]
 pub fn f3(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, Duplicated, Const, Active)]
 pub fn df3(x: &[f64], dx_0: &mut [f64], y: f64, dret: f64) -> f64 {
-    ::core::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, dx_0, y, dret))
+    ::core::intrinsics::autodiff(f3::<>, df3::<>, (x, dx_0, y, dret))
 }
 enum Foo { Reverse, }
 use Foo::Reverse;
 #[rustc_autodiff]
 pub fn f4(x: f32) { ::core::panicking::panic("not implemented") }
 #[rustc_autodiff(Reverse, 1, Const, None)]
-pub fn df4(x: f32) {
-    ::core::intrinsics::enzyme_autodiff(f4::<>, df4::<>, (x,))
-}
+pub fn df4(x: f32) { ::core::intrinsics::autodiff(f4::<>, df4::<>, (x,)) }
 #[rustc_autodiff]
 pub fn f5(x: *const f32, y: &f32) {
     ::core::panicking::panic("not implemented")
 }
 #[rustc_autodiff(Reverse, 1, DuplicatedOnly, Duplicated, None)]
 pub unsafe fn df5(x: *const f32, dx_0: *mut f32, y: &f32, dy_0: &mut f32) {
-    ::core::intrinsics::enzyme_autodiff(f5::<>, df5::<>, (x, dx_0, y, dy_0))
+    ::core::intrinsics::autodiff(f5::<>, df5::<>, (x, dx_0, y, dy_0))
 }
 fn main() {}

tests/pretty/autodiff/inherent_impl.pp

@@ -31,7 +31,7 @@
     }
     #[rustc_autodiff(Reverse, 1, Const, Active, Active)]
     fn df(&self, x: f64, dret: f64) -> (f64, f64) {
-        ::core::intrinsics::enzyme_autodiff(Self::f::<>, Self::df::<>,
+        ::core::intrinsics::autodiff(Self::f::<>, Self::df::<>,
             (self, x, dret))
     }
 }