Makefile

@@ -10,7 +10,7 @@ clean:
 	rm -f $(BIN) $(SRC:.reid=.o) $(SRC:.reid=.asm) $(SRC:.reid=.ll)
 
 $(BIN): $(SRC:.reid=.o)
-	$(LD) -O0 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /usr/lib/crt1.o -lc $(LDFLAGS) $< -o$@
+	$(LD) -dynamic-linker /lib64/ld-linux-x86-64.so.2 /usr/lib/crt1.o -lc $(LDFLAGS) $< -o$@
 
 .SUFFIXES: .o .reid
 .reid.o:

reid-llvm-lib/src/builder.rs

@@ -8,7 +8,6 @@ use crate::{
     TerminatorKind, Type, TypeData,
     debug_information::{
         DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue,
-        InstructionDebugRecordData,
     },
     util::match_types,
 };
@@ -61,7 +60,6 @@ pub struct BlockHolder {
 pub struct InstructionHolder {
     pub(crate) value: InstructionValue,
     pub(crate) data: InstructionData,
-    pub(crate) record: Option<InstructionDebugRecordData>,
 }
 
 #[derive(Clone)]
@@ -156,11 +154,7 @@ impl Builder {
             let function = module.functions.get_unchecked_mut(block_val.0.1);
             let block = function.blocks.get_unchecked_mut(block_val.1);
             let value = InstructionValue(block.value, block.instructions.len());
-            block.instructions.push(InstructionHolder {
+            block.instructions.push(InstructionHolder { value, data });
-                value,
-                data,
-                record: None,
-            });
 
             // Drop modules so that it is no longer mutable borrowed
             // (check_instruction requires an immutable borrow).
@@ -201,21 +195,6 @@ impl Builder {
         }
     }
 
-    pub(crate) unsafe fn add_instruction_record(
-        &self,
-        value: &InstructionValue,
-        record: InstructionDebugRecordData,
-    ) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(value.0.0.0.0);
-            let function = module.functions.get_unchecked_mut(value.0.0.1);
-            let block = function.blocks.get_unchecked_mut(value.0.1);
-            let instr = block.instructions.get_unchecked_mut(value.1);
-            instr.record = Some(record)
-        }
-    }
-
     pub(crate) unsafe fn set_debug_subprogram(
         &self,
         value: &FunctionValue,

reid-llvm-lib/src/compile.rs

@@ -417,6 +417,7 @@ impl DebugScopeHolder {
 
 impl DebugMetadataHolder {
     unsafe fn compile(&self, debug: &LLVMDebugInformation) -> LLVMMetadataRef {
+        dbg!(&self.program);
         unsafe {
             match &self.data {
                 DebugMetadata::ParamVar(param) => LLVMDIBuilderCreateParameterVariable(
@@ -431,19 +432,7 @@ impl DebugMetadataHolder {
                     param.always_preserve as i32,
                     param.flags.as_llvm(),
                 ),
-                DebugMetadata::LocalVar(var) => LLVMDIBuilderCreateAutoVariable(
+                DebugMetadata::LocalVar(debug_local_variable) => todo!(),
-                    debug.builder,
-                    *debug.programs.get(&self.program).unwrap(),
-                    into_cstring(var.name.clone()).as_ptr(),
-                    var.name.len(),
-                    debug.file_ref,
-                    var.location.line,
-                    *debug.types.get(&var.ty).unwrap(),
-                    var.always_preserve as i32,
-                    var.flags.as_llvm(),
-                    var.alignment,
-                ),
-                DebugMetadata::VarAssignment => todo!(),
             }
         }
     }
@@ -767,14 +756,11 @@ impl InstructionHolder {
                     module.values.get(&ptr).unwrap().value_ref,
                     c"load".as_ptr(),
                 ),
-                Store(ptr, val) => {
+                Store(ptr, val) => LLVMBuildStore(
-                    let store = LLVMBuildStore(
+                    module.builder_ref,
-                        module.builder_ref,
+                    module.values.get(&val).unwrap().value_ref,
-                        module.values.get(&val).unwrap().value_ref,
+                    module.values.get(&ptr).unwrap().value_ref,
-                        module.values.get(&ptr).unwrap().value_ref,
+                ),
-                    );
-                    store
-                }
                 ArrayAlloca(ty, len) => {
                     let array_len = ConstValue::U16(*len as u16).as_llvm(module);
                     LLVMBuildArrayAlloca(
@@ -822,51 +808,8 @@ impl InstructionHolder {
                 }
             }
         };
-        if let Some(record) = &self.record {
-            let debug = module.debug.as_ref().unwrap();
-
-            unsafe {
-                let mut addr = Vec::<u64>::new();
-                let expr =
-                    LLVMDIBuilderCreateExpression(debug.builder, addr.as_mut_ptr(), addr.len());
-
-                let location = LLVMDIBuilderCreateDebugLocation(
-                    module.context_ref,
-                    record.location.line,
-                    record.location.column,
-                    *debug.programs.get(&record.scope).unwrap(),
-                    null_mut(),
-                );
-
-                match record.kind {
-                    DebugRecordKind::Declare(instruction_value) => {
-                        dbg!(&self.value, &instruction_value);
-
-                        LLVMDIBuilderInsertDeclareRecordBefore(
-                            debug.builder,
-                            module.values.get(&instruction_value).unwrap().value_ref,
-                            *debug.metadata.get(&record.variable).unwrap(),
-                            expr,
-                            location,
-                            val,
-                        )
-                    }
-                    DebugRecordKind::Value(instruction_value) => {
-                        LLVMDIBuilderInsertDbgValueRecordBefore(
-                            debug.builder,
-                            module.values.get(&instruction_value).unwrap().value_ref,
-                            *debug.metadata.get(&record.variable).unwrap(),
-                            expr,
-                            location,
-                            val,
-                        )
-                    }
-                };
-            }
-        }
         if let Some(location) = &self.data.location {
             unsafe {
-                // dbg!(&self.data.kind, LLVMGetValueKind(val));
                 match LLVMGetValueKind(val) {
                     LLVMValueKind::LLVMInstructionValueKind
                     | LLVMValueKind::LLVMMemoryDefValueKind
@@ -892,26 +835,6 @@ impl InstructionHolder {
             value_ref: val,
         }
     }
-
-    fn get_inner_value(&self) -> Option<InstructionValue> {
-        match &self.data.kind {
-            crate::Instr::Param(_) => None,
-            crate::Instr::Constant(_) => None,
-            crate::Instr::Add(_, _) => None,
-            crate::Instr::Sub(_, _) => None,
-            crate::Instr::Mult(_, _) => None,
-            crate::Instr::And(_, _) => None,
-            crate::Instr::Phi(_) => None,
-            crate::Instr::Alloca(_, _) => todo!(),
-            crate::Instr::Load(_, _) => None,
-            crate::Instr::Store(_, val) => Some(*val),
-            crate::Instr::ArrayAlloca(_, _) => None,
-            crate::Instr::GetElemPtr(_, _) => None,
-            crate::Instr::GetStructElemPtr(_, _) => None,
-            crate::Instr::ICmp(_, _, _) => None,
-            crate::Instr::FunctionCall(_, _) => None,
-        }
-    }
 }
 
 impl TerminatorKind {

reid-llvm-lib/src/debug.rs

@@ -6,13 +6,8 @@ use std::{
 };
 
 use crate::{
-    CmpPredicate, Instr, InstructionData, TerminatorKind,
+    CmpPredicate, Instr, InstructionData, TerminatorKind, builder::*,
-    builder::*,
+    debug_information::DebugLocationValue,
-    debug_information::{
-        DebugBasicType, DebugLocation, DebugLocationValue, DebugMetadataHolder, DebugMetadataValue,
-        DebugProgramValue, DebugScopeValue, DebugSubprogramType, DebugTypeData, DebugTypeHolder,
-        DebugTypeValue,
-    },
 };
 
 impl Debug for Builder {
@@ -85,6 +80,15 @@ impl Debug for InstructionData {
     }
 }
 
+impl Debug for DebugLocationValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("DebugLocationValue")
+            .field(&self.0)
+            .field(&self.1)
+            .finish()
+    }
+}
+
 impl Debug for ModuleValue {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "M[{:0>2}]", self.0)
@@ -225,84 +229,3 @@ impl Debug for TerminatorKind {
         }
     }
 }
-
-impl Debug for DebugTypeHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple(&format!("DebugTypeHolder {:?}", self.value))
-            .field(&self.data)
-            .finish()
-    }
-}
-
-impl Debug for DebugTypeData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Basic(basic) => Debug::fmt(basic, f),
-            Self::Subprogram(subprogram) => Debug::fmt(subprogram, f),
-        }
-    }
-}
-
-impl Debug for DebugBasicType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("BasicType")
-            .field(&self.name)
-            .field(&self.size_bits)
-            .field(&self.encoding)
-            .field(&self.flags)
-            .finish()
-    }
-}
-
-impl Debug for DebugSubprogramType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Subprogram")
-            .field(&self.params)
-            .field(&self.flags)
-            .finish()
-    }
-}
-
-impl Debug for DebugMetadataValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Meta[{}]", self.0)
-    }
-}
-
-impl Debug for DebugScopeValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Scope[{}]",
-            self.0
-                .iter()
-                .map(|v| v.to_string())
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
-    }
-}
-
-impl Debug for DebugTypeValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Type[{}]", self.0)
-    }
-}
-
-impl Debug for DebugProgramValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Subprogram[{}]", self.0)
-    }
-}
-
-impl Debug for DebugLocationValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Value[{:?}][{}]", self.0, self.1)
-    }
-}
-
-impl Debug for DebugLocation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "ln {}, col {}", self.line, self.column)
-    }
-}

