feat: init functions for address-initialization (#1259)

Adds groundwork for initializer-function support

Author: mhasel

compiler/plc_ast/src/ast.rs

@@ -361,6 +361,32 @@ pub struct VariableBlock {
     pub location: SourceLocation,
 }
 
+impl VariableBlock {
+    pub fn with_block_type(mut self, block_type: VariableBlockType) -> Self {
+        self.variable_block_type = block_type;
+        self
+    }
+
+    pub fn with_variables(mut self, variables: Vec<Variable>) -> Self {
+        self.variables = variables;
+        self
+    }
+}
+
+impl Default for VariableBlock {
+    fn default() -> Self {
+        VariableBlock {
+            access: AccessModifier::Internal,
+            constant: false,
+            retain: false,
+            variables: vec![],
+            variable_block_type: VariableBlockType::Local,
+            linkage: LinkageType::Internal,
+            location: SourceLocation::internal(),
+        }
+    }
+}
+
 impl Debug for VariableBlock {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("VariableBlock")
@@ -401,6 +427,10 @@ impl Variable {
         };
         std::mem::replace(&mut self.data_type_declaration, new_data_type)
     }
+
+    pub fn get_name(&self) -> &str {
+        &self.name
+    }
 }
 
 #[derive(Clone, PartialEq)]

compiler/plc_ast/src/pre_processor.rs

@@ -281,7 +281,7 @@ fn replace_generic_type_name(dt: &mut DataTypeDeclaration, generics: &FxHashMap<
         },
         DataTypeDeclaration::DataTypeReference { referenced_type, .. } => {
             if let Some(type_name) = generics.get(referenced_type) {
-                *referenced_type = type_name.clone();
+                referenced_type.clone_from(type_name);
             }
         }
     }

compiler/plc_driver/src/pipelines.rs

@@ -11,10 +11,9 @@ use ast::{
     provider::IdProvider,
 };
 
