adressing feedback

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -29,7 +29,6 @@ use rustc_span::{BytePos, InnerSpan, Pos, SpanData, SyntaxContext, sym};
 use rustc_target::spec::{CodeModel, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel};
 use tracing::{debug, trace};
 
-//use crate::back::autodiff::*;
 use crate::back::lto::ThinBuffer;
 use crate::back::owned_target_machine::OwnedTargetMachine;
 use crate::back::profiling::{

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1492,26 +1492,6 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         }
     }
 
-    pub(crate) fn call2(
-        &mut self,
-        llty: &'ll Type,
-        llfn: &'ll Value,
-        args: &[&'ll Value],
-        fn_name: &core::ffi::CStr,
-    ) -> &'ll Value {
-        let call = unsafe {
-            llvm::LLVMBuildCall2(
-                self.llbuilder,
-                llty,
-                llfn,
-                args.as_ptr(),
-                args.len().try_into().unwrap(),
-                fn_name.as_ptr(),
-            )
-        };
-        call
-    }
-
     pub(crate) fn callbr(
         &mut self,
         llty: &'ll Type,

compiler/rustc_codegen_llvm/src/builder/autodiff.rs

@@ -1,12 +1,9 @@
-use std::ffi::CString;
 use std::ptr;
 
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, AutoDiffItem, DiffActivity, DiffMode};
 use rustc_codegen_ssa::ModuleCodegen;
 use rustc_codegen_ssa::back::write::ModuleConfig;
-use rustc_codegen_ssa::traits::{
-    BaseTypeCodegenMethods, BuilderMethods, TypeMembershipCodegenMethods,
-};
+use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 use rustc_errors::FatalError;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::Lto;
@@ -141,11 +138,11 @@ fn generate_enzyme_call<'ll, 'tcx>(
         let mut args = Vec::with_capacity(num_args as usize + 1);
         args.push(fn_to_diff);
 
-        let enzyme_const = cx.typeid_metadata("enzyme_const".to_string()).unwrap();
-        let enzyme_out = cx.typeid_metadata("enzyme_out".to_string()).unwrap();
-        let enzyme_dup = cx.typeid_metadata("enzyme_dup".to_string()).unwrap();
-        let enzyme_dupnoneed = cx.typeid_metadata("enzyme_dupnoneed".to_string()).unwrap();
-        let enzyme_primal_ret = cx.typeid_metadata("enzyme_primal_return".to_string()).unwrap();
+        let enzyme_const = cx.create_metadata("enzyme_const".to_string()).unwrap();
+        let enzyme_out = cx.create_metadata("enzyme_out".to_string()).unwrap();
+        let enzyme_dup = cx.create_metadata("enzyme_dup".to_string()).unwrap();
+        let enzyme_dupnoneed = cx.create_metadata("enzyme_dupnoneed".to_string()).unwrap();
+        let enzyme_primal_ret = cx.create_metadata("enzyme_primal_return".to_string()).unwrap();
 
         match output {
             DiffActivity::Dual => {
@@ -239,8 +236,7 @@ fn generate_enzyme_call<'ll, 'tcx>(
             }
         }
 
-        let c_ad_name = CString::new(ad_name.clone()).unwrap();
-        let call = builder.call2(enzyme_ty, ad_fn, &args, &c_ad_name);
+        let call = builder.call(enzyme_ty, None, None, ad_fn, &args, None, None);
 
         // This part is a bit iffy. LLVM requires that a call to an inlineable function has some
         // metadata attachted to it, but we just created this code oota. Given that the
@@ -250,8 +246,9 @@ fn generate_enzyme_call<'ll, 'tcx>(
         // FIXME(ZuseZ4): Work with Enzyme core devs to clarify what debug metadata issues we have,
         // and how to best improve it for enzyme core and rust-enzyme.
         let md_ty = cx.get_md_kind_id("dbg");
-        if llvm::LLVMRustHasMetadata(last_inst, md_ty) {
-            let md = llvm::LLVMRustDIGetInstMetadata(last_inst);
+        if llvm::LLVMRustHasMetadata(last_inst, md_ty) == True {
+            let md = llvm::LLVMRustDIGetInstMetadata(last_inst)
+                .expect("failed to get instruction metadata");
             let md_todiff = cx.get_metadata_value(md);
             llvm::LLVMSetMetadata(call, md_ty, md_todiff);
         } else {

compiler/rustc_codegen_llvm/src/context.rs

@@ -619,6 +619,12 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             )
         }
     }
+
+    pub(crate) fn create_metadata(&self, name: String) -> Option<&'ll Metadata> {
+        Some(unsafe {
+            llvm::LLVMMDStringInContext2(self.llcx, name.as_ptr() as *const c_char, name.len())
+        })
+    }
 }
 
 impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {

compiler/rustc_codegen_llvm/src/lib.rs

@@ -28,8 +28,8 @@ use std::mem::ManuallyDrop;
 
 use back::owned_target_machine::OwnedTargetMachine;
 use back::write::{create_informational_target_machine, create_target_machine};
-pub use llvm_util::target_features_cfg;
 use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
+pub use llvm_util::target_features_cfg;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};

compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs

@@ -1,34 +1,35 @@
 #![allow(non_camel_case_types)]
 
-use libc::{c_char, c_uint, size_t};
+use libc::{c_char, c_uint};
 
+use super::Bool;
 use super::ffi::{Attribute, BasicBlock, Builder, Metadata, Module, Type, Value};
 extern "C" {
     // Enzyme
-    pub fn LLVMRustHasMetadata(I: &Value, KindID: c_uint) -> bool;
+    pub fn LLVMRustHasMetadata(I: &Value, KindID: c_uint) -> Bool;
     pub fn LLVMRustEraseInstBefore(BB: &BasicBlock, I: &Value);
     pub fn LLVMRustGetLastInstruction<'a>(BB: &BasicBlock) -> Option<&'a Value>;
-    pub fn LLVMRustDIGetInstMetadata(I: &Value) -> &Metadata;
+    pub fn LLVMRustDIGetInstMetadata(I: &Value) -> Option<&Metadata>;
     pub fn LLVMRustEraseInstFromParent(V: &Value);
     pub fn LLVMRustGetTerminator<'a>(B: &BasicBlock) -> &'a Value;
     pub fn LLVMGetFunctionCallConv(F: &Value) -> c_uint;
 
     pub fn LLVMGetReturnType(T: &Type) -> &Type;
     pub fn LLVMDumpModule(M: &Module);
     pub fn LLVMCountStructElementTypes(T: &Type) -> c_uint;
-    pub fn LLVMVerifyFunction(V: &Value, action: LLVMVerifierFailureAction) -> bool;
+    pub fn LLVMVerifyFunction(V: &Value, action: LLVMVerifierFailureAction) -> Bool;
     pub fn LLVMGetParams(Fnc: &Value, parms: *mut &Value);
     pub fn LLVMBuildCall2<'a>(
         arg1: &Builder<'a>,
         ty: &Type,
         func: &Value,
         args: *const &Value,
-        num_args: size_t,
+        num_args: usize,
         name: *const c_char,
     ) -> &'a Value;
     pub fn LLVMGetNamedFunction(M: &Module, Name: *const c_char) -> Option<&Value>;
-    pub fn LLVMIsEnumAttribute(A: &Attribute) -> bool;
-    pub fn LLVMIsStringAttribute(A: &Attribute) -> bool;
+    pub fn LLVMIsEnumAttribute(A: &Attribute) -> Bool;
+    pub fn LLVMIsStringAttribute(A: &Attribute) -> Bool;
 }
 
 #[repr(C)]