add support for function pointers

IntegralPilot · IntegralPilot · commit b5bc18761dd5 · 2026-05-31T21:36:24.000+10:00
diff --git a/Readme.md b/Readme.md
@@ -54,6 +54,7 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 - Implementations for ADTs, including using and returning `self`, `&self`, `&mut self`
 - Traits, including dynamic dispatch (`&dyn Trait`)
 - Closures, including capturing closures
+- Function pointers
 - **Integration tests** for all features, in debug and release modes
 
 🚧 **Next Milestone:** Full support for the Rust `core` crate.
diff --git a/src/lower1/control_flow.rs b/src/lower1/control_flow.rs
@@ -608,12 +608,24 @@ pub fn convert_basic_block<'tcx>(
                         });
                     }
                 } else {
-                    // Fallback for function pointers
-                    let legacy_name = make_jvm_safe(format!("{:?}", func).as_str());
-                    instructions.push(oomir::Instruction::Call {
-                        dest: dest_var_name, // Note: Function pointers might also need Void check eventually
-                        function: legacy_name,
+                    let func_oomir_operand =
+                        convert_operand(&func, tcx, instance, mir, data_types, &mut instructions);
+
+                    let oomir_sig =
+                        super::types::fn_ptr_signature_from_ty(func_ty, tcx, data_types, instance);
+                    super::types::ensure_fn_ptr_interface(&oomir_sig, data_types);
+
+                    let effective_dest = if matches!(oomir_sig.ret.as_ref(), oomir::Type::Void) {
+                        None
+                    } else {
+                        dest_var_name.clone()
+                    };
+
+                    instructions.push(oomir::Instruction::CallIndirect {
+                        dest: effective_dest,
+                        function_ptr: Box::new(func_oomir_operand),
                         args: oomir_operands.clone(),
+                        signature: oomir_sig,
                     });
                 }
 
diff --git a/src/lower1/control_flow/rvalue.rs b/src/lower1/control_flow/rvalue.rs
diff --git a/src/lower1/types.rs b/src/lower1/types.rs
@@ -23,6 +23,69 @@ pub fn ty_is_never<'tcx>(ty: Ty<'tcx>) -> bool {
     matches!(ty.kind(), TyKind::Never)
 }
 
+pub fn fn_ptr_signature_from_ty<'tcx>(
+    ty: Ty<'tcx>,
+    tcx: TyCtxt<'tcx>,
+    data_types: &mut HashMap<String, oomir::DataType>,
+    instance_context: rustc_middle::ty::Instance<'tcx>,
+) -> oomir::Signature {
+    let sig = ty.fn_sig(tcx).skip_binder();
+    let params = sig
+        .inputs()
+        .iter()
+        .enumerate()
+        .map(|(i, ty)| {
+            (
+                format!("arg{}", i),
+                ty_to_oomir_type(*ty, tcx, data_types, instance_context),
+            )
+        })
+        .collect();
+    let ret = ty_to_oomir_type(sig.output(), tcx, data_types, instance_context);
+
+    oomir::Signature {
+        params,
+        ret: Box::new(ret),
+        is_static: true,
+    }
+}
+
+pub fn ensure_fn_ptr_interface(
+    signature: &oomir::Signature,
+    data_types: &mut HashMap<String, oomir::DataType>,
+) -> String {
+    let interface_name = signature.fn_ptr_interface_name();
+    let method_signature = signature.fn_ptr_interface_method_signature();
+
+    match data_types.get_mut(&interface_name) {
+        Some(oomir::DataType::Interface { methods }) => {
+            methods
+                .entry("call".to_string())
+                .or_insert(method_signature);
+        }
+        Some(oomir::DataType::Class { .. }) => {
+            breadcrumbs::log!(
+                breadcrumbs::LogLevel::Warn,
+                "type-mapping",
+                format!(
+                    "Function pointer interface name '{}' already exists as a class",
+                    interface_name
+                )
+            );
+        }
+        None => {
+            data_types.insert(
+                interface_name.clone(),
+                oomir::DataType::Interface {
+                    methods: HashMap::from([("call".to_string(), method_signature)]),
+                },
+            );
+        }
+    }
+
+    interface_name
+}
+
 /// Converts a Rust MIR type (`Ty`) to an OOMIR type (`oomir::Type`).
 pub fn ty_to_oomir_type<'tcx>(
     ty: Ty<'tcx>,
