feat: initialize configured template variables (#1317)

* feat: initialize var_config variables

Author: mhasel

compiler/plc_ast/src/pre_processor.rs

@@ -187,6 +187,34 @@ fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProv
     update_generated_globals(unit, mangled_globals);
 }
 
+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")
+        };
+
+        if hardware.is_template() {
+            return None;
+        }
+
+        let name = hardware.get_mangled_variable_name();
+        if block.is_some_and(|it| it.variables.iter().any(|v| v.name == name)) {
+            return None;
+        };
+
+        Some(Variable {
+            name,
+            data_type_declaration: data_type.get_inner_pointer_ty().unwrap_or(data_type.clone()),
+            initializer: None,
+            address: None,
+            location: address.get_location(),
+        })
+    });
+
+    update_generated_globals(unit, variables.collect())
+}
+
 fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
     let mut block = if let Some(index) = unit.global_vars.iter().position(|block| {
         block.variable_block_type == VariableBlockType::Global && block.location.is_internal()
@@ -200,32 +228,17 @@ fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Var
             block.variables.push(var);
         }
     }
+
     unit.global_vars.push(block);
 }
 
-fn process_var_config_variables(unit: &mut CompilationUnit) {
-    let variables =
-        unit.var_config.iter().filter_map(|ConfigVariable { data_type, address, location, .. }| {
-            let AstStatement::HardwareAccess(hardware) = &address.stmt else {
-                unreachable!("Must be parsed as hardware access")
-            };
-
-            if hardware.is_template() {
-                return None;
-            }
-
-            let name = hardware.get_mangled_variable_name();
-
-            Some(Variable {
-                name,
-                data_type_declaration: data_type.clone(),
-                initializer: None,
-                address: None,
-                location: location.clone(),
-            })
-        });
-
-    update_generated_globals(unit, variables.collect())
+fn get_internal_global_block(unit: &CompilationUnit) -> Option<&VariableBlock> {
+    unit.global_vars
+        .iter()
+        .position(|block| {
+            block.variable_block_type == VariableBlockType::Global && block.location.is_internal()
+        })
+        .and_then(|index| unit.global_vars.get(index))
 }
 
 fn build_enum_initializer(

src/codegen/tests/initialization_test/complex_initializers.rs

@@ -1170,3 +1170,116 @@ fn override_default_initializer() {
 
     insta::assert_snapshot!(res, @r###""###);
 }
+
+#[test]
+fn var_config_aliased_variables_initialized() {
+    let res = codegen(
+        r"
+    FUNCTION_BLOCK FB 
+    VAR 
+      foo AT %I* : DINT; 
+    END_VAR
+    END_FUNCTION_BLOCK
+
+    VAR_CONFIG
+      prog.instance1.foo AT %IX1.2.1 : DINT;
+      prog.instance2.foo AT %QX1.2.2 : DINT;
+    END_VAR
+
+    PROGRAM prog 
+    VAR
+        instance1: FB;
+        instance2: FB;
+    END_VAR
+    END_PROGRAM
+        ",
+    );
+
+    insta::assert_snapshot!(res, @r###"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+
+    %FB = type { i32* }
+    %prog = type { %FB, %FB }
+
+    @__PI_1_2_1 = global i32 0, section "var-$RUSTY$__PI_1_2_1:i32"
+    @__PI_1_2_2 = global i32 0, section "var-$RUSTY$__PI_1_2_2:i32"
+    @__FB__init = unnamed_addr constant %FB zeroinitializer, section "var-$RUSTY$__FB__init:r1pi32"
+    @prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r2r1pi32r1pi32"
+
+    define void @FB(%FB* %0) section "fn-$RUSTY$FB:v" {
+    entry:
+      %foo = getelementptr inbounds %FB, %FB* %0, i32 0, i32 0
+      ret void
+    }
+
+    define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" {
+    entry:
+      %instance1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0
+      %instance2 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1
+      ret void
+    }
+    ; ModuleID = '__initializers'
+    source_filename = "__initializers"
+
+    %FB = type { i32* }
+    %prog = type { %FB, %FB }
+
+    @__FB__init = external global %FB, section "var-$RUSTY$__FB__init:r1pi32"
+    @prog_instance = external global %prog, section "var-$RUSTY$prog_instance:r2r1pi32r1pi32"
+
+    define void @__init_fb(%FB* %0) section "fn-$RUSTY$__init_fb:v[pr1pi32]" {
+    entry:
+      %self = alloca %FB*, align 8
+      store %FB* %0, %FB** %self, align 8
+      ret void
+    }
+
+    declare void @FB(%FB*) section "fn-$RUSTY$FB:v"
+
+    define void @__init_prog(%prog* %0) section "fn-$RUSTY$__init_prog:v[pr2r1pi32r1pi32]" {
+    entry:
+      %self = alloca %prog*, align 8
+      store %prog* %0, %prog** %self, align 8
+      %deref = load %prog*, %prog** %self, align 8
+      %instance1 = getelementptr inbounds %prog, %prog* %deref, i32 0, i32 0
+      call void @__init_fb(%FB* %instance1)
+      %deref1 = load %prog*, %prog** %self, align 8
+      %instance2 = getelementptr inbounds %prog, %prog* %deref1, i32 0, i32 1
+      call void @__init_fb(%FB* %instance2)
+      ret void
+    }
+
+    declare void @prog(%prog*) section "fn-$RUSTY$prog:v"
+    ; ModuleID = '__init___testproject'
+    source_filename = "__init___testproject"
+
+    %prog = type { %FB, %FB }
+    %FB = type { i32* }
+
+    @prog_instance = external global %prog, section "var-$RUSTY$prog_instance:r2r1pi32r1pi32"
+    @__FB__init = external global %FB, section "var-$RUSTY$__FB__init:r1pi32"
+    @__PI_1_2_1 = external global i32, section "var-$RUSTY$__PI_1_2_1:i32"
+    @__PI_1_2_2 = external global i32, section "var-$RUSTY$__PI_1_2_2:i32"
+
+    define void @__init___testproject() section "fn-$RUSTY$__init___testproject:v" {
+    entry:
+      call void @__init_prog(%prog* @prog_instance)
+      call void @__init___var_config()
+      ret void
+    }
+
+    define void @__init___var_config() section "fn-$RUSTY$__init___var_config:v" {
+    entry:
+      store i32* @__PI_1_2_1, i32** getelementptr inbounds (%prog, %prog* @prog_instance, i32 0, i32 0, i32 0), align 8
+      store i32* @__PI_1_2_2, i32** getelementptr inbounds (%prog, %prog* @prog_instance, i32 0, i32 1, i32 0), align 8
+      ret void
+    }
+
+    declare void @__init_prog(%prog*) section "fn-$RUSTY$__init_prog:v[pr2r1pi32r1pi32]"
+
+    declare void @prog(%prog*) section "fn-$RUSTY$prog:v"
+
+    declare void @FB(%FB*) section "fn-$RUSTY$FB:v"
+    "###);
+}

src/index/tests/index_tests.rs

@@ -2120,12 +2120,12 @@ fn var_config_hardware_address_creates_global_variable() {
             span: Range(
                 TextLocation {
                     line: 2,
-                    column: 16,
-                    offset: 40,
+                    column: 24,
+                    offset: 48,
                 }..TextLocation {
                     line: 2,
-                    column: 23,
-                    offset: 47,
+                    column: 37,
+                    offset: 61,
                 },
             ),
         },

src/lowering.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use initializers::{Init, InitAssignments, Initializers, GLOBAL_SCOPE};
 use plc_ast::{
-    ast::{AstFactory, AstNode, CompilationUnit, DataType, LinkageType, PouType},
+    ast::{AstFactory, AstNode, CompilationUnit, ConfigVariable, DataType, LinkageType, PouType},
     mut_visitor::{AstVisitorMut, WalkerMut},
     provider::IdProvider,
     visit_all_nodes_mut,
@@ -17,6 +17,7 @@ pub struct AstLowerer {
     index: Index,
     annotations: AstAnnotations,
     unresolved_initializers: Initializers,
+    var_config_initializers: Vec<AstNode>,
     units: Vec<CompilationUnit>,
     ctxt: LoweringContext,
 }
@@ -51,6 +52,7 @@ impl AstLowerer {
             index,
             annotations,
             unresolved_initializers: Initializers::new(&unresolved_initializers),
+            var_config_initializers: vec![],
             units: vec![],
             ctxt: LoweringContext::new(id_provider),
         }
@@ -61,6 +63,7 @@ impl AstLowerer {
             index: self.index,
             annotations: self.annotations,
             unresolved_initializers: self.unresolved_initializers,
+            var_config_initializers: self.var_config_initializers,
             units,
             ctxt: self.ctxt,
         }
@@ -173,7 +176,6 @@ impl AstLowerer {
     /// Updates the scope and initialized variable for struct types. Adds entries for each encountered struct
     /// (this includes POU-structs, i.e. programs, ...) to the initializer map if no entry is present
     fn update_struct_initializers(&mut self, user_type: &mut plc_ast::ast::UserTypeDeclaration) {
-        // alias == subrangetype?
         let effective_type =
             user_type.data_type.get_name().and_then(|it| self.index.find_effective_type_by_name(it));
         if let DataType::StructType { .. } = &user_type.data_type {
@@ -224,6 +226,13 @@ impl AstLowerer {
 
         self.unresolved_initializers.maybe_insert_initializer(GLOBAL_SCOPE, Some(variable.get_name()), &None);
     }
+
+    fn collect_var_config_assignments(&mut self, var_config: &[ConfigVariable]) {
+        let assignments = var_config.iter().map(|var| {
+            AstFactory::create_assignment(var.reference.clone(), var.address.clone(), self.ctxt.next_id())
+        });
+        self.var_config_initializers.extend(assignments);
+    }
 }
 
 impl AstVisitorMut for AstLowerer {
@@ -232,6 +241,7 @@ impl AstVisitorMut for AstLowerer {
     }
 
     fn visit_compilation_unit(&mut self, unit: &mut CompilationUnit) {
+        self.collect_var_config_assignments(&unit.var_config);
         unit.walk(self)
     }
 
@@ -468,7 +478,7 @@ impl LoweringContext {
         self.id_provider.clone()
     }
 
-    fn _next_id(&mut self) -> usize {
+    fn next_id(&mut self) -> usize {
         self.id_provider.next_id()
     }
 }

src/lowering/initializers.rs

@@ -11,6 +11,8 @@ use plc_source::source_location::SourceLocation;
 
 use super::AstLowerer;
 pub(crate) const GLOBAL_SCOPE: &str = "__global";
+const INIT_COMPILATION_UNIT: &str = "__initializers";
+const VAR_CONFIG_INIT: &str = "__init___var_config";
 
 /// POUs and datatypes which require initialization via generated function call.
 /// The key corresponds to the scope in which the initializers were encountered.
@@ -99,23 +101,30 @@ impl<'lwr> Init<'lwr> for Initializers {
 
 impl AstLowerer {
     pub fn lower_init_functions(mut self, init_symbol_name: &str) -> Self {
-        let res = create_init_units(&self);
+        let units = create_init_units(&self);
 
-        if let Some(init_unit) = res.into_iter().reduce(|mut acc_unit, unit| {
+        if let Some(init_unit) = units.into_iter().reduce(|mut acc_unit, unit| {
             acc_unit.import(unit);
             acc_unit
         }) {
             self.units.push(init_unit);
         }
 
-        if let Some(init_unit) = create_init_wrapper_function(&self, init_symbol_name) {
-            self.units.push(init_unit);
+        if let Some(global_init) = create_init_wrapper_function(&mut self, init_symbol_name) {
+            self.units.push(global_init);
         }
 
         self
     }
 }
 
+fn create_var_config_init(statements: Vec<AstNode>) -> CompilationUnit {
+    let loc = SourceLocation::internal_in_unit(Some(INIT_COMPILATION_UNIT));
+    let pou = new_pou(VAR_CONFIG_INIT, vec![], &loc); // this can probably just be internal
+    let implementation = new_implementation(VAR_CONFIG_INIT, statements, &loc);
+    new_unit(pou, implementation, INIT_COMPILATION_UNIT)
+}
+
 fn create_init_units(lowerer: &AstLowerer) -> Vec<CompilationUnit> {
     let lookup = lowerer.unresolved_initializers.keys().map(|it| it.as_str()).collect::<FxIndexSet<_>>();
     lowerer
@@ -207,13 +216,14 @@ fn create_init_unit(
     statements.extend(member_init_calls);
     let implementation = new_implementation(&init_fn_name, statements, location);
 
-    Some(new_unit(init_pou, implementation, "__initializers"))
+    Some(new_unit(init_pou, implementation, INIT_COMPILATION_UNIT))
 }
 
-fn create_init_wrapper_function(lowerer: &AstLowerer, init_symbol_name: &str) -> Option<CompilationUnit> {
-    if lowerer.unresolved_initializers.is_empty() {
+fn create_init_wrapper_function(lowerer: &mut AstLowerer, init_symbol_name: &str) -> Option<CompilationUnit> {
+    let skip_var_config = lowerer.var_config_initializers.is_empty();
+    if skip_var_config && lowerer.unresolved_initializers.is_empty() {
         return None;
-    }
+    };
 
     let mut id_provider = lowerer.ctxt.id_provider.clone();
     let init_pou = new_pou(init_symbol_name, vec![], &SourceLocation::internal());
@@ -272,8 +282,25 @@ fn create_init_wrapper_function(lowerer: &AstLowerer, init_symbol_name: &str) ->
 
     assignments.extend(calls);
 
+    if !skip_var_config {
+        assignments.push(AstFactory::create_call_statement(
+            create_member_reference(VAR_CONFIG_INIT, id_provider.clone(), None),
+            None,
+            id_provider.next_id(),
+            SourceLocation::internal(),
+        ));
+    };
+
     let implementation = new_implementation(init_symbol_name, assignments, &SourceLocation::internal());
-    Some(new_unit(init_pou, implementation, init_symbol_name))
+    let mut global_init = new_unit(init_pou, implementation, init_symbol_name);
+
+    if skip_var_config {
+        return Some(global_init);
+    };
+
+    let var_config_init = create_var_config_init(std::mem::take(&mut lowerer.var_config_initializers));
+    global_init.import(var_config_init);
+    Some(global_init)
 }
 
 fn new_pou(name: &str, variable_blocks: Vec<VariableBlock>, location: &SourceLocation) -> Pou {