temporarily remove enum support

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::{fs, slice, str};
 
-use libc::{c_char, c_int, c_uint, c_void, size_t};
+use libc::{c_char, c_int, c_void, size_t};
 use llvm::{
     LLVMRustLLVMHasZlibCompressionForDebugSymbols, LLVMRustLLVMHasZstdCompressionForDebugSymbols,
 };
@@ -41,14 +41,8 @@ use crate::errors::{
     CopyBitcode, FromLlvmDiag, FromLlvmOptimizationDiag, LlvmError, UnknownCompression,
     WithLlvmError, WriteBytecode,
 };
-use crate::llvm::AttributePlace::Function;
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
-use crate::llvm::{
-    self, AttributeKind, DiagnosticInfo, LLVMGetFirstFunction,
-    LLVMGetNextFunction, LLVMGetStringAttributeAtIndex, LLVMIsEnumAttribute, LLVMIsStringAttribute,
-    LLVMRemoveStringAttributeAtIndex, LLVMRustGetEnumAttributeAtIndex,
-    LLVMRustRemoveEnumAttributeAtIndex, PassManager,
-};
+use crate::llvm::{self, DiagnosticInfo, PassManager};
 use crate::type_::Type;
 use crate::{LlvmCodegenBackend, ModuleLlvm, base, common, llvm_util};
 
@@ -689,39 +683,8 @@ pub(crate) fn differentiate(
         crate::builder::generate_enzyme_call(llmod, llcx, fn_def, fn_target, item.attrs.clone());
     }
 
