Add initializers to the global constructors (#1327)

* Use global ctors to initialize the project
Added a ProjectInit pou type to make it easy to find the initializers

* Update snapshot tests
* Update lit tests

Author: ghaith

Cargo.lock

@@ -258,6 +258,7 @@ pub enum PouType {
     Class,
     Method { owner_class: String },
     Init,
+    ProjectInit,
 }
 
 impl Display for PouType {
@@ -270,6 +271,7 @@ impl Display for PouType {
             PouType::Class => write!(f, "Class"),
             PouType::Method { .. } => write!(f, "Method"),
             PouType::Init => write!(f, "Init"),
+            PouType::ProjectInit => write!(f, "ProjectInit"),
         }
     }
 }
@@ -283,6 +285,10 @@ impl PouType {
             None
         }
     }
+
+    pub fn is_function_or_init(&self) -> bool {
+        matches!(self, PouType::Function | PouType::Init | PouType::ProjectInit)
+    }
 }
 
 #[derive(Debug, PartialEq)]

compiler/plc_ast/src/ast.rs

@@ -24,6 +24,8 @@ declare i16 @external()
 ; ModuleID = '__init___TestProject'
 source_filename = "__init___TestProject"
 
+@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___TestProject, i8* null }]
+
 define void @__init___TestProject() {
 entry:
   ret void

compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_function_call.snap

@@ -32,6 +32,8 @@ declare i16 @external()
 ; ModuleID = '__init___TestProject'
 source_filename = "__init___TestProject"
 
+@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___TestProject, i8* null }]
+
 define void @__init___TestProject() {
 entry:
   ret void

compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_global_var.snap

@@ -137,6 +137,7 @@ source_filename = "__init___TestProject"
 %mainProg = type {}
 
 @mainProg_instance = external global %mainProg, !dbg !0
+@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___TestProject, i8* null }]
 
 define void @__init___TestProject() !dbg !10 {
 entry:

compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap

@@ -137,6 +137,7 @@ source_filename = "__init___TestProject"
 %mainProg = type {}
 
 @mainProg_instance = external global %mainProg, !dbg !0
+@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___TestProject, i8* null }]
 
 define void @__init___TestProject() !dbg !10 {
 entry:

compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap

@@ -54,6 +54,7 @@ source_filename = "__init___TestProject"
 %mainProg = type {}
 
 @mainProg_instance = external global %mainProg
+@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___TestProject, i8* null }]
 
 define void @__init___TestProject() {
 entry:

compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap

@@ -531,7 +531,7 @@ impl<'ink> DebugBuilder<'ink> {
             }
         }
         let implementation = pou.find_implementation(index).expect("A POU will have an impl at this stage");
