Method exec_call_indirect

crates/tinywasm/src/interpreter/executor.rs:1032–1078

(&mut self, type_addr: u32, table_addr: u32)

    }

    fn exec_call_indirect<const IS_RETURN_CALL: bool>(&mut self, type_addr: u32, table_addr: u32) -> Result<(), Trap> {
        self.charge_call_fuel(FUEL_COST_CALL_TOTAL);

        // verify that the table is of the right type, this should be validated by the parser already
        let table_idx: u32 = <i32>::stack_pop(&mut self.store.value_stack) as u32;
        let table = self.store.state.get_table(self.module.resolve_table_addr(table_addr));
        debug_assert!(table.kind.element_type == WasmType::RefFunc, "table is not of type funcref");

        let Ok(table) = table.get(table_idx) else {
            cold_path();
            return Err(Trap::UndefinedElement { index: table_idx as usize });
        };

        let Some(func_ref) = table.addr() else {
            cold_path();
            return Err(Trap::UninitializedElement { index: table_idx as usize });
        };

        let call_ty = self.module.func_type_by_type_index(type_addr);
        match self.store.state.get_func(func_ref) {
            crate::FunctionInstance::Wasm(wasm_func) => {
                if wasm_func.ty() != call_ty {
                    cold_path();
                    return Err(Trap::IndirectCallTypeMismatch {
                        actual: wasm_func.ty().clone(),
                        expected: call_ty.clone(),
                    });
                }

                match IS_RETURN_CALL {
                    true => self.exec_return_call(wasm_func.clone(), func_ref),
                    false => self.exec_call(wasm_func.clone(), func_ref),
                }
            }
            crate::FunctionInstance::Host(host_func) => {
                if host_func.ty != *call_ty {
                    cold_path();
                    return Err(Trap::IndirectCallTypeMismatch {
                        actual: host_func.ty.clone(),
                        expected: call_ty.clone(),
                    });
                }

                self.exec_call_host(host_func.clone())
            }
        }
    }

    fn exec_return(&mut self) -> bool {
        self.store.value_stack.truncate_keep_counts(self.cf.locals_base, self.func.results);