-    // We needed the SanitizeHWAddress attribute to prevent LLVM from optimizing enums in a way
-    // which Enzyme doesn't understand.
-    unsafe {
-        let mut f = LLVMGetFirstFunction(llmod);
-        loop {
-            if let Some(lf) = f {
-                f = LLVMGetNextFunction(lf);
-                let myhwattr = "enzyme_hw";
-                let attr = LLVMGetStringAttributeAtIndex(
-                    lf,
-                    c_uint::MAX,
-                    myhwattr.as_ptr() as *const c_char,
-                    myhwattr.as_bytes().len() as c_uint,
-                );
-                if LLVMIsStringAttribute(attr) {
-                    LLVMRemoveStringAttributeAtIndex(
-                        lf,
-                        c_uint::MAX,
-                        myhwattr.as_ptr() as *const c_char,
-                        myhwattr.as_bytes().len() as c_uint,
-                    );
-                } else {
-                    LLVMRustRemoveEnumAttributeAtIndex(
-                        lf,
-                        c_uint::MAX,
-                        AttributeKind::SanitizeHWAddress,
-                    );
-                }
-            } else {
-                break;
-            }
-        }
-    }
+    // FIXME(ZuseZ4): In the following upstream PR, we want to add code to handle SanitizeHWAddress,
+    // to prevent some illegal/unsupported optimizations.
 
     if let Some(opt_level) = config.opt_level {
         let opt_stage = match cgcx.lto {
@@ -773,35 +736,8 @@ pub(crate) unsafe fn optimize(
         unsafe { llvm::LLVMWriteBitcodeToFile(llmod, out.as_ptr()) };
     }
 
-    // This code enables Enzyme to differentiate code containing Rust enums.
-    // By adding the SanitizeHWAddress attribute we prevent LLVM from Optimizing
-    // away the enums and allows Enzyme to understand why a value can be of different types in
-    // different code sections. We remove this attribute after Enzyme is done, to not affect the
-    // rest of the compilation.
-    //#[cfg(llvm_enzyme)]
-    unsafe {
-        let mut f = LLVMGetFirstFunction(llmod);
-        loop {
-            if let Some(lf) = f {
-                f = LLVMGetNextFunction(lf);
-                let myhwattr = "enzyme_hw";
-                let prevattr = LLVMRustGetEnumAttributeAtIndex(
-                    lf,
-                    c_uint::MAX,
-                    AttributeKind::SanitizeHWAddress,
-                );
-                if LLVMIsEnumAttribute(prevattr) {
-                    let attr = llvm::CreateAttrString(llcx, myhwattr);
-                    crate::attributes::apply_to_llfn(lf, Function, &[attr]);
-                } else {
-                    let attr = AttributeKind::SanitizeHWAddress.create_attr(llcx);
-                    crate::attributes::apply_to_llfn(lf, Function, &[attr]);
-                }
-            } else {
-                break;
-            }
-        }
-    }
+    // FIXME(ZuseZ4): In the following PR, we have to add code to apply the sanitize_hwaddress
+    // attribute to all functions in the module, to prevent some illegal/unsupported optimizations.
 
     if let Some(opt_level) = config.opt_level {
         let opt_stage = match cgcx.lto {

compiler/rustc_codegen_llvm/src/builder.rs

@@ -259,6 +259,7 @@ pub(crate) fn generate_enzyme_call<'ll>(
         }
         // Now that we copied the metadata, get rid of dummy code.
         llvm::LLVMRustEraseInstBefore(entry, last_inst);
+        llvm::LLVMRustEraseInstFromParent(last_inst);
 
         let void_ty = llvm::LLVMVoidTypeInContext(llcx);
         if llvm::LLVMTypeOf(call) != void_ty {

compiler/rustc_codegen_llvm/src/lib.rs

@@ -400,7 +400,6 @@ impl CodegenBackend for LlvmCodegenBackend {
     }
 }
 
-#[allow(dead_code)]
 pub struct ModuleLlvm {
     llcx: &'static mut llvm::Context,
     llmod_raw: *const llvm::Module,

compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs

@@ -2,8 +2,7 @@
 
 use libc::{c_char, c_uint, size_t};
 
-use super::ffi::*;
-
+use super::ffi::{Attribute, BasicBlock, Builder, Metadata, Module, Type, Value};
 extern "C" {
     // Enzyme
     pub fn LLVMRustHasMetadata(I: &Value, KindID: c_uint) -> bool;
@@ -12,13 +11,7 @@ extern "C" {
     pub fn LLVMRustDIGetInstMetadata(I: &Value) -> &Metadata;
     pub fn LLVMRustEraseInstFromParent(V: &Value);
     pub fn LLVMRustGetTerminator<'a>(B: &BasicBlock) -> &'a Value;
-    pub fn LLVMRustRemoveEnumAttributeAtIndex(V: &Value, index: c_uint, attr: AttributeKind);
-    pub fn LLVMRustGetEnumAttributeAtIndex(
-        V: &Value,
-        index: c_uint,
-        attr: AttributeKind,
-    ) -> &Attribute;
-    pub fn LLVMRustAddParamAttr<'a>(Instr: &'a Value, index: c_uint, Attr: &'a Attribute);
+    pub fn LLVMRustGetFunctionType(fnc: &Value) -> &Type;
 
     pub fn LLVMGetReturnType(T: &Type) -> &Type;
     pub fn LLVMDumpModule(M: &Module);
@@ -33,21 +26,9 @@ extern "C" {
         num_args: size_t,
         name: *const c_char,
     ) -> &'a Value;
-    pub fn LLVMGetFirstFunction(M: &Module) -> Option<&Value>;
-    pub fn LLVMGetNextFunction(V: &Value) -> Option<&Value>;
     pub fn LLVMGetNamedFunction(M: &Module, Name: *const c_char) -> Option<&Value>;
-    pub fn LLVMRustGetFunctionType(fnc: &Value) -> &Type;
-
-    pub fn LLVMRemoveStringAttributeAtIndex(F: &Value, Idx: c_uint, K: *const c_char, KLen: c_uint);
-    pub fn LLVMGetStringAttributeAtIndex(
-        F: &Value,
-        Idx: c_uint,
-        K: *const c_char,
-        KLen: c_uint,
-    ) -> &Attribute;
     pub fn LLVMIsEnumAttribute(A: &Attribute) -> bool;
     pub fn LLVMIsStringAttribute(A: &Attribute) -> bool;
-
 }
 
 #[repr(C)]

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1661,12 +1661,6 @@ unsafe extern "C" {
         Attrs: *const &'a Attribute,
         AttrsLen: size_t,
     );
-    pub fn LLVMRustRemoveFunctionAttributes<'a>(
-        Fn: &'a Value,
-        index: c_uint,
-        Attrs: *const &'a Attribute,
-        AttrsLen: size_t,
-    );
 
     // Operations on call sites
     pub fn LLVMRustAddCallSiteAttributes<'a>(

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -26,7 +26,6 @@ pub mod enzyme_ffi;
 mod ffi;
 
 pub use self::enzyme_ffi::*;
-pub use self::ffi::*;
 
 impl LLVMRustResult {
     pub fn into_result(self) -> Result<(), ()> {
@@ -42,11 +41,6 @@ pub fn AddFunctionAttributes<'ll>(llfn: &'ll Value, idx: AttributePlace, attrs:
         LLVMRustAddFunctionAttributes(llfn, idx.as_uint(), attrs.as_ptr(), attrs.len());
     }
 }
-//pub fn RemoveFunctionAttributes<'ll>(llfn: &'ll Value, idx: AttributePlace, attrs: &[&'ll Attribute]) {
-//    unsafe {
-//        LLVMRustRemoveFunctionAttributes(llfn, idx.as_uint(), attrs.as_ptr(), attrs.len());
-//    }
-//}
 
 pub fn AddCallSiteAttributes<'ll>(
     callsite: &'ll Value,

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -404,22 +404,11 @@ extern "C" LLVMTypeRef LLVMRustGetFunctionType(LLVMValueRef Fn) {
   return wrap(Ftype);
 }
 
-extern "C" void LLVMRustRemoveEnumAttributeAtIndex(LLVMValueRef F, size_t index,
-                                                   LLVMRustAttribute RustAttr) {
-  LLVMRemoveEnumAttributeAtIndex(F, index, fromRust(RustAttr));
-}
-
 extern "C" LLVMAttributeRef
 LLVMRustCreateAttrNoValue(LLVMContextRef C, LLVMRustAttributeKind RustAttr) {
   return wrap(Attribute::get(*unwrap(C), fromRust(RustAttr)));
 }
 
-extern "C" LLVMAttributeRef
-LLVMRustGetEnumAttributeAtIndex(LLVMValueRef F, size_t index,
-                                LLVMRustAttribute RustAttr) {
-  return LLVMGetEnumAttributeAtIndex(F, index, fromRust(RustAttr));
-}
-
 extern "C" LLVMAttributeRef LLVMRustCreateAlignmentAttr(LLVMContextRef C,
                                                         uint64_t Bytes) {
   return wrap(Attribute::getWithAlignment(*unwrap(C), llvm::Align(Bytes)));
@@ -994,7 +983,10 @@ extern "C" void LLVMRustEraseInstBefore(LLVMBasicBlockRef bb, LLVMValueRef I) {
   auto It = BB.begin();
   while (&*It != &Inst)
     ++It;
+  // Make sure we found the Instruction.
   assert(It != BB.end());
+  // We don't want to erase the instruction itself.
+  It--;
   // Delete in rev order to ensure no dangling references.
   while (It != BB.begin()) {
     auto Prev = std::prev(It);