fix: Function pointer to function block body

Function pointers can now point to the body of a function block, allowing
for code execution such as
```
FUNCTION_BLOCK A
    VAR
        localState: DINT := 5;
    END_VAR

    METHOD foo
        // ...
    END_METHOD

    printf('localState = %d$N', localState);
END_FUNCTION_BLOCK

FUNCTION main
    VAR
        instanceA: A;
        fnBodyPtr: FNPTR A := ADR(A);
    END_VAR

    fnBodyPtr^(instanceA); // prints "localState = 5"
END_FUNCTION
```

Author: volsa

.vscode/launch.json

@@ -4,29 +4,31 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
-    {
-        "type": "codelldb",
-        "request": "launch",
-        "name": "Debug codelldb standard_lib",
-        "cargo": {
+        {
+            "type": "codelldb",
+            "request": "launch",
+            "name": "Debug codelldb standard_lib",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=plc",
+                    "--package=plc_driver"
+                ],
+                "filter": {
+                    "name": "plc",
+                    "kind": "bin"
+                }
+            },
+            "program": "target/debug/plc",
             "args": [
-                "build",
-                "--bin=plc",
-                "--package=plc_driver"
+                "libs/stdlib/iec61131-st/*.st"
             ],
-            "filter": {
-                "name": "plc",
-                "kind": "bin"
-            }
-        },
-        "program": "target/debug/plc",
-        "args": ["libs/stdlib/iec61131-st/*.st"],
-        "cwd": "${workspaceFolder}",
-        "env": {
-            "RUST_LOG": "rusty"
+            "cwd": "${workspaceFolder}",
+            "env": {
+                "RUST_LOG": "rusty"
+            },
+            "terminal": "integrated"
         },
-        "terminal": "integrated"
-    },
         {
             "type": "codelldb",
             "request": "launch",
@@ -43,7 +45,11 @@
                 }
             },
             "program": "target/debug/plc",
-            "args": ["target/demo.st", "-g", "-c"],
+            "args": [
+                "target/demo.st",
+                "-g",
+                "-c"
+            ],
             "cwd": "${workspaceFolder}",
             "env": {
                 "RUST_LOG": "rusty"
@@ -67,7 +73,8 @@
             },
             "args": [
                 "target/demo.st",
-                "tests/lit/util/printf.pli"
+                "tests/lit/util/printf.pli",
+                "-j=1",
             ],
             "cwd": "${workspaceFolder}",
             "env": {
@@ -107,7 +114,6 @@
             "cwd": "${workspaceFolder}",
             "program": "target/demo",
             "terminal": "integrated"
-
         }
     ]
-}
+}

compiler/plc_ast/src/ast.rs