@@ -359,12 +422,22 @@ pub fn ty_to_oomir_type<'tcx>(
                     ExistentialPredicate::Trait(trait_ref) => {
                         let trait_name = tcx.def_path_str(trait_ref.def_id);
                         let safe_name = make_jvm_safe(&trait_name);
+                        data_types.entry(safe_name.clone()).or_insert_with(|| {
+                            oomir::DataType::Interface {
+                                methods: HashMap::new(),
+                            }
+                        });
                         resolved_types.push(oomir::Type::Interface(safe_name));
                     }
                     ExistentialPredicate::AutoTrait(def_id) => {
                         // Auto traits like Send/Sync — treat as interfaces as well.
                         let trait_name = tcx.def_path_str(def_id);
                         let safe_name = make_jvm_safe(&trait_name);
+                        data_types.entry(safe_name.clone()).or_insert_with(|| {
+                            oomir::DataType::Interface {
+                                methods: HashMap::new(),
+                            }
+                        });
                         resolved_types.push(oomir::Type::Interface(safe_name));
                     }
                     ExistentialPredicate::Projection(_) => {
@@ -428,6 +501,12 @@ pub fn ty_to_oomir_type<'tcx>(
             }
             oomir::Type::Class(safe_name)
         }
+        rustc_middle::ty::TyKind::FnPtr(_, _) => {
+            let signature =
+                fn_ptr_signature_from_ty(resolved_ty, tcx, data_types, instance_context);
+            let interface_name = ensure_fn_ptr_interface(&signature, data_types);
+            oomir::Type::Interface(interface_name)
+        }
         rustc_middle::ty::TyKind::FnDef(def_id, _args) => {
             // Named functions are Zero-Sized Types (ZSTs).
             // We generate a singleton class so generics like Map<Iter, MyFunc>
diff --git a/src/lower2/translator.rs b/src/lower2/translator.rs
@@ -2351,6 +2351,42 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
                     self.jvm_instructions.push(JI::Athrow);
                 }
             }
+            OI::CallIndirect {
+                dest,
+                function_ptr,
+                args,
+                signature,
+            } => {
+                let interface_name = signature.fn_ptr_interface_name();
+                let class_index = self.constant_pool.add_class(&interface_name)?;
+                let descriptor = signature.to_jvm_descriptor_with_explicit_params();
+                let method_ref = self.constant_pool.add_interface_method_ref(
+                    class_index,
+                    "call",
+                    &descriptor,
+                )?;
+
+                self.load_operand(function_ptr)?;
+                for arg in args.iter() {
+                    self.load_call_argument(arg)?;
+                }
+
+                let count = self.invokeinterface_count(args)?;
+                self.jvm_instructions
+                    .push(JI::Invokeinterface(method_ref, count));
+
+                if let Some(dest_var) = dest {
+                    if *signature.ret != oomir::Type::Void {
+                        self.store_result(dest_var, &signature.ret)?;
+                    }
+                } else if *signature.ret != oomir::Type::Void {
+                    match get_type_size(&signature.ret) {
+                        1 => self.jvm_instructions.push(JI::Pop),
+                        2 => self.jvm_instructions.push(JI::Pop2),
+                        _ => {}
+                    }
+                }
+            }
             OI::Move { dest, src } => {
                 // Determine the type of the VALUE being moved (from the source operand)
                 let value_type = match src {
@@ -2839,8 +2875,9 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
                 }
 
                 // 3. Emit 'invokeinterface' instruction
+                let count = self.invokeinterface_count(args)?;
                 self.jvm_instructions
-                    .push(JI::Invokeinterface(method_ref_index, args.len() as u8 + 1)); // Stack: [result]
+                    .push(JI::Invokeinterface(method_ref_index, count)); // Stack: [result]
 
                 // 4. Handle the return value
                 if let Some(dest_var) = dest {
@@ -2984,4 +3021,20 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
         }
         Ok(())
     }
+
+    fn call_argument_slot_size(operand: &oomir::Operand) -> u16 {
+        let ty = get_operand_type(operand);
+        match ty {
+            oomir::Type::Reference(inner) if inner.is_jvm_primitive() => get_type_size(&inner),
+            _ => get_type_size(&ty),
+        }
+    }
+
+    fn invokeinterface_count(&self, args: &[oomir::Operand]) -> Result<u8, jvm::Error> {
+        let slots = 1 + args.iter().map(Self::call_argument_slot_size).sum::<u16>();
+        u8::try_from(slots).map_err(|_| jvm::Error::VerificationError {
+            context: format!("Function {}", self.oomir_func.name),
+            message: format!("invokeinterface argument slot count {slots} exceeds u8 range"),
+        })
+    }
 }
diff --git a/src/oomir.rs b/src/oomir.rs
@@ -7,6 +7,7 @@ use super::lower2::BIG_INTEGER_CLASS;
 use breadcrumbs::LogLevel;
 use core::panic;
 use ristretto_classfile::attributes::Instruction as JVMInstruction;
