Merge branch 'master' into volsa/lit

PLC-lang · Jun 13, 2024 · e567c98 · e567c98
2 parents 5d9b3f2 + a9d55a1
commit e567c98
Show file tree

Hide file tree

Showing 337 changed files with 717 additions and 691 deletions.
diff --git a/...lc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap b/...lc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap
@@ -7,7 +7,7 @@ source_filename = "app/file1.st"
 
 %mainProg = type {}
 
-@mainProg_instance = external global %mainProg, section "var-mainProg_instance:v", !dbg !0
+@mainProg_instance = external global %mainProg, section "var-mainProg_instance:r0", !dbg !0
 
 define i16 @main() section "fn-main:i16" !dbg !10 {
 entry:
@@ -54,7 +54,7 @@ source_filename = "lib/file2.st"
 
 %mainProg = type {}
 
-@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:v", !dbg !0
+@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:r0", !dbg !0
 
 define void @mainProg(%mainProg* %0) section "fn-mainProg:v" !dbg !10 {
 entry:

diff --git a/...r/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap b/...r/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap
@@ -7,7 +7,7 @@ source_filename = "file1.st"
 
 %mainProg = type {}
 
-@mainProg_instance = external global %mainProg, section "var-mainProg_instance:v", !dbg !0
+@mainProg_instance = external global %mainProg, section "var-mainProg_instance:r0", !dbg !0
 
 define i16 @main() section "fn-main:i16" !dbg !10 {
 entry:
@@ -54,7 +54,7 @@ source_filename = "file2.st"
 
 %mainProg = type {}
 
-@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:v", !dbg !0
+@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:r0", !dbg !0
 
 define void @mainProg(%mainProg* %0) section "fn-mainProg:v" !dbg !10 {
 entry:

diff --git a/.../src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap b/.../src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap
@@ -7,7 +7,7 @@ source_filename = "external_file1.st"
 
 %mainProg = type {}
 
-@mainProg_instance = external global %mainProg, section "var-mainProg_instance:v"
+@mainProg_instance = external global %mainProg, section "var-mainProg_instance:r0"
 
 define i16 @main() section "fn-main:i16" {
 entry:
@@ -25,7 +25,7 @@ source_filename = "external_file2.st"
 
 %mainProg = type {}
 
-@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:v"
+@mainProg_instance = global %mainProg zeroinitializer, section "var-mainProg_instance:r0"
 
 define void @mainProg(%mainProg* %0) section "fn-mainProg:v" {
 entry:

diff --git a/compiler/section_mangler/src/lib.rs b/compiler/section_mangler/src/lib.rs
@@ -160,7 +160,9 @@ pub enum Type {
         semantic_size: Option<u32>,
     },
     /// Encoded as `f<size>`
-    Float { size: u32 },
+    Float {
+        size: u32,
+    },
     /// Encoded as `s<encoding><size>`
     String {
         size: usize, // FIXME: Is that okay? will all the constant expressions be folded at that point? Can we have TypeSize::Undetermined still?
@@ -172,23 +174,12 @@ pub enum Type {
         // TODO: Is changing the `auto_deref` mode an ABI break?
         // auto_deref: bool,
     },
-
-    // --- UNIMPLEMENTED
-
-    // FIXME: Do we need any info here? How are structs codegened?
     Struct {
-        // name: TypeId,
-        // members: Vec<VariableIndexEntry>,
-        // source: StructSource,
+        members: Vec<Type>,
     },
-
-    // FIXME: Same here
     Enum {
-        // name: TypeId,
-        // referenced_type: TypeId,
-        // // TODO: Would it make sense to store `VariableIndexEntry`s similar to how the `Struct` variant does?
-        // //       This would allow us to pattern match in the index `find_member` method
-        // elements: Vec<String>,
+        referenced_type: Box<Type>,
+        elements: usize,
     },
     Array {
         inner: Box<Type>,
@@ -226,10 +217,17 @@ impl fmt::Display for Type {
             Type::Float { size } => write!(f, "f{size}"),
             Type::String { size, encoding } => write!(f, "s{encoding}{size}",),
             Type::Pointer { inner } => write!(f, "p{}", inner),
+            Type::Struct { members } => {
+                write!(
+                    f,
+                    "r{}{}",
+                    members.len(),
+                    members.iter().fold(String::new(), |acc, m| format!("{acc}{m}"))
+                )
+            }
+            Type::Enum { referenced_type, elements } => write!(f, "e{elements}{referenced_type}"),
+            Type::Array { inner } => write!(f, "a{inner}"),
             // -- Unimplemented
-            Type::Struct {} => todo!(),
-            Type::Enum {} => todo!(),
-            Type::Array { .. } => todo!(),
             Type::SubRange {} => todo!(),
             Type::Alias {} => todo!(),
             Type::Generic {} => todo!(),

diff --git a/src/codegen/generators/section_names.rs b/src/codegen/generators/section_names.rs
@@ -4,6 +4,8 @@ use plc_diagnostics::diagnostics::Diagnostic;
 use section_mangler::{StringEncoding as SectionStringEncoding, Type};
 
 pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> Result<section_mangler::Type, Diagnostic> {
+    let access_inner = |ty_name| mangle_type(index, index.get_effective_type_by_name(ty_name)?);
+
     // TODO: This is a bit ugly because we keep dereferencing references to Copy types like
     // bool, u32, etc, because `DataTypeInformation::Pointer` keeps a `String` which is not
     // Copy. the alternative is for section_mangle::Type to keep references everywhere, and
@@ -23,10 +25,36 @@ pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> Result<section_m
 
             Type::String { size: *size as usize, encoding }
         }
-        DataTypeInformation::Pointer { inner_type_name, .. } => Type::Pointer {
-            inner: Box::new(mangle_type(index, index.get_effective_type_by_name(inner_type_name)?)?),
+        DataTypeInformation::Pointer { inner_type_name, .. } => {
+            Type::Pointer { inner: Box::new(access_inner(inner_type_name)?) }
+        }
+        DataTypeInformation::Enum { referenced_type, variants, .. } => {
+            Type::Enum { referenced_type: Box::new(access_inner(referenced_type)?), elements: variants.len() }
+        }
+        DataTypeInformation::Struct { members, .. } => Type::Struct {
+            members: members.iter().try_fold(Vec::new(), |mut acc, m| -> Result<Vec<Type>, Diagnostic> {
+                let inner = access_inner(m.get_type_name())?;
+
+                acc.push(inner);
+
+                Ok(acc)
+            })?,
         },
-        // FIXME: For now, encode all unknown types as "void" since this is not required for
+        DataTypeInformation::Array { inner_type_name, .. } => {
+            Type::Array { inner: Box::new(access_inner(inner_type_name)?) }
+        }
+        // FIXME: Is that correct?
+        // For code generation, the actual range does not matter - it is not a breaking change
+        // if a variable's range changes, at least not for codegen, since the underlying type will stay
+        // the same. Therefore, only encode it as its underlying type.
+        DataTypeInformation::SubRange { referenced_type, .. }
+        // Similarly, we do not care about the alias - only the type which is being codegen'd
+        | DataTypeInformation::Alias { referenced_type, .. } => access_inner(referenced_type)?,
+        DataTypeInformation::Generic { .. } => {
+            // FIXME: Is that correct?
+            unreachable!("generic types should not exist at codegen")
+        }
+         // FIXME: For now, encode all unknown types as "void" since this is not required for
         // execution. Not doing so (and doing an `unreachable!()` for example) obviously causes
         // failures, because complex types are already implemented in the compiler.
         _ => Type::Void,

diff --git a/...debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap b/...debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap
@@ -8,8 +8,8 @@ source_filename = "main"
 %myPrg = type {}
 %myFb = type {}
 
-@myPrg_instance = external global %myPrg, section "var-myPrg_instance:v", !dbg !0
-@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:v", !dbg !5
+@myPrg_instance = external global %myPrg, section "var-myPrg_instance:r0", !dbg !0
+@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:r0", !dbg !5
 
 declare i32 @myFunc() section "fn-myFunc:i32"
 

diff --git a/...odegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap b/...odegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap
@@ -8,8 +8,8 @@ source_filename = "main"
 %myPrg = type {}
 %myFb = type {}
 
-@myPrg_instance = global %myPrg zeroinitializer, section "var-myPrg_instance:v", !dbg !0
-@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:v", !dbg !5
+@myPrg_instance = global %myPrg zeroinitializer, section "var-myPrg_instance:r0", !dbg !0
+@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:r0", !dbg !5
 
 define i32 @myFunc() section "fn-myFunc:i32" !dbg !12 {
 entry:

diff --git a/...en__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap b/...en__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap
@@ -8,8 +8,8 @@ source_filename = "main"
 %myProg = type { i32 }
 %fb = type { i32 }
 
-@myProg_instance = global %myProg zeroinitializer, section "var-myProg_instance:v", !dbg !0
-@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-__fb__init:v", !dbg !7
+@myProg_instance = global %myProg zeroinitializer, section "var-myProg_instance:r1i32", !dbg !0
+@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-__fb__init:r1i32", !dbg !7
 
 define void @myProg(%myProg* %0) section "fn-myProg:v[i32]" !dbg !16 {
 entry:

diff --git a/..._debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap b/..._debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap
@@ -8,8 +8,8 @@ source_filename = "main"
 %myPrg = type {}
 %myFb = type {}
 
-@myPrg_instance = global %myPrg zeroinitializer, section "var-myPrg_instance:v", !dbg !0
-@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:v", !dbg !9
+@myPrg_instance = global %myPrg zeroinitializer, section "var-myPrg_instance:r3i32i32i32", !dbg !0
+@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-__myFb__init:r3i32i32i32", !dbg !9
 
 define i32 @myFunc() section "fn-myFunc:i32" !dbg !20 {
 entry:

diff --git a/...__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap b/...__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap
@@ -7,7 +7,7 @@ source_filename = "main"
 
 %commands = type { i8, i8 }
 
-@__commands__init = unnamed_addr constant %commands { i8 1, i8 0 }, section "var-__commands__init:v"
+@__commands__init = unnamed_addr constant %commands { i8 1, i8 0 }, section "var-__commands__init:r2u8u8"
 
 define i32 @main() section "fn-main:i32" {
 entry:

diff --git a/...t__global_initializers__global_constant_without_initializer_gets_default_initializer.snap b/...t__global_initializers__global_constant_without_initializer_gets_default_initializer.snap
@@ -7,7 +7,7 @@ source_filename = "main"
 
 %commands = type { i8, i8 }
 
-@__commands__init = unnamed_addr constant %commands zeroinitializer, section "var-__commands__init:v"
+@__commands__init = unnamed_addr constant %commands zeroinitializer, section "var-__commands__init:r2u8u8"
 @__main.myStr1__init = unnamed_addr constant [81 x i8] zeroinitializer
 
 define i32 @main() section "fn-main:i32" {

diff --git a/...alization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap b/...alization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap
@@ -8,9 +8,9 @@ source_filename = "main"
 %MyFB = type { i16 }
 %prg = type { %MyFB }
 
-@x = global %MyFB { i16 77 }, section "var-x:v"
-@__MyFB__init = unnamed_addr constant %MyFB { i16 77 }, section "var-__MyFB__init:v"
-@prg_instance = global %prg { %MyFB { i16 77 } }, section "var-prg_instance:v"
+@x = global %MyFB { i16 77 }, section "var-x:r1i16"
+@__MyFB__init = unnamed_addr constant %MyFB { i16 77 }, section "var-__MyFB__init:r1i16"
+@prg_instance = global %prg { %MyFB { i16 77 } }, section "var-prg_instance:r1r1i16"
 
 define void @MyFB(%MyFB* %0) section "fn-MyFB:v" {
 entry:

diff --git a/...codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap b/...codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap
@@ -5,4 +5,4 @@ expression: result
 ; ModuleID = 'main'
 source_filename = "main"
 
-@a = global [2 x i8] zeroinitializer, section "var-a:v"
+@a = global [2 x i8] zeroinitializer, section "var-a:au8"
diff --git a/...__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap b/...__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap
@@ -8,16 +8,16 @@ source_filename = "main"
 %fb = type { i16 }
 %main = type { %fb }
 
-@__fb__init = unnamed_addr constant %fb { i16 9 }, section "var-__fb__init:v"
-@main_instance = global %main { %fb { i16 9 } }, section "var-main_instance:v"
+@__fb__init = unnamed_addr constant %fb { i16 9 }, section "var-__fb__init:r1i16"
+@main_instance = global %main { %fb { i16 9 } }, section "var-main_instance:r1r1i16"
 
 define void @fb(%fb* %0) section "fn-fb:v" {
 entry:
   %a = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0
   ret void
 }
 
-define i32 @func(%fb* %0) section "fn-func:i32[v]" {
+define i32 @func(%fb* %0) section "fn-func:i32[r1i16]" {
 entry:
   %func = alloca i32, align 4
   %in = alloca %fb, align 8

diff --git a/...itializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap b/...itializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap
@@ -6,10 +6,10 @@ expression: function
 source_filename = "main"
 
 @x = global i32 10, section "var-x:i32"
-@__foo_position.x = unnamed_addr constant i32 1, section "var-x:v"
-@__bar_position.x = unnamed_addr constant i32 3, section "var-x:v"
-@__foo_position.y = unnamed_addr constant i32 2, section "var-y:v"
-@__bar_position.y = unnamed_addr constant i32 4, section "var-y:v"
+@__foo_position.x = unnamed_addr constant i32 1, section "var-x:e2i32"
+@__bar_position.x = unnamed_addr constant i32 3, section "var-x:e2i32"
+@__foo_position.y = unnamed_addr constant i32 2, section "var-y:e2i32"
+@__bar_position.y = unnamed_addr constant i32 4, section "var-y:e2i32"
 
 define i32 @foo() section "fn-foo:i32" {
 entry:

diff --git a/...initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap b/...initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap
@@ -8,15 +8,15 @@ source_filename = "main"
 %fb = type {}
 %main = type { %fb }
 
-@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-__fb__init:v"
-@main_instance = global %main zeroinitializer, section "var-main_instance:v"
+@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-__fb__init:r0"
+@main_instance = global %main zeroinitializer, section "var-main_instance:r1r0"
 
 define void @fb(%fb* %0) section "fn-fb:v" {
 entry:
   ret void
 }
 
-define i32 @func(%fb* %0) section "fn-func:i32[v]" {
+define i32 @func(%fb* %0) section "fn-func:i32[r0]" {
 entry:
   %func = alloca i32, align 4
   %in = alloca %fb, align 8

diff --git a/...__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap b/...__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap
@@ -7,7 +7,7 @@ source_filename = "main"
 
 %MyStruct = type { i32, i16 }
 
-@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-__MyStruct__init:v"
+@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-__MyStruct__init:r2i32i16"
 
 define i16 @foo_int() section "fn-foo_int:i16" {
 entry:
@@ -27,7 +27,7 @@ entry:
   ret void
 }
 
-define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" {
+define void @foo_arr([10 x float]* %0) section "fn-foo_arr:af32" {
 entry:
   %foo_arr = alloca [10 x float]*, align 8
   store [10 x float]* %0, [10 x float]** %foo_arr, align 8
@@ -37,7 +37,7 @@ entry:
   ret void
 }
 
-define void @foo_struct(%MyStruct* %0) section "fn-foo_struct:v" {
+define void @foo_struct(%MyStruct* %0) section "fn-foo_struct:r2i32i16" {
 entry:
   %foo_struct = alloca %MyStruct*, align 8
   store %MyStruct* %0, %MyStruct** %foo_struct, align 8

diff --git a/...n_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap b/...n_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap
@@ -7,10 +7,10 @@ source_filename = "main"
 
 %main = type { [4 x i32], [4 x i32] }
 
-@main_instance = global %main zeroinitializer, section "var-main_instance:v"
-@__myArray__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4], section "var-__myArray__init:v"
+@main_instance = global %main zeroinitializer, section "var-main_instance:r2ai32ai32"
+@__myArray__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4], section "var-__myArray__init:ai32"
 
-define void @target([4 x i32]* %0) section "fn-target:v" {
+define void @target([4 x i32]* %0) section "fn-target:ai32" {
 entry:
   %target = alloca [4 x i32]*, align 8
   store [4 x i32]* %0, [4 x i32]** %target, align 8

diff --git a/...ation_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap b/...ation_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap
@@ -8,10 +8,10 @@ source_filename = "main"
 %MyStrct = type { i32, i32, i32 }
 
 @__MyStr__init = unnamed_addr constant [11 x i8] c"init\00\00\00\00\00\00\00", section "var-__MyStr__init:s8u11"
-@__MyArr__init = unnamed_addr constant [10 x float] [float 0.000000e+00, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000, float 0x40119999A0000000, float 5.500000e+00, float 0x401A666660000000, float 0x401ECCCCC0000000, float 0x40219999A0000000, float 0x4023CCCCC0000000], section "var-__MyArr__init:v"
-@__MyStrct__init = unnamed_addr constant %MyStrct { i32 1, i32 2, i32 3 }, section "var-__MyStrct__init:v"
+@__MyArr__init = unnamed_addr constant [10 x float] [float 0.000000e+00, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000, float 0x40119999A0000000, float 5.500000e+00, float 0x401A666660000000, float 0x401ECCCCC0000000, float 0x40219999A0000000, float 0x4023CCCCC0000000], section "var-__MyArr__init:af32"
+@__MyStrct__init = unnamed_addr constant %MyStrct { i32 1, i32 2, i32 3 }, section "var-__MyStrct__init:r3i32i32i32"
 
-define i16 @foo_int() section "fn-foo_int:v" {
+define i16 @foo_int() section "fn-foo_int:i16" {
 entry:
   %foo_int = alloca i16, align 2
   store i16 7, i16* %foo_int, align 2
@@ -29,7 +29,7 @@ entry:
   ret void
 }
 
-define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" {
+define void @foo_arr([10 x float]* %0) section "fn-foo_arr:af32" {
 entry:
   %foo_arr = alloca [10 x float]*, align 8
   store [10 x float]* %0, [10 x float]** %foo_arr, align 8
@@ -39,7 +39,7 @@ entry:
   ret void
 }
 
-define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:v" {
+define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:r3i32i32i32" {
 entry:
   %foo_strct = alloca %MyStrct*, align 8
   store %MyStrct* %0, %MyStrct** %foo_strct, align 8

diff --git a/...on_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap b/...on_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap
@@ -7,9 +7,9 @@ source_filename = "main"
 
 %MyStrct = type { i32, i32, i32 }
 
-@__MyStrct__init = unnamed_addr constant %MyStrct zeroinitializer, section "var-__MyStrct__init:v"
+@__MyStrct__init = unnamed_addr constant %MyStrct zeroinitializer, section "var-__MyStrct__init:r3i32i32i32"
 
-define i16 @foo_int() section "fn-foo_int:v" {
+define i16 @foo_int() section "fn-foo_int:i16" {
 entry:
   %foo_int = alloca i16, align 2
   store i16 0, i16* %foo_int, align 2
@@ -27,7 +27,7 @@ entry:
   ret void
 }
 
-define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" {
+define void @foo_arr([10 x float]* %0) section "fn-foo_arr:af32" {
 entry:
   %foo_arr = alloca [10 x float]*, align 8
   store [10 x float]* %0, [10 x float]** %foo_arr, align 8
@@ -37,7 +37,7 @@ entry:
   ret void
 }
 
-define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:v" {
+define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:r3i32i32i32" {
 entry:
   %foo_strct = alloca %MyStrct*, align 8
   store %MyStrct* %0, %MyStrct** %foo_strct, align 8