@@ -709,6 +709,9 @@ pub enum DataType {
         /// e.g., `foo : POINTER TO DINT := ADR(stringValue)`. When true, the type of the pointer must match
         /// the referenced type exactly.
         type_safe: bool,
+
+        /// Indicates whether the pointer is a function pointer.
+        is_function: bool,
     },
     StringType {
         name: Option<String>,
@@ -1262,6 +1265,17 @@ impl AstNode {
         matches!(self.stmt, AstStatement::This)
     }
 
+    pub fn is_this_deref(&self) -> bool {
+        match &self.stmt {
+            AstStatement::ReferenceExpr(
+                ReferenceExpr { access: ReferenceAccess::Deref, base: Some(base) },
+                ..,
+            ) => base.is_this(),
+
+            _ => false,
+        }
+    }
+
     pub fn is_paren(&self) -> bool {
         matches!(self.stmt, AstStatement::ParenExpression { .. })
     }

src/builtins.rs

@@ -51,11 +51,23 @@ lazy_static! {
                 code: |generator, params, location| {
                     if let [reference] = params {
                         // Return the pointer value of a function when dealing with them, e.g. `ADR(MyFb.myMethod)`
-                        if let Some(StatementAnnotation::Function { qualified_name, .. }) = generator.annotations.get(reference) {
-                            if let Some(fn_value) = generator.llvm_index.find_associated_implementation(qualified_name) {
-                                return Ok(ExpressionValue::RValue(fn_value.as_global_value().as_pointer_value().as_basic_value_enum()));
+                        match generator.annotations.get(reference) {
+                            Some(StatementAnnotation::Function { qualified_name, .. }) => {
+                                if let Some(fn_value) = generator.llvm_index.find_associated_implementation(qualified_name) {
+                                    return Ok(ExpressionValue::RValue(fn_value.as_global_value().as_pointer_value().as_basic_value_enum()));
+                                }
                             }
-                        }
+
+                            Some(StatementAnnotation::Type { type_name }) => {
+                                if generator.index.find_type(type_name).is_some_and(|opt| opt.information.is_function_block()) {
+                                    if let Some(fn_value) = generator.llvm_index.find_associated_implementation(type_name) {
+                                        return Ok(ExpressionValue::RValue(fn_value.as_global_value().as_pointer_value().as_basic_value_enum()));
+                                    }
+                                }
+                            }
+
+                            _ => (),
+                        };
 
                         generator
                             .generate_lvalue(reference)
@@ -95,7 +107,7 @@ lazy_static! {
                     let ptr_type = resolver::add_pointer_type(
                         &mut annotator.annotation_map.new_index,
                         input_type,
-                        true
+                        true,
                     );
 
                     annotator.annotate(

src/codegen/generators/data_type_generator.rs

@@ -19,7 +19,7 @@ use inkwell::{
     values::{BasicValue, BasicValueEnum},
     AddressSpace,
 };
-use plc_ast::ast::{AstNode, AstStatement, PouType};
+use plc_ast::ast::{AstNode, AstStatement};
 use plc_ast::literals::AstLiteral;
 use plc_diagnostics::diagnostics::Diagnostic;
 use plc_source::source_location::SourceLocation;
@@ -206,10 +206,6 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
         let information = data_type.get_type_information();
         match information {
             DataTypeInformation::Struct { source, .. } => match source {
-                StructSource::Pou(PouType::Method { .. }) => {
-                    Ok(self.create_function_type(name)?.as_any_type_enum())
-                }
-
                 StructSource::Pou(..) => self
                     .types_index
                     .get_associated_pou_type(data_type.get_name())
@@ -276,7 +272,12 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
                 .and_then(|data_type| self.create_type(name, data_type)),
             DataTypeInformation::Void => Ok(get_llvm_int_type(self.llvm.context, 32, "Void").into()),
             DataTypeInformation::Pointer { inner_type_name, .. } => {
-                let inner_type = self.create_type(inner_type_name, self.index.get_type(inner_type_name)?)?;
+                let inner_type = if information.is_function_pointer() {
+                    self.create_function_type(inner_type_name)?.as_any_type_enum()
+                } else {
+                    self.create_type(inner_type_name, self.index.get_type(inner_type_name)?)?
+                };
+
                 Ok(inner_type.create_ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into())
             }
             DataTypeInformation::Generic { .. } => {
@@ -298,24 +299,37 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
 
         // Methods are defined as functions in the LLVM IR, but carry the underlying POU type as their first
         // parameter to operate on them, hence push the POU type to the very first position.
-        if let Some(PouIndexEntry::Method { parent_name, .. }) = self.index.find_pou(pou_name) {
-            let ty = self.types_index.get_associated_type(parent_name).expect("must exist");
-            let ty_ptr = ty.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into();
+        match self.index.find_pou(pou_name) {
+            Some(PouIndexEntry::Method { parent_name, .. }) => {
+                let ty = self.types_index.get_associated_type(parent_name).expect("must exist");
+                let ty_ptr = ty.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into();
+
+                parameter_types.push(ty_ptr);
+                for parameter in self.index.get_declared_parameters(pou_name) {
+                    // Instead of relying on the LLVM index, we create data-types directly in here because some of
+                    // them may not have been registered yet. For example, at the time of writing this comment the
+                    // `__auto_pointer_to_DINT` type was not present in the index for a VAR_IN_OUT parameter which
+                    // resulted in an error
+                    let ty = self.create_type(
+                        parameter.get_name(),
+                        self.index.get_type(&parameter.data_type_name).expect("must exist"),
+                    )?;
+
+                    parameter_types.push(ty.try_into().unwrap());
+                }
+            }
 
-            parameter_types.push(ty_ptr);
-        }
+            // Function blocks are a bit "weird" in that they only expect an instance argument even if they
+            // define input, output and/or inout parameters. Effectively, while being methods per-se, their
+            // calling convention differs from regular methods.
+            Some(PouIndexEntry::FunctionBlock { name, .. }) => {
+                let ty = self.types_index.get_associated_type(name).expect("must exist");
+                let ty_ptr = ty.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into();
+
+                parameter_types.push(ty_ptr);
+            }
 
-        for parameter in self.index.get_declared_parameters(pou_name) {
-            // Instead of relying on the LLVM index, we create data-types directly in here because some of
-            // them may not have been registered yet. For example, at the time of writing this comment the
-            // `__auto_pointer_to_DINT` type was not present in the index for a VAR_IN_OUT parameter which
-            // resulted in an error
-            let ty = self.create_type(
-                parameter.get_name(),
-                self.index.get_type(&parameter.data_type_name).expect("must exist"),
-            )?;
-
-            parameter_types.push(ty.try_into().unwrap());
+            _ => unreachable!("internal error, invalid method call"),
         }
 
         let fn_type = match return_type {

src/codegen/generators/expression_generator.rs

@@ -31,13 +31,12 @@ use crate::{
         llvm_typesystem::{cast_if_needed, get_llvm_int_type},
     },
     index::{
-        const_expressions::ConstId, ArgumentType, ImplementationIndexEntry, Index, PouIndexEntry,
-        VariableIndexEntry, VariableType,
+        const_expressions::ConstId, ArgumentType, ImplementationIndexEntry, ImplementationType, Index,
+        PouIndexEntry, VariableIndexEntry, VariableType,
     },
     resolver::{AnnotationMap, AstAnnotations, StatementAnnotation},
-    typesystem,
     typesystem::{
-        is_same_type_class, DataType, DataTypeInformation, DataTypeInformationProvider, Dimension,
+        self, is_same_type_class, DataType, DataTypeInformation, DataTypeInformationProvider, Dimension,
         StringEncoding, VarArgs, DINT_TYPE, INT_SIZE, INT_TYPE, LINT_TYPE,
     },
 };
@@ -596,12 +595,15 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         arguments: Option<&AstNode>,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
         let Some(ReferenceExpr { base: Some(ref base), .. }) = operator.get_deref_expr() else {
-            unreachable!("internal error, invalid function invocation")
+            unreachable!("internal error, invalid method call")
         };
 
         let qualified_pou_name = self.annotations.get(operator).unwrap().qualified_name().unwrap();
         let impl_entry = self.index.find_implementation_by_name(qualified_pou_name).unwrap();
-        debug_assert!(impl_entry.is_method(), "internal error, invalid function invocation");
+        debug_assert!(
+            impl_entry.is_method() | impl_entry.is_function_block(),
+            "internal error, invalid method call"
+        );
 
         // Get the associated variable then load it, e.g. `%localFnPtrVariable = alloca void (%Fb*)*, align 8`
         // followed by `%1 = load void (%Fb*)*, void (%Fb*)** %localFnPtrVariable, align 8``
@@ -613,27 +615,40 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         // Generate the argument list; our assumption is function pointers are only supported for methods
         // right now, hence we explicitly fetch the instance arguments from the list. In desugared code it we
         // would have something alike `fnPtr^(instanceFb, arg1, arg2, ..., argN)`
-        let arguments = {
+        let (instance, arguments_raw, arguments_llvm) = {
             let arguments = arguments.map(flatten_expression_list).unwrap_or_default();
             let (instance, arguments) = match arguments.len() {
                 0 => panic!("invalid desugared code, no instance argument found"),
-                1 => (self.generate_lvalue(arguments[0])?, [].as_slice()),
-                _ => (self.generate_lvalue(arguments[0])?, &arguments[1..]),
+                1 => (self.generate_lvalue(arguments[0])?, Vec::new()),
+                _ => (self.generate_lvalue(arguments[0])?, arguments[1..].to_vec()),
             };
 
-            let mut generated_arguments = self.generate_function_arguments(
-                self.index.find_pou(qualified_pou_name).unwrap(),
-                arguments,
-                self.index.get_declared_parameters(qualified_pou_name),
-            )?;
+            let mut generated_arguments = match &impl_entry.implementation_type {
+                ImplementationType::Method => self.generate_function_arguments(
+                    self.index.find_pou(qualified_pou_name).unwrap(),
+                    &arguments,
+                    self.index.get_declared_parameters(qualified_pou_name),
+                )?,
+
+                // Function Block body calls have a slightly different calling convention compared to regular
+                // methods. Specifically the arguments aren't passed to the call itself but rather the
+                // instance struct is gep'ed and the arguments are stored into the gep'ed pointer value.
+                // Best to call `--ir` on a simple function block body call to see the generated IR.
+                ImplementationType::FunctionBlock => {
+                    self.generate_stateful_pou_arguments(qualified_pou_name, None, instance, &arguments)?;
+                    Vec::new()
+                }
 
-            generated_arguments.insert(0, instance.as_basic_value_enum().into());
-            generated_arguments
+                _ => unreachable!("internal error, invalid method call"),
+            };
+
+            generated_arguments.insert(0, instance.clone().as_basic_value_enum().into());
+            (instance, arguments, generated_arguments)
         };
 
         // Finally generate the function pointer call
         let callable = CallableValue::try_from(function_pointer_value).unwrap();
-        let call = self.llvm.builder.build_call(callable, &arguments, "fnptr_call");
+        let call = self.llvm.builder.build_call(callable, &arguments_llvm, "fnptr_call");
 
         let value = match call.try_as_basic_value() {
             Either::Left(value) => value,
@@ -646,6 +661,12 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             }
         };
 
+        // Output variables are assigned after the function block call, effectively gep'ing the instance
+        // struct fetching the output values
+        if impl_entry.is_function_block() {
+            self.assign_output_values(instance, qualified_pou_name, arguments_raw)?
+        }
+
         Ok(ExpressionValue::RValue(value))
     }
 

src/codegen/generators/statement_generator.rs

@@ -33,6 +33,7 @@ use plc_source::source_location::SourceLocation;
 use rustc_hash::FxHashMap;
 
 /// the full context when generating statements inside a POU
+#[derive(Debug)]
 pub struct FunctionContext<'ink, 'b> {
     /// the current pou's name. This means that a variable x may refer to "`linking_context`.x"
     pub linking_context: &'b ImplementationIndexEntry,