di: Remove the BTF map anonymization fixup

It was never necessary in the first place. There is no place in the
kernel that enforces BTF map structs themselves to be anonymous. Only
pointer types (that are members of BTF maps) have to be anonymous, but
that's handled by a separate fixup.

BTF maps work just fine without it.

Author: vadorovsky

src/llvm/di.rs

@@ -11,10 +11,7 @@ use gimli::{DW_TAG_pointer_type, DW_TAG_structure_type, DW_TAG_variant_part};
 use llvm_sys::{core::*, debuginfo::*, prelude::*};
 use tracing::{Level, span, trace, warn};
 
-use super::types::{
-    di::DIType,
-    ir::{Function, MDNode, Metadata, Value},
-};
+use super::types::ir::{Function, MDNode, Metadata, Value};
 use crate::llvm::{LLVMContext, LLVMModule, iter::*, types::di::DISubprogram};
 
 // KSYM_NAME_LEN from linux kernel intentionally set
@@ -90,8 +87,6 @@ impl<'ctx> DISanitizer<'ctx> {
                         }
 
                         let mut is_data_carrying_enum = false;
-                        let mut remove_name = false;
-                        let mut members: Vec<DIType<'_>> = Vec::new();
                         for element in di_composite_type.elements() {
                             match element {
                                 Metadata::DICompositeType(di_composite_type_inner) => {
@@ -123,50 +118,13 @@ impl<'ctx> DISanitizer<'ctx> {
                                         _ => {}
                                     }
                                 }
-                                Metadata::DIDerivedType(di_derived_type) => {
-                                    let base_type = di_derived_type.base_type();
-
-                                    match base_type {
-                                        Metadata::DICompositeType(base_type_di_composite_type) => {
-                                            if let Some(base_type_name) =
-                                                base_type_di_composite_type.name()
-                                            {
-                                                // `AyaBtfMapMarker` is a type which is used in fields of BTF map
-                                                // structs. We need to make such structs anonymous in order to get
-                                                // BTF maps accepted by the Linux kernel.
-                                                if base_type_name == b"AyaBtfMapMarker" {
-                                                    // Remove the name from the struct.
-                                                    remove_name = true;
-                                                    // And don't include the field in the sanitized DI.
-                                                } else {
-                                                    members.push(di_derived_type.into());
-                                                }
-                                            } else {
-                                                members.push(di_derived_type.into());
-                                            }
-                                        }
-                                        _ => {
-                                            members.push(di_derived_type.into());
-                                        }
-                                    }
-                                }
                                 _ => {}
                             }
                         }
                         if is_data_carrying_enum {
                             di_composite_type.replace_elements(MDNode::empty(self.context));
-                        } else if !members.is_empty() {
-                            members.sort_by_cached_key(|di_type| di_type.offset_in_bits());
-                            let sorted_elements =
-                                MDNode::with_elements(self.context, members.as_mut_slice());
-                            di_composite_type.replace_elements(sorted_elements);
                         }
