Merge pull request rust-lang#222 from ghaith/master

Add support for global variable expressions in debug info

Author: TheDan64

src/debug_info.rs

@@ -78,6 +78,19 @@
 //!     /* current_scope */ lexical_block.as_debug_info_scope(),
 //!     /* inlined_at */ None);
 //! builder.set_current_debug_location(&context, loc);
+//! 
+//! // Create global variable
+//! let gv = module.add_global(context.i64_type(), Some(inkwell::AddressSpace::Global), "gv");
+//!    
+//!
+//! let const_v = di.create_constant_expression(10);
+//!
+//! let gv_debug = di.create_global_variable_expression(cu.get_file().as_debug_info_scope(), "gv", "", cu.get_file(), 1, ditype.as_type(), true, Some(const_v), None, 8);
+//!
+//! let meta_value: inkwell::values::BasicMetadataValueEnum = gv_debug.as_metadata_value(&context).into();
+//! let metadata = context.metadata_node(&[meta_value]);
+//! gv.set_metadata(metadata, 0);//dbg
+//! 
 //! ```
 //!
 //! ## Finalize debug info
@@ -91,7 +104,8 @@ use crate::basic_block::BasicBlock;
 use crate::context::Context;
 pub use crate::debug_info::flags::{DIFlags, DIFlagsConstants};
 use crate::module::Module;
-use crate::values::{AsValueRef, BasicValueEnum, InstructionValue, PointerValue};
+use crate::values::{AsValueRef, BasicValueEnum, InstructionValue, PointerValue, MetadataValue};
+
 #[llvm_versions(8.0..=latest)]
 use llvm_sys::debuginfo::LLVMDIBuilderCreateTypedef;
 pub use llvm_sys::debuginfo::LLVMDWARFTypeEncoding;
@@ -104,14 +118,17 @@ use llvm_sys::debuginfo::{
     LLVMDIBuilderCreateAutoVariable, LLVMDIBuilderCreateBasicType, LLVMDIBuilderCreateCompileUnit,
     LLVMDIBuilderCreateDebugLocation, LLVMDIBuilderCreateExpression, LLVMDIBuilderCreateFile,
     LLVMDIBuilderCreateFunction, LLVMDIBuilderCreateLexicalBlock, LLVMDIBuilderCreateMemberType,
-    LLVMDIBuilderCreateNameSpace, LLVMDIBuilderCreateParameterVariable,
+    LLVMDIBuilderCreateNameSpace, LLVMDIBuilderCreateParameterVariable, 
     LLVMDIBuilderCreateStructType, LLVMDIBuilderCreateSubroutineType, LLVMDIBuilderCreateUnionType,
     LLVMDIBuilderFinalize, LLVMDIBuilderInsertDbgValueBefore, LLVMDIBuilderInsertDeclareAtEnd,
     LLVMDIBuilderInsertDeclareBefore, LLVMDILocationGetColumn, LLVMDILocationGetLine,
     LLVMDILocationGetScope, LLVMDITypeGetAlignInBits, LLVMDITypeGetOffsetInBits,
     LLVMDITypeGetSizeInBits,
 };
+#[llvm_versions(8.0..=latest)]
+use llvm_sys::debuginfo::{LLVMDIBuilderCreateGlobalVariableExpression,LLVMDIBuilderCreateConstantValueExpression};
 use llvm_sys::prelude::{LLVMDIBuilderRef, LLVMMetadataRef};
+use llvm_sys::core::LLVMMetadataAsValue;
 use std::convert::TryInto;
 use std::marker::PhantomData;
 
@@ -582,6 +599,63 @@ impl<'ctx> DebugInfoBuilder<'ctx> {
         }
     }
 
