codegen: Generate function pointer calls

volsa · volsa · commit 77827dc37424 · 2025-08-02T20:46:18.000+02:00
diff --git a/compiler/plc_ast/src/ast.rs b/compiler/plc_ast/src/ast.rs
@@ -1397,6 +1397,16 @@ impl AstNode {
     pub fn with_metadata(self, metadata: MetaData) -> AstNode {
         AstNode { metadata: Some(metadata), ..self }
     }
+
+    pub fn get_deref_expr(&self) -> Option<&ReferenceExpr> {
+        match &self.stmt {
+            AstStatement::ReferenceExpr(expr) => match expr {
+                ReferenceExpr { access: ReferenceAccess::Deref, .. } => Some(expr),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
diff --git a/src/builtins.rs b/src/builtins.rs
@@ -50,6 +50,13 @@ lazy_static! {
                 generic_name_resolver: no_generic_name_resolver,
                 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()));
+                            }
+                        }
+
                         generator
                             .generate_lvalue(reference)
                             .map(|it| ExpressionValue::RValue(it.as_basic_value_enum()))
@@ -103,6 +110,13 @@ lazy_static! {
                 generic_name_resolver: no_generic_name_resolver,
                 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()));
+                            }
+                        }
+
                         generator
                             .generate_lvalue(reference)
                             .map(|it| ExpressionValue::RValue(it.as_basic_value_enum()))
diff --git a/src/codegen/generators/data_type_generator.rs b/src/codegen/generators/data_type_generator.rs
@@ -330,7 +330,6 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
             AnyTypeEnum::FunctionType(_) => unreachable!(),
         };
 
-        eprintln!("created function type: {}", fn_type.print_to_string());
         Ok(fn_type)
     }
 
diff --git a/src/codegen/generators/expression_generator.rs b/src/codegen/generators/expression_generator.rs
@@ -9,6 +9,7 @@ use inkwell::{
     },
     AddressSpace, FloatPredicate, IntPredicate,
 };
+use itertools::Either;
 use rustc_hash::FxHashSet;
 
 use plc_ast::{
@@ -490,8 +491,9 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         operator: &AstNode,
         parameters: Option<&AstNode>,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
+        // Check if we are dealing with something alike `foo^(...)`
         if self.annotations.get(operator).is_some_and(StatementAnnotation::is_fnptr) {
-            unimplemented!();
+            return self.generate_fnptr_call(operator, parameters);
         }
 
         // find the pou we're calling
@@ -588,6 +590,65 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         value
     }
 
+    fn generate_fnptr_call(
+        &self,
+        operator: &AstNode,
+        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")
+        };
+
+        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");
+
+        // 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``
+        let function_pointer_value = match self.generate_expression_value(base)? {
+            ExpressionValue::LValue(value) => self.llvm.load_pointer(&value, "").into_pointer_value(),
+            ExpressionValue::RValue(_) => unreachable!(),
+        };
+
+        // 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 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..]),
+            };
+
+            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),
+            )?;
+
+            generated_arguments.insert(0, instance.as_basic_value_enum().into());
+            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 value = match call.try_as_basic_value() {
+            Either::Left(value) => value,
+            Either::Right(_) => {
+                // TODO: When is this neccessary?
+                get_llvm_int_type(self.llvm.context, INT_SIZE, INT_TYPE)
+                    .ptr_type(AddressSpace::from(ADDRESS_SPACE_CONST))
+                    .const_null()
+                    .as_basic_value_enum()
+            }
+        };
+
+        Ok(ExpressionValue::RValue(value))
+    }
+
     /// copies the output values to the assigned output variables
     /// - `parameter_struct` a pointer to a struct-instance that holds all function-parameters
     /// - `function_name` the name of the callable
@@ -2614,13 +2675,32 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             }
 
             // `INT#target` (INT = base)