-use plc::index::FxIndexSet;
 use plc::{
     codegen::{CodegenContext, GeneratedModule},
-    index::Index,
+    index::{FxIndexSet, Index},
     output::FormatOption,
     parser::parse_file,
     resolver::{AnnotationMapImpl, AstAnnotations, Dependency, StringLiterals, TypeAnnotator},
@@ -127,6 +126,7 @@ impl<T: SourceContainer + Sync> ParsedProject<T> {
         // import builtin functions
         let builtins = plc::builtins::parse_built_ins(id_provider);
         global_index.import(plc::index::visitor::visit(&builtins));
+        global_index.register_global_init_function();
 
         IndexedProject { project: ParsedProject { project: self.project, units }, index: global_index }
     }
@@ -148,7 +148,8 @@ impl<T: SourceContainer + Sync> IndexedProject<T> {
     pub fn annotate(self, mut id_provider: IdProvider) -> AnnotatedProject<T> {
         //Resolve constants
         //TODO: Not sure what we are currently doing with unresolvables
-        let (mut full_index, _unresolvables) = plc::resolver::const_evaluator::evaluate_constants(self.index);
+        let (mut full_index, unresolvables) = plc::resolver::const_evaluator::evaluate_constants(self.index);
+
         //Create and call the annotator
         let mut annotated_units = Vec::new();
         let mut all_annotations = AnnotationMapImpl::default();
@@ -171,8 +172,15 @@ impl<T: SourceContainer + Sync> IndexedProject<T> {
 
         full_index.import(std::mem::take(&mut all_annotations.new_index));
 
-        let annotations = AstAnnotations::new(all_annotations, id_provider.next_id());
+        TypeAnnotator::lower_init_functions(
+            unresolvables,
+            &mut all_annotations,
+            &mut full_index,
+            &id_provider,
+            &mut annotated_units,
+        );
 
+        let annotations = AstAnnotations::new(all_annotations, id_provider.next_id());
         AnnotatedProject {
             project: self.project.project,
             units: annotated_units,
@@ -341,7 +349,11 @@ impl<T: SourceContainer + Sync> AnnotatedProject<T> {
                         let current_dir = env::current_dir()?;
                         let current_dir = compile_options.root.as_deref().unwrap_or(&current_dir);
                         let unit_location = PathBuf::from(&unit.file_name);
-                        let unit_location = fs::canonicalize(unit_location)?;
+                        let unit_location = if unit_location.exists() {
+                            fs::canonicalize(unit_location)?
+                        } else {
+                            unit_location
+                        };
                         let output_name = if unit_location.starts_with(current_dir) {
                             unit_location.strip_prefix(current_dir).map_err(|it| {
                                 Diagnostic::new(format!(

compiler/plc_xml/src/model/pou.rs

@@ -60,7 +60,7 @@ impl<'xml> Parseable for Pou<'xml> {
                     let actions: Vec<Action<'_>> = Parseable::visit(reader, Some(tag))?;
                     for mut action in actions.into_iter() {
                         // Copy the action type names
-                        action.type_name = pou.name.clone();
+                        action.type_name.clone_from(&pou.name);
                         pou.actions.push(action);
                     }
                 }

src/builtins.rs

@@ -42,13 +42,15 @@ lazy_static! {
                 END_FUNCTION
             ",
                 annotation: None,
-                validation: None,
+                validation: Some(|validator, operator, parameters, _, _| {
+                    validate_argument_count(validator, operator, &parameters, 1);
+                }),
                 generic_name_resolver: no_generic_name_resolver,
                 code: |generator, params, location| {
                     if let [reference] = params {
                         generator
                             .generate_lvalue(reference)
-                            .map(|it| ExpressionValue::RValue(generator.ptr_as_value(it)))
+                            .map(|it| ExpressionValue::RValue(it.as_basic_value_enum()))
                     } else {
                         Err(Diagnostic::codegen_error(
                             "Expected exactly one parameter for REF",
@@ -91,16 +93,7 @@ lazy_static! {
                     );
                 }),
                 validation: Some(|validator, operator, parameters, _, _| {
-                    let Some(params) = parameters else {
-                        validator.push_diagnostic(Diagnostic::invalid_argument_count(1, 0, operator.get_location()));
-                        return;
-                    };
-
-                    let params = flatten_expression_list(params);
-
-                    if params.len() > 1 {
-                        validator.push_diagnostic(Diagnostic::invalid_argument_count(1, params.len(), operator.get_location()));
-                    }
+                    validate_argument_count(validator, operator, &parameters, 1);
                 }),
                 generic_name_resolver: no_generic_name_resolver,
                 code: |generator, params, location| {
@@ -804,6 +797,28 @@ fn validate_variable_length_array_bound_function(
     }
 }
 
+fn validate_argument_count(
+    validator: &mut Validator,
+    operator: &AstNode,
+    parameters: &Option<&AstNode>,
+    expected: usize,
+) {
+    let Some(params) = parameters else {
+        validator.push_diagnostic(Diagnostic::invalid_argument_count(expected, 0, operator.get_location()));
+        return;
+    };
+
+    let params = flatten_expression_list(params);
+
+    if params.len() != expected {
+        validator.push_diagnostic(Diagnostic::invalid_argument_count(
+            expected,
+            params.len(),
+            operator.get_location(),
+        ));
+    }
+}
+
 /// Generates the code for the LOWER- AND UPPER_BOUND built-in functions, returning an error if the function
 /// arguments are incorrect.
 fn generate_variable_length_array_bound_function<'ink>(

src/codegen/generators/data_type_generator.rs

@@ -119,6 +119,7 @@ pub fn generate_data_types<'ink>(
 
     let mut tries = 0;
     let mut errors = FxHashMap::default();
+
     // If the tries are equal to the number of types remaining, it means we failed to resolve
     // anything
     while tries < types_to_init.len() {
@@ -149,20 +150,26 @@ pub fn generate_data_types<'ink>(
     }
     //If we didn't resolve anything this cycle, report the remaining issues and exit
     if !types_to_init.is_empty() {
+        let mut init_later = 0;
         //Report each error as a new diagnostic, add the type's location as related to the error
         let diags = types_to_init
             .into_iter()
             .map(|(name, ty)| {
+                if index.type_has_init_function(name) {
+                    init_later += 1;
+                }
                 errors
                     .remove(name)
                     .map(|diag| diag.with_secondary_location(&ty.location))
                     .unwrap_or_else(|| Diagnostic::cannot_generate_initializer(name, ty.location.clone()))
             })
             .collect::<Vec<_>>();
-        //Report the operation failure
-        return Err(Diagnostic::new("Some initial values were not generated")
-            .with_error_code("E075")
-            .with_sub_diagnostics(diags));
+        if diags.len() > init_later {
+            //Report the operation failure
+            return Err(Diagnostic::new("Some initial values were not generated")
+                .with_error_code("E075")
+                .with_sub_diagnostics(diags)); // FIXME: these sub-diagnostics aren't printed to the console
+        }
     }
     Ok(generator.types_index)
 }
@@ -372,6 +379,7 @@ impl<'ink, 'b> DataTypeGenerator<'ink, 'b> {
                 self.annotations,
                 &self.types_index,
             );
+
             generator.generate_expression(initializer).map(Some).map_err(|_| {
                 Diagnostic::cannot_generate_initializer(qualified_name, initializer.get_location())
             })

src/codegen/generators/expression_generator.rs

@@ -717,7 +717,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 let assigned_output = self.generate_lvalue(expr)?;
                 let assigned_output_type =
                     self.annotations.get_type_or_void(expr, self.index).get_type_information();
-
                 let output = builder.build_struct_gep(parameter_struct, index, "").map_err(|_| {
                     Diagnostic::codegen_error(
                         format!("Cannot build generate parameter: {parameter:#?}"),

src/codegen/generators/statement_generator.rs

@@ -255,7 +255,7 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
             let expr = exp.generate_reference_expression(&data.access, data.base.as_deref(), left)?;
             expr.get_basic_value_enum().into_pointer_value()
         };
-        let right_expr_val = ref_builtin.codegen(&exp, &[&right], right.get_location())?;
+        let right_expr_val = ref_builtin.codegen(&exp, &[right], right.get_location())?;
 
         self.llvm.builder.build_store(left_ptr_val, right_expr_val.get_basic_value_enum());
         Ok(())
@@ -276,6 +276,16 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
         if left_statement.has_direct_access() {
             return self.generate_assignment_statement_direct_access(left_statement, right_statement);
         }
+
+        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())
+        }) {
+            return self.generate_ref_assignment(left_statement, right_statement);
+        };
+
         //TODO: Also hacky but for now we cannot generate assignments for hardware access
         if matches!(left_statement.get_stmt(), AstStatement::HardwareAccess { .. }) {
             return Ok(());

src/codegen/generators/variable_generator.rs

@@ -2,7 +2,12 @@
 
 /// offers operations to generate global variables
 use crate::{
-    codegen::{debug::Debug, llvm_index::LlvmTypedIndex, llvm_typesystem::cast_if_needed},
+    codegen::{
+        const_expressions::{ConstExpression, UnresolvableKind},
+        debug::Debug,
+        llvm_index::LlvmTypedIndex,
+        llvm_typesystem::cast_if_needed,
+    },
     index::{get_initializer_name, Index, PouIndexEntry, VariableIndexEntry},
     resolver::{AnnotationMap, AstAnnotations, Dependency},
 };
@@ -127,7 +132,15 @@ impl<'ctx, 'b> VariableGenerator<'ctx, 'b> {
         if linkage == LinkageType::External {
             global_ir_variable = global_ir_variable.make_external();
         } else {
-            let initial_value = if let Some(initializer) = self
+            let initial_value = if let Some(ConstExpression::Unresolvable {
+                reason: UnresolvableKind::Address { .. },
+                ..
+            }) = global_variable
+                .initial_value
+                .and_then(|it| self.global_index.get_const_expressions().find_const_expression(&it))
+            {
+                None
+            } else if let Some(initializer) = self
                 .global_index
                 .get_const_expressions()
                 .maybe_get_constant_statement(&global_variable.initial_value)
@@ -153,7 +166,6 @@ impl<'ctx, 'b> VariableGenerator<'ctx, 'b> {
             } else {
                 None
             };
-
             let initial_value = initial_value
                 // 2nd try: find an associated default value for the declared type
                 .or_else(|| self.types_index.find_associated_initial_value(type_name))

src/codegen/tests/expression_tests.rs

@@ -290,7 +290,7 @@ fn builtin_function_call_adr() {
         ",
     );
     // WHEN compiled
-    // We expect a direct conversion to lword and subsequent assignment (no call)
+    // We expect the same behaviour as if REF was called, due to the assignee being a pointer
     insta::assert_snapshot!(result);
 }