WebKit · webkit-commit-queue · Jun 6, 2025 · Jun 6, 2025
@@ -0,0 +1,139 @@
+//@ skip if !$isSIMDPlatform
+
+async function instantiate(imports={}, runInitializer=true) {
+    const cachedJsObjects = new WeakMap();
+    // ref must be non-null
+    function getCachedJsObject(ref, ifNotCached) {
+        if (typeof ref !== 'object' && typeof ref !== 'function') return ifNotCached;
+        const cached = cachedJsObjects.get(ref);
+        if (cached !== void 0) return cached;
+        cachedJsObjects.set(ref, ifNotCached);
+        return ifNotCached;
+    }
+
+
+
+    const js_code = {
+        'kotlin.captureStackTrace' : () => new Error().stack,
+        'kotlin.wasm.internal.throwJsError' : (message, wasmTypeName, stack) => { 
+            const error = new Error();
+            error.message = message;
+            error.name = wasmTypeName;
+            error.stack = stack;
+            throw error;
+             },
+        'kotlin.wasm.internal.stringLength' : (x) => x.length,
+        'kotlin.wasm.internal.jsExportStringToWasm' : (src, srcOffset, srcLength, dstAddr) => { 
+            const mem16 = new Uint16Array(wasmExports.memory.buffer, dstAddr, srcLength);
+            let arrayIndex = 0;
+            let srcIndex = srcOffset;
+            while (arrayIndex < srcLength) {
+                mem16.set([src.charCodeAt(srcIndex)], arrayIndex);
+                srcIndex++;
+                arrayIndex++;
+            }     
+             },
+        'kotlin.wasm.internal.importStringFromWasm' : (address, length, prefix) => { 
+            const mem16 = new Uint16Array(wasmExports.memory.buffer, address, length);
+            const str = String.fromCharCode.apply(null, mem16);
+            return (prefix == null) ? str : prefix + str;
+             },
+        'kotlin.wasm.internal.getJsEmptyString' : () => '',
+        'kotlin.wasm.internal.isNullish' : (ref) => ref == null,
+        'kotlin.wasm.internal.getCachedJsObject_$external_fun' : (p0, p1) => getCachedJsObject(p0, p1),
+        'kotlin.js.stackPlaceHolder_js_code' : () => (''),
+        'kotlin.js.message_$external_prop_getter' : (_this) => _this.message,
+        'kotlin.js.stack_$external_prop_getter' : (_this) => _this.stack,
+        'kotlin.js.JsError_$external_class_instanceof' : (x) => x instanceof Error
+    }
+
+    // Placed here to give access to it from externals (js_code)
+    let wasmInstance;
+    let require; 
+    let wasmExports;
+
+    const isNodeJs = (typeof process !== 'undefined') && (process.release.name === 'node');
+    const isDeno = !isNodeJs && (typeof Deno !== 'undefined')
+    const isStandaloneJsVM =
+        !isDeno && !isNodeJs && (
+            typeof d8 !== 'undefined' // V8
+            || typeof inIon !== 'undefined' // SpiderMonkey
+            || typeof jscOptions !== 'undefined' // JavaScriptCore
+        );
+    const isBrowser = !isNodeJs && !isDeno && !isStandaloneJsVM && (typeof window !== 'undefined' || typeof self !== 'undefined');
+
+    if (!isNodeJs && !isDeno && !isStandaloneJsVM && !isBrowser) {
+      throw "Supported JS engine not detected";
+    }
+
+    const wasmFilePath = './resources/wasm-gc-ref-cast.wasm';
+    const importObject = {
+        js_code,
+        intrinsics: {
+
+        },
+
+    };
+
+      if (isNodeJs) {
+        const module = await import(/* webpackIgnore: true */'node:module');
+        const importMeta = import.meta;
+        require = module.default.createRequire(importMeta.url);
+        const fs = require('fs');
+        const url = require('url');
+        const filepath = import.meta.resolve(wasmFilePath);
+        const wasmBuffer = fs.readFileSync(url.fileURLToPath(filepath));
+        const wasmModule = new WebAssembly.Module(wasmBuffer);
+        wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+      }
+
+      if (isDeno) {
+        const path = await import(/* webpackIgnore: true */'https://deno.land/std/path/mod.ts');
+        const binary = Deno.readFileSync(path.fromFileUrl(import.meta.resolve(wasmFilePath)));
+        const module = await WebAssembly.compile(binary);
+        wasmInstance = await WebAssembly.instantiate(module, importObject);
+      }
+
+      if (isStandaloneJsVM) {
+        const wasmBuffer = read(wasmFilePath, 'binary');
+        const wasmModule = new WebAssembly.Module(wasmBuffer);
+        wasmInstance = new WebAssembly.Instance(wasmModule, importObject);
+      }
+
+      if (isBrowser) {
+        wasmInstance = (await WebAssembly.instantiateStreaming(fetch(new URL('./resources/wasm-gc-ref-cast.wasm',import.meta.url).href), importObject)).instance;
+      }
+
+    wasmExports = wasmInstance.exports;
+    if (runInitializer) {
+        wasmExports._initialize();
+    }
+
+    return { instance: wasmInstance,  exports: wasmExports };
+}
+
+globalThis.console = {
+    log: print
+};
+
+if ($vm.useJIT()) {
+    let actualResult;
+    try {
+        let jsModule = (await instantiate({
+        })).exports;
+        actualResult = jsModule.box();
+    } catch(e) {
+        if (e instanceof WebAssembly.CompileError) {
+            actualResult = "OK";
+        } else {
+            console.log('Failed with exception!')
+            console.log('Message: ' + e.message)
+            console.log('Name:    ' + e.name)
+            console.log('Stack:')
+            console.log(e.stack)
+        }
+    }
+
+    if (actualResult !== "OK")
+        throw `Wrong box result '${actualResult}'; Expected "OK"`;
+}
@@ -838,7 +838,7 @@ struct WasmToWasmImportableFunction : public WasmCallableFunction {
     // FIXME: Pack type index and code pointer into one 64-bit value. See <https://bugs.webkit.org/show_bug.cgi?id=165511>.
     TypeIndex typeIndex { TypeDefinition::invalidIndex };
     // Used when GC proposal is enabled, otherwise can be null.
-    const RTT* rtt;
+    const RTT* rtt { nullptr };
 };
 using FunctionIndexSpace = Vector<WasmToWasmImportableFunction>;
 