-        if implementation.implementation_type != ImplementationType::Function {
+        if !implementation.get_implementation_type().is_function_or_init() {
             if implementation.get_implementation_type() == &ImplementationType::Method {
                 //Methods ignored for now
             } else {

src/codegen/debug.rs

@@ -30,7 +30,7 @@ use crate::index::Index;
 use index::VariableType;
 
 use inkwell::{
-    module::Module,
+    module::{Linkage, Module},
     types::{BasicMetadataTypeEnum, BasicTypeEnum, FunctionType},
     values::{BasicValue, BasicValueEnum, FunctionValue},
     AddressSpace,
@@ -113,7 +113,7 @@ pub fn generate_global_constants_for_pou_members<'ink>(
     });
     for implementation in implementations {
         let type_name = implementation.get_type_name();
-        if index.is_init_function(type_name) {
+        if implementation.is_init() {
             // initializer functions don't need global constants to initialize members
             continue;
         }
@@ -235,10 +235,7 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
                     }
                     _ => {
                         dti.map(|it| {
-                            if !matches!(
-                                implementation.get_implementation_type(),
-                                ImplementationType::Function
-                            ) {
+                            if !implementation.get_implementation_type().is_function_or_init() {
                                 return *p;
                             }
                             // for aggregate function parameters we will generate a pointer instead of the value type.
@@ -296,9 +293,11 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
 
         let curr_f = module.add_function(implementation.get_call_name(), function_declaration, None);
 
-        if self.online_change.is_enabled() {
-            let section_name = self.mangle_function(implementation)?;
-            curr_f.set_section(Some(&section_name));
+        let section_name = self.get_section(implementation)?;
+        curr_f.set_section(section_name.as_deref());
+
+        if implementation.get_implementation_type().is_project_init() {
+            self.add_global_constructor(module, curr_f)?;
         }
 
         let pou_name = implementation.get_call_name();
@@ -320,14 +319,52 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
         Ok(curr_f)
     }
 
+    /// Generates a global constructors entry
+    /// The entry contains the a call to the initializer function
+    fn add_global_constructor(
+        &self,
+        module: &Module<'ink>,
+        curr_f: FunctionValue<'ink>,
+    ) -> Result<(), Diagnostic> {
+        //Create a constructor struct
+        let ctor_str = self.llvm.context.struct_type(
+            &[
+                //Priority
+                self.llvm.context.i32_type().as_basic_type_enum(),
+                // Function pointer
+                curr_f.as_global_value().as_basic_value_enum().get_type(),
+                //Data
+                self.llvm.context.i8_type().ptr_type(AddressSpace::default()).as_basic_type_enum(),
+            ],
+            false,
+        );
+
+        //Create an entry for the global constructor of the project
+        let str_value = ctor_str.const_named_struct(&[
+            self.llvm.context.i32_type().const_zero().as_basic_value_enum(),
+            curr_f.as_global_value().as_basic_value_enum(),
+            self.llvm.context.i8_type().ptr_type(AddressSpace::default()).const_zero().as_basic_value_enum(),
+        ]);
+        //Create an array with the global constructor as an entry
+        let arr = ctor_str.const_array(&[str_value]);
+        //Create the global constructors variable or fetch it and append to it if already
+        //availabe
+        let global_ctors = module.get_global("llvm.global_ctors").unwrap_or_else(|| {
+            module.add_global(arr.get_type().as_basic_type_enum(), None, "llvm.global_ctors")
+        });
+
+        global_ctors.set_initializer(&arr);
+        global_ctors.set_linkage(Linkage::Appending);
+        Ok(())
+    }
     /// creates and returns all parameters for the given implementation
     /// for functions, this method creates a full list of parameters, for other POUs
     /// this method creates a single state-struct parameter
     fn collect_parameters_for_implementation(
         &self,
         implementation: &ImplementationIndexEntry,
     ) -> Result<Vec<BasicMetadataTypeEnum<'ink>>, Diagnostic> {
-        if implementation.implementation_type != ImplementationType::Function {
+        if !implementation.implementation_type.is_function_or_init() {
             let mut parameters = vec![];
             if implementation.get_implementation_type() == &ImplementationType::Method {
                 let class_name =
@@ -426,7 +463,7 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
         }
 
         // generate local variables
-        if matches!(implementation.pou_type, PouType::Function | PouType::Init) {
+        if implementation.pou_type.is_function_or_init() {
             self.generate_local_function_arguments_accessors(
                 &mut local_index,
                 &implementation.type_name,
@@ -877,4 +914,12 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
             None
         }
     }
+
+    fn get_section(&self, implementation: &ImplementationIndexEntry) -> Result<Option<String>, Diagnostic> {
+        if self.online_change.is_enabled() {
+            self.mangle_function(implementation).map(Some)
+        } else {
+            Ok(None)
+        }
+    }
 }

src/codegen/generators/pou_generator.rs

@@ -280,8 +280,7 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
         if self.annotations.get(left_statement).is_some_and(|it| {
             // TODO(mhasel): ideally the resolver decides which assignment statement to call when lowering the init functions,
             // but that requires refactoring of how `aliases` and `reference to` LHS/RHS nodes are annotated. this is a workaround.
-            self.index.is_init_function(self.function_context.linking_context.get_call_name())
-                && (it.is_alias() || it.is_reference_to())
+            self.function_context.linking_context.is_init() && (it.is_alias() || it.is_reference_to())
         }) {
             return self.generate_ref_assignment(left_statement, right_statement);
         };