diff options
Diffstat (limited to 'js/src/jit-test/tests/wasm/regress/bug1440512.js')
| -rw-r--r-- | js/src/jit-test/tests/wasm/regress/bug1440512.js | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/regress/bug1440512.js b/js/src/jit-test/tests/wasm/regress/bug1440512.js new file mode 100644 index 0000000000..1997b34f7f --- /dev/null +++ b/js/src/jit-test/tests/wasm/regress/bug1440512.js @@ -0,0 +1,216 @@ +// |jit-test| skip-if: !wasmDebuggingEnabled() +var g = newGlobal({newCompartment: true}); +var dbg = new g.Debugger(this); +var dbg = new Debugger; +var kWasmH0 = 0; +var kWasmH1 = 0x61; +var kWasmH2 = 0x73; +var kWasmH3 = 0x6d; +var kWasmV0 = 0x1; +var kWasmV1 = 0; +var kWasmV2 = 0; +var kWasmV3 = 0; +let kTypeSectionCode = 1; // Function signature declarations +let kImportSectionCode = 2; // Import declarations +let kFunctionSectionCode = 3; // Function declarations +let kExportSectionCode = 7; // Exports +let kCodeSectionCode = 10; // Function code +let kWasmFunctionTypeForm = 0x60; +let kWasmI32 = 0x7f; +let kExternalFunction = 0; +let kSig_i_i = makeSig([kWasmI32], [kWasmI32]); +function makeSig(params, results) { + return { + params: params, + results: results + }; +} +let kExprEnd = 0x0b; +let kExprGetLocal = 0x20; +class Binary extends Array { + emit_u8(val) { + this.push(val); + } + emit_u32v(val) { + while (true) { + let v = val & 0xff; + val = val >>> 7; + this.push(v); + break; + } + } + emit_bytes(data) { + for (let i = 0; i < data.length; i++) { + this.push(data[i] & 0xff); + } + } + emit_string(string) { + let string_utf8 = unescape(encodeURIComponent(string)); + this.emit_u32v(string_utf8.length); + for (let i = 0; i < string_utf8.length; i++) { + this.emit_u8(string_utf8.charCodeAt(i)); + } + } + emit_header() { + this.push(kWasmH0, kWasmH1, kWasmH2, kWasmH3, kWasmV0, kWasmV1, kWasmV2, kWasmV3); + } + emit_section(section_code, content_generator) { + this.emit_u8(section_code); + let section = new Binary; + content_generator(section); + this.emit_u32v(section.length); + for (var i = 0; i < section.length; i++) this.push(section[i]); + } +} +class WasmFunctionBuilder { + constructor(module, name, type_index) { + this.module = module; + } + exportAs(name) { + this.module.addExport(name, this.index); + } + addBody(body) { + this.body = body.slice(); + this.body.push(kExprEnd); + return this; + } +} +class WasmModuleBuilder { + constructor() { + this.types = []; + this.imports = []; + this.exports = []; + this.functions = []; + } + addType(type) { + this.types.push(type); + } + addFunction(name, type) { + let type_index = (typeof type) == "number" ? type : this.addType(type); + let func = new WasmFunctionBuilder(this, name, type_index); + this.functions.push(func); + return func; + } + addImport(module = "", name, type) { + this.imports.push({ + module: module, + name: name, + kind: kExternalFunction, + }); + } + addExport(name, index) { + this.exports.push({ + name: name, + }); + } + toArray(debug = false) { + let binary = new Binary; + let wasm = this; + binary.emit_header(); + if (wasm.types.length > 0) { + binary.emit_section(kTypeSectionCode, section => { + section.emit_u32v(wasm.types.length); + for (let type of wasm.types) { + section.emit_u8(kWasmFunctionTypeForm); + section.emit_u32v(type.params.length); + for (let param of type.params) { + section.emit_u8(param); + } + section.emit_u32v(type.results.length); + for (let result of type.results) { + section.emit_u8(result); + } + } + }); + binary.emit_section(kImportSectionCode, section => { + section.emit_u32v(wasm.imports.length); + for (let imp of wasm.imports) { + section.emit_string(imp.module); + section.emit_string(imp.name || ''); + section.emit_u8(imp.kind); + if (imp.kind == kExternalFunction) { + section.emit_u32v(imp.type); + } + } + }); + binary.emit_section(kFunctionSectionCode, section => { + section.emit_u32v(wasm.functions.length); + for (let func of wasm.functions) { + section.emit_u32v(func.type_index); + } + }); + } + var mem_export = (wasm.memory !== undefined && wasm.memory.exp); + var exports_count = wasm.exports.length + (mem_export ? 1 : 0); + if (exports_count > 0) { + binary.emit_section(kExportSectionCode, section => { + section.emit_u32v(exports_count); + for (let exp of wasm.exports) { + section.emit_string(exp.name); + section.emit_u8(exp.kind); + section.emit_u8(0); + } + }); + } + if (wasm.start_index !== undefined) { + } + if (wasm.functions.length > 0) { + binary.emit_section(kCodeSectionCode, section => { + section.emit_u32v(wasm.functions.length); + for (let func of wasm.functions) { + let local_decls = []; + let header = new Binary; + header.emit_u32v(local_decls.length); + section.emit_u32v(header.length + func.body.length); + section.emit_bytes(header); + section.emit_bytes(func.body); + } + }); + } + let num_function_names = 0; + let num_functions_with_local_names = 0; + if (num_function_names > 0 || num_functions_with_local_names > 0 || wasm.name !== undefined) { + binary.emit_section(kUnknownSectionCode, section => { + if (num_function_names > 0) { + } + }); + } + return binary; + } + toBuffer(debug = false) { + let bytes = this.toArray(debug); + let buffer = new ArrayBuffer(bytes.length); + let view = new Uint8Array(buffer); + for (let i = 0; i < bytes.length; i++) { + let val = bytes[i]; + view[i] = val | 0; + } + return buffer; + } + toModule(debug = false) { + return new WebAssembly.Module(this.toBuffer(debug)); + } +} +const verifyHeap = gc; +function testProperties(obj) { + for (let i = 0; i < 3; i++) { + verifyHeap(); + } +} +(function ExportedFunctionTest() { + var builder = new WasmModuleBuilder(); + builder.addFunction("exp", kSig_i_i).addBody([ + kExprGetLocal, 0, + ]).exportAs("exp"); + let module1 = builder.toModule(); + let instance1 = new WebAssembly.Instance(module1); + let g = instance1.exports.exp; + testProperties(g); + builder.addImport("imp", "func", kSig_i_i); + let module2 = builder.toModule(); + let instance2 = new WebAssembly.Instance(module2, { + imp: { + func: g + } + }); +})(); |