@@ -3792,12 +3792,7 @@ void OMGIRGenerator::emitCheckOrBranchForCast(CastKind kind, Value* condition, c
 
 Value* OMGIRGenerator::emitLoadRTTFromFuncref(Value* funcref)
 {
-    PatchpointValue* patch = m_currentBlock->appendNew<PatchpointValue>(m_proc, pointerType(), Origin());
-    patch->append(funcref, ValueRep::SomeRegister);
-    patch->setGenerator([](CCallHelpers& jit, const B3::StackmapGenerationParams& params) {
-        jit.loadCompactPtr(CCallHelpers::Address(params[1].gpr(), WebAssemblyFunctionBase::offsetOfRTT()), params[0].gpr());
-    });
-    return patch;
+    return m_currentBlock->appendNew<MemoryValue>(m_proc, B3::Load, pointerType(), origin(), funcref, safeCast<int32_t>(WebAssemblyFunctionBase::offsetOfRTT()));
 }
 
 Value* OMGIRGenerator::decodeNonNullStructure(Value* structureID)

@@ -3853,12 +3853,7 @@ void OMGIRGenerator::emitCheckOrBranchForCast(CastKind kind, Value* condition, c
 
 Value* OMGIRGenerator::emitLoadRTTFromFuncref(Value* funcref)
 {
-    PatchpointValue* patch = m_currentBlock->appendNew<PatchpointValue>(m_proc, pointerType(), Origin());
-    patch->append(funcref, ValueRep::SomeRegister);
-    patch->setGenerator([](CCallHelpers& jit, const B3::StackmapGenerationParams& params) {
-        jit.loadCompactPtr(CCallHelpers::Address(params[1].gpr(), WebAssemblyFunctionBase::offsetOfRTT()), params[0].gpr());
-    });
-    return patch;
+    return m_currentBlock->appendNew<MemoryValue>(m_proc, B3::Load, pointerType(), origin(), funcref, safeCast<int32_t>(WebAssemblyFunctionBase::offsetOfRTT()));
 }
 
 Value* OMGIRGenerator::decodeNonNullStructure(Value* structureID)