COMMIT_MESSAGE

wasm->wasm

Changes to the WebAssembly implementation:

  - Add a new JSType for WebAssemblyFunction, and use it when creating its

    structure. This will be used to quickly detect from wasm whether the import

    call is to another wasm module, or whether it's to JS.

  - Use cell instead of objects to detect wasm->wasm, the previous code was wrong.

  - Improve diagnostic printout for wasm stubs: print the full signature.

  - Properly check that wasm -> wasm calls have matching signatures. Add testing for this.

  - Test some of the wasm -> wasm calls, not working yet, and more tests need to

    get implemented.

  - Generate two stubs from the import stub generator: one for wasm->JS and one

    for wasm -> wasm. This is done at Module time. Which is called will only be

    known at Instance time, once we've received the import object. We want to

    avoid codegen at Instance time, so having both around is great.

  - Restore the WebAssembly global state (VM top Instance, and pinned registers)

    after call / call_indirect, and in the JS->wasm entry stub.

Support changes:

  - Add a Proxy to Builder.js, which intercepts unknown property lookups. This

    creates way better error messages on typos than 'undefined is not a

    function', which happens semi-frequently as I typo opcode names (and which

    one is a typo is hard to find because we chain builders).

  - Add limited support for var{u}int64 (only the 32-bit values).

  - Get rid of much of the function index space: we already have all of its

    information elsewhere, and as-is it provides no extra efficiency.

  - Store Wasm::Memory directly on JSWebAssemblyMemory, instead of through a

    unique_ptr. This removes an indirection and useless allocation.

  - Remove VM'a WebAssembly memory / size, and obtain them from Instance

    instead. This requires an extra indirection, but is cleaner.

JSTests/wasm/Builder.js

@@const _isValidValue = (value, type) => {

    switch (type) {

    // We allow both signed and unsigned numbers.

    case "i32": return Math.round(value) === value && LLB.varint32Min <= value && value <= LLB.varuint32Max;

41 case "i64": th~~row~~ ~~new Error(`Unimplemented: value check for ${type}`)~~; // FIXME https://bugs.webkit.org/show_bug.cgi?id=163420 64-bit values

41 case "i64": return true; // FIXME https://bugs.webkit.org/show_bug.cgi?id=163420 64-bit values

    case "f32": return typeof(value) === "number" && isFinite(value);

    case "f64": return typeof(value) === "number" && isFinite(value);

    default: throw new Error(`Implementation problem: unknown type ${type}`);

@@const _normalizeFunctionSignature = (params, ret) => {

    return [params, ret];

};

const _errorHandlingProxyFor = builder => builder["__isProxy"] ? builder : new Proxy(builder, {

    get: (target, property, receiver) => {

        if (property === "__isProxy")

            return true;

        if (target[property] === undefined)

            throw new Error(`WebAssembly builder received unknown property '${property}'`);

        return target[property];

    }

});

const _maybeRegisterType = (builder, type) => {

    const typeSection = builder._getSection("Type");

    if (typeof(type) === "number") {

@@const _importFunctionContinuation = (builder, section, nextBuilder) => {

        section.data.push({ field: field, type: type, kind: "Function", module: module });

        // Imports also count in the function index space. Map them as objects to avoid clashing with Code functions' names.

        builder._registerFunctionToIndexSpace({ module: module, field: field });

103 return nextBuilder;

113 return _errorHandlingProxyFor(nextBuilder);

    };

};

@@const _importMemoryContinuation = (builder, section, nextBuilder) => {

        assert.isString(module, `Import Memory module should be a string, got "${module}"`);

        assert.isString(field, `Import Memory field should be a string, got "${field}"`);

        section.data.push({module, field, kind: "Memory", memoryDescription: {initial, maximum}});

112 return nextBuilder;

122 return _errorHandlingProxyFor(nextBuilder);

    };

};

@@const _importTableContinuation = (builder, section, nextBuilder) => {

        assert.isString(module, `Import Table module should be a string, got "${module}"`);

        assert.isString(field, `Import Table field should be a string, got "${field}"`);

        section.data.push({module, field, kind: "Table", tableDescription: {initial, maximum, element}});

121 return nextBuilder;

131 return _errorHandlingProxyFor(nextBuilder);

    };

};

@@const _exportFunctionContinuation = (builder, section, nextBuilder) => {

                assert.eq(type, exportedImport.type, `Re-exporting import "${exportedImport.field}" as "${field}" has mismatching type`);

        }

        section.data.push({ field: field, type: type, kind: "Function", index: index });

175 return nextBuilder;

185 return _errorHandlingProxyFor(nextBuilder);

    };

};

@@const _exportGlobalContinuation = (builder, section, nextBuilder) => {

    return (field, index) => {

        assert.isNumber(index, `Global exports only support number indices right now`);

        section.data.push({ field, kind: "Global", index });

192 return nextBuilder;

202 return _errorHandlingProxyFor(nextBuilder);

    }

};

@@const _exportMemoryContinuation = (builder, section, nextBuilder) => {

    return (field, index) => {

        assert.isNumber(index, `Memory exports only support number indices`);

        section.data.push({field, kind: "Memory", index});

200 return nextBuilder;

210 return _errorHandlingProxyFor(nextBuilder);

    }

};

@@const _exportTableContinuation = (builder, section, nextBuilder) => {

    return (field, index) => {

        assert.isNumber(index, `Table exports only support number indices`);

        section.data.push({field, kind: "Table", index});

208 return nextBuilder;

218 return _errorHandlingProxyFor(nextBuilder);

    }

};

@@const _importGlobalContinuation = (builder, section, nextBuilder) => {

                assert.isString(field, `Import global field should be a string, got "${field}"`);

                assert.isString(mutability, `Import global mutability should be a string, got "${mutability}"`);

                section.data.push({ globalDescription: { type: op, mutability: _normalizeMutability(mutability) }, module, field, kind: "Global" });

223 return globalBuilder;

233 return _errorHandlingProxyFor(globalBuilder);

224234 };

225235 }

226 return globalBuilder;

236 return _errorHandlingProxyFor(globalBuilder);

    };

};

@@const _createFunctionBuilder = (func, builder, previousBuilder) => {

            default:

                nextBuilder = functionBuilder;

                break;

327 case "End":

337 case "End":

328338 nextBuilder = previousBuilder;

329 break;

339 break;

330340 case "Block":

331 case "Loop":

341 case "Loop":

            case "If":

                nextBuilder = _createFunctionBuilder(func, builder, functionBuilder);

                break;

@@const _createFunctionBuilder = (func, builder, previousBuilder) => {

            const stackArgs = []; // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706

            func.code.push({ name: op, value: value, arguments: stackArgs, immediates: imms });

            if (hasContinuation)

347 return continuation(nextBuilder).End();

348 return nextBuilder;

357 return _errorHandlingProxyFor(continuation(nextBuilder).End());

358 return _errorHandlingProxyFor(nextBuilder);

349359 };

350 }

351 return functionBuilder;

    };

    return _errorHandlingProxyFor(functionBuilder);

}

const _createFunction = (section, builder, previousBuilder) => {

@@export default class Builder {

                        Func: (params, ret) => {

                            [params, ret] = _normalizeFunctionSignature(params, ret);

                            s.data.push({ params: params, ret: ret });

452 return typeBuilder;

463 return _errorHandlingProxyFor(typeBuilder);

453464 },

454465 };

455 return typeBuilder;

466 return _errorHandlingProxyFor(typeBuilder);

                };

                break;

@@export default class Builder {

                    importBuilder.Function = _importFunctionContinuation(this, s, importBuilder);

                    importBuilder.Memory = _importMemoryContinuation(this, s, importBuilder);

                    importBuilder.Table = _importTableContinuation(this, s, importBuilder);

469 return importBuilder;

480 return _errorHandlingProxyFor(importBuilder);

                };

                break;

@@export default class Builder {

                        End: () => this

                        // FIXME: add ability to add this with whatever.

                    };

480 return functionBuilder;

491 return _errorHandlingProxyFor(functionBuilder);

                };

                break;

@@export default class Builder {

                        End: () => this,

                        Table: ({initial, maximum, element}) => {

                            s.data.push({tableDescription: {initial, maximum, element}});

491 return tableBuilder;

502 return _errorHandlingProxyFor(tableBuilder);

492503 }

493504 };

494 return tableBuilder;

505 return _errorHandlingProxyFor(tableBuilder);

                };

                break;

@@export default class Builder {

                        End: () => this,

                        InitialMaxPages: (initial, max) => {

                            s.data.push({ initial, max });

505 return memoryBuilder;

516 return _errorHandlingProxyFor(memoryBuilder);

506517 }

507518 };

508 return memoryBuilder;

519 return _errorHandlingProxyFor(memoryBuilder);

                };

                break;

@@export default class Builder {

                        End: () => this,

                        GetGlobal: (type, initValue, mutability) => {

                            s.data.push({ type, op: "get_global", mutability: _normalizeMutability(mutability), initValue });

519 return globalBuilder;

530 return _errorHandlingProxyFor(globalBuilder);

                        }

                    };

                    for (let op of WASM.description.value_type) {

                        globalBuilder[_toJavaScriptName(op)] = (initValue, mutability) => {

                            s.data.push({ type: op, op: op + ".const", mutability: _normalizeMutability(mutability), initValue });

525 return globalBuilder;

536 return _errorHandlingProxyFor(globalBuilder);

526537 };

527538 }

528 return globalBuilder;

539 return _errorHandlingProxyFor(globalBuilder);

                };

                break;

@@export default class Builder {

                    exportBuilder.Function = _exportFunctionContinuation(this, s, exportBuilder);

                    exportBuilder.Memory = _exportMemoryContinuation(this, s, exportBuilder);

                    exportBuilder.Table = _exportTableContinuation(this, s, exportBuilder);

542 return exportBuilder;

553 return _errorHandlingProxyFor(exportBuilder);

                };

                break;

@@export default class Builder {

                    if (typeof(functionIndexOrName) !== "number" && typeof(functionIndexOrName) !== "string")

                        throw new Error(`Start section's function index  must either be a number or a string`);

                    s.data.push(functionIndexOrName);

555 return startBuilder;

566 return _errorHandlingProxyFor(startBuilder);

                };

                break;

@@export default class Builder {

                        End: () => this,

                        Element: ({tableIndex = 0, offset, functionIndices}) => {

                            s.data.push({tableIndex, offset, functionIndices});

566 return elementBuilder;

577 return _errorHandlingProxyFor(elementBuilder);

                        }

                    };

570 return elementBuilder;

581 return _errorHandlingProxyFor(elementBuilder);

                };

                break;

@@export default class Builder {

                                    // FIXME in checked mode, test that the type is acceptable for start function. We probably want _registerFunctionToIndexSpace to also register types per index. https://bugs.webkit.org/show_bug.cgi?id=165658

                                }

                            }

635 return builder;

646 return _errorHandlingProxyFor(builder);

                        },

                    };

                    codeBuilder.Function = _createFunction(s, builder, codeBuilder);

640 return codeBuilder;

651 return _errorHandlingProxyFor(codeBuilder);

                };

                break;

@@export default class Builder {

                                Index: index => {

                                    assert.eq(index, 0); // Linear memory index must be zero in MVP.

                                    thisSegment.index = index;

663 return segmentBuilder;

674 return _errorHandlingProxyFor(segmentBuilder);

                                },

                                Offset: offset => {

                                    // FIXME allow complex init_expr here. https://bugs.webkit.org/show_bug.cgi?id=165700

                                    assert.isNumber(offset);

                                    thisSegment.offset = offset;

669 return segmentBuilder;

680 return _errorHandlingProxyFor(segmentBuilder);

670681 },

671682 };

672 return segmentBuilder;

683 return _errorHandlingProxyFor(segmentBuilder);

673684 },

674685 };

675 return dataBuilder;

686 return _errorHandlingProxyFor(dataBuilder);

                };

                break;

