How is externref represented in D when target is WASM, and does it need some prior import?

[ZILtoid1991]

I wrote a short testcase for my wasmtime binding for D, that would test with class references being passed to the WASM side, then used as types for a library. The official dlang wiki does not cover it in any of its chapters about WASM (yet).

[kinke]

Would something like the sketch in https://forum.dlang.org/post/[email protected] work? A generic magic struct to be recognized by the compiler, which has an address-space number as template param, and aliases some pointer/class ref/function pointer. And then a bunch of platform-specific convenience aliases, for wasm, dcompute etc.

[ZILtoid1991]

I have tried that, I still get the following error message from wasmtime:

Failed to instantiate. Error message:
incompatible import type for `classreftest::getClassRef`

Caused by:
    types incompatible: expected type `(func (param i32))`, found type `(func (result externref))`

My code is follows as:

import ldc.attributes;

extern(C): // disable D mangling

struct __as_pointer(T, uint addressSpace) { T* ptr; alias this = ptr; }

alias ExternRef(T) = __as_pointer!(T, 10);
alias FuncRef(T) = __as_pointer!(T, 20);

struct TestClass {}

alias TestClassRef = ExternRef!TestClass;

@llvmAttr("wasm-import-module", "classreftest") {
    double foo(TestClassRef _ref);
    double bar(TestClassRef _ref, int a, int b);
    TestClassRef getClassRef();
}

@llvmAttr("wasm-import-module", "math") {
    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);
}
@llvmAttr("wasm-import-module", "display") {
    void writeInt(int var);
    void writeDouble(double var);
}

void _start() {
    auto classRef = getClassRef();
    writeDouble(foo(classRef));
    writeDouble(classRef.bar(11, 31));
}

These two ( https://github.com/ZILtoid1991/wasmtime-d/blob/731da6da7762e4974837cade4aac58242add1274/source/wasmtime_nat/wrapper.d#L1691 and https://github.com/ZILtoid1991/wasmtime-d/blob/731da6da7762e4974837cade4aac58242add1274/source/wasmtime_nat/wrapper.d#L1780 ) are responsible for the automatic function binding generation, and they're forcing classes to be externref types.

I see you're a maintainer. An ExternRef!T intrinsic or some magic struct would be a very nice addition, making the WASM compatibility of D even more up to date.

[ZILtoid1991]

Thanks to Luna, I've found this snippet:

%extern = type opaque
%externref = type %extern addrspace(10)*
define %externref @int_to_externref(i32 %i) {
  %ref = inttoptr i32 %i to %externref
  ret %externref %ref
}

I guess this wouldn't work if I put it into an LLVM IR block the very moment it escapes the scope, but how hard would it to hack it into the compiler, as an intrinsic type like:

pragma(LDC_intrinsic, "llvm.wasm.externref") {
  struct ExternRef(T) {}
}

I'm looking into forking LDC and doing it by myself. I've looked into how can I build LDC on my PC, now I just need to figure out how the compiler works, where the modification needs to be done, and in what way.

[ZILtoid1991]

Looked into the source code, and very likely I have to ammend the UDA or the pragma intrinsic system, or hack something similar to how vector types are handled (if its handled on the LDC side and not on the LLVM side).