use llvm target info to get size

Author: ghaith

src/codegen/debug.rs

@@ -9,6 +9,7 @@ use inkwell::{
         DWARFEmissionKind, DebugInfoBuilder,
     },
     module::Module,
+    targets::TargetData,
     values::{BasicMetadataValueEnum, FunctionValue, GlobalValue, PointerValue},
 };
 use rustc_hash::FxHashMap;
@@ -18,13 +19,15 @@ use plc_diagnostics::diagnostics::Diagnostic;
 use plc_source::source_location::SourceLocation;
 
 use crate::{
-    datalayout::{Bytes, MemoryLocation},
     index::{Index, PouIndexEntry, VariableIndexEntry},
     typesystem::{DataType, DataTypeInformation, Dimension, StringEncoding, CHAR_TYPE, WCHAR_TYPE},
     DebugLevel, OptimizationLevel,
 };
 
-use super::generators::{llvm::Llvm, statement_generator::FunctionContext, ADDRESS_SPACE_GLOBAL};
+use super::{
+    generators::{llvm::Llvm, statement_generator::FunctionContext, ADDRESS_SPACE_GLOBAL},
+    llvm_index::LlvmTypedIndex,
+};
 
 #[derive(PartialEq, Eq)]
 #[allow(non_camel_case_types)]
@@ -83,6 +86,7 @@ pub trait Debug<'ink> {
         name: &str,
         datatype: &'idx DataType,
         index: &'idx Index,
+        types_index: &'idx LlvmTypedIndex,
     ) -> Result<(), Diagnostic>;
 
     /// Creates a globally accessible variable with the given datatype.
@@ -167,6 +171,7 @@ pub struct DebugBuilder<'ink> {
     variables: FxHashMap<VariableKey, DILocalVariable<'ink>>,
     optimization: OptimizationLevel,
     files: FxHashMap<&'static str, DIFile<'ink>>,
+    target_data: TargetData,
 }
 
 /// A wrapper that redirects to correct debug builder implementation based on the debug context.
@@ -230,6 +235,9 @@ impl<'ink> DebugBuilderEnum<'ink> {
                     "",
                 );
 
