externref-boxing.js

Enable keyboard shortcuts

// Moving a JS value through a wasm externref is a pair of boxing/unboxing

// conversions that leaves the value unchanged.  There are many cases,

// along these axes:

//

//  - global variables

//  - tables

//  - function parameters and returns

//  - struct fields [for the gc feature], see externref-boxing-struct.js

// Global variables can receive values via several mechanisms:

//

// - on initialization when created from JS

// - on initialization when created in Wasm, from an imported global

// - through the "value" property if the value is mutable

// - through the global.set wasm instruction, ditto

//

// Their values can be obtained in several ways:

//

// - through the "value" property

// - through the global.get wasm instruction

// - read when other globals are initialized from them

// Set via initialization and read via 'value'

for (let v of WasmExternrefValues)

    let g = new WebAssembly.Global({value: "externref"}, v);

    assertEq(g.value, v);

// Set via 'value' and read via 'value'

for (let v of WasmExternrefValues)

    let g = new WebAssembly.Global({value: "externref", mutable: true});

    g.value = v;

    assertEq(g.value, v);

// Set via initialization, then read via global.get and returned

for (let v of WasmExternrefValues)

    let g = new WebAssembly.Global({value: "externref"}, v);

    let ins = wasmEvalText(

        `(module

           (import "m" "g" (global $glob externref))

           (func (export "f") (result externref)

             (global.get $glob)))`,

        {m:{g}});

    assertEq(ins.exports.f(), v);

// Set via global.set, then read via 'value'

for (let v of WasmExternrefValues)

    let g = new WebAssembly.Global({value: "externref", mutable: true});

    let ins = wasmEvalText(

        `(module

           (import "m" "g" (global $glob (mut externref)))

           (func (export "f") (param $v externref)

             (global.set $glob (local.get $v))))`,

        {m:{g}});

    ins.exports.f(v);

    assertEq(g.value, v);

// Tables of externref can receive values via several mechanisms:

//

// - through WebAssembly.Table.prototype.set()

// - through the table.set, table.copy, and table.grow instructions

// - through table.fill

// - through WebAssembly.Table.prototype.grow()

//

// Their values can be read in several ways:

//

// - through WebAssembly.Table.prototype.get()

// - through the table.get and table.copy instructions

//

// (Note, tables are always initialized to null when created from JS)

// .set() and .get()

for (let v of WasmExternrefValues)

    let t = new WebAssembly.Table({element: "externref", initial: 10});

    t.set(3, v);

    assertEq(t.get(3), v);

// write with table.set, read with .get()

for (let v of WasmExternrefValues)

    let t = new WebAssembly.Table({element: "externref", initial: 10});

    let ins = wasmEvalText(

        `(module

           (import "m" "t" (table $t 10 externref))

           (func (export "f") (param $v externref)

             (table.set $t (i32.const 3) (local.get $v))))`,

        {m:{t}});

    ins.exports.f(v);

    assertEq(t.get(3), v);

// write with .set(), read with table.get

for (let v of WasmExternrefValues)

    let t = new WebAssembly.Table({element: "externref", initial: 10});

    let ins = wasmEvalText(

        `(module

           (import "m" "t" (table $t 10 externref))

           (func (export "f") (result externref)

             (table.get $t (i32.const 3))))`,

        {m:{t}});

    t.set(3, v);

    assertEq(ins.exports.f(), v);

// Imported JS functions can receive externref values as parameters and return

// them.

for (let v of WasmExternrefValues)

    let returner = function () { return v; };

    let receiver = function (w) { assertEq(w, v); };

    let ins = wasmEvalText(

        `(module

           (import "m" "returner" (func $returner (result externref)))

           (import "m" "receiver" (func $receiver (param externref)))

           (func (export "test_returner") (result externref)

             (call $returner))

           (func (export "test_receiver") (param $v externref)

             (call $receiver (local.get $v))))`,

        {m:{returner, receiver}});

    assertEq(ins.exports.test_returner(), v);

    ins.exports.test_receiver(v);