Implement/add tests for wasm extern functions under same name #36104

Consider the following snippet:

constmyfunc=@extern(*constfn(...)callconv(.{.wasm_mvp=.{}})void,.{.name="myfunc",.library_name="js"});exportfnmain()void{myfunc(@as(i32,1));myfunc(@as(i32,2),@as(i32,3));}

The compiled code of this (with ReleaseSmall) converts the values a stack value and passes the pointer to javascript.

This works but requires glue code on the javascript side to decode the passed values from the pointer.

(module
 (func $js.myfunc (;0;) (import "js" "myfunc") (param i32))
 (table $table0 1 1 funcref)
 (memory $memory (;0;) (export "memory") 16)
 (global $global0 (mut i32) (i32.const 1048576))
 (func $main (;1;) (export "main")
 (local $var0 i32)
 global.get $global0
 i32.const 32
 i32.sub
 local.tee $var0
 global.set $global0
 local.get $var0
 i32.const 1
 i32.store offset=16
 local.get $var0
 i32.const 16
 i32.add
 call $js.myfunc
 local.get $var0
 i64.const 12884901890
 i64.store
 local.get $var0
 call $js.myfunc
 local.get $var0
 i32.const 32
 i32.add
 global.set $global0
 )
)

What can be done instead is to import the function twice with different names (wasm does allow you to do that) and call the function normally instead, this results in much simpler and faster codegen while at the same time requiring no extra js glue code introspecting wasm memory to function.

In this version I can map myfunc directly to console.log for example and it works as expected.

(module
 (func $js.myfunc (;0;) (import "js" "myfunc") (param i32))
 (func $js.myfunc2 (;1;) (import "js" "myfunc") (param i32 i32))
 (table $table0 1 1 funcref)
 (memory $memory (;0;) (export "memory") 16)
 (global $__stack_pointer (;0;) (mut i32) (i32.const 1048576))
 (func $main.main (;2;) (export "main")
 i32.const 1
 call $js.myfunc
 i32.const 2
 i32.const 6
 call $js.myfunc2
 )
)

Varargs exist for C ABI interop. We need to follow the C ABI when lowering this extern. You could achieve something similar by using fn myFunc(anytype) void and passing .{ a, b }, like in debug.print, then using comptime code to dispatch to what you need. However, there is still a problem, I am not sure how create duped imports.

As you say, I guess the real thing I would want out of this is the duped imports. My example was created by directly writing the wat file myself and converting it to wasm, so I have no idea how to make the imports be like that in Zig either.

Zig allows me to define two functions with different function types for the same symbol but only the first one called is what gets actually inserted into the final binary while the other call gets some sort of intermediary function to either discard or duplicate the inserted value(s).

constmyfunc1=@extern(*constfn(v:i32)callconv(.{.wasm_mvp=.{}})void,.{.name="myfunc",.library_name="js"});constmyfunc2=@extern(*constfn(v1:i32,v2:i32)callconv(.{.wasm_mvp=.{}})void,.{.name="myfunc",.library_name="js"});exportfnmain()void{myfunc1(1);myfunc2(2,3);}

(module
 (func $js.myfunc (;0;) (import "js" "myfunc") (param i32))
 (table $table0 1 1 funcref)
 (memory $memory (;0;) (export "memory") 16)
 (global $global0 (mut i32) (i32.const 1048576))
 (func $main (;1;) (export "main")
 i32.const 1
 call $js.myfunc
 i32.const 2
 i32.const 3
 call $func2
 )
 (func $func2 (param $var0 i32) (param $var1 i32)
 local.get $var0
 call $js.myfunc
 )
)

swapped myfunc1 and myfunc2 in main:

(module
 (func $js.myfunc (;0;) (import "js" "myfunc") (param i32 i32))
 (table $table0 1 1 funcref)
 (memory $memory (;0;) (export "memory") 16)
 (global $global0 (mut i32) (i32.const 1048576))
 (func $main (;1;) (export "main")
 i32.const 2
 i32.const 3
 call $js.myfunc
 i32.const 1
 call $func2
 )
 (func $func2 (param $var0 i32)
 local.get $var0
 local.get $var0
 call $js.myfunc
 )
)

Not sure if you've considered this approach. You could create wrapper around std.mem.print with a [256]u8 buffer allocated on the stack, then call js_print_buffer passing the pointer and length.

I have, not exactly with std.mem.print but something similar. I can make what I want to do work with the tools available, it would just be significantly easier and more performant with being able to dupe imports.