-            (ReferenceAccess::Cast(target), Some(_base)) => {
+            (ReferenceAccess::Cast(target), Some(base)) => {
                 if target.as_ref().is_identifier() {
                     let mr =
                         AstFactory::create_member_reference(target.as_ref().clone(), None, target.get_id());
                     self.generate_expression_value(&mr)
-                } else {
+                } else if target.as_ref().is_literal(){
                     self.generate_expression_value(target.as_ref())
+                } else {
+                    // Otherwise just bitcast the target to the given type
+                    let base_type = self.annotations.get_type_or_void(base, self.index);
+                    let base_type_name = base_type.get_name();
+
+                    // Generate the value we're casting
+                    let target_value = self.generate_expression_value(target.as_ref())?;
+
+                    // Get the LLVM type for the cast target
+                    let target_llvm_type = self.llvm_index.get_associated_type(base_type_name)
+                        .map(|t| t.ptr_type(AddressSpace::from(0)))
+                        .unwrap_or_else(|_| self.llvm.context.i8_type().ptr_type(AddressSpace::from(0)));
+
+                    // Perform the bitcast
+                    let basic_value = target_value.get_basic_value_enum();
+                    let cast_ptr = self.llvm.builder.build_bitcast(basic_value, target_llvm_type, "cast");
+                    let cast_value = ExpressionValue::RValue(cast_ptr);
+
+                    Ok(cast_value)
                 }
             }
 
diff --git a/src/codegen/llvm_index.rs b/src/codegen/llvm_index.rs
@@ -1,6 +1,6 @@
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
 use inkwell::types::{AnyTypeEnum, BasicType, BasicTypeEnum, PointerType};
-use inkwell::values::{BasicValueEnum, FunctionValue, GlobalValue, PointerValue};
+use inkwell::values::{AnyValue, BasicValueEnum, FunctionValue, GlobalValue, PointerValue};
 use inkwell::AddressSpace;
 use plc_diagnostics::diagnostics::Diagnostic;
 use plc_source::source_location::SourceLocation;
@@ -111,7 +111,10 @@ impl<'ink> LlvmTypedIndex<'ink> {
         type_name: &str,
         target_type: AnyTypeEnum<'ink>,
     ) -> Result<(), Diagnostic> {
-        self.type_associations.insert(type_name.to_lowercase(), target_type);
+        let name = type_name.to_lowercase();
+
+        log::debug!("registered `{name}` as type `{}`", target_type.print_to_string());
+        self.type_associations.insert(name, target_type);
         Ok(())
     }
 
@@ -120,7 +123,10 @@ impl<'ink> LlvmTypedIndex<'ink> {
         type_name: &str,
         target_type: AnyTypeEnum<'ink>,
     ) -> Result<(), Diagnostic> {
-        self.pou_type_associations.insert(type_name.to_lowercase(), target_type);
+        let name = type_name.to_lowercase();
+
+        log::debug!("registered `{name}` as POU type `{}`", target_type.print_to_string());
+        self.pou_type_associations.insert(name, target_type);
         Ok(())
     }
 
@@ -129,7 +135,10 @@ impl<'ink> LlvmTypedIndex<'ink> {
         type_name: &str,
         initial_value: BasicValueEnum<'ink>,
     ) -> Result<(), Diagnostic> {
-        self.initial_value_associations.insert(type_name.to_lowercase(), initial_value);
+        let name = type_name.to_lowercase();
+
+        log::debug!("registered `{name}` as initial value type `{}`", initial_value.print_to_string());
+        self.initial_value_associations.insert(name, initial_value);
         Ok(())
     }
 
@@ -139,8 +148,62 @@ impl<'ink> LlvmTypedIndex<'ink> {
         variable_name: &str,
         target_value: PointerValue<'ink>,
     ) -> Result<(), Diagnostic> {
-        let qualified_name = qualified_name(container_name, variable_name);
-        self.loaded_variable_associations.insert(qualified_name.to_lowercase(), target_value);
+        let name = qualified_name(container_name, variable_name).to_lowercase();
+
+        log::debug!("registered `{name}` as loaded local type `{}`", target_value.print_to_string());
+        self.loaded_variable_associations.insert(name, target_value);
+        Ok(())
+    }
+
+    pub fn associate_global(
+        &mut self,
+        variable_name: &str,
+        global_variable: GlobalValue<'ink>,
+    ) -> Result<(), Diagnostic> {
+        let name = variable_name.to_lowercase();
+
+        log::debug!("registered `{name}` as global variable type `{}`", global_variable.print_to_string());
+        self.global_values.insert(name.clone(), global_variable);
+        self.initial_value_associations.insert(name, global_variable.as_pointer_value().into());
+
+        // FIXME: Do we want to call .insert_new_got_index() here?
+        Ok(())
+    }
+
+    pub fn associate_implementation(
+        &mut self,
+        callable_name: &str,
+        function_value: FunctionValue<'ink>,
+    ) -> Result<(), Diagnostic> {
+        let name = callable_name.to_lowercase();
+
+        log::debug!("registered `{name}` as implementation type `{}`", function_value.print_to_string());
+        self.implementations.insert(name, function_value);
+
+        Ok(())
+    }
+
+    pub fn associate_utf08_literal(&mut self, literal: &str, literal_variable: GlobalValue<'ink>) {
+        log::debug!("registered literal {literal}");
+        self.utf08_literals.insert(literal.to_string(), literal_variable);
+    }
+
+    pub fn associate_utf16_literal(&mut self, literal: &str, literal_variable: GlobalValue<'ink>) {
+        log::debug!("registered literal {literal}");
+        self.utf16_literals.insert(literal.to_string(), literal_variable);
+    }
+
+    pub fn associate_got_index(&mut self, variable_name: &str, index: u64) -> Result<(), Diagnostic> {
+        let name = variable_name.to_lowercase();
+        self.got_indices.insert(name, index);
+
+        Ok(())
+    }
+
+    pub fn insert_new_got_index(&mut self, variable_name: &str) -> Result<(), Diagnostic> {
+        let idx = self.got_indices.values().max().copied().unwrap_or(0);
+        self.got_indices.insert(variable_name.to_lowercase(), idx);
+
         Ok(())
     }
 
@@ -192,42 +255,6 @@ impl<'ink> LlvmTypedIndex<'ink> {
             .or_else(|| self.parent_index.and_then(|it| it.find_associated_initial_value(type_name)))
     }
 
-    pub fn associate_global(
-        &mut self,
-        variable_name: &str,
-        global_variable: GlobalValue<'ink>,
-    ) -> Result<(), Diagnostic> {
-        self.global_values.insert(variable_name.to_lowercase(), global_variable);
-        self.initial_value_associations
-            .insert(variable_name.to_lowercase(), global_variable.as_pointer_value().into());
-
-        // FIXME: Do we want to call .insert_new_got_index() here?
-
-        Ok(())
-    }
-
-    pub fn associate_got_index(&mut self, variable_name: &str, index: u64) -> Result<(), Diagnostic> {
-        self.got_indices.insert(variable_name.to_lowercase(), index);
-        Ok(())
-    }
-
-    pub fn insert_new_got_index(&mut self, variable_name: &str) -> Result<(), Diagnostic> {
-        let idx = self.got_indices.values().max().copied().unwrap_or(0);
-
-        self.got_indices.insert(variable_name.to_lowercase(), idx);
-
-        Ok(())
-    }
-
-    pub fn associate_implementation(
-        &mut self,
-        callable_name: &str,
-        function_value: FunctionValue<'ink>,
-    ) -> Result<(), Diagnostic> {
-        self.implementations.insert(callable_name.to_lowercase(), function_value);
-        Ok(())
-    }
-
     pub fn find_associated_implementation(&self, callable_name: &str) -> Option<FunctionValue<'ink>> {
         self.implementations
             .get(&callable_name.to_lowercase())
@@ -260,20 +287,12 @@ impl<'ink> LlvmTypedIndex<'ink> {
         self.constants.get(qualified_name).copied()
     }
 
-    pub fn associate_utf08_literal(&mut self, literal: &str, literal_variable: GlobalValue<'ink>) {
-        self.utf08_literals.insert(literal.to_string(), literal_variable);
-    }
-
     pub fn find_utf08_literal_string(&self, literal: &str) -> Option<&GlobalValue<'ink>> {
         self.utf08_literals
             .get(literal)
             .or_else(|| self.parent_index.and_then(|it| it.find_utf08_literal_string(literal)))
     }
 
