add support for enumeration type and enumerators (#623)

* add support for enumeration debug types

* add doc

* guard enumeration debug info for LLVM 9+

LLVMDIBuilderCreateEnumerator was added in LLVM 9.0 =>
  guard create_enumerator, create_enumeration_type, and test.

* add llvm21-1 to the tests

---------

Co-authored-by: Dan Kolsoi <ThaDan64@gmail.com>

Author: abroooo

src/debug_info.rs

@@ -127,6 +127,9 @@ use llvm_sys::debuginfo::{
     LLVMDITypeGetAlignInBits, LLVMDITypeGetOffsetInBits, LLVMDITypeGetSizeInBits,
 };
 
+#[llvm_versions(9..)]
+use llvm_sys::debuginfo::{LLVMDIBuilderCreateEnumerationType, LLVMDIBuilderCreateEnumerator};
+
 #[llvm_versions(..19.1)]
 use llvm_sys::debuginfo::{
     LLVMDIBuilderInsertDbgValueBefore, LLVMDIBuilderInsertDeclareAtEnd, LLVMDIBuilderInsertDeclareBefore,
@@ -815,6 +818,55 @@ impl<'ctx> DebugInfoBuilder<'ctx> {
         }
     }
 
+    /// Create an enumeration type
+    #[llvm_versions(9..)]
+    pub fn create_enumeration_type(
+        &self,
+        scope: DIScope<'ctx>,
+        name: &str,
+        file: DIFile<'ctx>,
+        line_no: u32,
+        size_in_bits: u64,
+        align_in_bits: u32,
+        elements: &[DIEnumerator<'ctx>],
+        inner_type: DIType<'ctx>,
+    ) -> DICompositeType<'ctx> {
+        let mut elements: Vec<LLVMMetadataRef> = elements.iter().map(|dt| dt.metadata_ref).collect();
+        let metadata_ref = unsafe {
+            LLVMDIBuilderCreateEnumerationType(
+                self.builder,
+                scope.metadata_ref,
+                name.as_ptr() as _,
+                name.len(),
+                file.metadata_ref,
+                line_no,
+                size_in_bits,
+                align_in_bits,
+                elements.as_mut_ptr(),
+                elements.len().try_into().unwrap(),
+                inner_type.metadata_ref,
+            )
+        };
+
+        DICompositeType {
+            metadata_ref,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Create an enumerator
+    #[llvm_versions(9..)]
+    pub fn create_enumerator(&self, name: &str, value: i64, is_unsigned: bool) -> DIEnumerator<'ctx> {
+        let metadata_ref = unsafe {
+            LLVMDIBuilderCreateEnumerator(self.builder, name.as_ptr() as _, name.len(), value, is_unsigned as i32)
+        };
+
+        DIEnumerator {
+            metadata_ref,
+            _marker: PhantomData,
+        }
+    }
+
     pub fn create_global_variable_expression(
         &self,
         scope: DIScope<'ctx>,
@@ -1436,6 +1488,26 @@ impl DIExpression<'_> {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct DIEnumerator<'ctx> {
+    pub(crate) metadata_ref: LLVMMetadataRef,
+    _marker: PhantomData<&'ctx Context>,
+}
+
+impl<'ctx> DIEnumerator<'ctx> {
+    /// Acquires the underlying raw pointer belonging to this `DIEnumerator` type.
+    pub fn as_mut_ptr(&self) -> LLVMMetadataRef {
+        self.metadata_ref
+    }
+
+    pub fn as_type(&self) -> DIType<'ctx> {
+        DIType {
+            metadata_ref: self.metadata_ref,
+            _marker: PhantomData,
+        }
+    }
+}
+
 pub use flags::*;
 mod flags {
     pub use llvm_sys::debuginfo::LLVMDIFlags as DIFlags;

tests/all/test_debug_info.rs

@@ -636,3 +636,87 @@ fn test_array_type() {
 
     dibuilder.create_array_type(di_type, 160, 64, &[(0..20), (-1..30), (20..55)]);
 }
+
+#[llvm_versions(9..)]
+#[test]
+fn test_enumeration_types() {
+    let context = Context::create();
+    let module = context.create_module("bin");
+
+    let (dibuilder, compile_unit) = module.create_debug_info_builder(
+        true,
+        DWARFSourceLanguage::C,
+        "source_file",
+        ".",
+        "my llvm compiler frontend",
+        false,
+        "",
+        0,
+        "",
+        DWARFEmissionKind::Full,
+        0,
+        false,
+        false,
+        #[cfg(any(
+            feature = "llvm11-0",
+            feature = "llvm12-0",
+            feature = "llvm13-0",
+            feature = "llvm14-0",
+            feature = "llvm15-0",
+            feature = "llvm16-0",
+            feature = "llvm17-0",
+            feature = "llvm18-1",
+            feature = "llvm19-1",
+            feature = "llvm20-1",
+            feature = "llvm21-1"
+        ))]
+        "",
+        #[cfg(any(
+            feature = "llvm11-0",
+            feature = "llvm12-0",
+            feature = "llvm13-0",
+            feature = "llvm14-0",
+            feature = "llvm15-0",
+            feature = "llvm16-0",
+            feature = "llvm17-0",
+            feature = "llvm18-1",
+            feature = "llvm19-1",
+            feature = "llvm20-1",
+            feature = "llvm21-1"
+        ))]
+        "",
+    );
+
+    let di_type = dibuilder
+        .create_basic_type("type_name", 8_u64, 0x00, DIFlags::ZERO)
+        .unwrap()
+        .as_type();
+
+    // Smoke test that the enums get created
+    let enum_red = dibuilder.create_enumerator("RED", 0, false);
+    let enum_green = dibuilder.create_enumerator("GREEN", 1, false);
+    let enum_blue = dibuilder.create_enumerator("BLUE", 2, false);
+
+    // Smoke test that the enumeration type gets created
+    dibuilder.create_enumeration_type(
+        compile_unit.as_debug_info_scope(),
+        "Color",
+        compile_unit.get_file(),
+        1,
+        32,
+        32,
+        &[enum_red, enum_green, enum_blue],
+        di_type,
+    );
+
+    // Smoke test that we can get the pointer and type back from the enumerator
+    assert!(!enum_red.as_mut_ptr().is_null());
+
+    let _enum_red_as_type = enum_red.as_type();
+
+    // check that finalize works without errors
+    dibuilder.finalize();
+
+    // check that module is still valid
+    assert!(module.verify().is_ok());
+}