+use sha2::Digest;
 use std::{
     collections::{HashMap, HashSet},
     fmt,
@@ -203,6 +204,33 @@ pub struct Signature {
 }
 
 impl Signature {
+    pub fn to_jvm_descriptor_with_explicit_params(&self) -> String {
+        let mut result = String::new();
+        result.push('(');
+        for (_param_name, param_type) in &self.params {
+            result.push_str(&param_type.to_jvm_descriptor());
+        }
+        result.push(')');
+        result.push_str(&self.ret.to_jvm_descriptor());
+        result
+    }
+
+    pub fn fn_ptr_interface_name(&self) -> String {
+        let descriptor = self.to_jvm_descriptor_with_explicit_params();
+        let mut hasher = sha2::Sha256::new();
+        hasher.update(descriptor.as_bytes());
+        let hash = format!("{:x}", hasher.finalize());
+        format!("FnPtr_{}", &hash[..16])
+    }
+
+    pub fn fn_ptr_interface_method_signature(&self) -> Signature {
+        Signature {
+            params: self.params.clone(),
+            ret: self.ret.clone(),
+            is_static: false,
+        }
+    }
+
     /// Replaces all occurrences of `Type::Class(old_name)` with `Type::Class(new_name)`
     /// in the signature's parameters and return type.
     /// Returns a tuple (params_changed, return_changed) indicating whether any replacements were made.
@@ -378,6 +406,12 @@ pub enum Instruction {
         function: String,     // Name of the function to call
         args: Vec<Operand>,   // Arguments to the function
     },
+    CallIndirect {
+        dest: Option<String>,       // Optional destination variable for the return value
+        function_ptr: Box<Operand>, // Operand holding the function pointer object
+        args: Vec<Operand>,         // Arguments to the function
+        signature: Signature,       // Function pointer signature
+    },
     InvokeInterface {
         class_name: String,   // JVM interface name (e.g., MyTrait)
         method_name: String,  // Name of the method to call
diff --git a/src/optimise1/dataflow.rs b/src/optimise1/dataflow.rs
@@ -929,6 +929,79 @@ pub fn process_block_instructions(
                 };
                 keep_original_instruction = true; // Always keep the call itself
             }
+            Instruction::CallIndirect {
+                dest,
+                function_ptr,
+                args,
+                signature,
+            } => {
+                // Propagate constants into function pointer and arguments
+                let new_function_ptr = match function_ptr.as_ref() {
+                    Operand::Variable { name, ty } => lookup_const(
+                        &Operand::Variable {
+                            name: name.clone(),
+                            ty: ty.clone(),
+                        },
+                        &current_state,
+                    )
+                    .map_or(function_ptr.as_ref().clone(), Operand::Constant),
+                    other => other.clone(),
+                };
+                let new_args: Vec<Operand> = args
+                    .iter()
+                    .map(|arg| {
+                        lookup_const(arg, &current_state).map_or(arg.clone(), Operand::Constant)
+                    })
+                    .collect();
+
+                // Determine if any argument could potentially have side effects
+                let mut has_potential_side_effect_arg = false;
+                for arg_operand in &new_args {
+                    let arg_type = match arg_operand {
+                        Operand::Variable { ty, .. } => Some(ty.clone()),
+                        Operand::Constant(c) => Some(Type::from_constant(c)),
+                    };
+                    if let Some(ty) = arg_type {
+                        if matches!(ty, Type::Array(_) | Type::Class(_)) {
+                            has_potential_side_effect_arg = true;
+                            break;
+                        }
+                    }
+                }
+
+                // 1. Invalidate the destination variable
+                if let Some(d) = dest {
+                    current_state.remove(d);
+                }
+
+                // 2. CONSERVATIVE INVALIDATION due to potential side effects:
+                if has_potential_side_effect_arg {
+                    let keys_to_remove: Vec<String> = current_state.iter()
+                        .filter_map(|(key, constant_val)| {
+                            match constant_val {
+                                Constant::I8(_) | Constant::I16(_) | Constant::I32(_) | Constant::I64(_) |
+                                Constant::F32(_) | Constant::F64(_) | Constant::Boolean(_) | Constant::Char(_) |
+                                Constant::String(_) => None,
+                                _ => {
+                                    breadcrumbs::log!(breadcrumbs::LogLevel::Info, "optimisation", format!("Optimizer: Invalidating potentially mutable constant '{}' due to indirect call with array/class arg.", key));
+                                    Some(key.clone())
+                                }
+                            }
+                        })
+                        .collect();
+                    for key in keys_to_remove {
+                        current_state.remove(&key);
+                    }
+                }
+
+                optimised_instruction = Instruction::CallIndirect {
+                    dest: dest.clone(),
+                    function_ptr: Box::new(new_function_ptr),
+                    args: new_args,
+                    signature: signature.clone(),
+                };
+                keep_original_instruction = true;
+            }
             Instruction::ArrayStore {
                 array,
                 index,
diff --git a/tests/binary/fn_pointers/.cargo/config.toml b/tests/binary/fn_pointers/.cargo/config.toml
@@ -0,0 +1 @@
+../../../../config.toml
diff --git a/tests/binary/fn_pointers/Cargo.lock b/tests/binary/fn_pointers/Cargo.lock
diff --git a/tests/binary/fn_pointers/Cargo.toml b/tests/binary/fn_pointers/Cargo.toml
@@ -0,0 +1,8 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "fn_pointers"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
diff --git a/tests/binary/fn_pointers/src/main.rs b/tests/binary/fn_pointers/src/main.rs
