fix: function block calls with inherited parameters

Author: volsa

compiler/plc_ast/src/ast.rs

@@ -1484,6 +1484,15 @@ impl AstNode {
     pub fn is_real(&self) -> bool {
         matches!(self.stmt, AstStatement::Literal(AstLiteral::Real(_), ..))
     }
+
+    pub fn get_name_of_lhs_of_assignment(&self) -> Option<&str> {
+        match &self.stmt {
+            AstStatement::Assignment(Assignment { left, .. })
+            | AstStatement::OutputAssignment(Assignment { left, .. })
+            | AstStatement::RefAssignment(Assignment { left, .. }) => left.get_flat_reference_name(),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

src/codegen/generators/expression_generator.rs

@@ -74,6 +74,8 @@ struct CallParameterAssignment<'a, 'b> {
     function_name: &'b str,
     /// the position of the argument in the POU's argument's list
     index: u32,
+    depth: u32,
+    arg_pou: &'b str,
     /// a pointer to the struct instance that carries the call's arguments
     parameter_struct: PointerValue<'a>,
 }
@@ -702,14 +704,18 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             let is_output = pou_info.get(index).is_some_and(|param| param.get_variable_type().is_output());
 
             if assignment_statement.is_output_assignment() || (implicit && is_output) {
+                let Some(StatementAnnotation::Argument { position, depth, pou, .. }) =
+                    self.annotations.get_hint(assignment_statement)
+                else {
+                    panic!()
+                };
+
                 self.assign_output_value(&CallParameterAssignment {
                     assignment: assignment_statement,
                     function_name,
-                    index: self
-                        .annotations
-                        .get_hint(assignment_statement)
-                        .and_then(StatementAnnotation::get_location_in_parent)
-                        .expect("arguments must have a type hint"),
+                    index: *position as u32,
+                    depth: *depth as u32,
+                    arg_pou: pou,
                     parameter_struct,
                 })?
             }
@@ -720,11 +726,9 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
 
     fn assign_output_value(&self, param_context: &CallParameterAssignment) -> Result<(), CodegenError> {
         match &param_context.assignment.stmt {
-            AstStatement::OutputAssignment(assignment) => self.generate_explicit_output_assignment(
-                param_context.parameter_struct,
-                param_context.function_name,
-                assignment,
-            ),
+            AstStatement::OutputAssignment(assignment) => {
+                self.generate_explicit_output_assignment(param_context, assignment)
+            }
 
             _ => self.generate_output_assignment(param_context),
         }
@@ -840,15 +844,23 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
     }
 
     fn generate_output_assignment(&self, context: &CallParameterAssignment) -> Result<(), CodegenError> {
-        let &CallParameterAssignment { assignment: expr, function_name, index, parameter_struct } = context;
+        let &CallParameterAssignment {
+            assignment: expr,
+            function_name,
+            index,
+            depth: _,
+            arg_pou,
+            parameter_struct,
+        } = context;
+
         let builder = &self.llvm.builder;
 
         // We don't want to generate any code if the right side of an assignment is empty, e.g. `foo(out =>)`
         if expr.is_empty_statement() {
             return Ok(());
         }
 
-        let parameter = self.index.get_declared_parameter(function_name, index).expect("must exist");
+        let parameter = self.index.get_declared_parameter(arg_pou, index).expect("must exist");
 
         match expr.get_stmt() {
             AstStatement::ReferenceExpr(_) if expr.has_direct_access() => {
@@ -889,12 +901,18 @@ 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:#?}"),
-                        &parameter.source_location,
-                    )
-                })?;
+                let output = unsafe {
+                    let mut gep_index = vec![0; (context.depth + 1) as usize];
+                    gep_index.push(context.index);
+
+                    let i32_type = self.llvm.context.i32_type();
+                    let gep_index = gep_index
+                        .into_iter()
+                        .map(|value| i32_type.const_int(value as u64, false))
+                        .collect::<Vec<_>>();
+
+                    builder.build_gep(parameter_struct, &gep_index, "").unwrap()
+                };
 
                 let output_value_type = self.index.get_type_information_or_void(parameter.get_type_name());
 
@@ -919,24 +937,21 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
 
     fn generate_explicit_output_assignment(
         &self,
-        parameter_struct: PointerValue<'ink>,
-        function_name: &str,
+        param_context: &CallParameterAssignment,
         assignment: &Assignment,
     ) -> Result<(), CodegenError> {
+        let parameter_struct = param_context.parameter_struct;
+        let function_name = param_context.function_name;
         let Assignment { left, right } = assignment;
 
-        if let Some(StatementAnnotation::Variable { qualified_name, .. }) = self.annotations.get(left) {
-            let parameter = self
-                .index
-                .find_fully_qualified_variable(qualified_name)
-                .ok_or_else(|| Diagnostic::unresolved_reference(qualified_name, left.as_ref()))?;
-            let index = parameter.get_location_in_parent();
-
+        if let Some(StatementAnnotation::Variable { .. }) = self.annotations.get(left) {
             self.generate_output_assignment(&CallParameterAssignment {
                 assignment: right,
                 function_name,
-                index,
+                index: param_context.index,
+                depth: param_context.depth,
                 parameter_struct,
+                arg_pou: param_context.arg_pou,
             })?
         };
 
@@ -1280,14 +1295,18 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             })
             .unwrap_or_else(|| vec![parameter_struct.as_basic_value_enum().into()]);
         for argument in arguments.iter() {
+            let Some(StatementAnnotation::Argument { position, depth, pou, .. }) =
+                self.annotations.get_hint(argument)
+            else {
+                panic!()
+            };
+
             let parameter = self.generate_call_struct_argument_assignment(&CallParameterAssignment {
                 assignment: argument,
                 function_name: pou_name,
-                index: self
-                    .annotations
-                    .get_hint(argument)
-                    .and_then(StatementAnnotation::get_location_in_parent)
-                    .expect("arguments must have a type hint"),
+                index: *position as u32,
+                depth: *depth as u32,
+                arg_pou: pou,
                 parameter_struct,
             })?;
             if let Some(parameter) = parameter {
@@ -1378,28 +1397,35 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         param_context: &CallParameterAssignment,
     ) -> Result<Option<BasicValueEnum<'ink>>, CodegenError> {
         let builder = &self.llvm.builder;
-        let function_name = param_context.function_name;
+        // let function_name = param_context.function_name;
         let index = param_context.index;
         let parameter_struct = param_context.parameter_struct;
         let expression = param_context.assignment;
-        if let Some(parameter) = self.index.get_declared_parameter(function_name, index) {
+
+        if let Some(parameter) = self.index.get_declared_parameter(param_context.arg_pou, index) {
             // this happens before the pou call
             // before the call statement we may only consider inputs and inouts
             // after the call we need to copy the output values to the correct assigned variables
             if matches!(parameter.get_variable_type(), VariableType::Output) {
                 return Ok(None);
             }
 
-            let pointer_to_param = builder.build_struct_gep(parameter_struct, index, "").map_err(|_| {
-                Diagnostic::codegen_error(
-                    format!("Cannot build generate parameter: {expression:#?}"),
-                    expression,
-                )
-            })?;
+            let pointer_to_param = unsafe {
+                let mut gep_index = vec![0; (param_context.depth + 1) as usize];
+                gep_index.push(param_context.index);
+
+                let i32_type = self.llvm.context.i32_type();
+                let gep_index = gep_index
+                    .into_iter()
+                    .map(|value| i32_type.const_int(value as u64, false))
+                    .collect::<Vec<_>>();
+
+                builder.build_gep(parameter_struct, &gep_index, "").unwrap()
+            };
 
             let parameter = self
                 .index
-                .find_parameter(function_name, index)
+                .find_parameter(param_context.arg_pou, index)
                 .and_then(|var| self.index.find_effective_type_by_name(var.get_type_name()))
                 .map(|var| var.get_type_information())
                 .unwrap_or_else(|| self.index.get_void_type().get_type_information());
@@ -1444,21 +1470,23 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 .index
                 .find_fully_qualified_variable(qualified_name)
                 .ok_or_else(|| Diagnostic::unresolved_reference(qualified_name, left))?;
-            let index = parameter.get_location_in_parent();
 
             // don't generate param assignments for empty statements, with the exception
             // of VAR_IN_OUT params - they need an address to point to
             let is_auto_deref = self
                 .index
                 .find_effective_type_by_name(parameter.get_type_name())
-                .map(|var| var.get_type_information())
-                .unwrap_or(self.index.get_void_type().get_type_information())
+                .map(DataType::get_type_information)
+                .unwrap_or_else(|| self.index.get_void_type().get_type_information())
                 .is_auto_deref();
+
             if !right.is_empty_statement() || is_auto_deref {
                 self.generate_call_struct_argument_assignment(&CallParameterAssignment {
                     assignment: right,
                     function_name,
-                    index,
+                    index: param_context.index,
+                    depth: param_context.depth,
+                    arg_pou: param_context.arg_pou,
                     parameter_struct,
                 })?;
             };

src/codegen/tests/directaccess_test.rs

@@ -169,7 +169,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
       %0 = bitcast %FOO* %f to i8*
       call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 getelementptr inbounds (%FOO, %FOO* @__FOO__init, i32 0, i32 0), i64 ptrtoint (%FOO* getelementptr (%FOO, %FOO* null, i32 1) to i64), i1 false)
       store i32 0, i32* %main, align 4
-      %1 = getelementptr inbounds %FOO, %FOO* %f, i32 0, i32 0
+      %1 = getelementptr %FOO, %FOO* %f, i32 0, i32 0
       %load_error_bits = load i8, i8* %error_bits, align 1
       %shift = lshr i8 %load_error_bits, 0
       %2 = and i8 %shift, 1
@@ -182,7 +182,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
       %value = shl i8 %5, 0
       %or = or i8 %erase, %value
       store i8 %or, i8* %error_bits, align 1
-      %6 = getelementptr inbounds %FOO, %FOO* %f, i32 0, i32 0
+      %6 = getelementptr %FOO, %FOO* %f, i32 0, i32 0
       %load_error_bits1 = load i8, i8* %error_bits, align 1
       %shift2 = lshr i8 %load_error_bits1, 0
       %7 = and i8 %shift2, 1
@@ -195,7 +195,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
       %value4 = shl i8 %10, 0
       %or5 = or i8 %erase3, %value4
       store i8 %or5, i8* %error_bits, align 1
-      %11 = getelementptr inbounds %FOO, %FOO* %f, i32 0, i32 0
+      %11 = getelementptr %FOO, %FOO* %f, i32 0, i32 0
       %load_error_bits6 = load i8, i8* %error_bits, align 1
       %shift7 = lshr i8 %load_error_bits6, 0
       %12 = and i8 %shift7, 1
@@ -208,7 +208,7 @@ fn direct_acess_in_output_assignment_implicit_explicit_and_mixed() {
       %value9 = shl i8 %15, 0
       %or10 = or i8 %erase8, %value9
       store i8 %or10, i8* %error_bits, align 1
-      %16 = getelementptr inbounds %FOO, %FOO* %f, i32 0, i32 0
+      %16 = getelementptr %FOO, %FOO* %f, i32 0, i32 0
       %load_error_bits11 = load i8, i8* %error_bits, align 1
       %shift12 = lshr i8 %load_error_bits11, 0
       %17 = and i8 %shift12, 1

src/codegen/tests/fnptr.rs

@@ -412,13 +412,13 @@ fn function_block_body() {
       store i32 0, i32* %localOut, align 4
       store i64 0, i64* %localInout, align 8
       %1 = load void (%A*)*, void (%A*)** %bodyPtr, align 8
-      %2 = getelementptr inbounds %A, %A* %instanceA, i32 0, i32 1
+      %2 = getelementptr %A, %A* %instanceA, i32 0, i32 1
       %load_localIn = load i16, i16* %localIn, align 2
       store i16 %load_localIn, i16* %2, align 2
-      %3 = getelementptr inbounds %A, %A* %instanceA, i32 0, i32 3
+      %3 = getelementptr %A, %A* %instanceA, i32 0, i32 3
       store i64* %localInout, i64** %3, align 8
       call void %1(%A* %instanceA)
-      %4 = getelementptr inbounds %A, %A* %instanceA, i32 0, i32 2
+      %4 = getelementptr %A, %A* %instanceA, i32 0, i32 2
       %5 = load i32, i32* %4, align 4
       store i32 %5, i32* %localOut, align 4
       ret void