Fix tests

Author: volsa

compiler/plc_ast/src/pre_processor.rs

@@ -196,7 +196,6 @@ fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProv
 }
 
 fn process_var_config_variables(unit: &mut CompilationUnit) {
-    let block = get_internal_global_block(unit);
     let variables = unit.var_config.iter().filter_map(|ConfigVariable { data_type, address, .. }| {
         let AstStatement::HardwareAccess(hardware) = &address.stmt else {
             unreachable!("Must be parsed as hardware access")
@@ -206,10 +205,12 @@ fn process_var_config_variables(unit: &mut CompilationUnit) {
             return None;
         }
 
+        // Check if the mangled variable already exists in any of the global variable blocks
+        // XXX: Not a fan of this, we should fix the underlying issue with variable block creation here...
         let name = hardware.get_mangled_variable_name();
-        if block.is_some_and(|it| it.variables.iter().any(|v| v.name == name)) {
-            return None;
-        };
+        if find_mangled_variable(unit, &name) {
+            return None; // Already exists, skip
+        }
 
         Some(Variable {
             name,
@@ -220,7 +221,7 @@ fn process_var_config_variables(unit: &mut CompilationUnit) {
         })
     });
 
-    update_generated_globals(unit, variables.collect())
+    update_generated_globals(unit, variables.collect());
 }
 
 fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
@@ -242,11 +243,8 @@ fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Var
     unit.global_vars.push(block);
 }
 
-fn get_internal_global_block(unit: &CompilationUnit) -> Option<&VariableBlock> {
-    unit.global_vars
-        .iter()
-        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
-        .and_then(|index| unit.global_vars.get(index))
+fn find_mangled_variable(unit: &CompilationUnit, name: &str) -> bool {
+    unit.global_vars.iter().flat_map(|block| &block.variables).any(|var| var.name == name)
 }
 
 fn build_enum_initializer(

compiler/plc_driver/src/runner.rs

@@ -66,7 +66,7 @@ pub fn compile<T: Compilable>(codegen_context: &CodegenContext, source: T) -> Ge
 pub fn compile_and_run<T, U, S: Compilable>(source: S, params: &mut T) -> U {
     let context: CodegenContext = CodegenContext::create();
     let module = compile(&context, source);
-    module.print_to_stderr();
+    // module.print_to_stderr();
     module.run::<T, U>("main", params)
 }
 
@@ -77,6 +77,6 @@ pub fn compile_and_run<T, U, S: Compilable>(source: S, params: &mut T) -> U {
 pub fn compile_and_run_no_params<U, S: Compilable>(source: S) -> U {
     let context: CodegenContext = CodegenContext::create();
     let module = compile(&context, source);
-    module.print_to_stderr();
+    // module.print_to_stderr();
     module.run_no_param::<U>("main")
 }

compiler/plc_driver/src/tests/.multi_files.rs.pending-snap

@@ -159,13 +159,13 @@ fn forward_declared_constant_is_also_marked_constant() {
     let results = compile_with_root(vec![src1, src2], vec![], "root", DebugLevel::Full(5)).unwrap();
 
     // THEN the constant is marked as constant in the generated code
-    filtered_assert_snapshot!(results.join("\n"), @r###"
+    filtered_assert_snapshot!(results.join("\n"), @r#"
     ; ModuleID = 'external_file1.st'
     source_filename = "external_file1.st"
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
-    %foo = type { i16 }
+    %foo = type { i32*, i16 }
     %mainProg = type { i16 }
 
     @__foo__init = external unnamed_addr constant %foo
@@ -175,28 +175,28 @@ fn forward_declared_constant_is_also_marked_constant() {
     entry:
       %main = alloca i16, align 2
       %f = alloca %foo, align 8
-      call void @llvm.dbg.declare(metadata %foo* %f, metadata !9, metadata !DIExpression()), !dbg !15
+      call void @llvm.dbg.declare(metadata %foo* %f, metadata !9, metadata !DIExpression()), !dbg !18
       %0 = bitcast %foo* %f to i8*
       call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 bitcast (%foo* @__foo__init to i8*), i64 ptrtoint (%foo* getelementptr (%foo, %foo* null, i32 1) to i64), i1 false)
-      call void @llvm.dbg.declare(metadata i16* %main, metadata !16, metadata !DIExpression()), !dbg !17
+      call void @llvm.dbg.declare(metadata i16* %main, metadata !19, metadata !DIExpression()), !dbg !20
       store i16 0, i16* %main, align 2
-      call void @__init_foo(%foo* %f), !dbg !18
-      call void @__user_init_foo(%foo* %f), !dbg !18
-      %something_to_initialize = getelementptr inbounds %foo, %foo* %f, i32 0, i32 0, !dbg !18
-      %load_something_to_initialize = load i16, i16* %something_to_initialize, align 2, !dbg !18
-      store i16 %load_something_to_initialize, i16* getelementptr inbounds (%mainProg, %mainProg* @mainProg_instance, i32 0, i32 0), align 2, !dbg !18
-      call void @mainProg(%mainProg* @mainProg_instance), !dbg !19
-      %main_ret = load i16, i16* %main, align 2, !dbg !20
-      ret i16 %main_ret, !dbg !20
+      call void @__init_foo(%foo* %f), !dbg !21
+      call void @__user_init_foo(%foo* %f), !dbg !21
+      %something_to_initialize = getelementptr inbounds %foo, %foo* %f, i32 0, i32 1, !dbg !21
+      %load_something_to_initialize = load i16, i16* %something_to_initialize, align 2, !dbg !21
+      store i16 %load_something_to_initialize, i16* getelementptr inbounds (%mainProg, %mainProg* @mainProg_instance, i32 0, i32 0), align 2, !dbg !21
+      call void @mainProg(%mainProg* @mainProg_instance), !dbg !22
+      %main_ret = load i16, i16* %main, align 2, !dbg !23
+      ret i16 %main_ret, !dbg !23
     }
 
-    declare !dbg !21 void @foo(%foo*)
+    declare !dbg !24 void @foo(%foo*)
 
     declare void @__init_foo(%foo*)
 
-    declare !dbg !24 void @__user_init_foo(%foo*)
+    declare void @__user_init_foo(%foo*)
 
-    declare !dbg !29 void @mainProg(%mainProg*)
+    declare !dbg !27 void @mainProg(%mainProg*)
 
     ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
     declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
@@ -220,67 +220,66 @@ fn forward_declared_constant_is_also_marked_constant() {
     !7 = !{null}
     !8 = !{}
     !9 = !DILocalVariable(name: "f", scope: !4, file: !5, line: 4, type: !10, align: 64)
-    !10 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", scope: !11, file: !11, line: 12, size: 16, align: 64, flags: DIFlagPublic, elements: !12, identifier: "foo")
+    !10 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", scope: !11, file: !11, line: 12, size: 128, align: 64, flags: DIFlagPublic, elements: !12, identifier: "foo")
     !11 = !DIFile(filename: "external_file2.st", directory: "")
-    !12 = !{!13}
-    !13 = !DIDerivedType(tag: DW_TAG_member, name: "something_to_initialize", scope: !11, file: !11, line: 14, baseType: !14, size: 16, align: 16, flags: DIFlagPublic)
-    !14 = !DIBasicType(name: "INT", size: 16, encoding: DW_ATE_signed, flags: DIFlagPublic)
-    !15 = !DILocation(line: 4, column: 8, scope: !4)
-    !16 = !DILocalVariable(name: "main", scope: !4, file: !5, line: 2, type: !14, align: 16)
-    !17 = !DILocation(line: 2, column: 13, scope: !4)
-    !18 = !DILocation(line: 0, scope: !4)
-    !19 = !DILocation(line: 6, column: 8, scope: !4)
-    !20 = !DILocation(line: 7, column: 4, scope: !4)
-    !21 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !11, file: !11, line: 12, type: !22, scopeLine: 16, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8)
-    !22 = !DISubroutineType(flags: DIFlagPublic, types: !23)
-    !23 = !{null, !10}
-    !24 = distinct !DISubprogram(name: "__user_init_foo", linkageName: "__user_init_foo", scope: !25, file: !25, type: !26, scopeLine: 1, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8)
-    !25 = !DIFile(filename: "__initializers", directory: "")
-    !26 = !DISubroutineType(flags: DIFlagPublic, types: !27)
-    !27 = !{null, !28}
-    !28 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__auto_pointer_to_foo", baseType: !10, size: 64, align: 64, dwarfAddressSpace: 1)
-    !29 = distinct !DISubprogram(name: "mainProg", linkageName: "mainProg", scope: !11, file: !11, line: 6, type: !30, scopeLine: 10, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8)
-    !30 = !DISubroutineType(flags: DIFlagPublic, types: !31)
-    !31 = !{null, !32, !14}
-    !32 = !DICompositeType(tag: DW_TAG_structure_type, name: "mainProg", scope: !11, file: !11, line: 6, size: 16, align: 64, flags: DIFlagPublic, elements: !33, identifier: "mainProg")
-    !33 = !{!34}
-    !34 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !11, file: !11, line: 8, baseType: !14, size: 16, align: 16, flags: DIFlagPublic)
+    !12 = !{!13, !16}
+    !13 = !DIDerivedType(tag: DW_TAG_member, name: "__vtable", scope: !11, file: !11, baseType: !14, size: 64, align: 64, flags: DIFlagPublic)
+    !14 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__VOID_POINTER", baseType: !15, size: 64, align: 64, dwarfAddressSpace: 1)
+    !15 = !DIBasicType(name: "__VOID", encoding: DW_ATE_unsigned, flags: DIFlagPublic)
+    !16 = !DIDerivedType(tag: DW_TAG_member, name: "something_to_initialize", scope: !11, file: !11, line: 14, baseType: !17, size: 16, align: 16, offset: 64, flags: DIFlagPublic)
+    !17 = !DIBasicType(name: "INT", size: 16, encoding: DW_ATE_signed, flags: DIFlagPublic)
+    !18 = !DILocation(line: 4, column: 8, scope: !4)
+    !19 = !DILocalVariable(name: "main", scope: !4, file: !5, line: 2, type: !17, align: 16)
+    !20 = !DILocation(line: 2, column: 13, scope: !4)
+    !21 = !DILocation(line: 0, scope: !4)
+    !22 = !DILocation(line: 6, column: 8, scope: !4)
+    !23 = !DILocation(line: 7, column: 4, scope: !4)
+    !24 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !11, file: !11, line: 12, type: !25, scopeLine: 16, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8)
+    !25 = !DISubroutineType(flags: DIFlagPublic, types: !26)
+    !26 = !{null, !10}
+    !27 = distinct !DISubprogram(name: "mainProg", linkageName: "mainProg", scope: !11, file: !11, line: 6, type: !28, scopeLine: 10, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !8)
+    !28 = !DISubroutineType(flags: DIFlagPublic, types: !29)
+    !29 = !{null, !30, !17}
+    !30 = !DICompositeType(tag: DW_TAG_structure_type, name: "mainProg", scope: !11, file: !11, line: 6, size: 16, align: 64, flags: DIFlagPublic, elements: !31, identifier: "mainProg")
+    !31 = !{!32}
+    !32 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !11, file: !11, line: 8, baseType: !17, size: 16, align: 16, flags: DIFlagPublic)
 
     ; ModuleID = 'external_file2.st'
     source_filename = "external_file2.st"
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
     %mainProg = type { i16 }
-    %foo = type { i16 }
+    %foo = type { i32*, i16 }
 
     @a = unnamed_addr constant i16 10, !dbg !0
     @mainProg_instance = global %mainProg zeroinitializer, !dbg !5
-    @__foo__init = unnamed_addr constant %foo { i16 20 }, !dbg !10
+    @__foo__init = unnamed_addr constant %foo { i32* null, i16 20 }, !dbg !10
 
-    define void @mainProg(%mainProg* %0) !dbg !21 {
+    define void @mainProg(%mainProg* %0) !dbg !24 {
     entry:
-      call void @llvm.dbg.declare(metadata %mainProg* %0, metadata !25, metadata !DIExpression()), !dbg !26
+      call void @llvm.dbg.declare(metadata %mainProg* %0, metadata !28, metadata !DIExpression()), !dbg !29
       %a = getelementptr inbounds %mainProg, %mainProg* %0, i32 0, i32 0
-      ret void, !dbg !26
+      ret void, !dbg !29
     }
 
-    define void @foo(%foo* %0) !dbg !27 {
+    define void @foo(%foo* %0) !dbg !30 {
     entry:
-      call void @llvm.dbg.declare(metadata %foo* %0, metadata !30, metadata !DIExpression()), !dbg !31
+      call void @llvm.dbg.declare(metadata %foo* %0, metadata !33, metadata !DIExpression()), !dbg !34
       %this = alloca %foo*, align 8
       store %foo* %0, %foo** %this, align 8
-      %something_to_initialize = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0
-      ret void, !dbg !31
+      %__vtable = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0
+      %something_to_initialize = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1
+      ret void, !dbg !34
     }
 
     ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
     declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
 
     attributes #0 = { nofree nosync nounwind readnone speculatable willreturn }
 
-    !llvm.module.flags = !{!16, !17}
-    !llvm.dbg.cu = !{!18}
+    !llvm.module.flags = !{!19, !20}
+    !llvm.dbg.cu = !{!21}
 
     !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
     !1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !2, line: 3, type: !3, isLocal: false, isDefinition: true)
@@ -295,33 +294,36 @@ fn forward_declared_constant_is_also_marked_constant() {
     !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
     !11 = distinct !DIGlobalVariable(name: "__foo__init", scope: !2, file: !2, line: 12, type: !12, isLocal: false, isDefinition: true)
     !12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
-    !13 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", scope: !2, file: !2, line: 12, size: 16, align: 64, flags: DIFlagPublic, elements: !14, identifier: "foo")
-    !14 = !{!15}
-    !15 = !DIDerivedType(tag: DW_TAG_member, name: "something_to_initialize", scope: !2, file: !2, line: 14, baseType: !4, size: 16, align: 16, flags: DIFlagPublic)
-    !16 = !{i32 2, !"Dwarf Version", i32 5}
-    !17 = !{i32 2, !"Debug Info Version", i32 3}
-    !18 = distinct !DICompileUnit(language: DW_LANG_C, file: !19, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !20, splitDebugInlining: false)
-    !19 = !DIFile(filename: "external_file2.st", directory: "root")
-    !20 = !{!0, !5, !10}
-    !21 = distinct !DISubprogram(name: "mainProg", linkageName: "mainProg", scope: !2, file: !2, line: 6, type: !22, scopeLine: 10, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !18, retainedNodes: !24)
-    !22 = !DISubroutineType(flags: DIFlagPublic, types: !23)
-    !23 = !{null, !7, !4}
-    !24 = !{}
-    !25 = !DILocalVariable(name: "mainProg", scope: !21, file: !2, line: 10, type: !7)
-    !26 = !DILocation(line: 10, column: 4, scope: !21)
-    !27 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !2, file: !2, line: 12, type: !28, scopeLine: 16, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !18, retainedNodes: !24)
-    !28 = !DISubroutineType(flags: DIFlagPublic, types: !29)
-    !29 = !{null, !13}
-    !30 = !DILocalVariable(name: "foo", scope: !27, file: !2, line: 16, type: !13)
-    !31 = !DILocation(line: 16, column: 4, scope: !27)
+    !13 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", scope: !2, file: !2, line: 12, size: 128, align: 64, flags: DIFlagPublic, elements: !14, identifier: "foo")
+    !14 = !{!15, !18}
+    !15 = !DIDerivedType(tag: DW_TAG_member, name: "__vtable", scope: !2, file: !2, baseType: !16, size: 64, align: 64, flags: DIFlagPublic)
+    !16 = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__VOID_POINTER", baseType: !17, size: 64, align: 64, dwarfAddressSpace: 1)
+    !17 = !DIBasicType(name: "__VOID", encoding: DW_ATE_unsigned, flags: DIFlagPublic)
+    !18 = !DIDerivedType(tag: DW_TAG_member, name: "something_to_initialize", scope: !2, file: !2, line: 14, baseType: !4, size: 16, align: 16, offset: 64, flags: DIFlagPublic)
+    !19 = !{i32 2, !"Dwarf Version", i32 5}
+    !20 = !{i32 2, !"Debug Info Version", i32 3}
+    !21 = distinct !DICompileUnit(language: DW_LANG_C, file: !22, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !23, splitDebugInlining: false)
+    !22 = !DIFile(filename: "external_file2.st", directory: "root")
+    !23 = !{!0, !5, !10}
+    !24 = distinct !DISubprogram(name: "mainProg", linkageName: "mainProg", scope: !2, file: !2, line: 6, type: !25, scopeLine: 10, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !21, retainedNodes: !27)
+    !25 = !DISubroutineType(flags: DIFlagPublic, types: !26)
+    !26 = !{null, !7, !4}
+    !27 = !{}
+    !28 = !DILocalVariable(name: "mainProg", scope: !24, file: !2, line: 10, type: !7)
+    !29 = !DILocation(line: 10, column: 4, scope: !24)
+    !30 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: !2, file: !2, line: 12, type: !31, scopeLine: 16, flags: DIFlagPublic, spFlags: DISPFlagDefinition, unit: !21, retainedNodes: !27)
+    !31 = !DISubroutineType(flags: DIFlagPublic, types: !32)
+    !32 = !{null, !13}
+    !33 = !DILocalVariable(name: "foo", scope: !30, file: !2, line: 16, type: !13)
+    !34 = !DILocation(line: 16, column: 4, scope: !30)
 
     ; ModuleID = '__initializers'
     source_filename = "__initializers"
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
     %mainProg = type { i16 }
-    %foo = type { i16 }
+    %foo = type { i32*, i16 }
 
     @mainProg_instance = external global %mainProg
     @__foo__init = external unnamed_addr constant %foo
@@ -380,5 +382,5 @@ fn forward_declared_constant_is_also_marked_constant() {
     declare void @mainProg(%mainProg*)
 
     declare void @__user_init_mainProg(%mainProg*)
-    "###);
+    "#);
 }

compiler/plc_driver/src/tests/multi_files.rs

@@ -422,7 +422,7 @@ impl SourceLocation {
     }
 
     pub fn is_internal(&self) -> bool {
-        self.file.is_internal()
+        matches!(self.file, FileMarker::Internal(_)) | matches!(self.span, CodeSpan::None)
     }
 
     pub fn is_builtin_internal(&self) -> bool {

compiler/plc_source/src/source_location.rs

@@ -1,6 +1,7 @@
 #[repr(C)]
 #[derive(Debug, Default)]
 pub struct SetResetParams {
+    __vtable: usize,
     set: bool,
     reset: bool,
     output: bool,
@@ -12,6 +13,21 @@ impl SetResetParams {
     }
 }
 
+#[repr(C)]
+pub struct VTable {
+    pub body: extern "C" fn(&mut SetResetParams),
+}
+
+#[allow(non_upper_case_globals)]
+#[no_mangle]
+#[used]
+pub static __vtable_SR: VTable = VTable { body: SR };
+
+#[allow(non_upper_case_globals)]
+#[no_mangle]
+#[used]
+pub static __SR__init: SetResetParams =
+    SetResetParams { __vtable: 0, set: false, reset: false, output: false };
 ///.
 /// Bistable function, set dominant
 ///
@@ -21,6 +37,17 @@ pub extern "C" fn SR(params: &mut SetResetParams) {
     params.set_output(params.set | (!params.reset & params.output));
 }
 
+#[allow(non_upper_case_globals)]
+#[no_mangle]
+#[used]
+pub static __vtable_RS: VTable = VTable { body: RS };
+
+#[allow(non_upper_case_globals)]
+#[no_mangle]
+#[used]
+pub static __RS__init: SetResetParams =
+    SetResetParams { __vtable: 0, set: false, reset: false, output: false };
+
 ///.
 /// Bistable function, reset dominant
 ///