@@export default class Builder {

                Byte: b => {

                    assert.eq(b & 0xFF, b, `Unknown section expected byte, got: "${b}"`);

                    s.data.push(b);

693 return unknownBuilder;

704 return _errorHandlingProxyFor(unknownBuilder);

694705 }

695706 };

696 return unknownBuilder;

707 return _errorHandlingProxyFor(unknownBuilder);

        };

    }

    _addSection(nameOrNumber, extraObject) {

JSTests/wasm/LowLevelBinary.js

@@export default class LowLevelBinary {

            this.uint8(0x80 | b);

        } while (true);

    }

    varuint64(v) {

        assert.isNumber(v);

        if (v < varuint32Min || varuint32Max < v)

            throw new RangeError(`unimplemented: varuint64 larger than 32-bit`);

        this.varuint32(v); // FIXME implement 64-bit var{u}int https://bugs.webkit.org/show_bug.cgi?id=163420

    }

    varint64(v) {

        assert.isNumber(v);

        if (v < varint32Min || varint32Max < v)

            throw new RangeError(`unimplemented: varint64 larger than 32-bit`);

        this.varint32(v); // FIXME implement 64-bit var{u}int https://bugs.webkit.org/show_bug.cgi?id=163420

    }

    varuint1(v) {

        if (v !== 0 && v !== 1)

            throw new RangeError(`Invalid varuint1 ${v} range is [0, 1]`);

JSTests/wasm/function-tests/exceptions.js

@@function makeInstance() {

    assert.eq(table.get(0), null);

    for (let i = 0; i < 1000; i++) {

48 assert.throws(() => foo(0, i), WebAssembly.RuntimeError, "call_indirect to a null table entry ~~(evaluating 'func(...args)')~~");

48 assert.throws(() => foo(0, i), WebAssembly.RuntimeError, "call_indirect to a null table entry");

    }

    table.set(0, foo);

    assert.eq(table.get(0), foo);

    for (let i = 0; i < 1000; i++) {

55 assert.throws(() => foo(1 + i, i), WebAssembly.RuntimeError, "Out of bounds call_indirect ~~(evaluating 'func(...args)')~~");

55 assert.throws(() => foo(1 + i, i), WebAssembly.RuntimeError, "Out of bounds call_indirect");

    }

    for (let i = 0; i < 1000; i++) {

59 assert.throws(() => foo(0, i), WebAssembly.RuntimeError, "call_indirect to a signature that does not match ~~(evaluating 'func(...args)')~~");

59 assert.throws(() => foo(0, i), WebAssembly.RuntimeError, "call_indirect to a signature that does not match");

    }

    table.set(0, bar);

JSTests/wasm/function-tests/trap-load.js

@@function wasmFrameCountFromError(e) {

}

for (let i = 0; i < 1000; i++) {

32 const e = assert.throws(() => foo(numPages * pageSize + 1), WebAssembly.RuntimeError, "Out of bounds memory access ~~(evaluating 'func(...args)')~~");

32 const e = assert.throws(() => foo(numPages * pageSize + 1), WebAssembly.RuntimeError, "Out of bounds memory access");

3333 assert.eq(wasmFrameCountFromError(e), 2);

3434}

JSTests/wasm/function-tests/trap-store.js

@@const numPages = 10;

    const foo = new WebAssembly.Instance(module, {a: {b: new WebAssembly.Memory({initial: numPages})}}).exports.foo;

    for (let i = 0; i < 10000; i++)

28 assert.throws(() => foo(i, numPages * pageSize + 1), WebAssembly.RuntimeError, "Out of bounds memory access ~~(evaluating 'func(...args)')~~");

28 assert.throws(() => foo(i, numPages * pageSize + 1), WebAssembly.RuntimeError, "Out of bounds memory access");

2929}

JSTests/wasm/js-api/wasm-to-wasm-bad-signature.js

import * as assert from '../assert.js';

import Builder from '../Builder.js';

const importName = "pierOne";

const types = ["i32", "i64", "f32", "f64", "void"];

const typesNonVoid = ["i32", "i64", "f32", "f64"];

const swapType = (type, index) => types[(types.indexOf(type) + index) % types.length];

const swapTypeNonVoid = (type, index) => typesNonVoid[(typesNonVoid.indexOf(type) + index) % typesNonVoid.length];

const signatures = [

    { params: ["i32"], ret: "void" },

    { params: ["i64"], ret: "void" },

    { params: ["f32"], ret: "void" },

    { params: ["f64"], ret: "void" },

    { params: ["i32"], ret: "i32" },

    { params: ["i64"], ret: "i64" },

    { params: ["f32"], ret: "f32" },

    { params: ["f64"], ret: "f64" },

    { params: ["i32", "f32"], ret: "i32" },

    { params: ["f32", "i32"], ret: "i32" },

    { params: ["i64", "f64"], ret: "i64" },

    { params: ["f64", "i64"], ret: "i64" },

    { params: ["i32", "f32", "i32"], ret: "i32" },

    { params: ["i32", "f32", "i32"], ret: "i32" },

    { params: ["i64", "f64", "i64"], ret: "i64" },

    { params: ["i64", "f64", "i64"], ret: "i64" },

    { params: Array(32).fill("i32"), ret: "i64" },

    { params: Array(32).fill("i64"), ret: "i64" },

    { params: Array(32).fill("f32"), ret: "i64" },

    { params: Array(32).fill("f64"), ret: "i64" },

];

const makeImporter = signature => {

    const builder = (new Builder())

        .Type().End()

        .Import().Function("exports", importName, signature).End();

    return new WebAssembly.Module(builder.WebAssembly().get());

};

const makeImportee = signature => {

    const builder = (new Builder())

        .Type().End()

        .Function().End()

        .Export()

            .Function(importName)

        .End()

        .Code()

            .Function(importName, signature);

    switch (signature.ret) {

    case "i32": builder.I32Const(0); break;

    case "i64": builder.I64Const(0); break;

    case "f32": builder.F32Const(0); break;

    case "f64": builder.F64Const(0); break;

    case "void": break;

    }

    return new WebAssembly.Instance(new WebAssembly.Module(builder.Return().End().End().WebAssembly().get()));

};

(function BadSignatureDropStartParams() {

    for (let signature of signatures) {

        const importee = makeImportee(signature);

        for (let i = 1; i <= signature.params.length; ++i) {

            const badParamSignature = { params: signature.params.slice(i, signature.params.length), ret: signature.ret };

            const importer = makeImporter(badParamSignature);

            assert.throws(() => new WebAssembly.Instance(importer, importee), WebAssembly.LinkError, `imported function's signature mismatches the provided WebAssembly function's signature (evaluating 'new WebAssembly.Instance(importer, importee)')`);

        }

    }

})();

(function BadSignatureDropEndParams() {

    for (let signature of signatures) {

        const importee = makeImportee(signature);

        for (let i = 1; i < signature.params.length; ++i) {

            const badParamSignature = { params: signature.params.slice(0, i), ret: signature.ret };

            const importer = makeImporter(badParamSignature);

            assert.throws(() => new WebAssembly.Instance(importer, importee), WebAssembly.LinkError, `imported function's signature mismatches the provided WebAssembly function's signature (evaluating 'new WebAssembly.Instance(importer, importee)')`);

        }

    }

})();

(function BadSignatureSwapParam() {

    for (let signature of signatures) {

        const importee = makeImportee(signature);

        for (let signatureIndex = 0; signatureIndex < signature.length; ++signatureIndex) {

            for (let typeIndex = 1; typeIndex < typesNonVoid.length; ++typeIndex) {

                let badParams = signature.params.slice();

                badParams[signatureIndex] = swapTypeNonVoid(badParams[signatureIndex], typeIndex);

                const badParamSignature = { params: badParams, ret: signature.ret };

                const importer = makeImporter(badParamSignature);

                assert.throws(() => new WebAssembly.Instance(importer, importee), WebAssembly.LinkError, `imported function's signature mismatches the provided WebAssembly function's signature (evaluating 'new WebAssembly.Instance(importer, importee)')`);

            }

        }

    }

})();

(function BadSignatureRet() {

    for (let signature of signatures) {

        const importee = makeImportee(signature);

        for (let typeIndex = 1; typeIndex < types.length; ++typeIndex) {

            const badParamSignature = { params: signature.params, ret: swapType(signature.ret, typeIndex) };

            const importer = makeImporter(badParamSignature);

            assert.throws(() => new WebAssembly.Instance(importer, importee), WebAssembly.LinkError, `imported function's signature mismatches the provided WebAssembly function's signature (evaluating 'new WebAssembly.Instance(importer, importee)')`);

        }

    }

})();

JSTests/wasm/js-api/wasm-to-wasm.js

import * as assert from '../assert.js';

import Builder from '../Builder.js';

/*

const callerTopBits = 0xC0FEBEEF;

const innerReturnHi = 0xDEADFACE;

const innerReturnLo = 0xC0FEC0FE;

const callerModule = () => {

    const builder = (new Builder())

        .Type().End()

        .Import()

            .Function("exports", "callMe", { params: ["i64"], ret: "i64" })

        .End()

        .Function().End()

        .Export()

            .Function("entry")

        .End()

        .Code()

            .Function("entry", { params: ["i32"], ret: "i32" }, ["i64"])

                .I32Const(callerTopBits).I64ExtendUI32().I32Const(32).I64ExtendUI32().I64Shl() // ((i64)callerTopBits) << 32

                .GetLocal(0).I64ExtendUI32()

                .I64Or() // value: param | (((i64)callerTopBits << 32))

                .Call(0) // Calls exports.callMe(param | (((i64)callerTopBits) << 32)).

                .TeeLocal(1).I32WrapI64() // lo: (i32)callResult

                .GetLocal(1).I32Const(32).I64ExtendUI32().I64ShrU().I32WrapI64() // hi: (i32)(callResult >> 32)

                .I32Xor()

                .Return()

            .End()

        .End();

    return new WebAssembly.Module(builder.WebAssembly().get());

};

const calleeModule = () => {

    const builder = (new Builder())

        .Type().End()

        .Import()

            .Function("imp", "func", { params: ["i32", "i32"], ret: "i32" })

        .End()

        .Function().End()

        .Export()

            .Function("callMe")

        .End()

        .Code()

            .Function("callMe", { params: ["i64"], ret: "i64" })

                .GetLocal(0).I32WrapI64() // lo: (i32)param

                .GetLocal(0).I32Const(32).I64ExtendUI32().I64ShrU().I32WrapI64() // hi: (i32)(param >> 32)

                .Call(0) // Calls imp.func with the 64-bit value as i32 { hi, lo }.

                .Drop()

                .I32Const(innerReturnHi).I64ExtendUI32().I32Const(32).I64ExtendUI32().I64Shl().I32Const(innerReturnLo).I64ExtendUI32().I64Or() // ((i64)hi << 32) | (i64)lo

                .Return()

            .End()

        .End();

    return new WebAssembly.Module(builder.WebAssembly().get());

};

(function WasmToWasm() {

    let value;

    const func = (hi, lo) => { value = { hi: hi, lo: lo }; print(`${Error.stack}`); return hi ^ lo; };

    const callee = new WebAssembly.Instance(calleeModule(), { imp: { func: func } });

    const caller = new WebAssembly.Instance(callerModule(), callee);

    for (let i = 0; i < 4096; ++i) {

        assert.eq(caller.exports.entry(i), innerReturnHi ^ innerReturnLo);

        assert.eq(value.hi, callerTopBits);

        assert.eq(value.lo, i);

    }

})();

// FIXME: test wasm->wasm using 32-bit things (including float), as well as 64-bit NaNs that don't get canonicalized

// FIXME: do a throw two-deep

// FIXME: check that the first wasm's instance is back in OK state (with table or global?)

// FIXME: test calling through a Table

*/

Source/JavaScriptCore/jsc.cpp

#include "JSString.h"

#include "JSTypedArrays.h"

#include "JSWebAssemblyCallee.h"

57#include "JSWebAssemblyInstance.h"

58#include "JSWebAssemblyModule.h"

#include "LLIntData.h"

#include "LLIntThunks.h"

#include "ObjectConstructor.h"

#include "TypeProfilerLog.h"

#include "WasmPlan.h"

#include "WasmMemory.h"

75#include "WebAssemblyModuleRecord.h"

#include <locale.h>

#include <math.h>

#include <stdio.h>

@@static EncodedJSValue JSC_HOST_CALL functionTestWasmModuleFunctions(ExecState* e

{

    VM& vm = exec->vm();

    auto scope = DECLARE_THROW_SCOPE(vm);

2606 auto* globalObject = exec->lexicalGlobalObject();

    if (!Options::useWebAssembly())

        return throwVMTypeError(exec, scope, ASCIILiteral("testWasmModule should only be called if the useWebAssembly option is set"));

@@static EncodedJSValue JSC_HOST_CALL functionTestWasmModuleFunctions(ExecState* e

            });

    }

    void* memoryBytes = nullptr;

    uint32_t memorySize = 0;

    std::unique_ptr<Wasm::Memory> memory;

    std::unique_ptr<Wasm::ModuleInformation> moduleInformation = plan.takeModuleInformation();

    SymbolTable* exportSymbolTable = SymbolTable::create(vm);

    auto* moduleStructure = InternalFunction::createSubclassStructure(exec, JSValue(), exec->lexicalGlobalObject()->WebAssemblyModuleStructure());

    RETURN_IF_EXCEPTION(scope, encodedJSValue());

    JSWebAssemblyModule* module = JSWebAssemblyModule::create(vm, moduleStructure, plan.takeModuleInformation(), plan.takeCallLinkInfos(), plan.takeWasmExitStubs(), exportSymbolTable, 0);

    Structure* instanceStructure = InternalFunction::createSubclassStructure(exec, JSValue(), globalObject->WebAssemblyInstanceStructure());

    RETURN_IF_EXCEPTION(scope, encodedJSValue());

    Identifier moduleKey = Identifier::fromUid(PrivateName(PrivateName::Description, "WebAssemblyInstance"));

    WebAssemblyModuleRecord* moduleRecord = WebAssemblyModuleRecord::create(exec, vm, globalObject->webAssemblyModuleRecordStructure(), moduleKey, module->moduleInformation());

    RETURN_IF_EXCEPTION(scope, encodedJSValue());

    JSWebAssemblyInstance* instance = JSWebAssemblyInstance::create(vm, instanceStructure, module, moduleRecord->getModuleNamespace(exec));

    RETURN_IF_EXCEPTION(scope, encodedJSValue());

    vm.topJSWebAssemblyInstance = instance;

26402652

    if (!!moduleInformation->memory) {

        memory = std::make_unique<Wasm::Memory>(moduleInformation->memory.initial(), moduleInformation->memory.maximum());

        RELEASE_ASSERT(memory->isValid());

        memoryBytes = memory->memory();

        memorySize = memory->size();

    if (!!module->moduleInformation().memory) {

        Wasm::Memory memory(module->moduleInformation().memory.initial(), module->moduleInformation().memory.maximum());

        RELEASE_ASSERT(memory.isValid());

        instance->setMemory(vm, JSWebAssemblyMemory::create(vm, globalObject->WebAssemblyMemoryStructure(), WTFMove(memory)));

26462657 }

2647 vm.topWasmMemoryPointer = memoryBytes;

2648 vm.topWasmMemorySize = memorySize;

    for (uint32_t i = 0; i < functionCount; ++i) {

        JSArray* testCases = jsCast<JSArray*>(exec->argument(i + 2));

Source/JavaScriptCore/runtime/JSType.h

@@enum JSType : uint8_t {

    JSMapType,

    JSSetType,

96 WebAssemblyFunctionType,

97

    LastJSCObjectType = JSSetType,

    MaxJSType = 0b11111111,

};

Source/JavaScriptCore/runtime/VM.h

@@public:

    // https://bugs.webkit.org/show_bug.cgi?id=160441

    ExecState* topCallFrame;

    JSWebAssemblyInstance* topJSWebAssemblyInstance;

304 void* topWasmMemoryPointer;

305 uint32_t topWasmMemorySize;

    Strong<Structure> structureStructure;

    Strong<Structure> structureRareDataStructure;

    Strong<Structure> terminatedExecutionErrorStructure;

Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp

@@public:

            return fail(__VA_ARGS__);             \

    } while (0)

158 B3IRGenerator(VM&, const ModuleInformation&, Procedure&, WasmInternalFunction*, Vector<UnlinkedWasmToWasmCall>&~~, const ImmutableFunctionIndexSpace&~~);

158 B3IRGenerator(VM&, const ModuleInformation&, Procedure&, WasmInternalFunction*, Vector<UnlinkedWasmToWasmCall>&);

    PartialResult WARN_UNUSED_RETURN addArguments(const Signature*);

    PartialResult WARN_UNUSED_RETURN addLocal(Type, uint32_t);

@@private:

    Value* zeroForType(Type);

    VM& m_vm;

216 const ImmutableFunctionIndexSpace& m_functionIndexSpace;

    const ModuleInformation& m_info;

    Procedure& m_proc;

    BasicBlock* m_currentBlock;

@@private:

    Value* m_instanceValue;

};

228 B3IRGenerator::B3IRGenerator(VM& vm, const ModuleInformation& info, Procedure& procedure, WasmInternalFunction* compilation, Vector<UnlinkedWasmToWasmCall>& unlinkedWasmToWasmCalls~~, const ImmutableFunctionIndexSpace& functionIndexSpace~~)

227B3IRGenerator::B3IRGenerator(VM& vm, const ModuleInformation& info, Procedure& procedure, WasmInternalFunction* compilation, Vector<UnlinkedWasmToWasmCall>& unlinkedWasmToWasmCalls)

229228 : m_vm(vm)

230 , m_functionIndexSpace(functionIndexSpace)

    , m_info(info)

    , m_proc(procedure)

    , m_unlinkedWasmToWasmCalls(unlinkedWasmToWasmCalls)

@@B3IRGenerator::B3IRGenerator(VM& vm, const ModuleInformation& info, Procedure& p

        m_currentBlock->appendNew<ConstPtrValue>(m_proc, Origin(), &m_vm.topJSWebAssemblyInstance));

}