-    pub fn associate_utf16_literal(&mut self, literal: &str, literal_variable: GlobalValue<'ink>) {
-        self.utf16_literals.insert(literal.to_string(), literal_variable);
-    }
-
     pub fn find_utf16_literal_string(&self, literal: &str) -> Option<&GlobalValue<'ink>> {
         self.utf16_literals
             .get(literal)
diff --git a/src/codegen/tests.rs b/src/codegen/tests.rs
@@ -7,6 +7,7 @@ mod constants_tests;
 mod debug_tests;
 mod directaccess_test;
 mod expression_tests;
+mod fnptr;
 mod function_tests;
 mod generics_test;
 mod initialization_test;
diff --git a/src/codegen/tests/fnptr.rs b/src/codegen/tests/fnptr.rs
diff --git a/src/lowering/calls.rs b/src/lowering/calls.rs
diff --git a/src/lowering/snapshots/rusty__lowering__calls__tests__fnptr_no_argument.snap b/src/lowering/snapshots/rusty__lowering__calls__tests__fnptr_no_argument.snap

Original file line number	Diff line number	Diff line change
`@@ -330,7 +330,6 @@ impl<'ink> DataTypeGenerator<'ink, '_> {`
`330`	`330`	`AnyTypeEnum::FunctionType(_) => unreachable!(),`
`331`	`331`	`};`
`332`	`332`
`333`		`- eprintln!("created function type: {}", fn_type.print_to_string());`
`334`	`333`	`Ok(fn_type)`
`335`	`334`	`}`
`336`	`335`