Remove inlining for autodiff handling

Sa4dUs · Sa4dUs · commit b9c9a69cd2e0 · 2025-08-06T12:07:41.000Z
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -348,28 +348,10 @@ mod llvm_enzyme {
         let mut rustc_ad_attr =
             P(ast::NormalAttr::from_ident(Ident::with_dummy_span(sym::rustc_autodiff)));
 
-        let ts2: Vec<TokenTree> = vec![TokenTree::Token(
-            Token::new(TokenKind::Ident(sym::never, false.into()), span),
-            Spacing::Joint,
-        )];
-        let never_arg = ast::DelimArgs {
-            dspan: DelimSpan::from_single(span),
-            delim: ast::token::Delimiter::Parenthesis,
-            tokens: TokenStream::from_iter(ts2),
-        };
-        let inline_item = ast::AttrItem {
-            unsafety: ast::Safety::Default,
-            path: ast::Path::from_ident(Ident::with_dummy_span(sym::inline)),
-            args: ast::AttrArgs::Delimited(never_arg),
-            tokens: None,
-        };
-        let inline_never_attr = P(ast::NormalAttr { item: inline_item, tokens: None });
         let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
         let attr = outer_normal_attr(&rustc_ad_attr, new_id, span);
-        let new_id = ecx.sess.psess.attr_id_generator.mk_attr_id();
-        let inline_never = outer_normal_attr(&inline_never_attr, new_id, span);
 
-        // We're avoid duplicating the attributes `#[rustc_autodiff]` and `#[inline(never)]`.
+        // We're avoid duplicating the attribute `#[rustc_autodiff]`.
         fn same_attribute(attr: &ast::AttrKind, item: &ast::AttrKind) -> bool {
             match (attr, item) {
                 (ast::AttrKind::Normal(a), ast::AttrKind::Normal(b)) => {
@@ -388,18 +370,12 @@ mod llvm_enzyme {
                 if !iitem.attrs.iter().any(|a| same_attribute(&a.kind, &attr.kind)) {
                     iitem.attrs.push(attr);
                 }
-                if !iitem.attrs.iter().any(|a| same_attribute(&a.kind, &inline_never.kind)) {
-                    iitem.attrs.push(inline_never.clone());
-                }
                 Annotatable::Item(iitem.clone())
             }
             Annotatable::AssocItem(ref mut assoc_item, i @ Impl { .. }) => {
                 if !assoc_item.attrs.iter().any(|a| same_attribute(&a.kind, &attr.kind)) {
                     assoc_item.attrs.push(attr);
                 }
-                if !assoc_item.attrs.iter().any(|a| same_attribute(&a.kind, &inline_never.kind)) {
-                    assoc_item.attrs.push(inline_never.clone());
-                }
                 Annotatable::AssocItem(assoc_item.clone(), i)
             }
             Annotatable::Stmt(ref mut stmt) => {
@@ -408,10 +384,6 @@ mod llvm_enzyme {
                         if !iitem.attrs.iter().any(|a| same_attribute(&a.kind, &attr.kind)) {
                             iitem.attrs.push(attr);
                         }
-                        if !iitem.attrs.iter().any(|a| same_attribute(&a.kind, &inline_never.kind))
-                        {
-                            iitem.attrs.push(inline_never.clone());
-                        }
                     }
                     _ => unreachable!("stmt kind checked previously"),
                 };
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -10,10 +10,9 @@ use tracing::debug;
 use crate::builder::{Builder, PlaceRef, UNNAMED};
 use crate::context::SimpleCx;
 use crate::declare::declare_simple_fn;
-use crate::llvm::AttributePlace::Function;
+use crate::llvm;
 use crate::llvm::{Metadata, True, Type};
 use crate::value::Value;
-use crate::{attributes, llvm};
 
 pub(crate) fn adjust_activity_to_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -308,11 +307,6 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
         enzyme_ty,
     );
 
-    // Otherwise LLVM might inline our temporary code before the enzyme pass has a chance to
-    // do it's work.
-    let attr = llvm::AttributeKind::NoInline.create_attr(cx.llcx);
-    attributes::apply_to_llfn(ad_fn, Function, &[attr]);
-
     let num_args = llvm::LLVMCountParams(&fn_to_diff);
     let mut args = Vec::with_capacity(num_args as usize + 1);
     args.push(fn_to_diff);
diff --git a/tests/codegen-llvm/autodiff/batched.rs b/tests/codegen-llvm/autodiff/batched.rs
@@ -21,74 +21,39 @@ fn square(x: &f32) -> f32 {
     x * x
 }
 
-// d_square2
-// CHECK: define internal fastcc [4 x float] @fwddiffe4square(float %x.0.val, [4 x ptr] %"x'")
-// CHECK-NEXT: start:
-// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
-// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
-// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
-// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
-// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
-// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
-// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
-// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %4 = fadd fast float %"_2'ipl", %"_2'ipl"
-// CHECK-NEXT:   %5 = fmul fast float %4, %x.0.val
-// CHECK-NEXT:   %6 = insertvalue [4 x float] undef, float %5, 0
-// CHECK-NEXT:   %7 = fadd fast float %"_2'ipl1", %"_2'ipl1"
-// CHECK-NEXT:   %8 = fmul fast float %7, %x.0.val
-// CHECK-NEXT:   %9 = insertvalue [4 x float] %6, float %8, 1
-// CHECK-NEXT:   %10 = fadd fast float %"_2'ipl2", %"_2'ipl2"
-// CHECK-NEXT:   %11 = fmul fast float %10, %x.0.val
-// CHECK-NEXT:   %12 = insertvalue [4 x float] %9, float %11, 2
-// CHECK-NEXT:   %13 = fadd fast float %"_2'ipl3", %"_2'ipl3"
-// CHECK-NEXT:   %14 = fmul fast float %13, %x.0.val
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %12, float %14, 3
-// CHECK-NEXT:   ret [4 x float] %15
-// CHECK-NEXT:   }
-
-// d_square3, the extra float is the original return value (x * x)
-// CHECK: define internal fastcc { float, [4 x float] } @fwddiffe4square.1(float %x.0.val, [4 x ptr] %"x'")
-// CHECK-NEXT: start:
-// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
-// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
-// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
-// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
-// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
-// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
-// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
-// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %_0 = fmul float %x.0.val, %x.0.val
-// CHECK-NEXT:   %4 = fadd fast float %"_2'ipl", %"_2'ipl"
-// CHECK-NEXT:   %5 = fmul fast float %4, %x.0.val
-// CHECK-NEXT:   %6 = insertvalue [4 x float] undef, float %5, 0
-// CHECK-NEXT:   %7 = fadd fast float %"_2'ipl1", %"_2'ipl1"
-// CHECK-NEXT:   %8 = fmul fast float %7, %x.0.val
-// CHECK-NEXT:   %9 = insertvalue [4 x float] %6, float %8, 1
-// CHECK-NEXT:   %10 = fadd fast float %"_2'ipl2", %"_2'ipl2"
-// CHECK-NEXT:   %11 = fmul fast float %10, %x.0.val
-// CHECK-NEXT:   %12 = insertvalue [4 x float] %9, float %11, 2
-// CHECK-NEXT:   %13 = fadd fast float %"_2'ipl3", %"_2'ipl3"
-// CHECK-NEXT:   %14 = fmul fast float %13, %x.0.val
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %12, float %14, 3
-// CHECK-NEXT:   %16 = insertvalue { float, [4 x float] } undef, float %_0, 0
-// CHECK-NEXT:   %17 = insertvalue { float, [4 x float] } %16, [4 x float] %15, 1
-// CHECK-NEXT:   ret { float, [4 x float] } %17
-// CHECK-NEXT:   }
-
 fn main() {
     let x = std::hint::black_box(3.0);
+
+    // square(&x)
+    // CHECK: %_0.i = fmul float %_2.i, %_2.i
+    // CHECK-NEXT: store float %_0.i, ptr %output, align 4
     let output = square(&x);
     dbg!(&output);
     assert_eq!(9.0, output);
+
+    // square(&x)
+    // CHECK: %_2.i26 = load float, ptr %x, align 4
+    // CHECK-NEXT: %_0.i27 = fmul float %_2.i26, %_2.i26
     dbg!(square(&x));
 
     let mut df_dx1 = 1.0;
     let mut df_dx2 = 2.0;
     let mut df_dx3 = 3.0;
     let mut df_dx4 = 0.0;
+
+    // [o1, o2, o3, o4] (o4 is being optimized away as its smth * 0.0)
+    // CHECK: %x.val = load float, ptr %x, align 4
+    // CHECK-NEXT: %13 = fmul fast float %x.val, 2.000000e+00
+    // CHECK-NEXT: %14 = fmul fast float %x.val, 4.000000e+00
+    // CHECK-NEXT: %15 = fmul fast float %x.val, 6.000000e+00
     let [o1, o2, o3, o4] = d_square2(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
     dbg!(o1, o2, o3, o4);
+
+    // [output2, o1, o2, o3, o4] (o4 is being optimized away as its smth * 0.0)
+    // CHECK: %_0.i45 = fmul float %x.val35, %x.val35
+    // CHECK-NEXT: %40 = fmul fast float %x.val35, 2.000000e+00
+    // CHECK-NEXT: %41 = fmul fast float %x.val35, 4.000000e+00
+    // CHECK-NEXT: %42 = fmul fast float %x.val35, 6.000000e+00
     let [output2, o1, o2, o3, o4] =
         d_square1(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
     dbg!(o1, o2, o3, o4);
@@ -101,8 +66,22 @@ fn main() {
     assert_eq!(2.0, df_dx2);
     assert_eq!(3.0, df_dx3);
     assert_eq!(0.0, df_dx4);
+
+    // d_square3(&x, &mut df_dx1)
+    // CHECK: %x.val39 = load float, ptr %x, align 4
+    // CHECK-NEXT: %72 = fmul fast float %x.val39, 2.000000e+00
     assert_eq!(d_square3(&x, &mut df_dx1), 2.0 * o1);
+
+    // d_square3(&x, &mut df_dx2)
+    // CHECK: %74 = fmul fast float %x.val39, 4.000000e+00
+    // CHECK-NEXT: store float %74, ptr %_191, align 4
     assert_eq!(d_square3(&x, &mut df_dx2), 2.0 * o2);
+
+    // d_square3(&x, &mut df_dx3)
+    // CHECK: %76 = fmul fast float %x.val39, 6.000000e+00
+    // CHECK-NEXT: store float %76, ptr %_200, align 4
     assert_eq!(d_square3(&x, &mut df_dx3), 2.0 * o3);
+
+    // d_square3(&x, &mut df_dx3) is being optimized away as it's smth * 0.0
     assert_eq!(d_square3(&x, &mut df_dx4), 2.0 * o4);
 }
diff --git a/tests/codegen-llvm/autodiff/generic.rs b/tests/codegen-llvm/autodiff/generic.rs
@@ -10,23 +10,13 @@ fn square<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T {
     *x * *x
 }
 
-// Ensure that `d_square::<f32>` code is generated
+// Ensure that `square::<f32>` code is generated
 //
-// CHECK: ; generic::square
-// CHECK-NEXT: ; Function Attrs: {{.*}}
-// CHECK-NEXT: define internal {{.*}} float
-// CHECK-NEXT: start:
-// CHECK-NOT: ret
-// CHECK: fmul float
+// CHECK: %1 = fmul float %xf32, %xf32
 
 // 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 {{.*}} double
-// CHECK-NEXT: start:
-// CHECK-NOT: ret
-// CHECK: fmul double
+// CHECK: define internal { double } @diffe_ZN7generic6square17he5c855620985cd59E
 
 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
@@ -23,15 +23,13 @@ fn square2(x: &f64) -> f64 {
     x * x
 }
 
-// CHECK:; identical_fnc::main
-// CHECK-NEXT:; Function Attrs:
-// CHECK-NEXT:define internal void @_ZN13identical_fnc4main17h6009e4f751bf9407E()
-// CHECK-NEXT:start:
-// CHECK-NOT:br
-// CHECK-NOT:ret
-// 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)
-
+// CHECK: %0 = fadd fast double %x.val, %x.val
+// CHECK-NEXT: %1 = load double, ptr %dx1, align 8
+// CHECK-NEXT: %2 = fadd fast double %1, %0
+// CHECK-NEXT: store double %2, ptr %dx1, align 8
+// CHECK-NEXT: %3 = load double, ptr %dx2, align 8
+// CHECK-NEXT: %4 = fadd fast double %3, %0
+// CHECK-NEXT: store double %4, ptr %dx2, align 8
 fn main() {
     let x = std::hint::black_box(3.0);
     let mut dx1 = std::hint::black_box(1.0);
diff --git a/tests/codegen-llvm/autodiff/scalar.rs b/tests/codegen-llvm/autodiff/scalar.rs
@@ -11,16 +11,11 @@ fn square(x: &f64) -> f64 {
     x * x
 }
 
-// CHECK:define internal fastcc double @diffesquare(double %x.0.val, ptr nocapture nonnull align 8 %"x'"
-// CHECK-NEXT:invertstart:
-// CHECK-NEXT:  %_0 = fmul double %x.0.val, %x.0.val
-// CHECK-NEXT:  %0 = fadd fast double %x.0.val, %x.0.val
-// CHECK-NEXT:  %1 = load double, ptr %"x'", align 8
-// CHECK-NEXT:  %2 = fadd fast double %1, %0
-// CHECK-NEXT:  store double %2, ptr %"x'", align 8
-// CHECK-NEXT:  ret double %_0
-// CHECK-NEXT:}
+// square
+// CHECK: %_0.i = fmul double %_2.i, %_2.i
 
+// d_square
+// CHECK: %0 = fadd fast double %_2.i, %_2.i
 fn main() {
     let x = std::hint::black_box(3.0);
     let output = square(&x);
diff --git a/tests/codegen-llvm/autodiff/sret.rs b/tests/codegen-llvm/autodiff/sret.rs
@@ -17,19 +17,14 @@ fn primal(x: f32, y: f32) -> f64 {
     (x * x * y) as f64
 }
 
-// CHECK: define internal fastcc { double, float, float } @diffeprimal(float noundef %x, float noundef %y)
-// CHECK-NEXT: invertstart:
-// CHECK-NEXT: %_4 = fmul float %x, %x
-// CHECK-NEXT: %_3 = fmul float %_4, %y
-// CHECK-NEXT: %_0 = fpext float %_3 to double
-// CHECK-NEXT: %0 = fadd fast float %y, %y
-// CHECK-NEXT: %1 = fmul fast float %0, %x
-// CHECK-NEXT: %2 = insertvalue { double, float, float } undef, double %_0, 0
-// CHECK-NEXT: %3 = insertvalue { double, float, float } %2, float %1, 1
-// CHECK-NEXT: %4 = insertvalue { double, float, float } %3, float %_4, 2
-// CHECK-NEXT: ret { double, float, float } %4
-// CHECK-NEXT: }
-
+// CHECK: %_4.i = fmul float %x, %x
+// CHECK-NEXT: %_3.i = fmul float %_4.i, %y
+// CHECK-NEXT: %_0.i = fpext float %_3.i to double
+// CHECK-NEXT: %3 = fadd fast float %y, %y
+// CHECK-NEXT: %4 = fmul fast float %3, %x
+// CHECK-NEXT: store double %_0.i, ptr %r1, align 8
+// CHECK-NEXT: store float %4, ptr %r2, align 4
+// CHECK-NEXT: store float %_4.i, ptr %r3, align 4
 fn main() {
     let x = std::hint::black_box(3.0);
     let y = std::hint::black_box(2.5);
diff --git a/tests/pretty/autodiff/autodiff_forward.pp b/tests/pretty/autodiff/autodiff_forward.pp
@@ -16,7 +16,6 @@
 use std::autodiff::{autodiff_forward, autodiff_reverse};
 
 #[rustc_autodiff]
-#[inline(never)]
 pub fn f1(x: &[f64], y: f64) -> f64 {
 
 
@@ -40,7 +39,6 @@
     ::core::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")
 }
@@ -49,7 +47,6 @@
     ::core::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")
 }
@@ -58,14 +55,12 @@
     ::core::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, bx_0, y))
 }
 #[rustc_autodiff]
-#[inline(never)]
 pub fn f4() {}
 #[rustc_autodiff(Forward, 1, None)]
 pub fn df4() -> () {
     ::core::intrinsics::enzyme_autodiff(f4::<>, df4::<>, ())
 }
 #[rustc_autodiff]
-#[inline(never)]
 pub fn f5(x: &[f64], y: f64) -> f64 {
     ::core::panicking::panic("not implemented")
 }
@@ -84,7 +79,6 @@
 }
 struct DoesNotImplDefault;
 #[rustc_autodiff]
-#[inline(never)]
 pub fn f6() -> DoesNotImplDefault {
     ::core::panicking::panic("not implemented")
 }
@@ -93,15 +87,13 @@
     ::core::intrinsics::enzyme_autodiff(f6::<>, df6::<>, ())
 }
 #[rustc_autodiff]
-#[inline(never)]
 pub fn f7(x: f32) -> () {}
 #[rustc_autodiff(Forward, 1, Const, None)]
 pub fn df7(x: f32) -> () {
     ::core::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)]
 fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)
@@ -121,7 +113,6 @@
 }
 pub fn f9() {
     #[rustc_autodiff]
-    #[inline(never)]
     fn inner(x: f32) -> f32 { x * x }
     #[rustc_autodiff(Forward, 1, Dual, Dual)]
     fn d_inner_2(x: f32, bx_0: f32) -> (f32, f32) {
@@ -135,7 +126,6 @@
     }
 }
 #[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)]
 pub fn d_square<T: std::ops::Mul<Output = T> +