static void restoreWebAssemblyGlobalState(VM& vm, const MemoryInformation& memory, Value* instance, Procedure& proc, BasicBlock* block)

{

    block->appendNew<MemoryValue>(proc, Store, Origin(), instance, block->appendNew<ConstPtrValue>(proc, Origin(), &vm.topJSWebAssemblyInstance));

    if (!!memory) {

        Value* memoryObject = block->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), instance, JSWebAssemblyInstance::offsetOfMemory());

        static_assert(sizeof(decltype(vm.topJSWebAssemblyInstance->memory()->memory()->memory())) == sizeof(void*), "codegen relies on this size");

        static_assert(sizeof(decltype(vm.topJSWebAssemblyInstance->memory()->memory()->size())) == sizeof(uint32_t), "codegen relies on this size");

        Value* baseMemory = block->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(), memoryObject, JSWebAssemblyMemory::offsetOfMemory());

        Value* memorySize = block->appendNew<MemoryValue>(proc, Load, Int32, Origin(), memoryObject, JSWebAssemblyMemory::offsetOfSize());

        Vector<Value*> arguments;

        arguments.reserveCapacity(1 + memory.pinnedRegisters().sizeRegisters.size());

        arguments.append(baseMemory);

        for (auto info : memory.pinnedRegisters().sizeRegisters) {

            Value* sizeValue = block->appendNew<Value>(proc, Sub, Origin(), memorySize, block->appendNew<Const32Value>(proc, Origin(), info.sizeOffset));

            arguments.append(sizeValue);

        }

        B3::PatchpointValue* patchpoint = block->appendNew<B3::PatchpointValue>(proc, B3::Void, Origin());

        patchpoint->effects = Effects::none();

        patchpoint->effects.writesPinned = true;

        patchpoint->appendVectorWithRep(arguments, ValueRep::SomeRegister);

        patchpoint->setGenerator([memory] (CCallHelpers& jit, const B3::StackmapGenerationParams& params) {

            AllowMacroScratchRegisterUsage allowScratch(jit);

            jit.move(params[0].gpr(), memory.pinnedRegisters().baseMemoryPointer);

            for (uint32_t i = 0; i < memory.pinnedRegisters().sizeRegisters.size(); ++i)

                jit.move(params[1 + i].gpr(), memory.pinnedRegisters().sizeRegisters[i].sizeRegister);

        });

    }

}

void B3IRGenerator::emitExceptionCheck(CCallHelpers& jit, ExceptionType type)

