wip

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -327,6 +327,9 @@ pub enum LinkageType {
     /// This indicates an element that should not have any declarations within the compiled project
     /// For example a built in function is implied to exist but not declared
     BuiltIn,
+    // TODO: A private linkage indicates an internal element that should not be visible externally
+    // This is for example a static constructor that should not leak outside its module
+    // Private,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

compiler/plc_diagnostics/src/diagnostics.rs

@@ -303,8 +303,7 @@ impl Diagnostic {
 
     pub fn cannot_generate_call_statement(operator: &AstNode) -> Diagnostic {
         //TODO: We could probably get a better slice here
-        panic!("{operator:?}");
-        // Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
+        Diagnostic::codegen_error(format!("cannot generate call statement for {:?}", operator), operator)
     }
 
     pub fn cannot_generate_from_empty_literal<T>(type_name: &str, location: T) -> Diagnostic

src/codegen/tests/initialization_test/complex_initializers.rs

@@ -3333,15 +3333,15 @@ fn user_init_called_when_declared_as_external() {
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
-    %prog = type { %foo }
-    %foo = type { i32*, i16, i16 }
     %__vtable_foo = type { void (%foo*)*, void (%foo*)* }
+    %foo = type { i32*, i16, i16 }
+    %prog = type { %foo }
 
+    @__vtable_foo_instance = external global %__vtable_foo
     @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__init___Test, i8* null }]
     @prog_instance = global %prog zeroinitializer
     @__foo__init = external unnamed_addr constant %foo
     @____vtable_foo__init = unnamed_addr constant %__vtable_foo zeroinitializer
-    @__vtable_foo_instance = global %__vtable_foo zeroinitializer
 
     declare void @foo(%foo*)
 
@@ -3354,26 +3354,18 @@ fn user_init_called_when_declared_as_external() {
       ret void
     }
 
-    define void @__init___vtable_foo(%__vtable_foo* %0) {
-    entry:
-      %self = alloca %__vtable_foo*, align 8
-      store %__vtable_foo* %0, %__vtable_foo** %self, align 8
-      %deref = load %__vtable_foo*, %__vtable_foo** %self, align 8
-      %__body = getelementptr inbounds %__vtable_foo, %__vtable_foo* %deref, i32 0, i32 0
-      store void (%foo*)* @foo, void (%foo*)** %__body, align 8
-      %deref1 = load %__vtable_foo*, %__vtable_foo** %self, align 8
-      %FB_INIT = getelementptr inbounds %__vtable_foo, %__vtable_foo* %deref1, i32 0, i32 1
-      store void (%foo*)* @foo__FB_INIT, void (%foo*)** %FB_INIT, align 8
-      ret void
-    }
-
     define void @__init_prog(%prog* %0) {
     entry:
       %self = alloca %prog*, align 8
       store %prog* %0, %prog** %self, align 8
+      %deref = load %prog*, %prog** %self, align 8
+      %f = getelementptr inbounds %prog, %prog* %deref, i32 0, i32 0
+      call void @__init_foo(%foo* %f)
       ret void
     }
 
+    declare void @__init_foo(%foo*)
+
     define void @__user_init_prog(%prog* %0) {
     entry:
       %self = alloca %prog*, align 8
@@ -3384,28 +3376,12 @@ fn user_init_called_when_declared_as_external() {
       ret void
     }
 
-    define void @__user_init_foo(%foo* %0) {
-    entry:
-      %self = alloca %foo*, align 8
-      store %foo* %0, %foo** %self, align 8
-      %deref = load %foo*, %foo** %self, align 8
-      call void @foo__FB_INIT(%foo* %deref)
-      ret void
-    }
-
-    define void @__user_init___vtable_foo(%__vtable_foo* %0) {
-    entry:
-      %self = alloca %__vtable_foo*, align 8
-      store %__vtable_foo* %0, %__vtable_foo** %self, align 8
-      ret void
-    }
+    declare void @__user_init_foo(%foo*)
 
     define void @__init___Test() {
     entry:
       call void @__init_prog(%prog* @prog_instance)
-      call void @__init___vtable_foo(%__vtable_foo* @__vtable_foo_instance)
       call void @__user_init_prog(%prog* @prog_instance)
-      call void @__user_init___vtable_foo(%__vtable_foo* @__vtable_foo_instance)
       ret void
     }
     "#);

src/index/tests/index_tests.rs

@@ -1833,6 +1833,7 @@ fn aliased_hardware_access_variable_creates_global_var_for_address() {
                     "<internal>",
                 ),
             },
+            linkage: Internal,
         },
     )
     "#);