-                        if remove_name {
-                            // `AyaBtfMapMarker` is a type which is used in fields of BTF map
-                            // structs. We need to make such structs anonymous in order to get
-                            // BTF maps accepted by the Linux kernel.
-                            di_composite_type.replace_name(self.context, &[])
-                        } else if let Some((_, sanitized_name)) = names {
+                        if let Some((_, sanitized_name)) = names {
                             // Clear the name from characters incompatible with C.
                             di_composite_type.replace_name(self.context, sanitized_name.as_slice())
                         }

src/llvm/types/di.rs

@@ -5,8 +5,7 @@ use llvm_sys::{
     core::{LLVMGetNumOperands, LLVMGetOperand, LLVMReplaceMDNodeOperandWith, LLVMValueAsMetadata},
     debuginfo::{
         LLVMDIFileGetFilename, LLVMDIFlags, LLVMDIScopeGetFile, LLVMDISubprogramGetLine,
-        LLVMDITypeGetFlags, LLVMDITypeGetLine, LLVMDITypeGetName, LLVMDITypeGetOffsetInBits,
-        LLVMGetDINodeTag,
+        LLVMDITypeGetFlags, LLVMDITypeGetLine, LLVMDITypeGetName, LLVMGetDINodeTag,
     },
     prelude::{LLVMContextRef, LLVMMetadataRef, LLVMValueRef},
 };
@@ -108,60 +107,6 @@ unsafe fn di_type_name<'a>(metadata_ref: LLVMMetadataRef) -> Option<&'a [u8]> {
     (!ptr.is_null()).then(|| unsafe { slice::from_raw_parts(ptr.cast(), len) })
 }
 
-/// Represents the debug information for a primitive type in LLVM IR.
-pub(crate) struct DIType<'ctx> {
-    pub(super) metadata_ref: LLVMMetadataRef,
-    pub(super) value_ref: LLVMValueRef,
-    _marker: PhantomData<&'ctx ()>,
-}
-
-impl DIType<'_> {
-    /// Constructs a new [`DIType`] from the given `value`.
-    ///
-    /// # Safety
-    ///
-    /// This method assumes that the given `value` corresponds to a valid
-    /// instance of [LLVM `DIType`](https://llvm.org/doxygen/classllvm_1_1DIType.html).
-    /// It's the caller's responsibility to ensure this invariant, as this
-    /// method doesn't perform any validation checks.
-    pub(crate) unsafe fn from_value_ref(value_ref: LLVMValueRef) -> Self {
-        let metadata_ref = unsafe { LLVMValueAsMetadata(value_ref) };
-        Self {
-            metadata_ref,
-            value_ref,
-            _marker: PhantomData,
-        }
-    }
-
-    /// Returns the offset of the type in bits. This offset is used in case the
-    /// type is a member of a composite type.
-    pub(crate) fn offset_in_bits(&self) -> u64 {
-        unsafe { LLVMDITypeGetOffsetInBits(self.metadata_ref) }
-    }
-}
-
-impl<'ctx> From<DIDerivedType<'ctx>> for DIType<'ctx> {
-    fn from(di_derived_type: DIDerivedType<'_>) -> Self {
-        unsafe { Self::from_value_ref(di_derived_type.value_ref) }
-    }
-}
-
-/// Represents the operands for a [`DIDerivedType`]. The enum values correspond
-/// to the operand indices within metadata nodes.
-#[repr(u32)]
-enum DIDerivedTypeOperand {
-    /// [`DIType`] representing a base type of the given derived type.
-    /// Reference in [LLVM 19-20][llvm-19] and [LLVM 21][llvm-21].
-    ///
-    /// [llvm-19]: https://github.com/llvm/llvm-project/blob/llvmorg-19.1.7/llvm/include/llvm/IR/DebugInfoMetadata.h#L1084
-    /// [llvm-21]: https://github.com/llvm/llvm-project/blob/llvmorg-21.1.0-rc3/llvm/include/llvm/IR/DebugInfoMetadata.h#L1386
-    ///
-    #[cfg(any(feature = "llvm-19", feature = "llvm-20"))]
-    BaseType = 3,
-    #[cfg(feature = "llvm-21")]
-    BaseType = 5,
-}
-
 /// Represents the debug information for a derived type in LLVM IR.
 ///
 /// The types derived from other types usually add a level of indirection or an
@@ -191,14 +136,6 @@ impl DIDerivedType<'_> {
         }
     }
 
-    /// Returns the base type of this derived type.
-    pub(crate) fn base_type(&self) -> Metadata<'_> {
-        unsafe {
-            let value = LLVMGetOperand(self.value_ref, DIDerivedTypeOperand::BaseType as u32);
-            Metadata::from_value_ref(value)
-        }
-    }
-
     /// Replaces the name of the type with a new name.
     ///
     /// # Errors

src/llvm/types/ir.rs

@@ -19,7 +19,7 @@ use crate::llvm::{
     Message,
     iter::IterBasicBlocks as _,
     symbol_name,
-    types::di::{DICompositeType, DIDerivedType, DISubprogram, DIType},
+    types::di::{DICompositeType, DIDerivedType, DISubprogram},
 };
 
 pub(crate) fn replace_name(
@@ -229,26 +229,6 @@ impl MDNode<'_> {
         let metadata = unsafe { LLVMMDNodeInContext2(context, core::ptr::null_mut(), 0) };
         unsafe { Self::from_metadata_ref(context, metadata) }
     }
-
-    /// Constructs a new metadata node from an array of [`DIType`] elements.
-    ///
-    /// This function is used to create composite metadata structures, such as
-    /// arrays or tuples of different types or values, which can then be used
-    /// to represent complex data structures within the metadata system.
-    pub(crate) fn with_elements(context: LLVMContextRef, elements: &[DIType<'_>]) -> Self {
-        let metadata = unsafe {
-            let mut elements: Vec<LLVMMetadataRef> = elements
-                .iter()
-                .map(|di_type| LLVMValueAsMetadata(di_type.value_ref))
-                .collect();
-            LLVMMDNodeInContext2(
-                context,
-                elements.as_mut_slice().as_mut_ptr(),
-                elements.len(),
-            )
-        };
-        unsafe { Self::from_metadata_ref(context, metadata) }
-    }
 }
 
 pub(crate) struct MetadataEntries {