add target datalayout and triple to IR

Author: mhasel

compiler/plc_driver/src/pipelines.rs

@@ -410,6 +410,7 @@ impl<T: SourceContainer> Pipeline for BuildPipeline<T> {
                         dependencies,
                         literals,
                         &got_layout,
+                        self.compile_parameters.as_ref().and_then(|it| it.target.as_ref()),
                     )?;
                     self.participants.iter().try_fold((), |_, participant| participant.generate(&module))
                 })
@@ -684,8 +685,16 @@ impl AnnotatedProject {
             .iter()
             .map(|AnnotatedUnit { unit, dependencies, literals }| {
                 let context = CodegenContext::create();
-                self.generate_module(&context, compile_options, unit, dependencies, literals, &got_layout)
-                    .map(|it| it.persist_to_string())
+                self.generate_module(
+                    &context,
+                    compile_options,
+                    unit,
+                    dependencies,
+                    literals,
+                    &got_layout,
+                    None,
+                )
+                .map(|it| it.persist_to_string())
             })
             .collect()
     }
@@ -707,7 +716,15 @@ impl AnnotatedProject {
             .iter()
             // TODO: this can be parallelized
             .map(|AnnotatedUnit { unit, dependencies, literals }| {
-                self.generate_module(context, compile_options, unit, dependencies, literals, &got_layout)
+                self.generate_module(
+                    context,
+                    compile_options,
+                    unit,
+                    dependencies,
+                    literals,
+                    &got_layout,
+                    None,
+                )
             })
             .reduce(|a, b| {
                 let a = a?;
@@ -720,6 +737,7 @@ impl AnnotatedProject {
         module.map(Some)
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn generate_module<'ctx>(
         &self,
         context: &'ctx CodegenContext,
@@ -728,7 +746,11 @@ impl AnnotatedProject {
         dependencies: &FxIndexSet<Dependency>,
         literals: &StringLiterals,
         got_layout: &Mutex<HashMap<String, u64>>,
+        target: Option<&Target>,
     ) -> Result<GeneratedModule<'ctx>, Diagnostic> {
+        // Determine target from compile_options or use default
+        let target = target.unwrap_or(&Target::System);
+
         let mut code_generator = plc::codegen::CodeGen::new(
             context,
             compile_options.root.as_deref(),
@@ -737,6 +759,7 @@ impl AnnotatedProject {
             compile_options.debug_level,
             //FIXME don't clone here
             compile_options.online_change.clone(),
+            target,
         );
         //Create a types codegen, this contains all the type declarations
         //Associate the index type with LLVM types
@@ -796,7 +819,15 @@ impl AnnotatedProject {
         self.units
             .iter()
             .map(|AnnotatedUnit { unit, dependencies, literals }| {
-                self.generate_module(context, compile_options, unit, dependencies, literals, &got_layout)
+                self.generate_module(
+                    context,
+                    compile_options,
+                    unit,
+                    dependencies,
+                    literals,
+                    &got_layout,
+                    None,
+                )
             })
             .collect()
     }

src/codegen.rs

@@ -99,10 +99,38 @@ impl<'ink> CodeGen<'ink> {
         optimization_level: OptimizationLevel,
         debug_level: DebugLevel,
         online_change: OnlineChange,
+        target: &Target,
     ) -> CodeGen<'ink> {
         let module_location = file_marker.get_name().unwrap_or_default();
         let module = context.create_module(module_location);
         module.set_source_file_name(module_location);
+
+        // Initialize all targets
+        let initialization_config = &InitializationConfig::default();
+        inkwell::targets::Target::initialize_all(initialization_config);
+        let triple = target.get_target_triple();
+
+        // Create target from triple
+        let target_obj =
+            inkwell::targets::Target::from_triple(&triple).expect("Failed to create target from triple");
+
+        // Create a target machine with default options
+        let target_machine = target_obj
+            .create_target_machine(
+                &triple,
+                "generic", // CPU features - generic for portability
+                "",        // CPU features - empty string for default
+                optimization_level.into(),
+                inkwell::targets::RelocMode::Default,
+                inkwell::targets::CodeModel::Default,
+            )
+            .expect("Failed to create target machine");
+
+        // Get the data layout from the target machine and set the module's data layout and triple
+        let target_data = target_machine.get_target_data();
+        module.set_data_layout(&target_data.get_data_layout());
+        module.set_triple(&triple);
+
         let debug_level = if file_marker.is_internal() { DebugLevel::None } else { debug_level };
         let debug = debug::DebugBuilderEnum::new(context, &module, root, optimization_level, debug_level);
         CodeGen { module, debug, module_location: module_location.to_string(), online_change }

src/codegen/debug.rs

@@ -303,60 +303,24 @@ impl<'ink> DebugBuilder<'ink> {
             .unwrap_or_else(|| self.compile_unit.get_file());
 
         let mut types = vec![];
-        let mut last_offset_bits = 0;
-        let mut last_size_bits = 0;
 
         for (element_index, (member_name, dt, location)) in index_types.iter().enumerate() {
             let di_type = self.get_or_create_debug_type(dt, index, types_index)?;
 
-            // Get the size and alignment
+            // Get the size and alignment from LLVM
             let llvm_type = types_index.find_associated_type(dt.get_name());
             let align_bits =
                 llvm_type.map(|ty| self.target_data.get_preferred_alignment(&ty) * 8).unwrap_or(0);
             let size_bits = llvm_type.map(|ty| self.target_data.get_bit_size(&ty)).unwrap_or(0);
 
             // Get LLVM's calculated offset
-            let llvm_offset_bits = self
+            let offset_bits = self
                 .target_data
                 .offset_of_element(&struct_type, element_index as u32)
                 .map(|offset| offset * 8)
                 .unwrap_or(0);
 
-            // Calculate the properly aligned offset based on the previous field
-            // and this field's alignment requirements
-            let offset_bits = if size_bits == 0 || (last_size_bits == 0 && element_index > 0) {
-                // For zero-sized types, always use LLVM's offset directly
-                // This ensures they don't contribute to the overall layout calculation
-                // If the previous field was zero-sized, use LLVM's offset
-                // for proper alignment of fields after zero-sized types
-                llvm_offset_bits
-            } else {
-                let next_offset_bits: u64 = last_offset_bits + last_size_bits;
-
-                // Special handling based on alignment requirements:
-                // - Fields with alignment of 64 bits need to be explicitly aligned
-                //   to their alignment boundary to prevent misaligned accesses
-                // - Fields with a lower alignment can use LLVM's natural layout
-                // This differentiation is crucial for correctly representing complex structures
-                // where some fields (like LWORD, LINT) need specific alignment while others (like BYTE, BOOL)
-                // can be packed more efficiently
-                if align_bits == 64 {
-                    // For fields requiring special alignment (64 bit types),
-                    // round up to the nearest alignment boundary
-                    next_offset_bits.div_ceil(align_bits as u64) * align_bits as u64
-                } else {
-                    // For smaller fields fields (BYTE, BOOL, DINT), we still ensure we don't
-                    // overlap with previous fields by using the maximum of our calculated offset
-                    // and LLVM's calculated offset
-                    std::cmp::max(next_offset_bits, llvm_offset_bits)
-                }
-            };
-
-            // Update tracking variables for next field
-            last_offset_bits = offset_bits;
-            last_size_bits = size_bits;
-
-            // Create the member type with calculated offset
+            // Create the member type with LLVM's calculated offset
             types.push(
                 self.debug_info
                     .create_member_type(
@@ -374,39 +338,17 @@ impl<'ink> DebugBuilder<'ink> {
             );
         }
 
-        // Calculate struct size based on the last field's offset + size, properly aligned
+        // Use LLVM's calculation for the struct size
         let llvm_size = self.target_data.get_bit_size(&struct_type);
-        // Calculate our manual size based on adjusted offsets
-        let calculated_size = {
-            // Get struct alignment requirement (usually 8 bytes/64 bits for 64-bit architectures)
-            let struct_align_bits = self.target_data.get_preferred_alignment(&struct_type) * 8;
-
-            // Calculate total size based on last field offset + size, rounded up to alignment
-            let last_field_end_bits = last_offset_bits + last_size_bits;
-            let aligned_size_bits =
-                last_field_end_bits.div_ceil(struct_align_bits as u64) * struct_align_bits as u64;
-
-            // If our calculated size is larger than LLVM's, use ours
-            if aligned_size_bits > llvm_size {
-                log::trace!(
-                    "Struct {}: adjusted size from {} to {} bits due to field alignment",
-                    name,
-                    llvm_size,
-                    aligned_size_bits
-                );
-                aligned_size_bits
-            } else {
-                llvm_size
-            }
-        };
+        let struct_align_bits = self.target_data.get_preferred_alignment(&struct_type) * 8;
 
         let struct_type = self.debug_info.create_struct_type(
             file.as_debug_info_scope(),
             name,
             file,
             location.get_line_plus_one() as u32,
-            calculated_size,
-            self.target_data.get_preferred_alignment(&struct_type) * 8,
+            llvm_size,
+            struct_align_bits,
             DIFlags::PUBLIC,
             None,
             types.as_slice(),

src/test_utils.rs

@@ -25,7 +25,7 @@ pub mod tests {
             StringLiterals, TypeAnnotator,
         },
         typesystem::get_builtin_types,
-        DebugLevel, OnlineChange, Validator,
+        DebugLevel, OnlineChange, Target, Validator,
     };
 
     pub fn parse(src: &str) -> (CompilationUnit, Vec<Diagnostic>) {
@@ -254,6 +254,7 @@ pub mod tests {
             crate::OptimizationLevel::None,
             debug_level,
             online_change.clone(),
+            &Target::System,
         );
         let llvm_index = code_generator
             .generate_llvm_index(&context, &annotations, &literals, &dependencies, &index, &got_layout)
@@ -321,6 +322,7 @@ pub mod tests {
                     crate::OptimizationLevel::None,
                     debug_level,
                     crate::OnlineChange::Disabled,
+                    &Target::System,
                 );
                 let got_layout = Mutex::new(HashMap::default());