Skip to content

Add multi-value support #330

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
tolauwae merged 10 commits into from
Apr 22, 2026
Merged

Add multi-value support #330

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
7fe98d6
feat: multivalue
abelstuker Nov 14, 2025
7507cf1
Clang format
abelstuker Nov 16, 2025
37357de
Fix printf type for int64_t in block_type fatal
abelstuker Nov 22, 2025
420f889
Fix printf type for int64_t in block_type fatal
abelstuker Nov 22, 2025
8224d3f
Fix printf type for uint32_t in block_type fatal
abelstuker Nov 22, 2025
ed9b97d
Add function spectests
abelstuker Dec 3, 2025
e9f6a5f
Re-add tests involving 64 bit values
abelstuker Apr 7, 2026
d011803
Add missing function ptrs spectests
abelstuker Apr 7, 2026
5549e1b
Add multi-value tutorial example
abelstuker Apr 7, 2026
1b1bd32
Fix overly complex WARDuino::invoke multivalue return handling
abelstuker Apr 21, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/Interpreter/instructions.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -130,9 +130,9 @@ bool i_instr_if(Module *m, uint8_t *block_ptr) {
sprintf(exception, "call stack exhausted");
return false;
}
uint32_t cond = m->stack[m->sp--].value.uint32;
m->warduino->interpreter->push_block(m, block, m->sp);
Comment thread
tolauwae marked this conversation as resolved.