{

    jit.move(CCallHelpers::TrustedImm32(static_cast<uint32_t>(type)), GPRInfo::argumentGPR1);

@@auto B3IRGenerator::addCall(uint32_t functionIndex, const Signature* signature,

    ASSERT(signature->argumentCount() == args.size());

    Type returnType = signature->returnType();

728 Vector<UnlinkedWasmToWasmCall>* unlinkedWasmToWasmCalls = &m_unlinkedWasmToWasmCalls;

695729

    result = wasmCallingConvention().setupCall(m_proc, m_currentBlock, Origin(), args, toB3Type(returnType),

        [&] (PatchpointValue* patchpoint) {

            patchpoint->effects.writesPinned = true;

            patchpoint->effects.readsPinned = true;

    if (m_info.isImportedFunctionFromFunctionIndexSpace(functionIndex)) {

        // FIXME imports can be linked here, instead of generating a patchpoint, because all import stubs are generated before B3 compilation starts. https://bugs.webkit.org/show_bug.cgi?id=166462

        ExpressionType functionImport = m_currentBlock->appendNew<MemoryValue>(m_proc, Load, pointerType(), Origin(), m_instanceValue, JSWebAssemblyInstance::offsetOfImportFunction(functionIndex));

        ExpressionType jsTypeOfImport = m_currentBlock->appendNew<MemoryValue>(m_proc, Load8Z, Origin(), functionImport, JSCell::typeInfoTypeOffset());

        Value* isWasmCall = m_currentBlock->appendNew<Value>(m_proc, Equal, Origin(), jsTypeOfImport, m_currentBlock->appendNew<Const32Value>(m_proc, Origin(), WebAssemblyFunctionType));

700735

            Vector<UnlinkedWasmToWasmCall>* unlinkedWasmToWasmCalls = &m_unlinkedWasmToWasmCalls;

            patchpoint->setGenerator([unlinkedWasmToWasmCalls, functionIndex] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {

                AllowMacroScratchRegisterUsage allowScratch(jit);

        BasicBlock* isWasmBlock = m_proc.addBlock();

        BasicBlock* isJSBlock = m_proc.addBlock();

        BasicBlock* continuation = m_proc.addBlock();

        m_currentBlock->appendNewControlValue(m_proc, B3::Branch, Origin(), isWasmCall, FrequentedBlock(isWasmBlock), FrequentedBlock(isJSBlock));

        Value* wasmCallResult = wasmCallingConvention().setupCall(m_proc, isWasmBlock, Origin(), args, toB3Type(returnType),

            [&] (PatchpointValue* patchpoint) {

                patchpoint->effects.writesPinned = true;

                patchpoint->effects.readsPinned = true;

                patchpoint->setGenerator([unlinkedWasmToWasmCalls, functionIndex] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {

                    AllowMacroScratchRegisterUsage allowScratch(jit);

                    CCallHelpers::Call call = jit.call();

                    jit.addLinkTask([unlinkedWasmToWasmCalls, call, functionIndex] (LinkBuffer& linkBuffer) {

                        bool toJS = false; // Maybe external wasm -> wasm.

                        unlinkedWasmToWasmCalls->append({ linkBuffer.locationOf(call), functionIndex, toJS });

                    });

                });

            });

        UpsilonValue* wasmCallResultUpsilon = returnType == Void ? nullptr : isWasmBlock->appendNew<UpsilonValue>(m_proc, Origin(), wasmCallResult);

        isWasmBlock->appendNewControlValue(m_proc, Jump, Origin(), continuation);

        Value* jsCallResult = wasmCallingConvention().setupCall(m_proc, isJSBlock, Origin(), args, toB3Type(returnType),

            [&] (PatchpointValue* patchpoint) {

                patchpoint->effects.writesPinned = true;

                patchpoint->effects.readsPinned = true;

                patchpoint->setGenerator([unlinkedWasmToWasmCalls, functionIndex] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {

                    AllowMacroScratchRegisterUsage allowScratch(jit);

                    CCallHelpers::Call call = jit.call();

                    jit.addLinkTask([unlinkedWasmToWasmCalls, call, functionIndex] (LinkBuffer& linkBuffer) {

                        bool toJS = true; // External wasm -> JS.

                        unlinkedWasmToWasmCalls->append({ linkBuffer.locationOf(call), functionIndex, toJS });

                    });

                });

            });

        UpsilonValue* jsCallResultUpsilon = returnType == Void ? nullptr : isJSBlock->appendNew<UpsilonValue>(m_proc, Origin(), jsCallResult);

        isJSBlock->appendNewControlValue(m_proc, Jump, Origin(), continuation);

704772

705 CCallHelpers::Call call = jit.call();

        m_currentBlock = continuation;

        if (returnType == Void)

            result = nullptr;

        else {

            result = continuation->appendNew<Value>(m_proc, Phi, toB3Type(returnType), Origin());

            wasmCallResultUpsilon->setPhi(result);

            jsCallResultUpsilon->setPhi(result);

        }

706782

707 jit.addLinkTask([unlinkedWasmToWasmCalls, call, functionIndex] (LinkBuffer& linkBuffer) {

708 unlinkedWasmToWasmCalls->append({ linkBuffer.locationOf(call), functionIndex });

        // The call could have been to another WebAssembly instance, and / or could have modified our Memory.

        restoreWebAssemblyGlobalState(m_vm, m_info.memory, m_instanceValue, m_proc, continuation);

    } else {

        result = wasmCallingConvention().setupCall(m_proc, m_currentBlock, Origin(), args, toB3Type(returnType),

            [&] (PatchpointValue* patchpoint) {

                patchpoint->effects.writesPinned = true;

                patchpoint->effects.readsPinned = true;

                patchpoint->setGenerator([unlinkedWasmToWasmCalls, functionIndex] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {

                    AllowMacroScratchRegisterUsage allowScratch(jit);

                    CCallHelpers::Call call = jit.call();

                    jit.addLinkTask([unlinkedWasmToWasmCalls, call, functionIndex] (LinkBuffer& linkBuffer) {

                        bool toJS = false; // Internal wasm -> wasm.

                        unlinkedWasmToWasmCalls->append({ linkBuffer.locationOf(call), functionIndex, toJS });

                    });

709797 });

710798 });

711 });

799 }

800

    return { };

}

@@auto B3IRGenerator::addCallIndirect(const Signature* signature, SignatureIndex s

            });

        });

    // The call could have been to another WebAssembly instance, and / or could have modified our Memory.

    restoreWebAssemblyGlobalState(m_vm, m_info.memory, m_instanceValue, m_proc, m_currentBlock);

    return { };

}

@@static void createJSToWasmWrapper(VM& vm, CompilationContext& compilationContext

        });

    }

    // Move memory values to the approriate places, if needed.

    Value* baseMemory = nullptr;

    Vector<Value*> sizes;

    if (!!memory) {

        baseMemory = block->appendNew<MemoryValue>(proc, Load, Int64, Origin(),

            block->appendNew<ConstPtrValue>(proc, Origin(), &vm.topWasmMemoryPointer));

        Value* size = block->appendNew<MemoryValue>(proc, Load, Int32, Origin(),

            block->appendNew<ConstPtrValue>(proc, Origin(), &vm.topWasmMemorySize));

        sizes.reserveCapacity(memory.pinnedRegisters().sizeRegisters.size());

        for (auto info : memory.pinnedRegisters().sizeRegisters) {

            sizes.append(block->appendNew<Value>(proc, Sub, origin, size,

                block->appendNew<Const32Value>(proc, origin, info.sizeOffset)));

        }

    }

    // FIXME The instance is currently set by the C++ code in WebAssemblyFunction::call. We shouldn't go through the extra C++ hoop. https://bugs.webkit.org/show_bug.cgi?id=166486

    Value* instance = block->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(),

        block->appendNew<ConstPtrValue>(proc, Origin(), &vm.topJSWebAssemblyInstance));

    restoreWebAssemblyGlobalState(vm, memory, instance, proc, block);

    // Get our arguments.

    Vector<Value*> arguments;

@@static void createJSToWasmWrapper(VM& vm, CompilationContext& compilationContext

    // Move the arguments into place.

    Value* result = wasmCallingConvention().setupCall(proc, block, origin, arguments, toB3Type(signature->returnType()), [&] (PatchpointValue* patchpoint) {

        if (!!memory) {

            ASSERT(sizes.size() == memory.pinnedRegisters().sizeRegisters.size());

            patchpoint->append(ConstrainedValue(baseMemory, ValueRep::reg(memory.pinnedRegisters().baseMemoryPointer)));

            for (unsigned i = 0; i < sizes.size(); ++i)

                patchpoint->append(ConstrainedValue(sizes[i], ValueRep::reg(memory.pinnedRegisters().sizeRegisters[i].sizeRegister)));

        }

        CompilationContext* context = &compilationContext;

        patchpoint->setGenerator([context] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {

            AllowMacroScratchRegisterUsage allowScratch(jit);

@@static void createJSToWasmWrapper(VM& vm, CompilationContext& compilationContext

    function.jsToWasmEntrypoint.calleeSaveRegisters = proc.calleeSaveRegisters();

}

920 Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM& vm, CompilationContext& compilationContext, const uint8_t* functionStart, size_t functionLength, const Signature* signature, Vector<UnlinkedWasmToWasmCall>& unlinkedWasmToWasmCalls, const ~~ImmutableFunctionIndexSpace& functionIndexSpace, const~~ ModuleInformation& info, unsigned optLevel)

995Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM& vm, CompilationContext& compilationContext, const uint8_t* functionStart, size_t functionLength, const Signature* signature, Vector<UnlinkedWasmToWasmCall>& unlinkedWasmToWasmCalls, const ModuleInformation& info, unsigned optLevel)

{

    auto result = std::make_unique<WasmInternalFunction>();

@@Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM& vm,

    compilationContext.wasmEntrypointJIT = std::make_unique<CCallHelpers>(&vm);

    Procedure procedure;

928 B3IRGenerator context(vm, info, procedure, result.get(), unlinkedWasmToWasmCalls~~, functionIndexSpace~~);

929 FunctionParser<B3IRGenerator> parser(&vm, context, functionStart, functionLength, signature, ~~functionIndexSpace,~~ info);

1003 B3IRGenerator context(vm, info, procedure, result.get(), unlinkedWasmToWasmCalls);

1004 FunctionParser<B3IRGenerator> parser(&vm, context, functionStart, functionLength, signature, info);

    WASM_FAIL_IF_HELPER_FAILS(parser.parse());

    procedure.resetReachability();

Source/JavaScriptCore/wasm/WasmB3IRGenerator.h

@@struct CompilationContext {

    CCallHelpers::Call jsEntrypointToWasmEntrypointCall;

};

50 Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM&, CompilationContext&, const uint8_t*, size_t, const Signature*, Vector<UnlinkedWasmToWasmCall>&, const ~~ImmutableFunctionIndexSpace&, const~~ ModuleInformation&, unsigned optLevel = 1);

50Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM&, CompilationContext&, const uint8_t*, size_t, const Signature*, Vector<UnlinkedWasmToWasmCall>&, const ModuleInformation&, unsigned optLevel = 1);

} } // namespace JSC::Wasm

Source/JavaScriptCore/wasm/WasmBinding.cpp

namespace JSC { namespace Wasm {

39 WasmToJS~~Stub importStubGenerator~~(VM* vm, Bag<CallLinkInfo>& callLinkInfos, SignatureIndex signatureIndex, unsigned importIndex)

39static MacroAssemblerCodeRef wasmToJS(VM* vm, Bag<CallLinkInfo>& callLinkInfos, SignatureIndex signatureIndex, unsigned importIndex)

{

    const WasmCallingConvention& wasmCC = wasmCallingConvention();

    const JSCCallingConvention& jsCC = jscCallingConvention();

@@WasmToJSStub importStubGenerator(VM* vm, Bag<CallLinkInfo>& callLinkInfos, Signa

    CodeLocationLabel hotPathBegin(patchBuffer.locationOf(targetToCheck));

    CodeLocationNearCall hotPathOther = patchBuffer.locationOfNearCall(fastCall);

    callLinkInfo->setCallLocations(callReturnLocation, hotPathBegin, hotPathOther);

234 return FINALIZE_CODE(patchBuffer, ("WebAssembly import[%i] stub for signature %i", importIndex, signatureIndex));

    String signatureDescription = SignatureInformation::get(vm, signatureIndex)->toString();

    return FINALIZE_CODE(patchBuffer, ("WebAssembly->JavaScript import[%i] %s", importIndex, signatureDescription.ascii().data()));

}

static MacroAssemblerCodeRef wasmToWasm(VM* vm, Bag<CallLinkInfo>& callLinkInfos, SignatureIndex signatureIndex, unsigned importIndex)

{

    const WasmCallingConvention& wasmCC = wasmCallingConvention();

    const Signature* signature = SignatureInformation::get(vm, signatureIndex);

    unsigned argCount = signature->argumentCount();

    typedef AssemblyHelpers JIT;

    JIT jit(vm, nullptr);

    jit.emitFunctionPrologue();

    jit.store64(JIT::TrustedImm32(0), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register)))); // FIXME Stop using 0 as codeBlocks. https://bugs.webkit.org/show_bug.cgi?id=165321

    jit.storePtr(JIT::TrustedImmPtr(vm->webAssemblyToJSCallee.get()), JIT::Address(GPRInfo::callFrameRegister, CallFrameSlot::callee * static_cast<int>(sizeof(Register))));

    // FIXME perform a stack check before updating SP. https://bugs.webkit.org/show_bug.cgi?id=165546

    unsigned numberOfParameters = argCount + 1; // There is a "this" argument.

    unsigned numberOfRegsForCall = CallFrame::headerSizeInRegisters + numberOfParameters;

    unsigned numberOfBytesForCall = numberOfRegsForCall * sizeof(Register) - sizeof(CallerFrameAndPC);

    const unsigned stackOffset = WTF::roundUpToMultipleOf(stackAlignmentBytes(), numberOfBytesForCall);

    jit.subPtr(MacroAssembler::TrustedImm32(stackOffset), MacroAssembler::stackPointerRegister);

    JIT::Address calleeFrame = CCallHelpers::Address(MacroAssembler::stackPointerRegister, -static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC)));

    // FIXME implement this.

    jit.breakpoint();

    jit.emitFunctionEpilogue();

    jit.ret();

    LinkBuffer patchBuffer(*vm, jit, GLOBAL_THUNK_ID);

    String signatureDescription = SignatureInformation::get(vm, signatureIndex)->toString();

    return FINALIZE_CODE(patchBuffer, ("WebAssembly->WebAssembly import[%i] %s", importIndex, signatureDescription.ascii().data()));

}

WasmExitStubs exitStubGenerator(VM* vm, Bag<CallLinkInfo>& callLinkInfos, SignatureIndex signatureIndex, unsigned importIndex)

{

    WasmExitStubs stubs;

    stubs.wasmToJS = wasmToJS(vm, callLinkInfos, signatureIndex, importIndex);

    stubs.wasmToWasm = wasmToWasm(vm, callLinkInfos, signatureIndex, importIndex);

    return stubs;

}

} } // namespace JSC::Wasm

Source/JavaScriptCore/wasm/WasmBinding.h