@@ -1903,6 +1904,7 @@ fn aliased_hardware_access_variable_is_indexed_as_a_pointer() {
                     "<internal>",
                 ),
             },
+            linkage: Internal,
         },
     )
     "#);

src/lowering.rs

@@ -54,7 +54,7 @@ impl InitVisitor {
         unresolved_initializers: Vec<UnresolvableConstant>,
         id_provider: IdProvider,
     ) -> Self {
-        let unresolved_initializers = dbg!(Initializers::new(&unresolved_initializers, &index));
+        let unresolved_initializers = Initializers::new(&unresolved_initializers, &index);
         Self {
             index,
             unresolved_initializers,
@@ -75,19 +75,18 @@ impl InitVisitor {
 
     fn collect_user_init_candidates(&mut self, unit: &mut CompilationUnit) {
         // collect all candidates for user-defined init functions
-        for pou in unit.pous.iter().filter(|it| matches!(it.kind, PouType::FunctionBlock | PouType::Program))
+        for pou in unit.pous.iter().filter(|it| matches!(it.kind, PouType::FunctionBlock | PouType::Program)).filter(|it| !matches!(it.linkage, LinkageType::BuiltIn))
         {
             // add the POU to potential `FB_INIT` candidates
             self.user_inits
                 .insert(pou.name.to_owned(), self.index.find_method(&pou.name, "FB_INIT").is_some());
         }
 
         for user_type in
-            unit.user_types.iter_mut().filter(|it| matches!(it.data_type, DataType::StructType { .. }))
+            unit.user_types.iter_mut().filter(|it| matches!(it.data_type, DataType::StructType { .. })).filter(|it| !matches!(it.linkage, LinkageType::BuiltIn))
         {
             // add the struct to potential `STRUCT_INIT` candidates
             if let Some(name) = user_type.data_type.get_name() {
-                eprintln!("insert user init for {name}");
                 self.user_inits.insert(name.to_string(), false);
             };
         }
@@ -357,8 +356,8 @@ impl AstVisitorMut for InitVisitor {
     fn visit_user_type_declaration(&mut self, user_type: &mut plc_ast::ast::UserTypeDeclaration) {
         if !matches!(user_type.linkage, LinkageType::BuiltIn) {
             self.update_struct_initializers(user_type);
+            user_type.walk(self);
         }
-        user_type.walk(self);
     }
 
     fn visit_data_type(&mut self, data_type: &mut DataType) {

src/lowering/initializers.rs

@@ -59,7 +59,7 @@ impl<'lwr> Init<'lwr> for Initializers {
                 }
             })
             .filter(|(scope, _)| {
-                dbg!(index.find_type(dbg!(scope)))
+                index.find_type(scope)
                     .is_some_and(|it| !matches!(it.linkage, LinkageType::BuiltIn))
             })
             .for_each(|(scope, data)| {
@@ -342,7 +342,7 @@ fn create_init_wrapper_function(
     let global_instances = if let Some(global_instances) =
         lowerer.unresolved_initializers.get(GLOBAL_SCOPE).map(|it| {
             it.keys().filter_map(|var_name| {
-                lowerer.index.find_variable(None, &[var_name]).and_then(|it| {
+                lowerer.index.find_variable(None, &[var_name]).filter(|it| !it.is_external()).and_then(|it| {
                     lowerer.index.find_effective_type_by_name(it.get_type_name()).and_then(|dt| {
                         let name = dt.get_type_information().get_name();
                         if dt.get_type_information().is_struct() {

src/resolver/tests/fnptr.rs

@@ -535,6 +535,7 @@ fn function_pointer_arguments_have_correct_type_hint() {
                 location: SourceLocation {
                     span: None,
                 },
+                linkage: Internal,
             },
         )
         "#);