uint32_t cond = m->stack[m->sp--].value.uint32;
if (cond == 0) { // if false (I32)
// branch to else block or after end of if
if (block->else_ptr == nullptr) {
Expand Down
16 changes: 8 additions & 8 deletions src/Interpreter/interpreter.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -45,20 +45,20 @@ Block *Interpreter::pop_block(Module *m) {
m->fp = frame->fp; // Restore frame pointer

// Validate the return value
if (t->result_count == 1) {
if (m->stack[m->sp].value_type != t->results[0]) {
for (uint32_t i = 0; i < t->result_count; i++) {
if (m->stack[m->sp - (t->result_count - 1 - i)].value_type !=
t->results[i]) {
sprintf(exception, "call type mismatch");
return nullptr;
}
}

// Restore stack pointer
if (t->result_count == 1) {
// Save top value as result
if (frame->sp < m->sp) {
m->stack[frame->sp + 1] = m->stack[m->sp];
m->sp = frame->sp + 1;
if (t->result_count > 0) {
for (uint32_t i = 0; i < t->result_count; i++) {
m->stack[frame->sp + 1 + i] =
m->stack[m->sp - (t->result_count - 1) + i];
}
m->sp = frame->sp + t->result_count;
} else {
if (frame->sp < m->sp) {
m->sp = frame->sp;
Expand Down
4 changes: 2 additions & 2 deletions src/WARDuino.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,8 +59,8 @@ class WARDuino {

void update_module(Module *old_module, uint8_t *wasm, uint32_t wasm_len);

bool invoke(Module *m, uint32_t fidx, uint32_t arity = 0,
StackValue *args = nullptr);
std::vector<StackValue> invoke(Module *m, uint32_t fidx, uint32_t arity = 0,
StackValue *args = nullptr);

uint32_t get_export_fidx(Module *m, const char *name);

Expand Down
67 changes: 46 additions & 21 deletions src/WARDuino/WARDuino.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -72,21 +72,33 @@ void initTypes() {
block_types[4].results = block_type_results[3];
}

Type *get_block_type(uint8_t value_type) {
switch (value_type) {
case 0x40:
return &block_types[0];
case I32:
return &block_types[1];
case I64:
return &block_types[2];
case F32:
return &block_types[3];
case F64:
return &block_types[4];
default:
FATAL("invalid block_type value_type: %d\n", value_type);
Type *get_block_type(Module *m, uint8_t type) {
uint8_t *pos = &type;
int64_t type_s = read_LEB_signed(&pos, 33);

if (type_s < 0) {
switch (type) {
case 0x40:
return &block_types[0]; // empty
case I32:
return &block_types[1];
case I64:
return &block_types[2];
case F32:
return &block_types[3];
case F64:
return &block_types[4];
default:
FATAL("invalid block_type value_type: %d\n", type);
return nullptr;
}
} else {
if ((uint32_t)type_s >= m->type_count) {
FATAL("block_type index out of bounds: %lld >= %u\n",
(long long)type_s, (unsigned int)m->type_count);
return nullptr;
}
return &m->types[type_s];
}
}

Expand Down Expand Up @@ -213,7 +225,7 @@ void find_blocks(Module *m) {
case 0x04: // if
block = (Block *)acalloc(1, sizeof(Block), "Block");
block->block_type = opcode;
block->type = get_block_type(*(pos + 1));
block->type = get_block_type(m, *(pos + 1));
block->start_ptr = pos;
blockstack[++top] = block;
m->block_lookup[pos] = block;
Expand Down Expand Up @@ -259,7 +271,7 @@ void WARDuino::run_init_expr(Module *m, uint8_t type, uint8_t **pc) {
WARDuino::instance()->program_state = WARDUINOinit;
Block block;
block.block_type = 0x01;
block.type = get_block_type(type);
block.type = get_block_type(m, type);
block.start_ptr = *pc;

m->pc_ptr = *pc;
Expand Down Expand Up @@ -908,8 +920,8 @@ WARDuino::WARDuino() {
}

// Return value of false means exception occurred
bool WARDuino::invoke(Module *m, uint32_t fidx, uint32_t arity,
StackValue *args) {
std::vector<StackValue> WARDuino::invoke(Module *m, uint32_t fidx,
uint32_t arity, StackValue *args) {
bool result;
m->sp = -1;
m->fp = -1;
Expand All @@ -927,7 +939,18 @@ bool WARDuino::invoke(Module *m, uint32_t fidx, uint32_t arity,
result = interpreter->interpret(m);
dbg_trace("Interpretation ended\n");
dbg_dump_stack(m);
return result;

if (!result) {
return {};
}

uint32_t rescount = 0;
Type *ftype = m->functions[fidx].type;
rescount = ftype->result_count;
std::vector<StackValue> out(rescount);
for (uint32_t i = 0; i < rescount; ++i)
out[i] = m->stack[m->sp - (rescount - 1) + i];
return out;
}

void WARDuino::setInterpreter(Interpreter *interpreter) {
Expand All @@ -939,9 +962,11 @@ int WARDuino::run_module(Module *m) {

// execute main
if (fidx != UNDEF) {
this->invoke(m, fidx);
return m->stack->value.uint32;
auto results = this->invoke(m, fidx);
if (results.empty()) return 0;
return (int)results[0].value.uint32;
}
fflush(stdout);

// wait
m->warduino->debugger->pauseRuntime(m);
Expand Down
108 changes: 108 additions & 0 deletions tests/latch/core/func_0.asserts.wast
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,108 @@
;; https://github.com/WebAssembly/testsuite/blob/1144e51585d4571a443dbcbb3300d8d20d9b6d4d/func.wast

(assert_return (invoke "type-use-1"))
(assert_return (invoke "type-use-2") (i32.const 0))
(assert_return (invoke "type-use-3" (i32.const 1)))
(assert_return
(invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1))
(i32.const 0)
)
(assert_return (invoke "type-use-5") (i32.const 0))
(assert_return (invoke "type-use-6" (i32.const 1)))
(assert_return
(invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1))
(i32.const 0)
)

(assert_return (invoke "local-first-i32") (i32.const 0))
(assert_return (invoke "local-first-i64") (i64.const 0))
(assert_return (invoke "local-first-f32") (f32.const 0))
(assert_return (invoke "local-first-f64") (f64.const 0))
(assert_return (invoke "local-second-i32") (i32.const 0))
(assert_return (invoke "local-second-i64") (i64.const 0))
(assert_return (invoke "local-second-f32") (f32.const 0))
(assert_return (invoke "local-second-f64") (f64.const 0))
(assert_return (invoke "local-mixed") (f64.const 0))

(assert_return (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2))
(assert_return (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2))
(assert_return (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2))
(assert_return (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2))
(assert_return (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3))
(assert_return (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3))
(assert_return (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3))
(assert_return (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3))

(assert_return (invoke "param-mixed" (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4) (f64.const 5.5) (i32.const 6)) (f64.const 5.5))

(assert_return (invoke "empty"))
(assert_return (invoke "value-void"))
(assert_return (invoke "value-i32") (i32.const 77))
(assert_return (invoke "value-i64") (i64.const 7777))
;; (assert_return (invoke "value-f32") (f32.const 77.7))
(assert_return (invoke "value-f64") (f64.const 77.77))
(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7))
(assert_return (invoke "value-i32-i32-i32") (i32.const 1) (i32.const 2) (i32.const 3))
(assert_return (invoke "value-block-void"))
(assert_return (invoke "value-block-i32") (i32.const 77))
(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2))

(assert_return (invoke "return-empty"))
(assert_return (invoke "return-i32") (i32.const 78))
(assert_return (invoke "return-i64") (i64.const 7878))
;; (assert_return (invoke "return-f32") (f32.const 78.7))
(assert_return (invoke "return-f64") (f64.const 78.78))
(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78))
(assert_return (invoke "return-i32-i32-i32") (i32.const 1) (i32.const 2) (i32.const 3))
(assert_return (invoke "return-block-i32") (i32.const 77))
(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2))

(assert_return (invoke "break-empty"))
(assert_return (invoke "break-i32") (i32.const 79))
(assert_return (invoke "break-i64") (i64.const 7979))
;; (assert_return (invoke "break-f32") (f32.const 79.9))
(assert_return (invoke "break-f64") (f64.const 79.79))
(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79))
(assert_return (invoke "break-i32-i32-i32") (i32.const 1) (i32.const 2) (i32.const 3))
(assert_return (invoke "break-block-i32") (i32.const 77))
(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2))

(assert_return (invoke "break-br_if-empty" (i32.const 0)))
(assert_return (invoke "break-br_if-empty" (i32.const 2)))
(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
(assert_return (invoke "break-br_if-num-num" (i32.const 0)) (i32.const 51) (i64.const 52))
(assert_return (invoke "break-br_if-num-num" (i32.const 1)) (i32.const 50) (i64.const 51))

(assert_return (invoke "break-br_table-empty" (i32.const 0)))
(assert_return (invoke "break-br_table-empty" (i32.const 1)))
(assert_return (invoke "break-br_table-empty" (i32.const 5)))
(assert_return (invoke "break-br_table-empty" (i32.const -1)))
(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
(assert_return (invoke "break-br_table-num-num" (i32.const 0)) (f32.const 50) (i64.const 51))
(assert_return (invoke "break-br_table-num-num" (i32.const 1)) (f32.const 50) (i64.const 51))
(assert_return (invoke "break-br_table-num-num" (i32.const 10)) (f32.const 50) (i64.const 51))
(assert_return (invoke "break-br_table-num-num" (i32.const -100)) (f32.const 50) (i64.const 51))
(assert_return (invoke "break-br_table-nested-empty" (i32.const 0)))
(assert_return (invoke "break-br_table-nested-empty" (i32.const 1)))
(assert_return (invoke "break-br_table-nested-empty" (i32.const 3)))
(assert_return (invoke "break-br_table-nested-empty" (i32.const -2)))
(assert_return (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52))
(assert_return (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50))
(assert_return (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52))
(assert_return (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52))
(assert_return (invoke "break-br_table-nested-num-num" (i32.const 0)) (i32.const 101) (i32.const 52))
(assert_return (invoke "break-br_table-nested-num-num" (i32.const 1)) (i32.const 50) (i32.const 51))
(assert_return (invoke "break-br_table-nested-num-num" (i32.const 2)) (i32.const 101) (i32.const 52))
(assert_return (invoke "break-br_table-nested-num-num" (i32.const -3)) (i32.const 101) (i32.const 52))

(assert_return (invoke "large-sig" (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3) (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7) (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11) (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15) (f32.const 16)) (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8) (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9)
(i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11) (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12))

(assert_return (invoke "init-local-i32") (i32.const 0))
(assert_return (invoke "init-local-i64") (i64.const 0))
(assert_return (invoke "init-local-f32") (f32.const 0))
(assert_return (invoke "init-local-f64") (f64.const 0))
Loading
Loading