@@class CallLinkInfo;

namespace Wasm {

41 Wasm~~ToJS~~Stub ~~impor~~tStubGenerator(VM*, Bag<CallLinkInfo>&, SignatureIndex, unsigned);

41WasmExitStubs exitStubGenerator(VM*, Bag<CallLinkInfo>&, SignatureIndex, unsigned);

} } // namespace JSC::Wasm

Source/JavaScriptCore/wasm/WasmFormat.h

@@private:

};

struct ModuleInformation {

190 Vector<SignatureIndex> signatureIndices;

190 Vector<SignatureIndex> moduleSignatureIndicesToUniquedSignatureIndices;

    Vector<Import> imports;

    Vector<SignatureIndex> importFunctionSignatureIndices;

    Vector<SignatureIndex> internalFunctionSignatureIndices;

@@struct ModuleInformation {

    TableInformation tableInformation;

    Vector<Global> globals;

    unsigned firstInternalGlobal { 0 };

    size_t functionIndexSpaceSize() const { return importFunctionSignatureIndices.size() + internalFunctionSignatureIndices.size(); }

    bool isImportedFunctionFromFunctionIndexSpace(size_t functionIndex) const

    {

        ASSERT(functionIndex < functionIndexSpaceSize());

        return functionIndex < importFunctionSignatureIndices.size();

    }

    SignatureIndex signatureIndexFromFunctionIndexSpace(size_t functionIndex) const

    {

        return isImportedFunctionFromFunctionIndexSpace(functionIndex)

            ? importFunctionSignatureIndices[functionIndex]

            : internalFunctionSignatureIndices[functionIndex - importFunctionSignatureIndices.size()];

    }

    ~ModuleInformation();

};

@@struct ModuleInformation {

struct UnlinkedWasmToWasmCall {

    CodeLocationCall callLocation;

    size_t functionIndex;

221 bool toJS;

};

struct Entrypoint {

@@struct WasmInternalFunction {

    Entrypoint jsToWasmEntrypoint;

};

224 typedef MacroAssemblerCodeRef WasmToJSStub;

struct WasmExitStubs {

    MacroAssemblerCodeRef wasmToJS;

    MacroAssemblerCodeRef wasmToWasm;

};

// WebAssembly direct calls and call_indirect use indices into "function index space". This space starts with all imports, and then all internal functions.

// CallableFunction and FunctionIndexSpace are only meant as fast lookup tables for these opcodes, and do not own code.

@@struct CallableFunction {

};

typedef Vector<CallableFunction> FunctionIndexSpace;

struct ImmutableFunctionIndexSpace {

    MallocPtr<CallableFunction> buffer;

    size_t size;

};

} } // namespace JSC::Wasm

#endif // ENABLE(WEBASSEMBLY)

Source/JavaScriptCore/wasm/WasmFunctionParser.h

@@public:

    typedef typename Context::ControlType ControlType;

    typedef typename Context::ExpressionList ExpressionList;

49 FunctionParser(VM*, Context&, const uint8_t* functionStart, size_t functionLength, const Signature*, const ~~ImmutableFunctionIndexSpace&, const~~ ModuleInformation&);

49 FunctionParser(VM*, Context&, const uint8_t* functionStart, size_t functionLength, const Signature*, const ModuleInformation&);

    Result WARN_UNUSED_RETURN parse();

@@private:

    ExpressionList m_expressionStack;

    Vector<ControlEntry> m_controlStack;

    const Signature* m_signature;

85 const ImmutableFunctionIndexSpace& m_functionIndexSpace;

    const ModuleInformation& m_info;

    unsigned m_unreachableBlocks { 0 };

};

template<typename Context>

91 FunctionParser<Context>::FunctionParser(VM* vm, Context& context, const uint8_t* functionStart, size_t functionLength, const Signature* signature, const ~~ImmutableFunctionIndexSpace& functionIndexSpace, const~~ ModuleInformation& info)

90FunctionParser<Context>::FunctionParser(VM* vm, Context& context, const uint8_t* functionStart, size_t functionLength, const Signature* signature, const ModuleInformation& info)

    : Parser(vm, functionStart, functionLength)

    , m_context(context)

    , m_signature(signature)

95 , m_functionIndexSpace(functionIndexSpace)

    , m_info(info)