+    #[llvm_versions(8.0..=latest)]
+    pub fn create_global_variable_expression(
+        &self,
+        scope: DIScope<'ctx>,
+        name: &str,
+        linkage: &str,
+        file: DIFile<'ctx>,
+        line_no: u32,
+        ty: DIType<'ctx>,
+        local_to_unit: bool,
+        expression: Option<DIExpression>,
+        declaration: Option<DIScope>,
+        align_in_bits: u32,
+    ) -> DIGlobalVariableExpression<'ctx> {
+        let expression_ptr = expression.map_or(std::ptr::null_mut(), |dt| dt.metadata_ref);
+        let decl_ptr = declaration.map_or(std::ptr::null_mut(), |dt| dt.metadata_ref);
+        let metadata_ref = unsafe {
+            LLVMDIBuilderCreateGlobalVariableExpression(
+                self.builder,
+                scope.metadata_ref,
+                name.as_ptr() as _,
+                name.len(),
+                linkage.as_ptr() as _,
+                linkage.len(),
+                file.metadata_ref,
+                line_no,
+                ty.metadata_ref,
+                local_to_unit as _,
+                expression_ptr,
+                decl_ptr,
+                align_in_bits,
+            )
+        };
+        DIGlobalVariableExpression {
+            metadata_ref,
+            _marker: PhantomData,
+        }
+    }
+
+    #[llvm_versions(8.0..=latest)]
+    pub fn create_constant_expression(
+        &self,
+        value : i64,
+    ) -> DIExpression<'ctx> {
+        let metadata_ref = unsafe {
+            LLVMDIBuilderCreateConstantValueExpression(
+                self.builder,
+                value,
+            )
+        };
+
+        DIExpression {
+            metadata_ref,
+            _marker: PhantomData,
+        }
+    }
+
     /// Create function parameter variable.
     pub fn create_parameter_variable(
         &self,
@@ -1028,6 +1102,21 @@ pub struct DILocalVariable<'ctx> {
     _marker: PhantomData<&'ctx Context>,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct DIGlobalVariableExpression<'ctx> {
+    pub(crate) metadata_ref: LLVMMetadataRef,
+    _marker: PhantomData<&'ctx Context>,
+}
+
+impl <'ctx> DIGlobalVariableExpression<'ctx>  {
+    pub fn as_metadata_value(&self, context: &Context) -> MetadataValue<'ctx> {
+        let value = unsafe {
+            LLVMMetadataAsValue(context.context, self.metadata_ref)
+        };
+        MetadataValue::new(value)
+    }
+}
+
 /// https://llvm.org/docs/LangRef.html#diexpression
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct DIExpression<'ctx> {

src/values/global_value.rs

@@ -9,6 +9,8 @@ use llvm_sys::core::{LLVMHasUnnamedAddr, LLVMSetUnnamedAddr};
 use llvm_sys::core::{LLVMGetUnnamedAddress, LLVMSetUnnamedAddress};
 #[llvm_versions(7.0..=latest)]
 use llvm_sys::LLVMUnnamedAddr;
+#[llvm_versions(8.0..=latest)]
+use llvm_sys::core::LLVMGlobalSetMetadata;
 use llvm_sys::prelude::LLVMValueRef;
 
 use std::ffi::CStr;
@@ -20,6 +22,8 @@ use crate::support::{to_c_str, LLVMString};
 use crate::comdat::Comdat;
 use crate::values::traits::AsValueRef;
 use crate::values::{BasicValueEnum, BasicValue, PointerValue, Value};
+#[llvm_versions(8.0..=latest)]
+use crate::values::MetadataValue;
 
 // REVIEW: GlobalValues are always PointerValues. With SubTypes, we should
 // compress this into a PointerValue<Global> type
@@ -265,6 +269,14 @@ impl<'ctx> GlobalValue<'ctx> {
         }
     }
 
+    /// Sets a metadata of the given type on the GlobalValue
+    #[llvm_versions(8.0..=latest)]
+    pub fn set_metadata(self, metadata: MetadataValue<'ctx>, kind_id: u32) {
+        unsafe {
+            LLVMGlobalSetMetadata(self.as_value_ref(), kind_id, metadata.as_metadata_ref())
+        }
+    }
+
     /// Gets a `Comdat` assigned to this `GlobalValue`, if any.
     #[llvm_versions(7.0..=latest)]
     pub fn get_comdat(self) -> Option<Comdat> {

tests/all/test_debug_info.rs

@@ -1,8 +1,9 @@
 use inkwell::context::Context;
 use inkwell::debug_info::{
     AsDIScope, DIFlags, DIFlagsConstants, DISubprogram, DWARFEmissionKind, DWARFSourceLanguage,
-    DebugInfoBuilder,
 };
+#[llvm_versions(8.0..=latest)]
+use inkwell::debug_info::DebugInfoBuilder;
 use inkwell::module::FlagBehavior;
 
 #[test]
@@ -301,3 +302,52 @@ fn test_anonymous_basic_type() {
         Err("basic types must have names")
     );
 }
+
+#[llvm_versions(8.0..=latest)]
+#[test]
+fn test_global_expressions() {
+    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,
+    );
+
+    let di_type = dibuilder.create_basic_type("type_name", 0_u64, 0x00, DIFlags::ZERO);
+    let gv = module.add_global(context.i64_type(), Some(inkwell::AddressSpace::Global), "gv");
+
+    let const_v = dibuilder.create_constant_expression(10);
+
+    let gv_debug = dibuilder.create_global_variable_expression(
+        compile_unit.as_debug_info_scope(), 
+        "gv", 
+        "", 
+        compile_unit.get_file(), 
+        1, 
+        di_type.unwrap().as_type(),
+        true,
+        Some(const_v),
+        None,
+        8,
+    );
+    
+    let metadata = context.metadata_node(&[gv_debug.as_metadata_value(&context).into()]);
+
+    gv.set_metadata(metadata, 0);
+
+    // TODO: Metadata set on the global values cannot be retrieved using the C api, 
+    // therefore, it's currently not possible to test that the data was set without generating the IR
+    assert!(gv.print_to_string().to_string().contains("!dbg"), format!("expected !dbg but generated gv was {}",gv.print_to_string()));
+}