diff --git a/tests/pretty/autodiff/autodiff_reverse.pp b/tests/pretty/autodiff/autodiff_reverse.pp
diff --git a/tests/pretty/autodiff/inherent_impl.pp b/tests/pretty/autodiff/inherent_impl.pp

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@`
`16`	`16`	`use std::autodiff::{autodiff_forward, autodiff_reverse};`
`17`	`17`
`18`	`18`	`#[rustc_autodiff]`
`19`		`-#[inline(never)]`
`20`	`19`	`pub fn f1(x: &[f64], y: f64) -> f64 {`
`21`	`20`
`22`	`21`
`@@ -40,7 +39,6 @@`
`40`	`39`	`::core::intrinsics::enzyme_autodiff(f1::<>, df1::<>, (x, bx_0, y))`
`41`	`40`	`}`
`42`	`41`	`#[rustc_autodiff]`
`43`		`-#[inline(never)]`
`44`	`42`	`pub fn f2(x: &[f64], y: f64) -> f64 {`
`45`	`43`	`::core::panicking::panic("not implemented")`
`46`	`44`	`}`
`@@ -49,7 +47,6 @@`
`49`	`47`	`::core::intrinsics::enzyme_autodiff(f2::<>, df2::<>, (x, bx_0, y))`
`50`	`48`	`}`
`51`	`49`	`#[rustc_autodiff]`
`52`		`-#[inline(never)]`
`53`	`50`	`pub fn f3(x: &[f64], y: f64) -> f64 {`
`54`	`51`	`::core::panicking::panic("not implemented")`
`55`	`52`	`}`
`@@ -58,14 +55,12 @@`
`58`	`55`	`::core::intrinsics::enzyme_autodiff(f3::<>, df3::<>, (x, bx_0, y))`
`59`	`56`	`}`
`60`	`57`	`#[rustc_autodiff]`
`61`		`-#[inline(never)]`
`62`	`58`	`pub fn f4() {}`
`63`	`59`	`#[rustc_autodiff(Forward, 1, None)]`
`64`	`60`	`pub fn df4() -> () {`
`65`	`61`	`::core::intrinsics::enzyme_autodiff(f4::<>, df4::<>, ())`
`66`	`62`	`}`
`67`	`63`	`#[rustc_autodiff]`
`68`		`-#[inline(never)]`
`69`	`64`	`pub fn f5(x: &[f64], y: f64) -> f64 {`
`70`	`65`	`::core::panicking::panic("not implemented")`
`71`	`66`	`}`
`@@ -84,7 +79,6 @@`
`84`	`79`	`}`
`85`	`80`	`struct DoesNotImplDefault;`
`86`	`81`	`#[rustc_autodiff]`
`87`		`-#[inline(never)]`
`88`	`82`	`pub fn f6() -> DoesNotImplDefault {`
`89`	`83`	`::core::panicking::panic("not implemented")`
`90`	`84`	`}`
`@@ -93,15 +87,13 @@`
`93`	`87`	`::core::intrinsics::enzyme_autodiff(f6::<>, df6::<>, ())`
`94`	`88`	`}`
`95`	`89`	`#[rustc_autodiff]`
`96`		`-#[inline(never)]`
`97`	`90`	`pub fn f7(x: f32) -> () {}`
`98`	`91`	`#[rustc_autodiff(Forward, 1, Const, None)]`
`99`	`92`	`pub fn df7(x: f32) -> () {`
`100`	`93`	`::core::intrinsics::enzyme_autodiff(f7::<>, df7::<>, (x,))`
`101`	`94`	`}`
`102`	`95`	`#[no_mangle]`
`103`	`96`	`#[rustc_autodiff]`
`104`		`-#[inline(never)]`
`105`	`97`	`fn f8(x: &f32) -> f32 { ::core::panicking::panic("not implemented") }`
`106`	`98`	`#[rustc_autodiff(Forward, 4, Dual, Dual)]`
`107`	`99`	`fn f8_3(x: &f32, bx_0: &f32, bx_1: &f32, bx_2: &f32, bx_3: &f32)`
`@@ -121,7 +113,6 @@`
`121`	`113`	`}`
`122`	`114`	`pub fn f9() {`
`123`	`115`	`#[rustc_autodiff]`
`124`		`- #[inline(never)]`
`125`	`116`	`fn inner(x: f32) -> f32 { x * x }`
`126`	`117`	`#[rustc_autodiff(Forward, 1, Dual, Dual)]`
`127`	`118`	`fn d_inner_2(x: f32, bx_0: f32) -> (f32, f32) {`
`@@ -135,7 +126,6 @@`
`135`	`126`	`}`
`136`	`127`	`}`
`137`	`128`	`#[rustc_autodiff]`
`138`		`-#[inline(never)]`
`139`	`129`	`pub fn f10<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T { x *x }`
`140`	`130`	`#[rustc_autodiff(Reverse, 1, Duplicated, Active)]`
`141`	`131`	`pub fn d_square<T: std::ops::Mul<Output = T> +`