[1/2] call_indirect implementation

codegen/masm/src/artifact.rs

@@ -13,6 +13,10 @@ use crate::{Event, lower::NativePtr, masm};
 
 pub struct MasmComponent {
     pub id: Option<builtin::ComponentId>,
+    /// True if [`Self::id`] belongs to a component the compiler invented to wrap a bare core
+    /// module, rather than one an author wrote — see
+    /// [`builtin::Component::SYNTHETIC_WRAPPER_ATTR`], which is where this comes from.
+    pub synthetic_wrapper: bool,
     /// The path of the root module for this component
     ///
     /// All components must have a canonical root module, even if empty
@@ -261,10 +265,7 @@ impl MasmComponent {
     /// a namespace, not what that namespace is, so a target that names a different one is not
     /// contradicting the file the way a component id would be.
     fn has_no_authored_identity(&self) -> bool {
-        match self.id.as_ref() {
-            Some(id) => id.is_synthetic_wrapper(),
-            None => true,
-        }
+        self.id.is_none() || self.synthetic_wrapper
     }
 
     /// Generate an executable module which when run expects the raw data segment data to be
@@ -598,15 +599,6 @@ mod tests {
 
         use super::*;
 
-        /// The identity `frontend/wasm` gives every component it wraps around a core Wasm module.
-        fn wrapper_id() -> builtin::ComponentId {
-            builtin::ComponentId {
-                namespace: Symbol::intern("root_ns"),
-                name: Symbol::intern("root"),
-                version: Version::new(1, 0, 0),
-            }
-        }
-
         /// The identity a real Wasm *component* carries, which its author chose.
         fn authored_id() -> builtin::ComponentId {
             builtin::ComponentId {
@@ -616,7 +608,22 @@ mod tests {
             }
         }
 
-        /// A component of `id`, rooted at the path that id renders to.
+        /// The component `frontend/wasm` wraps around a core Wasm module: the identity it gives
+        /// that wrapper, plus the marker saying the compiler invented it — which is what
+        /// [`MasmComponent::has_no_authored_identity`] reads. The id alone is a name an author
+        /// may write, and says nothing on its own.
+        fn wrapper_component() -> MasmComponent {
+            let id = builtin::ComponentId {
+                namespace: Symbol::intern("root_ns"),
+                name: Symbol::intern("root"),
+                version: Version::new(1, 0, 0),
+            };
+            let mut component = component(id);
+            component.synthetic_wrapper = true;
+            component
+        }
+
+        /// A component of `id` whose author wrote that id, rooted at the path it renders to.
         fn component(id: builtin::ComponentId) -> MasmComponent {
             let root_path: Arc<Path> = Arc::from(
                 id.to_library_path()
@@ -674,6 +681,7 @@ mod tests {
 
             MasmComponent {
                 id,
+                synthetic_wrapper: false,
                 root: root_path,
                 init: None,
                 entrypoint: Some(exec_target(&child_path.join(masm::Path::new("caller")))),
@@ -859,7 +867,7 @@ mod tests {
         fn a_synthetic_wrappers_library_is_rooted_at_the_target_namespace() {
             let context = context();
             let target = library_target("::example");
-            let component = component(wrapper_id());
+            let component = wrapper_component();
             let decorated = decorations(&component.modules[1], "caller");
 
             let sources = component.source_inputs(&target, context.session()).unwrap();
@@ -904,7 +912,7 @@ mod tests {
         #[test]
         fn a_library_target_named_after_the_wrapper_is_left_alone() {
             let context = context();
-            let component = component(wrapper_id());
+            let component = wrapper_component();
             let expected = paths(&component.modules[1]);
             let decorated = decorations(&component.modules[1], "caller");
             let allocations = target_allocations(&component.modules[1]);
@@ -1027,7 +1035,7 @@ mod tests {
         /// `.masm` program takes.
         #[test]
         fn an_executable_target_still_gets_the_generated_main_module() {
-            for component in [component(wrapper_id()), component_less("::init")] {
+            for component in [wrapper_component(), component_less("::init")] {
                 let context = context();
                 let expected = paths(&component.modules[1]);
                 let target = Target::executable("main", Uri::new("main.wasm"));

codegen/masm/src/emit/mod.rs

@@ -262,6 +262,9 @@ impl<'a> OpEmitter<'a> {
             masm::Instruction::SysCall(id) => {
                 self.invoked.insert(masm::Invoke::new(InvokeKind::SysCall, id.clone()));
             }
+            masm::Instruction::ProcRef(id) => {
+                self.invoked.insert(masm::Invoke::new(InvokeKind::ProcRef, id.clone()));
+            }
             _ => (),
         }
     }

codegen/masm/src/emit/primop.rs

@@ -326,6 +326,110 @@ impl OpEmitter<'_> {
         self.emit(masm::Instruction::EmitImm(Event::FrameEnd.as_event_id().as_felt().into()), span);
     }
 
+    /// Execute the procedure whose MAST root is stored in slot `index` (stack top) of a function
+    /// table with `num_slots` slots based at `base_elem_addr` (a word-aligned element address).
+    ///
+    /// Traps with an assertion failure if `index >= num_slots`, or if the slot's signature tag
+    /// differs from `type_tag` — which also covers null slots, whose tag is the reserved 0. The
+    /// callee is invoked in the same memory context as the caller (`dynexec`).
+    ///
+    /// Expects `[index, args...]` on the operand stack, with the index on top. The index is
+    /// rewritten in place to the slot's element address, which `dynexec` pops before
+    /// transferring control, so the callee observes `[args...]` in normal argument order.
+    pub fn exec_indirect(
+        &mut self,
+        num_slots: u32,
+        base_elem_addr: u32,
+        type_tag: u32,
+        signature: &Signature,
+        span: SourceSpan,
+    ) {
+        // Consume the index operand; all further effects on it are transient
+        let index = self.stack.pop().expect("operand stack is empty");
+        assert_eq!(index.ty(), Type::U32, "expected u32 table index for exec_indirect");
+
+        // Bounds check: [index, ..] -> [index < num_slots, index, ..] -> [index, ..]
+        self.emit(masm::Instruction::Dup0, span);
+        self.emit_push(num_slots, span);
+        self.emit(masm::Instruction::U32Lt, span);
+        self.emit(
+            Self::assert_with_message_inst(
+                "indirect call: function table index out of bounds",
+                span,
+            ),
+            span,
+        );
+
+        // Rewrite the index to the slot's element address: base_elem_addr + index * slot size.
+        // The felt arithmetic cannot overflow: index < num_slots, and the linker guarantees
+        // that the whole table fits in the 32-bit address space.
+        self.emit(
+            masm::Instruction::MulImm(
+                Felt::new_unchecked(crate::linker::FunctionTableLayout::SLOT_SIZE_ELEMENTS as u64)
+                    .into(),
+            ),
+            span,
+        );
+        self.emit(
+            masm::Instruction::AddImm(Felt::new_unchecked(base_elem_addr as u64).into()),
+            span,
+        );
+
+        // Signature check: the tag stored next to the slot's digest must equal the tag the call
+        // site expects. A null slot keeps the zero tag that memory is initialized with, so it
+        // can never match and traps here too.
+        // [slot_addr, ..] -> [tag_addr, slot_addr, ..] -> [tag, slot_addr, ..] -> [slot_addr, ..]
+        self.emit(masm::Instruction::Dup0, span);
+        self.emit(
+            masm::Instruction::AddImm(
+                Felt::new_unchecked(
+                    crate::linker::FunctionTableLayout::TYPE_TAG_OFFSET_ELEMENTS as u64,
+                )
+                .into(),
+            ),
+            span,
+        );
+        self.emit(masm::Instruction::MemLoad, span);
+        self.emit_push(type_tag, span);
+        self.emit(
+            Self::assert_eq_with_message_inst(
+                "indirect call: callee signature mismatch or null function reference",
+                span,
+            ),
+            span,
+        );
+
+        // Consume the arguments and produce the results on the emulated stack. Signatures for
+        // indirect calls never carry argument-extension attributes, so argument types must match
+        // the parameter types exactly. NOTE: this deliberately does not reuse
+        // `process_call_signature`: its zext/sext paths emit instructions that operate on the
+        // physical stack top, which at this point holds the transient slot address.
+        for (i, param) in signature.params.iter().enumerate() {
+            assert!(
+                matches!(param.extension(), ArgumentExtension::None),
+                "invalid exec_indirect: argument extension is not supported for parameter at \
+                 index {i}"
+            );
+            let arg = self.stack.pop().expect("operand stack is empty");
+            assert_eq!(
+                arg.ty(),
+                param.ty,
+                "invalid exec_indirect: invalid argument type for parameter at index {i}"
+            );
+        }
+        for result in signature.results.iter().rev() {
+            self.push(result.ty.clone());
+        }
+
+        // `dynexec` pops the element address and reads the callee MAST root word at it
+        self.emit(
+            masm::Instruction::EmitImm(Event::FrameStart.as_event_id().as_felt().into()),
+            span,
+        );
+        self.emit(masm::Instruction::DynExec, span);
+        self.emit(masm::Instruction::EmitImm(Event::FrameEnd.as_event_id().as_felt().into()), span);
+    }
+
     /// Execute the given procedure in a new context.
     ///
     /// A function called using this operation is invoked in a new memory context.
@@ -502,6 +606,95 @@ mod tests {
         assert_eq!(&block[0], &Op::Inst(masm::Span::new(span, masm::Instruction::Caller)));
     }
 
+    /// Pin the exact instruction sequence and stack effect of an indirect call: the bounds
+    /// check, the in-place index-to-address rewrite, the signature-tag check, and the
+    /// frame-traced `dynexec`.
+    #[test]
+    fn exec_indirect_emits_bounds_check_tag_check_and_dynexec() {
+        use midenc_hir::{CallConv, Felt};
+
+        use crate::linker::FunctionTableLayout;
+
+        let mut block = Vec::default();
+        let context = Rc::new(Context::default());
+        let mut stack = OperandStack::new(context.clone());
+        let mut invoked = BTreeSet::default();
+        let mut emitter = OpEmitter::new(&mut invoked, &mut block, &mut stack);
+
+        let signature =
+            Signature::with_convention(&context, CallConv::C, [Type::I32, Type::I32], [Type::I32]);
+
+        // The scheduled operand order is [index, args...], index on top
+        emitter.push(Type::I32);
+        emitter.push(Type::I32);
+        emitter.push(Type::U32);
+
+        let span = SourceSpan::default();
+        let num_slots = 5u32;
+        let base_elem_addr = 294912u32;
+        let type_tag = 3u32;
+        emitter.exec_indirect(num_slots, base_elem_addr, type_tag, &signature, span);
+
+        // The emulated stack holds exactly the call result
+        assert_eq!(emitter.stack_len(), 1);
+        assert_eq!(emitter.stack()[0], Type::I32);
+
+        let insts = block
+            .iter()
+            .map(|op| match op {
+                Op::Inst(inst) => inst.clone().into_inner(),
+                op => panic!("unexpected non-instruction op: {op:?}"),
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(insts.len(), 14);
+        // Bounds check: duplicate the index and assert it is in bounds
+        assert_eq!(insts[0], masm::Instruction::Dup0);
+        assert!(
+            matches!(&insts[1], masm::Instruction::Push(masm::Immediate::Value(value)) if *value.inner() == num_slots.into()),
+            "expected push of the slot count, got {:?}",
+            &insts[1]
+        );
+        assert_eq!(insts[2], masm::Instruction::U32Lt);
+        assert!(
+            matches!(&insts[3], masm::Instruction::AssertWithError(masm::Immediate::Value(msg)) if msg.inner().contains("function table index out of bounds")),
+            "expected bounds-check assertion, got {:?}",
+            &insts[3]
+        );
+        // Rewrite the index to the slot's element address
+        assert!(
+            matches!(&insts[4], masm::Instruction::MulImm(masm::Immediate::Value(value)) if *value.inner() == Felt::new_unchecked(FunctionTableLayout::SLOT_SIZE_ELEMENTS as u64)),
+            "expected multiply by the slot size, got {:?}",
+            &insts[4]
+        );
+        assert!(
+            matches!(&insts[5], masm::Instruction::AddImm(masm::Immediate::Value(value)) if *value.inner() == Felt::new_unchecked(base_elem_addr as u64)),
+            "expected add of the table base address, got {:?}",
+            &insts[5]
+        );
+        // Signature check: load the slot's tag and assert it matches the expected tag
+        assert_eq!(insts[6], masm::Instruction::Dup0);
+        assert!(
+            matches!(&insts[7], masm::Instruction::AddImm(masm::Immediate::Value(value)) if *value.inner() == Felt::new_unchecked(FunctionTableLayout::TYPE_TAG_OFFSET_ELEMENTS as u64)),
+            "expected add of the tag offset, got {:?}",
+            &insts[7]
+        );
+        assert_eq!(insts[8], masm::Instruction::MemLoad);
+        assert!(
+            matches!(&insts[9], masm::Instruction::Push(masm::Immediate::Value(value)) if *value.inner() == type_tag.into()),
+            "expected push of the expected signature tag, got {:?}",
+            &insts[9]
+        );
+        assert!(
+            matches!(&insts[10], masm::Instruction::AssertEqWithError(masm::Immediate::Value(msg)) if msg.inner().contains("callee signature mismatch")),
+            "expected signature-check assertion, got {:?}",
+            &insts[10]
+        );
+        // Frame-traced dynexec, which itself pops the slot address
+        assert!(matches!(&insts[11], masm::Instruction::EmitImm(_)));
+        assert_eq!(insts[12], masm::Instruction::DynExec);
+        assert!(matches!(&insts[13], masm::Instruction::EmitImm(_)));
+    }
+
     #[test]
     fn clk_emits_vm_instruction_and_pushes_felt() {
         let mut block = Vec::default();