{

    if (verbose)

@@auto FunctionParser<Context>::parseExpression(OpType op) -> PartialResult

    case Call: {

        uint32_t functionIndex;

        WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't parse call's function index");

311 WASM_PARSER_FAIL_IF(functionIndex >= m_functionIndexSpace.size, "call function index ", functionIndex, " exceeds function index space ", m_functionIndexSpace.size);

309 WASM_PARSER_FAIL_IF(functionIndex >= m_info.functionIndexSpaceSize(), "call function index ", functionIndex, " exceeds function index space ", m_info.functionIndexSpaceSize());

312310

313 SignatureIndex calleeSignatureIndex = m_functionIndexSpace~~.buffer.get()[~~functionIndex~~].signatureIndex~~;

311 SignatureIndex calleeSignatureIndex = m_info.signatureIndexFromFunctionIndexSpace(functionIndex);

        const Signature* calleeSignature = SignatureInformation::get(m_vm, calleeSignatureIndex);

        WASM_PARSER_FAIL_IF(calleeSignature->argumentCount() > m_expressionStack.size(), "call function index ", functionIndex, " has ", calleeSignature->argumentCount(), " arguments, but the expression stack currently holds ", m_expressionStack.size(), " values");

@@auto FunctionParser<Context>::parseExpression(OpType op) -> PartialResult

        WASM_PARSER_FAIL_IF(!parseVarUInt32(signatureIndex), "can't get call_indirect's signature index");

        WASM_PARSER_FAIL_IF(!parseVarUInt1(reserved), "can't get call_indirect's reserved byte");

        WASM_PARSER_FAIL_IF(reserved, "call_indirect's 'reserved' varuint1 must be 0x0");

340 WASM_PARSER_FAIL_IF(m_info.signatureIndices.size() <= signatureIndex, "call_indirect's signature index ", signatureIndex, " exceeds known signatures ", m_info.signatureIndices.size());

338 WASM_PARSER_FAIL_IF(m_info.moduleSignatureIndicesToUniquedSignatureIndices.size() <= signatureIndex, "call_indirect's signature index ", signatureIndex, " exceeds known signatures ", m_info.moduleSignatureIndicesToUniquedSignatureIndices.size());

341339

342 SignatureIndex calleeSignatureIndex = m_info.signatureIndices[signatureIndex];

340 SignatureIndex calleeSignatureIndex = m_info.moduleSignatureIndicesToUniquedSignatureIndices[signatureIndex];

        const Signature* calleeSignature = SignatureInformation::get(m_vm, calleeSignatureIndex);

        size_t argumentCount = calleeSignature->argumentCount() + 1; // Add the callee's index.

        WASM_PARSER_FAIL_IF(argumentCount > m_expressionStack.size(), "call_indirect expects ", argumentCount, " arguments, but the expression stack currently holds ", m_expressionStack.size(), " values");

Source/JavaScriptCore/wasm/WasmMemory.cpp

namespace JSC { namespace Wasm {

Memory::Memory(PageCount initial, PageCount maximum)

34 : m_mode(Mode::BoundsChecking)

35 , m_size(initial.bytes())

34 : m_size(initial.bytes())

    , m_capacity(maximum ? maximum.bytes() : PageCount::max().bytes())

    , m_initial(initial)

    , m_maximum(maximum)

38 , m_mode(Mode::BoundsChecking)

    // FIXME: If we add signal based bounds checking then we need extra space for overflow on load.

    // see: https://bugs.webkit.org/show_bug.cgi?id=162693

{

Source/JavaScriptCore/wasm/WasmMemory.h

@@class Memory {

    WTF_MAKE_NONCOPYABLE(Memory);

    WTF_MAKE_FAST_ALLOCATED;

public:

    Memory(Memory&& other)

        : m_memory(other.m_memory)

        , m_size(other.m_size)

        , m_capacity(other.m_capacity)

        , m_initial(other.m_initial)

        , m_maximum(other.m_maximum)

        , m_mappedCapacity(other.m_mappedCapacity)

        , m_mode(other.m_mode)

    {

        memset(&other, 0, sizeof(other));

    }

    // FIXME: We should support other modes. see: https://bugs.webkit.org/show_bug.cgi?id=162693

    enum class Mode {

@@public:

    void* memory() const { return m_memory; }

    uint32_t size() const { return m_size; }

60 Mode mode() const { return m_mode; }

61

    PageCount initial() const { return m_initial; }

    PageCount maximum() const { return m_maximum; }

74 Mode mode() const { return m_mode; }

75

    bool grow(uint32_t newSize)

    {

        ASSERT(m_memory);

@@public:

        return !mprotect(m_memory, newSize, PROT_READ | PROT_WRITE);

    }

85 static ptrdiff_t offsetOfMemory() { return OBJECT_OFFSETOF(Memory, m_memory); }

    static ptrdiff_t offsetOfSize() { return OBJECT_OFFSETOF(Memory, m_size); }

private:

    void* m_memory { nullptr };

79 Mode m_mode;

    uint32_t m_size { 0 };

    uint32_t m_capacity { 0 };

    PageCount m_initial;

    PageCount m_maximum;

    uint64_t m_mappedCapacity { 0 };

96 Mode m_mode { Mode::BoundsChecking };

};

} } // namespace JSC::Wasm

Source/JavaScriptCore/wasm/WasmModuleParser.cpp

@@auto ModuleParser::parseType() -> PartialResult

    WASM_PARSER_FAIL_IF(!parseVarUInt32(count), "can't get Type section's count");

    WASM_PARSER_FAIL_IF(count == std::numeric_limits<uint32_t>::max(), "Type section's count is too big ", count);

102 WASM_PARSER_FAIL_IF(!m_result.module->signatureIndices.tryReserveCapacity(count), "can't allocate enough memory for Type section's ", count, " entries");

102 WASM_PARSER_FAIL_IF(!m_result.module->moduleSignatureIndicesToUniquedSignatureIndices.tryReserveCapacity(count), "can't allocate enough memory for Type section's ", count, " entries");

    for (uint32_t i = 0; i < count; ++i) {

        int8_t type;

@@auto ModuleParser::parseType() -> PartialResult

        signature->returnType() = returnType;

        SignatureIndex signatureIndex = SignatureInformation::adopt(m_vm, signature.release());

134 m_result.module->signatureIndices.uncheckedAppend(signatureIndex);

134 m_result.module->moduleSignatureIndicesToUniquedSignatureIndices.uncheckedAppend(signatureIndex);

    }

    return { };

}

@@auto ModuleParser::parseImport() -> PartialResult

    WASM_PARSER_FAIL_IF(!m_result.module->globals.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " globals"); // FIXME this over-allocates when we fix the FIXMEs below.

    WASM_PARSER_FAIL_IF(!m_result.module->imports.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " imports"); // FIXME this over-allocates when we fix the FIXMEs below.

    WASM_PARSER_FAIL_IF(!m_result.module->importFunctionSignatureIndices.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " import function signatures"); // FIXME this over-allocates when we fix the FIXMEs below.

147 WASM_PARSER_FAIL_IF(!m_result.functionIndexSpace.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " functions in the index space"); // FIXME this over-allocates when we fix the FIXMEs below. We'll allocate some more here when we know how many functions to expect.

    for (uint32_t importNumber = 0; importNumber < importCount; ++importNumber) {

        Import imp;

@@auto ModuleParser::parseImport() -> PartialResult

        case ExternalKind::Function: {

            uint32_t functionSignatureIndex;

            WASM_PARSER_FAIL_IF(!parseVarUInt32(functionSignatureIndex), "can't get ", importNumber, "th Import's function signature in module '", moduleString, "' field '", fieldString, "'");

169 WASM_PARSER_FAIL_IF(functionSignatureIndex >= m_result.module->signatureIndices.size(), "invalid function signature for ", importNumber, "th Import, ", functionSignatureIndex, " is out of range of ", m_result.module->signatureIndices.size(), " in module '", moduleString, "' field '", fieldString, "'");

168 WASM_PARSER_FAIL_IF(functionSignatureIndex >= m_result.module->moduleSignatureIndicesToUniquedSignatureIndices.size(), "invalid function signature for ", importNumber, "th Import, ", functionSignatureIndex, " is out of range of ", m_result.module->moduleSignatureIndicesToUniquedSignatureIndices.size(), " in module '", moduleString, "' field '", fieldString, "'");

170169 imp.kindIndex = m_result.module->importFunctionSignatureIndices.size();

171 SignatureIndex signatureIndex = m_result.module->signatureIndices[functionSignatureIndex];

170 SignatureIndex signatureIndex = m_result.module->moduleSignatureIndicesToUniquedSignatureIndices[functionSignatureIndex];

172171 m_result.module->importFunctionSignatureIndices.uncheckedAppend(signatureIndex);

173 m_result.functionIndexSpace.uncheckedAppend(signatureIndex);

            break;

        }

        case ExternalKind::Table: {

@@auto ModuleParser::parseFunction() -> PartialResult

    WASM_PARSER_FAIL_IF(count == std::numeric_limits<uint32_t>::max(), "Function section's count is too big ", count);

    WASM_PARSER_FAIL_IF(!m_result.module->internalFunctionSignatureIndices.tryReserveCapacity(count), "can't allocate enough memory for ", count, " Function signatures");

    WASM_PARSER_FAIL_IF(!m_result.functionLocationInBinary.tryReserveCapacity(count), "can't allocate enough memory for ", count, "Function locations");

215 WASM_PARSER_FAIL_IF(!m_result.functionIndexSpace.tryReserveCapacity(m_result.functionIndexSpace.size() + count), "can't allocate enough memory for ", count, " more functions in the function index space");

    for (uint32_t i = 0; i < count; ++i) {

        uint32_t typeNumber;

        WASM_PARSER_FAIL_IF(!parseVarUInt32(typeNumber), "can't get ", i, "th Function's type number");

220 WASM_PARSER_FAIL_IF(typeNumber >= m_result.module->signatureIndices.size(), i, "th Function type number is invalid ", typeNumber);

217 WASM_PARSER_FAIL_IF(typeNumber >= m_result.module->moduleSignatureIndicesToUniquedSignatureIndices.size(), i, "th Function type number is invalid ", typeNumber);

221218

222 SignatureIndex signatureIndex = m_result.module->signatureIndices[typeNumber];

219 SignatureIndex signatureIndex = m_result.module->moduleSignatureIndicesToUniquedSignatureIndices[typeNumber];

        // The Code section fixes up start and end.

        size_t start = 0;

        size_t end = 0;

        m_result.module->internalFunctionSignatureIndices.uncheckedAppend(signatureIndex);

        m_result.functionLocationInBinary.uncheckedAppend({ start, end });

228 m_result.functionIndexSpace.uncheckedAppend(signatureIndex);

    }

    return { };

@@auto ModuleParser::parseExport() -> PartialResult

        WASM_PARSER_FAIL_IF(!parseVarUInt32(exp.kindIndex), "can't get ", exportNumber, "th Export's kind index, named '", fieldString, "'");

        switch (exp.kind) {

        case ExternalKind::Function: {

399 WASM_PARSER_FAIL_IF(exp.kindIndex >= m_result.functionIndexSpace.size(), exportNumber, "th Export has invalid function number ", exp.kindIndex, " it exceeds the function index space ", m_result.functionIndexSpace.size(), ", named '", fieldString, "'");

395 WASM_PARSER_FAIL_IF(exp.kindIndex >= m_result.module->functionIndexSpaceSize(), exportNumber, "th Export has invalid function number ", exp.kindIndex, " it exceeds the function index space ", m_result.module->functionIndexSpaceSize(), ", named '", fieldString, "'");

            break;

        }

        case ExternalKind::Table: {

@@auto ModuleParser::parseStart() -> PartialResult

{

    uint32_t startFunctionIndex;

    WASM_PARSER_FAIL_IF(!parseVarUInt32(startFunctionIndex), "can't get Start index");

429 WASM_PARSER_FAIL_IF(startFunctionIndex >= m_result.functionIndexSpace.size(), "Start index ", startFunctionIndex, " exceeds function index space ", m_result.functionIndexSpace.size());

430 SignatureIndex signatureIndex = m_result.functionIndexSpace[startFunctionIndex~~].signatureIndex~~;

425 WASM_PARSER_FAIL_IF(startFunctionIndex >= m_result.module->functionIndexSpaceSize(), "Start index ", startFunctionIndex, " exceeds function index space ", m_result.module->functionIndexSpaceSize());

426 SignatureIndex signatureIndex = m_result.module->signatureIndexFromFunctionIndexSpace(startFunctionIndex);

    const Signature* signature = SignatureInformation::get(m_vm, signatureIndex);

    WASM_PARSER_FAIL_IF(signature->argumentCount(), "Start function can't have arguments");

    WASM_PARSER_FAIL_IF(signature->returnType() != Void, "Start function can't return a value");

@@auto ModuleParser::parseElement() -> PartialResult

        for (unsigned index = 0; index < indexCount; ++index) {

            uint32_t functionIndex;

            WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");

480 WASM_PARSER_FAIL_IF(functionIndex >= m_result.functionIndexSpace.size(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_result.functionIndexSpace.size());

476 WASM_PARSER_FAIL_IF(functionIndex >= m_result.module->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_result.module->functionIndexSpaceSize());

            element.functionIndices.uncheckedAppend(functionIndex);

        }

Source/JavaScriptCore/wasm/WasmModuleParser.h

@@namespace JSC { namespace Wasm {

struct ModuleParserResult {

    std::unique_ptr<ModuleInformation> module;

39 FunctionIndexSpace functionIndexSpace;

    Vector<FunctionLocationInBinary> functionLocationInBinary;

};

Source/JavaScriptCore/wasm/WasmPlan.cpp

@@bool Plan::parseAndValidateModule()

        }

        m_moduleInformation = WTFMove(parseResult->module);

        m_functionLocationInBinary = WTFMove(parseResult->functionLocationInBinary);

79 m_functionIndexSpace.size = parseResult->functionIndexSpace.size();

80 m_functionIndexSpace.buffer = parseResult->functionIndexSpace.releaseBuffer();

    }

    for (unsigned functionIndex = 0; functionIndex < m_functionLocationInBinary.size(); ++functionIndex) {

@@bool Plan::parseAndValidateModule()

        SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[functionIndex];

        const Signature* signature = SignatureInformation::get(m_vm, signatureIndex);

92 auto validationResult = validateFunction(m_vm, functionStart, functionLength, signature, ~~m_functionIndexSpace,~~ *m_moduleInformation);

90 auto validationResult = validateFunction(m_vm, functionStart, functionLength, signature, *m_moduleInformation);

        if (!validationResult) {

            if (verbose) {

                for (unsigned i = 0; i < functionLength; ++i)

@@void Plan::run()

        return true;

    };

130 if (!tryReserveCapacity(m_wasm~~ToJS~~Stubs, m_moduleInformation->importFunctionSignatureIndices.size(), " WebAssembly to JavaScript stubs")

128 if (!tryReserveCapacity(m_wasmExitStubs, m_moduleInformation->importFunctionSignatureIndices.size(), " WebAssembly to JavaScript stubs")

        || !tryReserveCapacity(m_unlinkedWasmToWasmCalls, m_functionLocationInBinary.size(), " unlinked WebAssembly to WebAssembly calls")

        || !tryReserveCapacity(m_wasmInternalFunctions, m_functionLocationInBinary.size(), " WebAssembly functions")

        || !tryReserveCapacity(m_compilationContexts, m_functionLocationInBinary.size(), " compilation contexts"))

@@void Plan::run()

        Import* import = &m_moduleInformation->imports[importIndex];

        if (import->kind != ExternalKind::Function)

            continue;

144 unsigned importFunctionIndex = m_wasm~~ToJS~~Stubs.size();

142 unsigned importFunctionIndex = m_wasmExitStubs.size();

        if (verbose)

            dataLogLn("Processing import function number ", importFunctionIndex, ": ", import->module, ": ", import->field);

        SignatureIndex signatureIndex = m_moduleInformation->importFunctionSignatureIndices.at(import->kindIndex);

148 m_wasmToJSStubs.uncheckedAppend(importStubGenerator(m_vm, m_callLinkInfos, signatureIndex, importFunctionIndex));

149 m_functionIndexSpace.buffer.get()[importFunctionIndex].code = m_wasmToJSStubs[importFunctionIndex].code().executableAddress();

146 m_wasmExitStubs.uncheckedAppend(exitStubGenerator(m_vm, m_callLinkInfos, signatureIndex, importFunctionIndex));

    }

    m_currentIndex = 0;

@@void Plan::run()

            ASSERT(functionLength <= m_sourceLength);

            SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[functionIndex];

            const Signature* signature = SignatureInformation::get(m_vm, signatureIndex);

            unsigned functionIndexSpace = m_wasmToJSStubs.size() + functionIndex;

            ASSERT_UNUSED(functionIndexSpace, m_functionIndexSpace.buffer.get()[functionIndexSpace].signatureIndex == signatureIndex);

            ASSERT(validateFunction(m_vm, functionStart, functionLength, signature, m_functionIndexSpace, *m_moduleInformation));

            unsigned functionIndexSpace = m_wasmExitStubs.size() + functionIndex;

            ASSERT_UNUSED(functionIndexSpace, m_moduleInformation->signatureIndexFromFunctionIndexSpace(functionIndexSpace) == signatureIndex);

            ASSERT(validateFunction(m_vm, functionStart, functionLength, signature, *m_moduleInformation));

173170

174171 m_unlinkedWasmToWasmCalls[functionIndex] = Vector<UnlinkedWasmToWasmCall>();

175 auto parseAndCompileResult = parseAndCompile(*m_vm, m_compilationContexts[functionIndex], functionStart, functionLength, signature, m_unlinkedWasmToWasmCalls[functionIndex], ~~m_functionIndexSpace,~~ *m_moduleInformation);

172 auto parseAndCompileResult = parseAndCompile(*m_vm, m_compilationContexts[functionIndex], functionStart, functionLength, signature, m_unlinkedWasmToWasmCalls[functionIndex], *m_moduleInformation);

            if (UNLIKELY(!parseAndCompileResult)) {

                auto locker = holdLock(m_lock);

@@void Plan::run()

                    std::make_unique<B3::Compilation>(FINALIZE_CODE(linkBuffer, ("Wasm JS entrypoint")), WTFMove(context.jsEntrypointByproducts));

            }

        }

        unsigned functionIndexSpace = m_wasmToJSStubs.size() + functionIndex;

        m_functionIndexSpace.buffer.get()[functionIndexSpace].code = m_wasmInternalFunctions[functionIndex]->wasmEntrypoint.compilation->code().executableAddress();

    }

    if (verbose || Options::reportCompileTimes()) {

@@void Plan::run()

    // Patch the call sites for each WebAssembly function.

    for (auto& unlinked : m_unlinkedWasmToWasmCalls) {

238 for (auto& call : unlinked)

239 MacroAssembler::repatchCall(call.callLocation, CodeLocationLabel(m_functionIndexSpace.buffer.get()[call.functionIndex].code));

        for (auto& call : unlinked) {

            void* executableAddress;

            if (m_moduleInformation->isImportedFunctionFromFunctionIndexSpace(call.functionIndex)) {

                // FIXME imports could have been linked in B3, instead of generating a patchpoint. This condition should be replaced by a RELEASE_ASSERT. https://bugs.webkit.org/show_bug.cgi?id=166462

                executableAddress = call.toJS

                    ? m_wasmExitStubs.at(call.functionIndex).wasmToJS.code().executableAddress()

                    : m_wasmExitStubs.at(call.functionIndex).wasmToWasm.code().executableAddress();

            } else {

                ASSERT(!call.toJS);

                executableAddress = m_wasmInternalFunctions.at(call.functionIndex - m_wasmExitStubs.size())->wasmEntrypoint.compilation->code().executableAddress();

            }

            MacroAssembler::repatchCall(call.callLocation, CodeLocationLabel(executableAddress));

        }

    }

    m_failed = false;

Source/JavaScriptCore/wasm/WasmPlan.h

@@public:

        return WTFMove(m_callLinkInfos);

    }

89 Vector<Wasm~~ToJS~~Stub>&& takeWasm~~ToJS~~Stubs()

89 Vector<WasmExitStubs>&& takeWasmExitStubs()

9090 {

9191 RELEASE_ASSERT(!failed());

        return WTFMove(m_wasmToJSStubs);

    }

    ImmutableFunctionIndexSpace&& takeFunctionIndexSpace()

    {

        RELEASE_ASSERT(!failed());

        return WTFMove(m_functionIndexSpace);

92 return WTFMove(m_wasmExitStubs);

    }

private:

    std::unique_ptr<ModuleInformation> m_moduleInformation;

    Vector<FunctionLocationInBinary> m_functionLocationInBinary;

    Bag<CallLinkInfo> m_callLinkInfos;

105 Vector<Wasm~~ToJS~~Stub> m_wasm~~ToJS~~Stubs;

99 Vector<WasmExitStubs> m_wasmExitStubs;

106100 Vector<std::unique_ptr<WasmInternalFunction>> m_wasmInternalFunctions;

107101 Vector<CompilationContext> m_compilationContexts;

108 ImmutableFunctionIndexSpace m_functionIndexSpace;

    VM* m_vm;

    Vector<Vector<UnlinkedWasmToWasmCall>> m_unlinkedWasmToWasmCalls;

Source/JavaScriptCore/wasm/WasmSignature.cpp

@@const bool verbose = false;

const constexpr SignatureIndex Signature::invalidIndex;

String Signature::toString() const

{

    String result(makeString(returnType()));

    result.append(" (");

    for (SignatureArgCount arg = 0; arg < argumentCount(); ++arg) {

        if (arg)

            result.append(", ");

        result.append(makeString(argument(arg)));

    }

    result.append(')');

    return result;

}

void Signature::dump(PrintStream& out) const

{

    out.print(makeString(returnType()), " (");

Source/JavaScriptCore/wasm/WasmSignature.h

@@public:

    }

    Type argument(SignatureArgCount i) const { return const_cast<Signature*>(this)->argument(i); }

85 WTF::String toString() const;

    void dump(WTF::PrintStream& out) const;

    bool operator==(const Signature& rhs) const

    {

Source/JavaScriptCore/wasm/WasmValidate.cpp

@@void Validate::dump(const Vector<ControlEntry>&, const ExpressionList&)

    // Think of this as penance for the sin of bad error messages.

}

365 Expected<void, String> validateFunction(VM* vm, const uint8_t* source, size_t length, const Signature* signature, const ~~ImmutableFunctionIndexSpace& functionIndexSpace, const~~ ModuleInformation& module)

365Expected<void, String> validateFunction(VM* vm, const uint8_t* source, size_t length, const Signature* signature, const ModuleInformation& module)

366366{

367367 Validate context(module);

368 FunctionParser<Validate> validator(vm, context, source, length, signature, ~~functionIndexSpace,~~ module);

368 FunctionParser<Validate> validator(vm, context, source, length, signature, module);

    WASM_FAIL_IF_HELPER_FAILS(validator.parse());

    return { };

}

Source/JavaScriptCore/wasm/WasmValidate.h

@@class VM;

namespace Wasm {

39 Expected<void, String> validateFunction(VM*, const uint8_t*, size_t, const Signature*, const ~~ImmutableFunctionIndexSpace&, const~~ ModuleInformation&);

39Expected<void, String> validateFunction(VM*, const uint8_t*, size_t, const Signature*, const ModuleInformation&);

} } // namespace JSC::Wasm

Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h

@@public:

        return offsetOfImportFunctions() + sizeof(WriteBarrier<JSCell>) * idx;

    }

89 static ptrdiff_t offsetOfMemory() { return OBJECT_OFFSETOF(JSWebAssemblyInstance, m_memory); }

8990 static ptrdiff_t offsetOfTable() { return OBJECT_OFFSETOF(JSWebAssemblyInstance, m_table); }

9091 static ptrdiff_t offsetOfGlobals() { return OBJECT_OFFSETOF(JSWebAssemblyInstance, m_globals); }

92 static size_t offsetOfImportFunctions() { return WTF::roundUpToMultipleOf<sizeof(WriteBarrier<JSCell>)>(sizeof(JSWebAssemblyInstance)); }

93 static size_t offsetOfImportFunction(size_t importFunctionNum) { return offsetOfImportFunctions() + importFunctionNum * sizeof(sizeof(WriteBarrier<JSCell>)); }

protected:

    JSWebAssemblyInstance(VM&, Structure*, unsigned numImportFunctions);

@@protected:

    static void destroy(JSCell*);

    static void visitChildren(JSCell*, SlotVisitor&);

    static size_t offsetOfImportFunctions()

    {

        return WTF::roundUpToMultipleOf<sizeof(WriteBarrier<JSCell>)>(sizeof(JSWebAssemblyInstance));

    }

    static size_t allocationSize(unsigned numImportFunctions)

    {

        return offsetOfImportFunctions() + sizeof(WriteBarrier<JSCell>) * numImportFunctions;

Source/JavaScriptCore/wasm/js/JSWebAssemblyMemory.cpp

@@namespace JSC {

const ClassInfo JSWebAssemblyMemory::s_info = { "WebAssembly.Memory", &Base::s_info, 0, CREATE_METHOD_TABLE(JSWebAssemblyMemory) };

40 JSWebAssemblyMemory* JSWebAssemblyMemory::create(VM& vm, Structure* structure, ~~std::unique_ptr<~~Wasm::Memory>&& memory)

40JSWebAssemblyMemory* JSWebAssemblyMemory::create(VM& vm, Structure* structure, Wasm::Memory&& memory)

4141{

42 auto* instance = new (NotNull, allocateCell<JSWebAssemblyMemory>(vm.heap)) JSWebAssemblyMemory(vm, structure, ~~WTF~~M~~ove~~(memory));

42 auto* instance = new (NotNull, allocateCell<JSWebAssemblyMemory>(vm.heap)) JSWebAssemblyMemory(vm, structure, std::forward<Wasm::Memory>(memory));

    instance->finishCreation(vm);

    return instance;

}

@@Structure* JSWebAssemblyMemory::createStructure(VM& vm, JSGlobalObject* globalOb

    return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());

}

52 JSWebAssemblyMemory::JSWebAssemblyMemory(VM& vm, Structure* structure, ~~std::unique_ptr<~~Wasm::Memory>&& memory)

52JSWebAssemblyMemory::JSWebAssemblyMemory(VM& vm, Structure* structure, Wasm::Memory&& memory)

    : Base(vm, structure)

    , m_memory(WTFMove(memory))

{

@@JSArrayBuffer* JSWebAssemblyMemory::buffer(VM& vm, JSGlobalObject* globalObject)

    auto destructor = [] (void*) {

        // We don't need to do anything here to destroy the memory.

        // The ArrayBuffer backing the JSArrayBuffer is only owned by us,

66 // so we guarantee its lifecylce.

66 // so we guarantee its lifecycle.

    };

    m_buffer = ArrayBuffer::createFromBytes(memory()->memory(), memory()->size(), WTFMove(destructor));

    m_bufferWrapper.set(vm, this, JSArrayBuffer::create(vm, globalObject->m_arrayBufferStructure.get(), m_buffer.get()));

Source/JavaScriptCore/wasm/js/JSWebAssemblyMemory.h

@@class JSWebAssemblyMemory : public JSDestructibleObject {

public:

    typedef JSDestructibleObject Base;

44 static JSWebAssemblyMemory* create(VM&, Structure*, ~~std::unique_ptr<~~Wasm::Memory>&&);

44 static JSWebAssemblyMemory* create(VM&, Structure*, Wasm::Memory&&);

    static Structure* createStructure(VM&, JSGlobalObject*, JSValue);

    DECLARE_INFO;

49 Wasm::Memory* memory() { return m_memory~~.get()~~; }

49 Wasm::Memory* memory() { return &m_memory; }

5050 JSArrayBuffer* buffer(VM& vm, JSGlobalObject*);

5151

    static ptrdiff_t offsetOfMemory() { return OBJECT_OFFSETOF(JSWebAssemblyMemory, m_memory) + Wasm::Memory::offsetOfMemory(); }

    static ptrdiff_t offsetOfSize() { return OBJECT_OFFSETOF(JSWebAssemblyMemory, m_memory) + Wasm::Memory::offsetOfSize(); }

5255protected:

53 JSWebAssemblyMemory(VM&, Structure*, ~~std::unique_ptr<~~Wasm::Memory>&&);

56 JSWebAssemblyMemory(VM&, Structure*, Wasm::Memory&&);

    void finishCreation(VM&);

    static void destroy(JSCell*);

    static void visitChildren(JSCell*, SlotVisitor&);

58 ~~std::unique_ptr<~~Wasm::Memory> m_memory;

61 Wasm::Memory m_memory;

    WriteBarrier<JSArrayBuffer> m_bufferWrapper;

    RefPtr<ArrayBuffer> m_buffer;

};

Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.cpp

@@namespace JSC {

const ClassInfo JSWebAssemblyModule::s_info = { "WebAssembly.Module", &Base::s_info, nullptr, CREATE_METHOD_TABLE(JSWebAssemblyModule) };

41 JSWebAssemblyModule* JSWebAssemblyModule::create(VM& vm, Structure* structure, std::unique_ptr<Wasm::ModuleInformation>&& moduleInformation, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::Wasm~~ToJS~~Stub>&& wasm~~ToJS~~Stubs~~, Wasm::ImmutableFunctionIndexSpace&& functionIndexSpace~~, SymbolTable* exportSymbolTable, unsigned calleeCount)

41JSWebAssemblyModule* JSWebAssemblyModule::create(VM& vm, Structure* structure, std::unique_ptr<Wasm::ModuleInformation>&& moduleInformation, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& wasmExitStubs, SymbolTable* exportSymbolTable, unsigned calleeCount)

4242{

43 auto* instance = new (NotNull, allocateCell<JSWebAssemblyModule>(vm.heap, allocationSize(calleeCount))) JSWebAssemblyModule(vm, structure, std::forward<std::unique_ptr<Wasm::ModuleInformation>>(moduleInformation), std::forward<Bag<CallLinkInfo>>(callLinkInfos), std::forward<Vector<Wasm::Wasm~~ToJS~~Stub>>(wasm~~ToJS~~Stubs~~), std::forward<Wasm::ImmutableFunctionIndexSpace>(functionIndexSpace~~), calleeCount);

43 auto* instance = new (NotNull, allocateCell<JSWebAssemblyModule>(vm.heap, allocationSize(calleeCount))) JSWebAssemblyModule(vm, structure, std::forward<std::unique_ptr<Wasm::ModuleInformation>>(moduleInformation), std::forward<Bag<CallLinkInfo>>(callLinkInfos), std::forward<Vector<Wasm::WasmExitStubs>>(wasmExitStubs), calleeCount);

    instance->finishCreation(vm, exportSymbolTable);

    return instance;

}

@@Structure* JSWebAssemblyModule::createStructure(VM& vm, JSGlobalObject* globalOb

    return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());

}

53 JSWebAssemblyModule::JSWebAssemblyModule(VM& vm, Structure* structure, std::unique_ptr<Wasm::ModuleInformation>&& moduleInformation, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::Wasm~~ToJS~~Stub>&& wasm~~ToJS~~Stubs~~, Wasm::ImmutableFunctionIndexSpace&& functionIndexSpace~~, unsigned calleeCount)

53JSWebAssemblyModule::JSWebAssemblyModule(VM& vm, Structure* structure, std::unique_ptr<Wasm::ModuleInformation>&& moduleInformation, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& wasmExitStubs, unsigned calleeCount)

    : Base(vm, structure)

    , m_moduleInformation(WTFMove(moduleInformation))

    , m_callLinkInfos(WTFMove(callLinkInfos))

57 , m_wasmToJSStubs(WTFMove(wasmToJSStubs))

58 , m_functionIndexSpace(WTFMove(functionIndexSpace))

57 , m_wasmExitStubs(WTFMove(wasmExitStubs))

    , m_calleeCount(calleeCount)

{

    memset(callees(), 0, m_calleeCount * sizeof(WriteBarrier<JSWebAssemblyCallee>) * 2);

Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.h

@@class JSWebAssemblyModule : public JSDestructibleObject {

public:

    typedef JSDestructibleObject Base;

46 static JSWebAssemblyModule* create(VM&, Structure*, std::unique_ptr<Wasm::ModuleInformation>&&, Bag<CallLinkInfo>&&, Vector<Wasm::Wasm~~ToJS~~Stub~~>&&, Wasm::ImmutableFunctionIndexSpace~~&&, SymbolTable*, unsigned);

46 static JSWebAssemblyModule* create(VM&, Structure*, std::unique_ptr<Wasm::ModuleInformation>&&, Bag<CallLinkInfo>&&, Vector<Wasm::WasmExitStubs>&&, SymbolTable*, unsigned);

    static Structure* createStructure(VM&, JSGlobalObject*, JSValue);

    DECLARE_INFO;

    const Wasm::ModuleInformation& moduleInformation() const { return *m_moduleInformation.get(); }

    SymbolTable* exportSymbolTable() const { return m_exportSymbolTable.get(); }

53 Wasm::SignatureIndex signatureForFunctionIndexSpace(unsigned functionIndexSpace) const

53 Wasm::SignatureIndex signatureIndexFromFunctionIndexSpace(unsigned functionIndexSpace) const

5454 {

55 ASSERT(functionIndexSpace < m_functionIndexSpace.size);

56 return m_functionIndexSpace.buffer.get()[functionIndexSpace].signatureIndex;

55 return m_moduleInformation->signatureIndexFromFunctionIndexSpace(functionIndexSpace);

5756 }

58 unsigned importCount() const { return m_wasm~~ToJS~~Stubs.size(); }

57 unsigned importCount() const { return m_wasmExitStubs.size(); }

    JSWebAssemblyCallee* jsEntrypointCalleeFromFunctionIndexSpace(unsigned functionIndexSpace)

    {

@@public:

        return bitwise_cast<WriteBarrier<JSWebAssemblyCallee>*>(bitwise_cast<char*>(this) + offsetOfCallees());

    }

93 static ptrdiff_t offsetOfFunctionIndexSpace() { return OBJECT_OFFSETOF(JSWebAssemblyModule, m_functionIndexSpace); }

94

9592protected:

96 JSWebAssemblyModule(VM&, Structure*, std::unique_ptr<Wasm::ModuleInformation>&&, Bag<CallLinkInfo>&&, Vector<Wasm::Wasm~~ToJS~~Stub~~>&&, Wasm::ImmutableFunctionIndexSpace~~&&, unsigned calleeCount);

93 JSWebAssemblyModule(VM&, Structure*, std::unique_ptr<Wasm::ModuleInformation>&&, Bag<CallLinkInfo>&&, Vector<Wasm::WasmExitStubs>&&, unsigned calleeCount);

    void finishCreation(VM&, SymbolTable*);

    static void destroy(JSCell*);

    static void visitChildren(JSCell*, SlotVisitor&);

@@private:

    std::unique_ptr<Wasm::ModuleInformation> m_moduleInformation;

    Bag<CallLinkInfo> m_callLinkInfos;

    WriteBarrier<SymbolTable> m_exportSymbolTable;

120 Vector<Wasm::WasmToJSStub> m_wasmToJSStubs;

121 const Wasm::ImmutableFunctionIndexSpace m_functionIndexSpace;

117 Vector<Wasm::WasmExitStubs> m_wasmExitStubs;

    unsigned m_calleeCount;

};

Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp

@@static EncodedJSValue JSC_HOST_CALL callWebAssemblyFunction(ExecState* exec)

EncodedJSValue WebAssemblyFunction::call(VM& vm, ProtoCallFrame* protoCallFrame)

{

    // Setup the memory that the entrance loads.

    if (JSWebAssemblyMemory* memory = instance()->memory()) {

        Wasm::Memory* wasmMemory = memory->memory();

        vm.topWasmMemoryPointer = wasmMemory->memory();

        vm.topWasmMemorySize = wasmMemory->size();

    } else {

        vm.topWasmMemoryPointer = nullptr;

        vm.topWasmMemorySize = 0;

    }

108 // FIXME Do away with this entire function, and only use the entrypoint generated by B3. https://bugs.webkit.org/show_bug.cgi?id=166486

    JSWebAssemblyInstance* prevJSWebAssemblyInstance = vm.topJSWebAssemblyInstance;

    vm.topJSWebAssemblyInstance = instance();

    ASSERT(instance());

@@WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalO

Structure* WebAssemblyFunction::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

{

    ASSERT(globalObject);

156 return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info());

147 return Structure::create(vm, globalObject, prototype, TypeInfo(WebAssemblyFunctionType, StructureFlags), info());

}

WebAssemblyFunction::WebAssemblyFunction(VM& vm, JSGlobalObject* globalObject, Structure* structure, Wasm::SignatureIndex signatureIndex)

Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp

@@static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyInstance(ExecState* ex

                return JSValue::encode(throwException(exec, throwScope, createJSWebAssemblyLinkError(exec, vm, ASCIILiteral("import function must be callable"))));

            JSCell* cell = value.asCell();

            // ii. If v is an Exported Function Exotic Object:

            if (WebAssemblyFunction* importedExports = jsDynamicCast<WebAssemblyFunction*>(object)) {

                // FIXME handle Function Exotic Object properly. https://bugs.webkit.org/show_bug.cgi?id=165282

                // a. If the signature of v does not match the signature of i, throw a TypeError.

            if (WebAssemblyFunction* importedExport = jsDynamicCast<WebAssemblyFunction*>(cell)) {

                // a. If the signature of v does not match the signature of i, throw a WebAssembly.LinkError.

                Wasm::SignatureIndex importedSignatureIndex = importedExport->signatureIndex();

                Wasm::SignatureIndex expectedSignatureIndex = moduleInformation.importFunctionSignatureIndices[import.kindIndex];

                if (importedSignatureIndex != expectedSignatureIndex)

                    return JSValue::encode(throwException(exec, throwScope, createJSWebAssemblyLinkError(exec, vm, ASCIILiteral("imported function's signature mismatches the provided WebAssembly function's signature"))));

120123 // b. Let closure be v.[[Closure]].

                RELEASE_ASSERT_NOT_REACHED();

                UNUSED_PARAM(importedExports);

                break;

            }

            // iii. Otherwise:

            // a. Let closure be a new host function of the given signature which calls v by coercing WebAssembly arguments to JavaScript arguments via ToJSValue and returns the result, if any, by coercing via ToWebAssemblyValue.

            // Note: done as part of Plan compilation.

            // iv. Append v to funcs.

129 // Note: adding the JSCell to the instance list fulfills closure requirements b. above (the WebAssembly.Instance wil be kept alive) and v. below (the JSFunction).

            instance->setImportFunction(vm, cell, numImportFunctions++);

            // v. Append closure to imports.

            break;

@@static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyInstance(ExecState* ex

        if (moduleInformation.memory && !hasMemoryImport) {

            RELEASE_ASSERT(!moduleInformation.memory.isImport());

            // We create a memory when it's a memory definition.

232 ~~std::unique_ptr<~~Wasm::Memory> memory ~~= std::make_unique<Wasm::Memory>~~(moduleInformation.memory.initial(), moduleInformation.memory.maximum());

233 if (!memory->isValid())

233 Wasm::Memory memory(moduleInformation.memory.initial(), moduleInformation.memory.maximum());

234 if (!memory.isValid())

                return JSValue::encode(throwException(exec, throwScope, createOutOfMemoryError(exec)));

            instance->setMemory(vm,

               JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory)));

Source/JavaScriptCore/wasm/js/WebAssemblyMemoryConstructor.cpp

@@static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyMemory(ExecState* exec

        }

    }

99 ~~std::unique_ptr<~~Wasm::Memory> memory ~~= std::make_unique<Wasm::Memory>~~(initialPageCount, maximumPageCount);

100 if (!memory->isValid())

99 Wasm::Memory memory(initialPageCount, maximumPageCount);

100 if (!memory.isValid())

        return JSValue::encode(throwException(exec, throwScope, createOutOfMemoryError(exec)));

    return JSValue::encode(JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory)));

Source/JavaScriptCore/wasm/js/WebAssemblyModuleConstructor.cpp

@@JSValue WebAssemblyModuleConstructor::createModule(ExecState* state, Structure*

    // Only wasm-internal functions have a callee, stubs to JS do not.

    unsigned calleeCount = plan.internalFunctionCount();

100 JSWebAssemblyModule* result = JSWebAssemblyModule::create(vm, structure, plan.takeModuleInformation(), plan.takeCallLinkInfos(), plan.takeWasm~~ToJS~~Stubs~~(), plan.takeFunctionIndexSpace~~(), exportSymbolTable, calleeCount);

100 JSWebAssemblyModule* result = JSWebAssemblyModule::create(vm, structure, plan.takeModuleInformation(), plan.takeCallLinkInfos(), plan.takeWasmExitStubs(), exportSymbolTable, calleeCount);

    plan.initializeCallees(state->jsCallee()->globalObject(), 

        [&] (unsigned calleeIndex, JSWebAssemblyCallee* jsEntrypointCallee, JSWebAssemblyCallee* wasmEntrypointCallee) {

            result->setJSEntrypointCallee(vm, calleeIndex, jsEntrypointCallee);

Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp

@@void WebAssemblyModuleRecord::link(ExecState* state, JSWebAssemblyInstance* inst

            //     c. Return func.

            JSWebAssemblyCallee* jsEntrypointCallee = module->jsEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);

            JSWebAssemblyCallee* wasmEntrypointCallee = module->wasmEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);

121 Wasm::SignatureIndex signatureIndex = module->signatureForFunctionIndexSpace(exp.kindIndex);

121 Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(exp.kindIndex);

            const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);

            WebAssemblyFunction* function = WebAssemblyFunction::create(vm, globalObject, signature->argumentCount(), exp.field.string(), instance, jsEntrypointCallee, wasmEntrypointCallee, signatureIndex);

            exportedValue = function;

@@void WebAssemblyModuleRecord::link(ExecState* state, JSWebAssemblyInstance* inst

    bool hasStart = !!moduleInformation.startFunctionIndexSpace;

    if (hasStart) {

        auto startFunctionIndexSpace = moduleInformation.startFunctionIndexSpace.value_or(0);

178 Wasm::SignatureIndex signatureIndex = module->signatureForFunctionIndexSpace(startFunctionIndexSpace);

178 Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(startFunctionIndexSpace);

        const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);

        // The start function must not take any arguments or return anything. This is enforced by the parser.

        ASSERT(!signature->argumentCount());

@@JSValue WebAssemblyModuleRecord::evaluate(ExecState* state)

                JSWebAssemblyCallee* jsEntrypointCallee = module->jsEntrypointCalleeFromFunctionIndexSpace(functionIndex);

                JSWebAssemblyCallee* wasmEntrypointCallee = module->wasmEntrypointCalleeFromFunctionIndexSpace(functionIndex);

241 Wasm::SignatureIndex signatureIndex = module->signatureForFunctionIndexSpace(functionIndex);

241 Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(functionIndex);

                const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);

                // FIXME: Say we export local function "foo" at funciton index 0.

                // What if we also set it to the table an Element w/ index 0.