Use LLVMDIBuilderCreateUnionType

Author: Zalathar

compiler/rustc_codegen_llvm/src/debuginfo/di_builder.rs

@@ -1,6 +1,7 @@
 //! Safe wrappers for [`DIBuilder`] FFI functions.
 
 use libc::c_uint;
+use rustc_abi::{Align, Size};
 
 use crate::llvm::debuginfo::{DIBuilder, DIFlags};
 use crate::llvm::{self, Metadata};
@@ -21,4 +22,36 @@ impl<'ll> DIBuilder<'ll> {
             )
         }
     }
+
+    pub(crate) fn create_union_type(
+        &self,
+        scope: Option<&'ll Metadata>,
+        name: &str,
+        file_metadata: &'ll Metadata,
+        line_number: c_uint,
+        size: Size,
+        align: Align,
+        flags: DIFlags,
+        elements: &[&'ll Metadata],
+        unique_id: &str,
+    ) -> &'ll Metadata {
+        unsafe {
+            llvm::LLVMDIBuilderCreateUnionType(
+                self,
+                scope,
+                name.as_ptr(),
+                name.len(),
+                file_metadata,
+                line_number,
+                size.bits(),
+                align.bits() as u32,
+                flags,
+                elements.as_ptr(),
+                elements.len() as c_uint,
+                0, // ("Objective-C runtime version"; default is 0)
+                unique_id.as_ptr(),
+                unique_id.len(),
+            )
+        }
+    }
 }

compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs

@@ -226,23 +226,17 @@ pub(super) fn stub<'ll, 'tcx>(
                 )
             }
         }
-        Stub::Union => unsafe {
-            llvm::LLVMRustDIBuilderCreateUnionType(
-                DIB(cx),
-                containing_scope,
-                name.as_c_char_ptr(),
-                name.len(),
-                file_metadata,
-                line_number,
-                size.bits(),
-                align.bits() as u32,
-                flags,
-                Some(empty_array),
-                0,
-                unique_type_id_str.as_c_char_ptr(),
-                unique_type_id_str.len(),
-            )
-        },
+        Stub::Union => DIB(cx).create_union_type(
+            containing_scope,
+            name,
+            file_metadata,
+            line_number,
+            size,
+            align,
+            flags,
+            &[],
+            &unique_type_id_str,
+        ),
     };
     StubInfo { metadata, unique_type_id }
 }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1775,6 +1775,23 @@ unsafe extern "C" {
         NumParameterTypes: c_uint,
         Flags: DIFlags, // (optional; default is `DIFlags::FlagZero`)
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateUnionType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: Option<&'ll Metadata>,
+        Name: *const c_uchar,
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNumber: c_uint,
+        SizeInBits: u64,
+        AlignInBits: u32,
+        Flags: DIFlags,
+        Elements: *const &'ll Metadata,
+        NumElements: c_uint,
+        RunTimeLang: c_uint, // ("Objective-C runtime version"; default is 0)
+        UniqueId: *const c_uchar,
+        UniqueIdLen: size_t,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2285,22 +2302,6 @@ unsafe extern "C" {
         IsScoped: bool,
     ) -> &'a DIType;
 
-    pub fn LLVMRustDIBuilderCreateUnionType<'a>(
-        Builder: &DIBuilder<'a>,
-        Scope: Option<&'a DIScope>,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNumber: c_uint,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        Flags: DIFlags,
-        Elements: Option<&'a DIArray>,
-        RunTimeLang: c_uint,
-        UniqueId: *const c_char,
-        UniqueIdLen: size_t,
-    ) -> &'a DIType;
-
     pub fn LLVMRustDIBuilderCreateVariantPart<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIScope,

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -1278,19 +1278,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
       /* RunTimeLang */ 0, "", IsScoped));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
-    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
-    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
-    LLVMMetadataRef Elements, unsigned RunTimeLang, const char *UniqueId,
-    size_t UniqueIdLen) {
-  return wrap(unwrap(Builder)->createUnionType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
-      fromRust(Flags), DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
-      StringRef(UniqueId, UniqueIdLen)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef Ty) {