reid-llvm-lib/src/debug_information.rs

@@ -1,21 +1,19 @@
 use std::{cell::RefCell, rc::Rc};
 
-use crate::builder::InstructionValue;
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-
-#[derive(Clone, Hash, PartialEq, Eq)]
 pub struct DebugScopeValue(pub Vec<usize>);
 
 #[derive(Clone, Copy, Hash, PartialEq, Eq)]
 pub struct DebugLocationValue(pub DebugProgramValue, pub usize);
 
-#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub struct DebugTypeValue(pub usize);
 
-#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub struct DebugMetadataValue(pub usize);
 
 /// Represents either a subprogram, or the compilation context
-#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub struct DebugProgramValue(pub usize);
 
 #[derive(Debug, Clone)]
@@ -39,7 +37,7 @@ pub struct DebugMetadataHolder {
     pub(crate) data: DebugMetadata,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct DebugTypeHolder {
     pub(crate) value: DebugTypeValue,
     pub(crate) data: DebugTypeData,
@@ -155,7 +153,6 @@ impl DebugInformation {
         match &metadata {
             DebugMetadata::ParamVar(debug_param_variable) => todo!(),
             DebugMetadata::LocalVar(debug_local_variable) => todo!(),
-            DebugMetadata::VarAssignment => todo!(),
         }
     }
 
@@ -200,7 +197,7 @@ impl DebugInformation {
     }
 }
 
-#[derive(Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct DebugLocation {
     pub line: u32,
     pub column: u32,
@@ -210,7 +207,6 @@ pub struct DebugLocation {
 pub enum DebugMetadata {
     ParamVar(DebugParamVariable),
     LocalVar(DebugLocalVariable),
-    VarAssignment,
 }
 
 #[derive(Debug, Clone)]
@@ -233,10 +229,9 @@ pub struct DebugParamVariable {
 pub struct DebugLocalVariable {
     pub name: String,
     pub location: DebugLocation,
-    pub ty: DebugTypeValue,
+    pub ty: DebugMetadataValue,
     pub always_preserve: bool,
     pub alignment: u32,
-    pub flags: DwarfFlags,
 }
 
 impl Default for DebugSubprogramOptionals {
@@ -254,13 +249,13 @@ impl Default for DebugSubprogramOptionals {
 #[derive(Debug, Clone)]
 pub struct DwarfFlags;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum DebugTypeData {
     Basic(DebugBasicType),
     Subprogram(DebugSubprogramTypeData),
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct DebugBasicType {
     pub name: String,
     /// Size of the type.
@@ -316,17 +311,3 @@ pub struct DebugSubprogramOptionals {
     /// prototyped or not.
     pub flags: DwarfFlags,
 }
-
-#[derive(Clone)]
-pub struct InstructionDebugRecordData {
-    pub scope: DebugProgramValue,
-    pub variable: DebugMetadataValue,
-    pub location: DebugLocation,
-    pub kind: DebugRecordKind,
-}
-
-#[derive(Clone, Copy)]
-pub enum DebugRecordKind {
-    Declare(InstructionValue),
-    Value(InstructionValue),
-}

reid-llvm-lib/src/lib.rs

@@ -8,7 +8,6 @@ use builder::{BlockValue, Builder, FunctionValue, InstructionValue, ModuleValue,
 use debug::PrintableModule;
 use debug_information::{
     DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue,
-    InstructionDebugRecordData,
 };
 use util::match_types;
 
@@ -276,12 +275,6 @@ impl InstructionValue {
         }
         self
     }
-
-    pub fn add_record(&self, block: &mut Block, record: InstructionDebugRecordData) {
-        unsafe {
-            block.builder.add_instruction_record(self, record);
-        }
-    }
 }
 
 #[derive(Clone)]

reid/src/codegen.rs

@@ -4,10 +4,10 @@ use reid_lib::{
     builder::{InstructionValue, TypeValue},
     compile::CompiledModule,
     debug_information::{
-        DebugBasicType, DebugFileData, DebugInformation, DebugLocalVariable, DebugLocation,
+        DebugBasicType, DebugFileData, DebugInformation, DebugLocation, DebugMetadata,
-        DebugMetadata, DebugMetadataValue, DebugParamVariable, DebugProgramValue, DebugRecordKind,
+        DebugMetadataValue, DebugParamVariable, DebugProgramValue, DebugScopeValue,
-        DebugScopeValue, DebugSubprogramData, DebugSubprogramOptionals, DebugSubprogramTypeData,
+        DebugSubprogramData, DebugSubprogramOptionals, DebugSubprogramTypeData, DebugTypeData,
-        DebugTypeData, DebugTypeValue, DwarfEncoding, DwarfFlags, InstructionDebugRecordData,
+        DebugTypeValue, DwarfEncoding, DwarfFlags,
     },
     Block, CmpPredicate, ConstValue, Context, CustomTypeKind, Function, FunctionFlags, Instr,
     Module, NamedStruct, TerminatorKind as Term, Type,
@@ -97,7 +97,7 @@ pub struct StackFunction<'ctx> {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StackValue(StackValueKind, TypeKind);
+pub struct StackValue(StackValueKind, Type);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StackValueKind {
@@ -106,16 +106,6 @@ pub enum StackValueKind {
     Any(InstructionValue),
 }
 
-impl StackValueKind {
-    unsafe fn get_inner(&self) -> InstructionValue {
-        match &self {
-            StackValueKind::Immutable(val) => *val,
-            StackValueKind::Mutable(val) => *val,
-            StackValueKind::Any(val) => *val,
-        }
-    }
-}
-
 impl<'ctx, 'a> Scope<'ctx, 'a> {
     fn with_block(&self, block: Block<'ctx>) -> Scope<'ctx, 'a> {
         Scope {
@@ -295,17 +285,12 @@ impl mir::Module {
             let mut stack_values = HashMap::new();
             for (i, (p_name, p_ty)) in mir_function.parameters.iter().enumerate() {
                 // Codegen actual parameters
-                let param = entry.build(Instr::Param(i)).unwrap();
-                let alloca = entry
-                    .build(Instr::Alloca(
-                        p_name.clone(),
-                        p_ty.get_type(&type_values, &types),
-                    ))
-                    .unwrap();
-                entry.build(Instr::Store(alloca, param)).unwrap();
                 stack_values.insert(
                     p_name.clone(),
-                    StackValue(StackValueKind::Immutable(alloca), p_ty.clone()),
+                    StackValue(
+                        StackValueKind::Immutable(entry.build(Instr::Param(i)).unwrap()),
+                        p_ty.get_type(&type_values, &types),
+                    ),
                 );
 
                 // Generate debug info
@@ -409,68 +394,41 @@ impl mir::Statement {
         scope: &mut Scope<'ctx, 'a>,
         state: &State,
     ) -> Option<InstructionValue> {
-        let location = self.1.into_debug(scope.tokens).unwrap();
-        let location = scope
-            .debug
-            .as_ref()
-            .map(|d| d.info.location(&d.scope, location));
-
         match &self.0 {
             mir::StmtKind::Let(NamedVariableRef(ty, name, _), mutable, expression) => {
                 let value = expression.codegen(scope, &state).unwrap();
-
+                scope.stack_values.insert(
-                let alloca = scope
+                    name.clone(),
-                    .block
+                    StackValue(
-                    .build(Instr::Alloca(
+                        match mutable {
-                        name.clone(),
+                            false => StackValueKind::Immutable(value),
-                        ty.get_type(scope.type_values, scope.types),
+                            true => match ty {
-                    ))
+                                // Struct is already allocated at initialization
-                    .unwrap()
+                                TypeKind::Array(_, _) => StackValueKind::Mutable(value),
-                    .maybe_location(&mut scope.block, location);
+                                TypeKind::CustomType(n) => match scope
-
+                                    .types
-                let store = scope
+                                    .get(scope.type_values.get(n).unwrap())
-                    .block
+                                    .unwrap()
-                    .build(Instr::Store(alloca, value))
+                                {
-                    .unwrap()
+                                    // Struct also is allocated at initialization
-                    .maybe_location(&mut scope.block, location);
+                                    TypeDefinitionKind::Struct(_) => StackValueKind::Mutable(value),
-
-                let stack_value = match mutable {
-                    true => StackValueKind::Mutable(alloca),
-                    false => StackValueKind::Immutable(alloca),
-                };
-
-                scope
-                    .stack_values
-                    .insert(name.clone(), StackValue(stack_value, ty.clone()));
-                if let Some(debug) = &scope.debug {
-                    match stack_value {
-                        StackValueKind::Immutable(_) => {}
-                        StackValueKind::Mutable(_) => {
-                            let location = self.1.into_debug(scope.tokens).unwrap();
-                            let var = debug.info.metadata(
-                                &debug.scope,
-                                DebugMetadata::LocalVar(DebugLocalVariable {
-                                    name: name.clone(),
-                                    location,
-                                    ty: scope.debug_const_tys.get(&TypeKind::U32).unwrap().clone(),
-                                    always_preserve: true,
-                                    alignment: 32,
-                                    flags: DwarfFlags,
-                                }),
-                            );
-                            store.add_record(
-                                &mut scope.block,
-                                InstructionDebugRecordData {
-                                    variable: var,
-                                    location,
-                                    kind: DebugRecordKind::Declare(value),
-                                    scope: debug.scope,
                                 },
-                            );
+                                _ => StackValueKind::Mutable({
-                        }
+                                    let alloca = scope
-                        StackValueKind::Any(_) => {}
+                                        .block
-                    }
+                                        .build(Instr::Alloca(
-                }
+                                            name.clone(),
+                                            ty.get_type(scope.type_values, scope.types),
+                                        ))
+                                        .unwrap();
+                                    scope.block.build(Instr::Store(alloca, value)).unwrap();
+                                    alloca
+                                }),
+                            },
+                        },
+                        ty.get_type(scope.type_values, scope.types),
+                    ),
+                );
                 None
             }
             mir::StmtKind::Set(lhs, rhs) => {
@@ -484,8 +442,7 @@ impl mir::Statement {
                     scope
                         .block
                         .build(Instr::Store(lhs_value, rhs_value))
-                        .unwrap()
+                        .unwrap(),
-                        .maybe_location(&mut scope.block, location),
                 )
             }
             mir::StmtKind::Import(_) => todo!(),
@@ -517,15 +474,19 @@ impl mir::Expression {
                     .stack_values
                     .get(&varref.1)
                     .expect("Variable reference not found?!");
-                dbg!(varref);
                 Some(match v.0 {
-                    StackValueKind::Immutable(val) | StackValueKind::Mutable(val) => scope
+                    StackValueKind::Immutable(val) => val.clone(),
-                        .block
+                    StackValueKind::Mutable(val) => {
-                        .build(Instr::Load(
+                        if state.should_load {
-                            val,
+                            match v.1 {
-                            v.1.get_type(scope.type_values, scope.types),
+                                // TODO probably wrong ..?
-                        ))
+                                Type::Ptr(_) => val,
-                        .unwrap(),
+                                _ => scope.block.build(Instr::Load(val, v.1.clone())).unwrap(),
+                            }
+                        } else {
+                            val
+                        }
+                    }
                     _ => panic!("Found an unknown-mutable variable!"),
                 })
             }
@@ -606,8 +567,7 @@ impl mir::Expression {
                 let mut ptr = scope
                     .block
                     .build(Instr::GetElemPtr(array, vec![idx]))
-                    .unwrap()
+                    .unwrap();
-                    .maybe_location(&mut scope.block, location);
 
                 if state.should_load {
                     ptr = scope
@@ -616,8 +576,7 @@ impl mir::Expression {
                             ptr,
                             val_t.get_type(scope.type_values, scope.types),
                         ))
-                        .unwrap()
+                        .unwrap();
-                        .maybe_location(&mut scope.block, location);
                 }
 
                 Some(ptr)
@@ -639,8 +598,7 @@ impl mir::Expression {
                         instr_t.get_type(scope.type_values, scope.types),
                         instr_list.len() as u32,
                     ))
-                    .unwrap()
+                    .unwrap();
-                    .maybe_location(&mut scope.block, location);
 
                 for (index, instr) in instr_list.iter().enumerate() {
                     let index_expr = scope
@@ -650,13 +608,8 @@ impl mir::Expression {
                     let ptr = scope
                         .block
                         .build(Instr::GetElemPtr(array, vec![index_expr]))
-                        .unwrap()
+                        .unwrap();
-                        .maybe_location(&mut scope.block, location);
+                    scope.block.build(Instr::Store(ptr, *instr)).unwrap();
-                    scope
-                        .block
-                        .build(Instr::Store(ptr, *instr))
-                        .unwrap()
-                        .maybe_location(&mut scope.block, location);
                 }
 
                 Some(array)
@@ -676,11 +629,12 @@ impl mir::Expression {
                 let TypeDefinitionKind::Struct(struct_ty) = scope.get_typedef(&name).unwrap();
                 let idx = struct_ty.find_index(field).unwrap();
 
+                dbg!(&scope.context);
+                dbg!(&struct_val);
                 let mut value = scope
                     .block
                     .build(Instr::GetStructElemPtr(struct_val, idx as u32))
-                    .unwrap()
+                    .unwrap();
-                    .maybe_location(&mut scope.block, location);
 
                 if state.should_load {
                     value = scope
@@ -701,21 +655,15 @@ impl mir::Expression {
                         name.clone(),
                         Type::CustomType(*scope.type_values.get(name)?),
                     ))
-                    .unwrap()
+                    .unwrap();
-                    .maybe_location(&mut scope.block, location);
 
                 for (i, (_, exp)) in items.iter().enumerate() {
                     let elem_ptr = scope
                         .block
                         .build(Instr::GetStructElemPtr(struct_ptr, i as u32))
-                        .unwrap()
+                        .unwrap();
-                        .maybe_location(&mut scope.block, location);
                     if let Some(val) = exp.codegen(scope, state) {
-                        scope
+                        scope.block.build(Instr::Store(elem_ptr, val)).unwrap();
-                            .block
-                            .build(Instr::Store(elem_ptr, val))
-                            .unwrap()
-                            .maybe_location(&mut scope.block, location);
                     }
                 }