+                let data_layout = module.get_data_layout();
+                let data_layout = data_layout.as_str().to_str().expect("Data layout is valid");
+                let target_data = TargetData::create(data_layout);
                 let dbg_obj = DebugBuilder {
                     context,
                     debug_info,
@@ -238,6 +246,7 @@ impl<'ink> DebugBuilderEnum<'ink> {
                     variables: Default::default(),
                     optimization,
                     files: Default::default(),
+                    target_data,
                 };
                 match debug_level {
                     DebugLevel::VariablesOnly(_) => DebugBuilderEnum::VariablesOnly(dbg_obj),
@@ -273,8 +282,9 @@ impl<'ink> DebugBuilder<'ink> {
         &mut self,
         name: &str,
         members: &[VariableIndexEntry],
-        index: &Index,
         location: &SourceLocation,
+        index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         //Create each type
         let index_types = members
@@ -285,21 +295,23 @@ impl<'ink> DebugBuilder<'ink> {
                 index.get_type(type_name.as_ref()).map(|dt| (name, dt, location))
             })
             .collect::<Result<Vec<_>, Diagnostic>>()?;
+        let struct_type = types_index.get_associated_type(name).map(|it| it.into_struct_type())?;
 
         let file = location
             .get_file_name()
             .map(|it| self.get_or_create_debug_file(it))
             .unwrap_or_else(|| self.compile_unit.get_file());
 
         let mut types = vec![];
-        let mut running_offset = MemoryLocation::new(0);
-        for (member_name, dt, location) in index_types.into_iter() {
-            let di_type = self.get_or_create_debug_type(dt, index)?;
+        let mut offset = 0; //self.target_data.offset_of_element(&struct_type, element_index as u32).unwrap_or(0);
+        for (element_index, (member_name, dt, location)) in index_types.into_iter().enumerate() {
+            let di_type = self.get_or_create_debug_type(dt, index, types_index)?;
 
             //Adjust the offset based on the field alignment
-            let type_info = dt.get_type_information();
-            // let alignment = type_info.get_alignment(index);
-            let size = type_info.get_size(index).unwrap();
+            let size = types_index
+                .find_associated_type(dt.get_name())
+                .map(|llvm_type| self.target_data.get_bit_size(&llvm_type))
+                .unwrap_or(0);
 
             types.push(
                 self.debug_info
@@ -308,24 +320,25 @@ impl<'ink> DebugBuilder<'ink> {
                         member_name,
                         file,
                         location.get_line_plus_one() as u32,
-                        size.bits().into(),
+                        size,
                         0, // no alignment for now
-                        running_offset.bits().into(),
+                        offset,
                         DIFlags::PUBLIC,
                         di_type.into(),
                     )
                     .as_type(),
             );
-            running_offset += size;
+            offset += size;
         }
 
+        let size = self.target_data.get_bit_size(&struct_type);
         //Create a struct type
         let struct_type = self.debug_info.create_struct_type(
             file.as_debug_info_scope(),
             name,
             file,
             location.get_line_plus_one() as u32,
-            running_offset.bits().into(),
+            size,
             0, // no alignment for now
             DIFlags::PUBLIC,
             None,
@@ -344,9 +357,9 @@ impl<'ink> DebugBuilder<'ink> {
         name: &str,
         inner_type: &str,
         dimensions: &[Dimension],
-        size: Bytes,
-        alignment: Bytes,
+        size: u64,
         index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         //find the inner type debug info
         let inner_type = index.get_type(inner_type)?;
@@ -357,11 +370,11 @@ impl<'ink> DebugBuilder<'ink> {
             //Convert to normal range
             .collect::<Result<Vec<Range<i64>>, _>>()
             .map_err(|err| Diagnostic::codegen_error(err, SourceLocation::undefined()))?;
-        let inner_type = self.get_or_create_debug_type(inner_type, index)?;
+        let inner_type = self.get_or_create_debug_type(inner_type, index, types_index)?;
         let array_type = self.debug_info.create_array_type(
             inner_type.into(),
-            size.bits().into(),
-            alignment.bits(),
+            size,
+            0, //No set alignment
             subscript.as_slice(),
         );
         self.register_concrete_type(name, DebugType::Composite(array_type));
@@ -372,17 +385,17 @@ impl<'ink> DebugBuilder<'ink> {
         &mut self,
         name: &str,
         inner_type: &str,
-        size: Bytes,
-        alignment: Bytes,
+        size: u64,
         index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         let inner_type = index.get_type(inner_type)?;
-        let inner_type = self.get_or_create_debug_type(inner_type, index)?;
+        let inner_type = self.get_or_create_debug_type(inner_type, index, types_index)?;
         let pointer_type = self.debug_info.create_pointer_type(
             name,
             inner_type.into(),
-            size.bits().into(),
-            alignment.bits(),
+            size,
+            0, //No set alignment
             inkwell::AddressSpace::from(ADDRESS_SPACE_GLOBAL),
         );
         self.register_concrete_type(name, DebugType::Derived(pointer_type));
@@ -393,14 +406,15 @@ impl<'ink> DebugBuilder<'ink> {
         &mut self,
         dt: &DataType,
         index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<DebugType<'ink>, Diagnostic> {
         //Try to find a type in the types
-        let dt_name = dt.get_name().to_lowercase();
+        let dt_name = dt.get_name();
         //Attempt to re-register the type, this will do nothing if the type exists.
         //TODO: This will crash on recursive datatypes
-        self.register_debug_type(&dt_name, dt, index)?;
+        self.register_debug_type(dt_name, dt, index, types_index)?;
         self.types
-            .get(&dt_name)
+            .get(&dt_name.to_lowercase())
             .ok_or_else(|| {
                 Diagnostic::new(format!("Cannot find debug information for type {dt_name}"))
                     .with_error_code("E076")
@@ -413,21 +427,21 @@ impl<'ink> DebugBuilder<'ink> {
         name: &str,
         length: i64,
         encoding: StringEncoding,
-        size: Bytes,
-        alignment: Bytes,
+        size: u64,
         index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         // Register a utf8 or 16 basic type
         let inner_type = match encoding {
             StringEncoding::Utf8 => index.get_effective_type_or_void_by_name(CHAR_TYPE),
             StringEncoding::Utf16 => index.get_effective_type_or_void_by_name(WCHAR_TYPE),
         };
-        let inner_type = self.get_or_create_debug_type(inner_type, index)?;
+        let inner_type = self.get_or_create_debug_type(inner_type, index, types_index)?;
         //Register an array
         let array_type = self.debug_info.create_array_type(
             inner_type.into(),
-            size.bits().into(),
-            alignment.bits(),
+            size,
+            0, //No set alignment
             #[allow(clippy::single_range_in_vec_init)]
             &[(0..length)],
         );
@@ -439,11 +453,12 @@ impl<'ink> DebugBuilder<'ink> {
         &mut self,
         name: &str,
         referenced_type: &str,
-        index: &Index,
         location: &SourceLocation,
+        index: &Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         let inner_dt = index.get_effective_type_by_name(referenced_type)?;
-        let inner_type = self.get_or_create_debug_type(inner_dt, index)?;
+        let inner_type = self.get_or_create_debug_type(inner_dt, index, types_index)?;
         let file = location
             .get_file_name()
             .map(|it| self.get_or_create_debug_file(it))
@@ -627,21 +642,26 @@ impl<'ink> Debug<'ink> for DebugBuilder<'ink> {
         name: &str,
         datatype: &'idx DataType,
         index: &'idx Index,
+        types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         //check if the type is currently registered
         if !self.types.contains_key(&name.to_lowercase()) {
             let type_info = datatype.get_type_information();
-            let size = type_info.get_size(index).unwrap();
+            let size = types_index
+                .find_associated_type(name)
+                .map(|llvm_type| self.target_data.get_bit_size(&llvm_type))
+                .unwrap_or(0);
             let location = &datatype.location;
             match type_info {
                 DataTypeInformation::Struct { members, .. } => {
-                    self.create_struct_type(name, members.as_slice(), index, location)
+                    //TODO: we can only register this after expansion
+                    self.create_struct_type(name, members.as_slice(), location, index, types_index)
                 }
                 DataTypeInformation::Array { name, inner_type_name, dimensions, .. } => {
-                    self.create_array_type(name, inner_type_name, dimensions, size, Bytes::new(0), index)
+                    self.create_array_type(name, inner_type_name, dimensions, size, index, types_index)
                 }
                 DataTypeInformation::Pointer { name, inner_type_name, .. } => {
-                    self.create_pointer_type(name, inner_type_name, size, Bytes::new(0), index)
+                    self.create_pointer_type(name, inner_type_name, size, index, types_index)
                 }
                 DataTypeInformation::Integer { signed, size, .. } => {
                     let encoding = if type_info.is_bool() {
@@ -663,11 +683,11 @@ impl<'ink> Debug<'ink> for DebugBuilder<'ink> {
                     let length = string_size
                         .as_int_value(index)
                         .map_err(|err| Diagnostic::codegen_error(err, SourceLocation::undefined()))?;
-                    self.create_string_type(name, length, *encoding, size, Bytes::new(0), index)
+                    self.create_string_type(name, length, *encoding, size, index, types_index)
                 }
                 DataTypeInformation::Alias { name, referenced_type }
                 | DataTypeInformation::Enum { name, referenced_type, .. } => {
-                    self.create_typedef_type(name, referenced_type, index, location)
+                    self.create_typedef_type(name, referenced_type, location, index, types_index)
                 }
                 // Other types are just derived basic types
                 _ => Ok(()),
@@ -897,10 +917,13 @@ impl<'ink> Debug<'ink> for DebugBuilderEnum<'ink> {
         name: &str,
         datatype: &'idx DataType,
         index: &'idx Index,
+        types_index: &'idx LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         match self {
             Self::None => Ok(()),
-            Self::VariablesOnly(obj) | Self::Full(obj) => obj.register_debug_type(name, datatype, index),
+            Self::VariablesOnly(obj) | Self::Full(obj) => {
+                obj.register_debug_type(name, datatype, index, types_index)
+            }
         }
     }
 

src/codegen/generators/data_type_generator.rs

@@ -117,6 +117,9 @@ pub fn generate_data_types<'ink>(
         generator.expand_opaque_types(user_type)?;
     }
 
+    // Now generate debug information for all types
+    generator.generate_debug_types()?;
+
     let mut tries = 0;
     let mut errors = FxHashMap::default();
 
@@ -198,7 +201,6 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
     /// Generates only an opaque type for structs.
     /// Eagerly generates but does not associate nested array and referenced aliased types
     fn create_type(&mut self, name: &str, data_type: &DataType) -> Result<BasicTypeEnum<'ink>, Diagnostic> {
-        self.debug.register_debug_type(name, data_type, self.index)?;
         let information = data_type.get_type_information();
         match information {
             DataTypeInformation::Struct { source, .. } => match source {
@@ -462,6 +464,30 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
 
         Ok(result)
     }
+
+    fn generate_debug_types(&mut self) -> Result<(), Diagnostic> {
+        for data_type in self
+            .index
+            .get_types()
+            .entries()
+            .flat_map(|(_, data_type)| data_type.first())
+            .filter(|data_type| !data_type.is_generic(self.index))
+        {
+            self.debug.register_debug_type(data_type.get_name(), data_type, self.index, &self.types_index)?;
+        }
+        for data_type in self
+            .index
+            .get_pou_types()
+            .entries()
+            .flat_map(|(_, data_type)| data_type.first())
+            .filter(|data_type| !data_type.is_generic(self.index))
+            .filter(|data_type| data_type.is_backed_by_struct())
+        {
+            self.debug.register_debug_type(data_type.get_name(), data_type, self.index, &self.types_index)?;
+        }
+
+        Ok(())
+    }
 }
 
 pub fn get_default_for(basic_type: BasicTypeEnum) -> BasicValueEnum {

src/codegen/generators/expression_generator.rs

@@ -2402,6 +2402,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                     .as_int_value(self.index)
                     .map_err(|err| Diagnostic::codegen_error(err.as_str(), right_location))?;
                 let size = std::cmp::min(target_size - 1, value_size);
+                //FIXME: use the target_layout for this operation
                 let alignment = left_type.get_string_character_width(self.index).value();
                 //Multiply by the string alignment to copy enough for widestrings
                 //This is done at compile time to avoid generating an extra mul

src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__aggregate_return_value_variable_in_function.snap

@@ -39,7 +39,7 @@ attributes #1 = { argmemonly nofree nounwind willreturn }
 !7 = !{null, !8}
 !8 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__auto_pointer_to_STRING", baseType: !9, size: 64, dwarfAddressSpace: 1)
 !9 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, size: 648, elements: !11)
-!10 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
+!10 = !DIBasicType(name: "CHAR", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
 !11 = !{!12}
 !12 = !DISubrange(count: 81, lowerBound: 0)
 !13 = !{}

src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__string_size_correctly_set_in_dwarf_info.snap

@@ -14,7 +14,7 @@ source_filename = "<internal>"
 !1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !2, line: 3, type: !3, isLocal: false, isDefinition: true)
 !2 = !DIFile(filename: "<internal>", directory: "")
 !3 = !DICompositeType(tag: DW_TAG_array_type, baseType: !4, size: 520, elements: !5)
-!4 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
+!4 = !DIBasicType(name: "CHAR", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
 !5 = !{!6}
 !6 = !DISubrange(count: 65, lowerBound: 0)
 !7 = !{i32 2, !"Dwarf Version", i32 5}

src/codegen/tests/oop_tests/debug_tests.rs

@@ -82,7 +82,7 @@ fn members_from_base_class_are_available_in_subclasses() {
     !6 = !DIBasicType(name: "INT", size: 16, encoding: DW_ATE_signed, flags: DIFlagPublic)
     !7 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !2, file: !2, line: 5, baseType: !8, size: 648, offset: 16, flags: DIFlagPublic)
     !8 = !DICompositeType(tag: DW_TAG_array_type, baseType: !9, size: 648, elements: !10)
-    !9 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
+    !9 = !DIBasicType(name: "CHAR", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
     !10 = !{!11}
     !11 = !DISubrange(count: 81, lowerBound: 0)
     !12 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !2, file: !2, line: 6, baseType: !13, size: 7128, offset: 664, flags: DIFlagPublic)
@@ -389,7 +389,7 @@ fn write_to_parent_variable_in_instance() {
     !7 = !{!8}
     !8 = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: !2, file: !2, line: 4, baseType: !9, size: 648, flags: DIFlagPublic)
     !9 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, size: 648, elements: !11)
-    !10 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
+    !10 = !DIBasicType(name: "CHAR", size: 8, encoding: DW_ATE_UTF, flags: DIFlagPublic)
     !11 = !{!12}
     !12 = !DISubrange(count: 81, lowerBound: 0)
     !13 = !DIGlobalVariableExpression(var: !14, expr: !DIExpression())