<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[207363] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/207363">207363</a></dd>
<dt>Author</dt> <dd>jfbastien@apple.com</dd>
<dt>Date</dt> <dd>2016-10-14 17:10:31 -0700 (Fri, 14 Oct 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Basic WebAssembly testing
Create a small DSL in JavaScript which can build WebAssembly binary modules based on the JSON description of the format as described in:
https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
This DSL can then be used to write small text description of valid and invalid WebAssembly binaries, making testing the JSC implementation much easier.
Details and example in README.md.
Basic WebAssembly testing
https://bugs.webkit.org/show_bug.cgi?id=163267
Reviewed by Keith Miller.
JSTests:
* stress/wasm/wasm.json: Removed.
* wasm.yaml: Added.
* wasm/Builder.js: Added.
(const._isValidValue):
(const._BuildWebAssemblyBinary):
(export.default.Builder):
(export.default.Builder.prototype.setChecked):
(export.default.Builder.prototype.setPreamble):
(export.default.Builder.prototype._registerSectionBuilders.switch.case.string_appeared_here.this.section):
(export.default.Builder.prototype._registerSectionBuilders.this.Unknown):
(export.default.Builder.prototype._registerSectionBuilders):
(export.default.Builder.prototype._addSection):
(export.default.Builder.prototype.optimize):
(export.default.Builder.prototype.json):
(export.default.Builder.prototype.AsmJS):
(export.default.Builder.prototype.WebAssembly):
* wasm/LowLevelBinary.js: Added.
(const._getterRangeCheck):
(const._hexdump):
(export.default.LowLevelBinary):
(export.default.LowLevelBinary.prototype.newPatchable):
(export.default.LowLevelBinary.prototype.hexdump):
(export.default.LowLevelBinary.prototype._maybeGrow):
(export.default.LowLevelBinary.prototype._push8):
(export.default.LowLevelBinary.prototype.uint8):
(export.default.LowLevelBinary.prototype.uint16):
(export.default.LowLevelBinary.prototype.uint32):
(export.default.LowLevelBinary.prototype.varuint):
(export.default.LowLevelBinary.prototype.varint):
(export.default.LowLevelBinary.prototype.varuint7):
(export.default.LowLevelBinary.prototype.string):
(export.default.LowLevelBinary.prototype.getSize):
(export.default.LowLevelBinary.prototype.getUint8):
(export.default.LowLevelBinary.prototype.getUint16):
(export.default.LowLevelBinary.prototype.getUint32):
(export.default.LowLevelBinary.prototype.getVaruint):
(export.default.LowLevelBinary.prototype.getVarint):
(export.default.LowLevelBinary.prototype.getVaruint7):
(export.default.LowLevelBinary.prototype.getString):
(PatchableLowLevelBinary):
(PatchableLowLevelBinary.prototype._push8):
(PatchableLowLevelBinary.prototype.apply):
* wasm/README.md: Added.
* wasm/WASM.js: Added.
* wasm/assert.js: Added.
(export.const.notUndef):
(export.const.eq):
(export.const.ge):
(export.const.throwsError):
(export.const.throwsRangeError):
* wasm/generate-wasmops-header.js: Renamed from JSTests/stress/wasm/generate-wasmops-header.js.
* wasm/self-test/test_BuilderJSON.js: Added.
(const.assertOpThrows):
(EmptyModule):
(CustomMagicNumber):
(CustomVersion):
(CustomSection):
(CustomSectionAllBytes):
(CustomSectionInvalidByte):
(TwoCustomSections):
(EmptyCodeSection):
(CodeSectionWithEmptyFunction):
(CodeSectionWithEmptyFunctionWithParameters):
(InvalidFunctionParameters):
(SimpleFunction):
(TwoSimpleFunctions):
(TwoBuildersAtTheSameTime):
(CheckedOpcodeArgumentsTooMany):
(CheckedOpcodeArgumentsNotEnough):
(CallNoArguments):
(CallInvalid):
(I32ConstInvalid):
(F32ConstInvalid):
(F64ConstInvalid):
(CallManyFromStack):
(OpcodeAdd):
(OpcodeUnreachable):
(OpcodeUnreachableCombinations):
(OpcodeSelect):
* wasm/self-test/test_BuilderWebAssembly.js: Added.
(EmptyModule):
(CustomSection):
(Basic):
* wasm/self-test/test_LowLevelBinary_encode.js: Added.
* wasm/self-test/test_LowLevelBinary_string.js: Added.
* wasm/self-test/test_LowLevelBinary_uint16.js: Added.
* wasm/self-test/test_LowLevelBinary_uint32.js: Added.
* wasm/self-test/test_LowLevelBinary_uint8.js: Added.
* wasm/self-test/test_LowLevelBinary_varint.js: Added.
* wasm/self-test/test_LowLevelBinary_varuint.js: Added.
* wasm/self-test/test_LowLevelBinary_varuint7.js: Added.
* wasm/self-test/test_WASM.js: Added.
* wasm/test.sh: Added.
* wasm/utilities.js: Added.
(const._read.filename.switch):
(const._load.filename.switch):
(const._json.filename.switch):
* wasm/wasm.json: Added.
Tools:
* Scripts/run-javascriptcore-tests:
(runJSCStressTests): run wasm.yaml tests
* Scripts/run-jsc-stress-tests: add a WebAssembly-specific runner</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJSTestsChangeLog">trunk/JSTests/ChangeLog</a></li>
<li><a href="#trunkToolsChangeLog">trunk/Tools/ChangeLog</a></li>
<li><a href="#trunkToolsScriptsrunjavascriptcoretests">trunk/Tools/Scripts/run-javascriptcore-tests</a></li>
<li><a href="#trunkToolsScriptsrunjscstresstests">trunk/Tools/Scripts/run-jsc-stress-tests</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li>trunk/JSTests/wasm/</li>
<li><a href="#trunkJSTestswasmBuilderjs">trunk/JSTests/wasm/Builder.js</a></li>
<li><a href="#trunkJSTestswasmLowLevelBinaryjs">trunk/JSTests/wasm/LowLevelBinary.js</a></li>
<li><a href="#trunkJSTestswasmREADMEmd">trunk/JSTests/wasm/README.md</a></li>
<li><a href="#trunkJSTestswasmWASMjs">trunk/JSTests/wasm/WASM.js</a></li>
<li><a href="#trunkJSTestswasmassertjs">trunk/JSTests/wasm/assert.js</a></li>
<li><a href="#trunkJSTestswasmgeneratewasmopsheaderjs">trunk/JSTests/wasm/generate-wasmops-header.js</a></li>
<li>trunk/JSTests/wasm/self-test/</li>
<li><a href="#trunkJSTestswasmselftesttest_BuilderJSONjs">trunk/JSTests/wasm/self-test/test_BuilderJSON.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_BuilderWebAssemblyjs">trunk/JSTests/wasm/self-test/test_BuilderWebAssembly.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_encodejs">trunk/JSTests/wasm/self-test/test_LowLevelBinary_encode.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_stringjs">trunk/JSTests/wasm/self-test/test_LowLevelBinary_string.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_uint16js">trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint16.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_uint32js">trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint32.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_uint8js">trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint8.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_varintjs">trunk/JSTests/wasm/self-test/test_LowLevelBinary_varint.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_varuintjs">trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_LowLevelBinary_varuint7js">trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint7.js</a></li>
<li><a href="#trunkJSTestswasmselftesttest_WASMjs">trunk/JSTests/wasm/self-test/test_WASM.js</a></li>
<li><a href="#trunkJSTestswasmtestsh">trunk/JSTests/wasm/test.sh</a></li>
<li><a href="#trunkJSTestswasmutilitiesjs">trunk/JSTests/wasm/utilities.js</a></li>
<li><a href="#trunkJSTestswasmwasmjson">trunk/JSTests/wasm/wasm.json</a></li>
<li><a href="#trunkJSTestswasmyaml">trunk/JSTests/wasm.yaml</a></li>
</ul>
<h3>Removed Paths</h3>
<ul>
<li>trunk/JSTests/stress/wasm/</li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJSTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/ChangeLog (207362 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/ChangeLog 2016-10-14 23:56:00 UTC (rev 207362)
+++ trunk/JSTests/ChangeLog 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -1,3 +1,118 @@
</span><ins>+2016-10-14 JF Bastien <jfbastien@apple.com>
+
+ Basic WebAssembly testing
+
+ Create a small DSL in JavaScript which can build WebAssembly binary modules based on the JSON description of the format as described in:
+ https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+
+ This DSL can then be used to write small text description of valid and invalid WebAssembly binaries, making testing the JSC implementation much easier.
+
+ Details and example in README.md.
+
+ Basic WebAssembly testing
+ https://bugs.webkit.org/show_bug.cgi?id=163267
+
+ Reviewed by Keith Miller.
+
+ * stress/wasm/wasm.json: Removed.
+ * wasm.yaml: Added.
+ * wasm/Builder.js: Added.
+ (const._isValidValue):
+ (const._BuildWebAssemblyBinary):
+ (export.default.Builder):
+ (export.default.Builder.prototype.setChecked):
+ (export.default.Builder.prototype.setPreamble):
+ (export.default.Builder.prototype._registerSectionBuilders.switch.case.string_appeared_here.this.section):
+ (export.default.Builder.prototype._registerSectionBuilders.this.Unknown):
+ (export.default.Builder.prototype._registerSectionBuilders):
+ (export.default.Builder.prototype._addSection):
+ (export.default.Builder.prototype.optimize):
+ (export.default.Builder.prototype.json):
+ (export.default.Builder.prototype.AsmJS):
+ (export.default.Builder.prototype.WebAssembly):
+ * wasm/LowLevelBinary.js: Added.
+ (const._getterRangeCheck):
+ (const._hexdump):
+ (export.default.LowLevelBinary):
+ (export.default.LowLevelBinary.prototype.newPatchable):
+ (export.default.LowLevelBinary.prototype.hexdump):
+ (export.default.LowLevelBinary.prototype._maybeGrow):
+ (export.default.LowLevelBinary.prototype._push8):
+ (export.default.LowLevelBinary.prototype.uint8):
+ (export.default.LowLevelBinary.prototype.uint16):
+ (export.default.LowLevelBinary.prototype.uint32):
+ (export.default.LowLevelBinary.prototype.varuint):
+ (export.default.LowLevelBinary.prototype.varint):
+ (export.default.LowLevelBinary.prototype.varuint7):
+ (export.default.LowLevelBinary.prototype.string):
+ (export.default.LowLevelBinary.prototype.getSize):
+ (export.default.LowLevelBinary.prototype.getUint8):
+ (export.default.LowLevelBinary.prototype.getUint16):
+ (export.default.LowLevelBinary.prototype.getUint32):
+ (export.default.LowLevelBinary.prototype.getVaruint):
+ (export.default.LowLevelBinary.prototype.getVarint):
+ (export.default.LowLevelBinary.prototype.getVaruint7):
+ (export.default.LowLevelBinary.prototype.getString):
+ (PatchableLowLevelBinary):
+ (PatchableLowLevelBinary.prototype._push8):
+ (PatchableLowLevelBinary.prototype.apply):
+ * wasm/README.md: Added.
+ * wasm/WASM.js: Added.
+ * wasm/assert.js: Added.
+ (export.const.notUndef):
+ (export.const.eq):
+ (export.const.ge):
+ (export.const.throwsError):
+ (export.const.throwsRangeError):
+ * wasm/generate-wasmops-header.js: Renamed from JSTests/stress/wasm/generate-wasmops-header.js.
+ * wasm/self-test/test_BuilderJSON.js: Added.
+ (const.assertOpThrows):
+ (EmptyModule):
+ (CustomMagicNumber):
+ (CustomVersion):
+ (CustomSection):
+ (CustomSectionAllBytes):
+ (CustomSectionInvalidByte):
+ (TwoCustomSections):
+ (EmptyCodeSection):
+ (CodeSectionWithEmptyFunction):
+ (CodeSectionWithEmptyFunctionWithParameters):
+ (InvalidFunctionParameters):
+ (SimpleFunction):
+ (TwoSimpleFunctions):
+ (TwoBuildersAtTheSameTime):
+ (CheckedOpcodeArgumentsTooMany):
+ (CheckedOpcodeArgumentsNotEnough):
+ (CallNoArguments):
+ (CallInvalid):
+ (I32ConstInvalid):
+ (F32ConstInvalid):
+ (F64ConstInvalid):
+ (CallManyFromStack):
+ (OpcodeAdd):
+ (OpcodeUnreachable):
+ (OpcodeUnreachableCombinations):
+ (OpcodeSelect):
+ * wasm/self-test/test_BuilderWebAssembly.js: Added.
+ (EmptyModule):
+ (CustomSection):
+ (Basic):
+ * wasm/self-test/test_LowLevelBinary_encode.js: Added.
+ * wasm/self-test/test_LowLevelBinary_string.js: Added.
+ * wasm/self-test/test_LowLevelBinary_uint16.js: Added.
+ * wasm/self-test/test_LowLevelBinary_uint32.js: Added.
+ * wasm/self-test/test_LowLevelBinary_uint8.js: Added.
+ * wasm/self-test/test_LowLevelBinary_varint.js: Added.
+ * wasm/self-test/test_LowLevelBinary_varuint.js: Added.
+ * wasm/self-test/test_LowLevelBinary_varuint7.js: Added.
+ * wasm/self-test/test_WASM.js: Added.
+ * wasm/test.sh: Added.
+ * wasm/utilities.js: Added.
+ (const._read.filename.switch):
+ (const._load.filename.switch):
+ (const._json.filename.switch):
+ * wasm/wasm.json: Added.
+
</ins><span class="cx"> 2016-10-14 Joseph Pecoraro <pecoraro@apple.com>
</span><span class="cx">
</span><span class="cx"> test262: @isConstructor incorrectly thinks Math.cos is a constructor
</span></span></pre></div>
<a id="trunkJSTestswasmBuilderjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/Builder.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/Builder.js (rev 0)
+++ trunk/JSTests/wasm/Builder.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,258 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import LowLevelBinary from 'LowLevelBinary.js';
+import * as WASM from 'WASM.js';
+
+const _toJavaScriptName = name => {
+ const camelCase = name.replace(/([^a-z0-9].)/g, c => c[1].toUpperCase());
+ const CamelCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+ return CamelCase;
+};
+
+const _isValidValue = (value, type) => {
+ switch (type) {
+ case "i32": return ((value & 0xFFFFFFFF) >>> 0) === value;
+ case "i64": throw new Error(`Unimplemented: value check for ${type}`); // 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 _unknownSectionId = 0;
+
+const _BuildWebAssemblyBinary = (preamble, sections) => {
+ let wasmBin = new LowLevelBinary();
+ const put = (bin, type, value) => bin[type](value);
+ for (const p of WASM.description.preamble)
+ put(wasmBin, p.type, preamble[p.name]);
+ for (const section of sections) {
+ put(wasmBin, WASM.sectionEncodingType, section.id);
+ let sectionBin = wasmBin.newPatchable("varuint");
+ switch (section.name) {
+ case "Type": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Import": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Function": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Table": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Memory": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Global": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Export": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Start": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Element": throw new Error(`Unimplemented: section type "${section.name}"`);
+ case "Code":
+ const numberOfFunctionBodies = section.data.length;
+ put(sectionBin, "varuint", numberOfFunctionBodies);
+ for (const func of section.data) {
+ let funcBin = sectionBin.newPatchable("varuint");
+ const localCount = func.locals.length;
+ put(funcBin, "varuint", localCount);
+ if (localCount !== 0) throw new Error(`Unimplemented: locals`); // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706
+ for (const op of func.code) {
+ put(funcBin, "uint8", op.value);
+ if (op.arguments.length !== 0) throw new Error(`Unimplemented: arguments`); // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706
+ if (op.immediates.length !== 0) throw new Error(`Unimplemented: immediates`); // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706
+ }
+ funcBin.apply();
+ }
+ break;
+ case "Data": throw new Error(`Unimplemented: section type "${section.name}"`);
+ default:
+ if (section.id !== _unknownSectionId) throw new Error(`Unknown section "${section.name}" with number ${section.id}`);
+ put(sectionBin, "string", section.name);
+ for (const byte of section.data)
+ put(sectionBin, "uint8", byte);
+ break;
+ }
+ sectionBin.apply();
+ }
+ return wasmBin;
+};
+
+export default class Builder {
+ constructor() {
+ this.setChecked(true);
+ let preamble = {};
+ for (const p of WASM.description.preamble)
+ preamble[p.name] = p.value;
+ this.setPreamble(preamble);
+ this._sections = [];
+ this._registerSectionBuilders();
+ }
+ setChecked(checked) {
+ this._checked = checked;
+ return this;
+ }
+ setPreamble(p) {
+ this._preamble = Object.assign(this._preamble || {}, p);
+ return this;
+ }
+ _registerSectionBuilders() {
+ for (const section in WASM.description.section) {
+ switch (section) {
+ case "Code":
+ this[section] = function() {
+ const s = this._addSection(section);
+ const builder = this;
+ const codeBuilder = {
+ End: () => builder,
+ Function: parameters => {
+ parameters = parameters || [];
+ const invalidParameterTypes = parameters.filter(p => !WASM.isValidValueType(p));
+ if (invalidParameterTypes.length !== 0) throw new Error(`Function declared with parameters [${parameters}], invalid: [${invalidParameterTypes}]`);
+ const func = {
+ locals: parameters, // Parameters are the first locals.
+ parameterCount: parameters.length,
+ code: []
+ };
+ s.data.push(func);
+ let functionBuilder = {};
+ for (const op in WASM.description.opcode) {
+ const name = _toJavaScriptName(op);
+ const value = WASM.description.opcode[op].value;
+ const ret = WASM.description.opcode[op]["return"];
+ const param = WASM.description.opcode[op].parameter;
+ const imm = WASM.description.opcode[op].immediate;
+ const checkStackArgs = builder._checked ? op => {
+ for (let expect of param) {
+ if (WASM.isValidValueType(expect)) {
+ // FIXME implement stack checks for arguments. https://bugs.webkit.org/show_bug.cgi?id=163421
+ } else {
+ // Handle our own meta-types.
+ switch (expect) {
+ case "addr": break; // FIXME implement addr. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "any": break; // FIXME implement any. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "bool": break; // FIXME implement bool. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "call": break; // FIXME implement call stack argument checks based on function signature. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "global": break; // FIXME implement global. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "local": break; // FIXME implement local. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "prev": break; // FIXME implement prev, checking for whetever the previous value was. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "size": break; // FIXME implement size. https://bugs.webkit.org/show_bug.cgi?id=163421
+ default: throw new Error(`Implementation problem: unhandled meta-type "${expect}" on "${op}"`);
+ }
+ }
+ }
+ } : () => {};
+ const checkStackReturn = builder._checked ? op => {
+ for (let expect of ret) {
+ if (WASM.isValidValueType(expect)) {
+ // FIXME implement stack checks for return. https://bugs.webkit.org/show_bug.cgi?id=163421
+ } else {
+ // Handle our own meta-types.
+ switch (expect) {
+ case "bool": break; // FIXME implement bool. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "call": break; // FIXME implement call stack return check based on function signature. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "control": break; // FIXME implement control. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "global": break; // FIXME implement global. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "local": break; // FIXME implement local. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "prev": break; // FIXME implement prev, checking for whetever the parameter type was. https://bugs.webkit.org/show_bug.cgi?id=163421
+ case "size": break; // FIXME implement size. https://bugs.webkit.org/show_bug.cgi?id=163421
+ default: throw new Error(`Implementation problem: unhandled meta-type "${expect}" on "${op}"`);
+ }
+ }
+ }
+ } : () => {};
+ const checkImms = builder._checked ? (op, imms) => {
+ if (imms.length != imm.length) throw new Error(`"${op}" expects ${imm.length} immediates, got ${imms.length}`);
+ for (let idx = 0; idx !== imm.length; ++idx) {
+ const got = imms[idx];
+ const expect = imm[idx];
+ switch (expect.name) {
+ case "function_index":
+ if (!_isValidValue(got, "i32")) throw new Error(`Invalid value on ${op}: got "${got}", expected i32`);
+ // FIXME check function indices. https://bugs.webkit.org/show_bug.cgi?id=163421
+ break;
+ case "local_index": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "global_index": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "type_index": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "value": if (!_isValidValue(got, ret[0])) throw new Error(`Invalid value on ${op}: got "${got}", expected ${ret[0]}`); break;
+ case "flags": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "offset": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ // Control:
+ case "default_target": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "relative_depth": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "sig": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "target_count": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ case "target_table": throw new Error(`Unimplemented: "${expect.name}" on "${op}"`);
+ default: throw new Error(`Implementation problem: unhandled immediate "${expect.name}" on "${op}"`);
+ }
+ }
+ } : () => {};
+ const nextBuilder = name === "End" ? codeBuilder : functionBuilder;
+ functionBuilder[name] = (...args) => {
+ const imms = args; // FIXME: allow passing in stack values, as-if code were a stack machine. Just check for a builder to this function, and drop. https://bugs.webkit.org/show_bug.cgi?id=163422
+ checkImms(op, imms);
+ checkStackArgs(op);
+ checkStackReturn(op);
+ const stackArgs = []; // FIXME https://bugs.webkit.org/show_bug.cgi?id=162706
+ func.code.push({ name: op, value: value, arguments: stackArgs, immediates: imms });
+ return nextBuilder;
+ };
+ }
+ return functionBuilder;
+ }
+ };
+ return codeBuilder;
+ };
+ break;
+ default:
+ this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
+ break;
+ }
+ }
+ this.Unknown = function(name) {
+ const s = this._addSection(name);
+ const builder = this;
+ const unknownBuilder = {
+ End: () => builder,
+ Byte: b => { if ((b & 0xFF) !== b) throw new RangeError(`Unknown section expected byte, got: "${b}"`); s.data.push(b); return unknownBuilder; }
+ };
+ return unknownBuilder;
+ };
+ }
+ _addSection(nameOrNumber, extraObject) {
+ const name = typeof(nameOrNumber) === "string" ? nameOrNumber : "";
+ const number = typeof(nameOrNumber) === "number" ? nameOrNumber : (WASM.description.section[name] ? WASM.description.section[name].value : _unknownSectionId);
+ const s = Object.assign({ name: name, id: number, data: [] }, extraObject || {});
+ this._sections.push(s);
+ return s;
+ }
+ optimize() {
+ // FIXME Add more optimizations. https://bugs.webkit.org/show_bug.cgi?id=163424
+ return this;
+ }
+ json() {
+ const obj = {
+ preamble: this._preamble,
+ section: this._sections
+ };
+ return JSON.stringify(obj);
+ }
+ AsmJS() {
+ "use asm"; // For speed.
+ // FIXME Create an asm.js equivalent string which can be eval'd. https://bugs.webkit.org/show_bug.cgi?id=163425
+ throw new Error("asm.js not implemented yet");
+ }
+ WebAssembly() { return _BuildWebAssemblyBinary(this._preamble, this._sections); }
+};
</ins></span></pre></div>
<a id="trunkJSTestswasmLowLevelBinaryjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/LowLevelBinary.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/LowLevelBinary.js (rev 0)
+++ trunk/JSTests/wasm/LowLevelBinary.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,215 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+const _initialAllocationSize = 1024;
+const _growAllocationSize = allocated => allocated * 2;
+
+export const varuintMin = 0;
+export const varuint7Max = 0b1111111;
+export const varuintMax = ((((1 << 31) >>> 0) - 1) * 2) + 1;
+export const varintMin = -((1 << 31) >>> 0);
+export const varintMax = ((1 << 31) - 1) >>> 0;
+export const varBitsMax = 5;
+
+const _getterRangeCheck = (llb, at, size) => {
+ if (0 > at || at + size > llb._used)
+ throw new RangeError(`[${at}, ${at + size}) is out of buffer range [0, ${llb._used})`);
+};
+
+const _hexdump = (buf, size) => {
+ let s = "";
+ const width = 16;
+ const base = 16;
+ for (let row = 0; row * width < size; ++row) {
+ const address = (row * width).toString(base);
+ s += "0".repeat(8 - address.length) + address;
+ let chars = "";
+ for (let col = 0; col !== width; ++col) {
+ const idx = row * width + col;
+ if (idx < size) {
+ const byte = buf[idx];
+ const bytestr = byte.toString(base);
+ s += " " + (bytestr.length === 1 ? "0" + bytestr : bytestr);
+ chars += 0x20 <= byte && byte < 0x7F ? String.fromCharCode(byte) : "·";
+ } else {
+ s += " ";
+ chars += " ";
+ }
+ }
+ s+= " |" + chars + "|\n";
+ }
+ return s;
+};
+
+export default class LowLevelBinary {
+ constructor() {
+ this._buf = new Uint8Array(_initialAllocationSize);
+ this._used = 0;
+ }
+
+ newPatchable(type) { return new PatchableLowLevelBinary(type, this); }
+
+ // Utilities.
+ hexdump() { return _hexdump(this._buf, this._used); }
+ _maybeGrow(bytes) {
+ const allocated = this._buf.length;
+ if (allocated - this._used < bytes) {
+ let buf = new Uint8Array(_growAllocationSize(allocated));
+ buf.set(this._buf);
+ this._buf = buf;
+ }
+ }
+ _push8(v) { this._buf[this._used] = v & 0xFF; this._used += 1; }
+
+ // Data types.
+ uint8(v) {
+ if ((v & 0xFF) >>> 0 !== v)
+ throw new RangeError(`Invalid uint8 ${v}`);
+ this._maybeGrow(1);
+ this._push8(v);
+ }
+ uint16(v) {
+ if ((v & 0xFFFF) >>> 0 !== v)
+ throw new RangeError(`Invalid uint16 ${v}`);
+ this._maybeGrow(2);
+ this._push8(v);
+ this._push8(v >>> 8);
+ }
+ uint32(v) {
+ if ((v & 0xFFFFFFFF) >>> 0 !== v)
+ throw new RangeError(`Invalid uint32 ${v}`);
+ this._maybeGrow(4);
+ this._push8(v);
+ this._push8(v >>> 8);
+ this._push8(v >>> 16);
+ this._push8(v >>> 24);
+ }
+ varuint(v) {
+ if (v < varuintMin || varuintMax < v)
+ throw new RangeError(`Invalid varuint ${v} range is [${varuintMin}, ${varuintMax}]`);
+ while (v >= 0x80) {
+ this.uint8(0x80 | (v & 0x7F));
+ v >>>= 7;
+ }
+ this.uint8(v);
+ }
+ varint(v) {
+ if (v < varintMin || varintMax < v)
+ throw new RangeError(`Invalid varint ${v} range is [${varintMin}, ${varintMax}]`);
+ do {
+ const b = v & 0x7F;
+ v >>= 7;
+ if ((v === 0 && ((b & 0x40) === 0)) || (v === -1 && ((b & 0x40) === 0x40))) {
+ this.uint8(b & 0x7F);
+ break;
+ }
+ this.uint8(0x80 | b);
+ } while (true);
+ }
+ varuint7(v) {
+ if (v < varuintMin || varuint7Max < v)
+ throw new RangeError(`Invalid varuint7 ${v} range is [${varuintMin}, ${varuint7Max}]`);
+ this.varuint(v);
+ }
+ string(str) {
+ let patch = this.newPatchable("varuint");
+ for (const char of str)
+ patch.uint16(char.charCodeAt());
+ patch.apply();
+ }
+
+ // Getters.
+ getSize() { return this._used; }
+ getUint8(at) {
+ _getterRangeCheck(this, at, 1);
+ return this._buf[at];
+ }
+ getUint16(at) {
+ _getterRangeCheck(this, at, 2);
+ return this._buf[at] | (this._buf[at + 1] << 8);
+ }
+ getUint32(at) {
+ _getterRangeCheck(this, at, 4);
+ return (this._buf[at] | (this._buf[at + 1] << 8) | (this._buf[at + 2] << 16) | (this._buf[at + 3] << 24)) >>> 0;
+ }
+ getVaruint(at) {
+ let v = 0;
+ let shift = 0;
+ let byte = 0;
+ do {
+ byte = this.getUint8(at++);
+ ++read;
+ v = (v | ((byte & 0x7F) << shift) >>> 0) >>> 0;
+ shift += 7;
+ } while ((byte & 0x80) !== 0);
+ if (shift - 7 > 32) throw new RangeError(`Shifting too much at ${at}`);
+ if ((shift == 35) && ((byte & 0xF0) != 0)) throw new Error(`Unexpected non-significant varuint bits in last byte 0x${byte.toString(16)}`);
+ return { value: v, next: at };
+ }
+ getVarint(at) {
+ let v = 0;
+ let shift = 0;
+ let byte = 0;
+ do {
+ byte = this.getUint8(at++);
+ v = (v | ((byte & 0x7F) << shift) >>> 0) >>> 0;
+ shift += 7;
+ } while ((byte & 0x80) !== 0);
+ if (shift - 7 > 32) throw new RangeError(`Shifting too much at ${at}`);
+ if ((shift == 35) && (((byte << 26) >> 30) != ((byte << 25) >> 31))) throw new Error(`Unexpected non-significant varint bits in last byte 0x${byte.toString(16)}`);
+ if ((byte & 0x40) === 0x40) {
+ const sext = shift < 32 ? 32 - shift : 0;
+ v = (v << sext) >> sext;
+ }
+ return { value: v, next: at };
+ }
+ getVaruint7(at) {
+ const res = this.getVaruint(at);
+ if (res.value > varuint7Max) throw new Error(`Expected a varuint7, got value ${res.value}`);
+ return res;
+ }
+ getString(at) {
+ const size = this.getVaruint(at);
+ let str = "";
+ for (let i = size.next; i !== size.next + size.value; i += 2)
+ str += String.fromCharCode(this.getUint16(i));
+ return str;
+ }
+};
+
+class PatchableLowLevelBinary extends LowLevelBinary {
+ constructor(type, lowLevelBinary) {
+ super();
+ this.type = type;
+ this.target = lowLevelBinary;
+ this._buffered_bytes = 0;
+ }
+ _push8(v) { ++this._buffered_bytes; super._push8(v); }
+ apply() {
+ this.target[this.type](this._buffered_bytes);
+ for (let i = 0; i < this._buffered_bytes; ++i)
+ this.target.uint8(this._buf[i]);
+ }
+};
</ins></span></pre></div>
<a id="trunkJSTestswasmREADMEmd"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/README.md (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/README.md (rev 0)
+++ trunk/JSTests/wasm/README.md 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,57 @@
</span><ins>+# `wasmjs`: JavaScript tooling for WebAssembly
+
+`wasmjs` is a self-contained collection of JavaScript tools which can manipulate
+WebAssembly. At its core is `wasm.json`, a JSON decription of the WebAssembly
+format and other interesting facts about WebAssembly as used by the Webkit
+project (such as the names of associated JavaScriptCore opcodes).
+
+`wasmjs` requires modern JavaScript features such as ES6 modules, which is
+acceptable because WebAssembly is itself contemporary to these other features.
+
+
+# `Builder` API
+
+The current core API of `wasmjs` is the `Builder` API from `Builder.js`. It is
+used to build WebAssembly modules.
+
+A simple example:
+
+```javascript
+import Builder from 'Builder.js';
+
+const builder = new Builder();
+
+// Construct the equivalent of: (module (func (nop) (nop)))
+builder
+ .Code()
+ .Function()
+ .Nop()
+ .Nop()
+ .End()
+ .End();
+
+// Create an ArrayBuffer which is a valid WebAssembly `.wasm` file.
+const binary = builder.WebAssembly();
+```
+
+Code such as the above can then be used with JavaScript's `WebAssembly` global
+object.
+
+
+# Testing
+
+Tests can be executed using:
+
+```bash
+JSSHELL=/path/to/my/js-shell test.sh
+```
+
+They can also be executed by using WebKit's `run-javascriptcore-tests` tool:
+
+```bash
+./Tools/Scripts/run-javascriptcore-tests --release --filter wasm -arch x86_64
+```
+
+The `self-test` folder contains tests for `wasmjs` itself. Future additions will
+also test the JavaScript engine's WebAssembly implementation (both JavaScript
+API and usage of that API to compile and execute WebAssembly modules).
</ins></span></pre></div>
<a id="trunkJSTestswasmWASMjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/WASM.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/WASM.js (rev 0)
+++ trunk/JSTests/wasm/WASM.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,33 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import * as utilities from 'utilities.js';
+
+export const description = utilities.json("wasm.json");
+export const valueType = Object.keys(description.value_type);
+const _valueTypeSet = new Set(valueType);
+export const isValidValueType = v => _valueTypeSet.has(v);
+export const sections = Object.keys(description.section);
+export const sectionEncodingType = description.section[sections[0]].type;
</ins></span></pre></div>
<a id="trunkJSTestswasmassertjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/assert.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/assert.js (rev 0)
+++ trunk/JSTests/wasm/assert.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,69 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+export const notUndef = (v) => {
+ if (v === undefined)
+ throw new Error("Shouldn't be undefined");
+};
+
+export const eq = (lhs, rhs) => {
+ if (lhs !== rhs)
+ throw new Error(`Not the same: "${lhs}" and "${rhs}"`);
+};
+
+export const ge = (lhs, rhs) => {
+ notUndef(lhs);
+ notUndef(rhs);
+ if (!(lhs >= rhs))
+ throw new Error(`Expected: "${lhs}" < "${rhs}"`);
+};
+
+export const throwsError = (opFn, message, ...args) => {
+ if (message)
+ message = " for " + message;
+
+ try {
+ opFn(...args);
+ } catch (e) {
+ if (e instanceof Error)
+ return;
+ throw new Error(`Expected an Error${message}, got ${e}`);
+ }
+ throw new Error(`Expected to throw an Error${message}`);
+};
+
+export const throwsRangeError = (opFn, message, ...args) => {
+ if (message)
+ message = " for " + message;
+
+ try {
+ opFn(...args);
+ } catch (e) {
+ if (e instanceof RangeError)
+ return;
+ throw new Error(`Expected a RangeError${message}, got ${e}`);
+ }
+ throw new Error(`Expected to throw a RangeError${message}`);
+};
</ins></span></pre></div>
<a id="trunkJSTestswasmgeneratewasmopsheaderjsfromrev207362trunkJSTestsstresswasmgeneratewasmopsheaderjs"></a>
<div class="copfile"><h4>Copied: trunk/JSTests/wasm/generate-wasmops-header.js (from rev 207362, trunk/JSTests/stress/wasm/generate-wasmops-header.js) (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/generate-wasmops-header.js (rev 0)
+++ trunk/JSTests/wasm/generate-wasmops-header.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,141 @@
</span><ins>+// Use the JSON description of WebAssembly to generate the JavaScriptCore's WASMOps.h.
+
+const jsonFile = 'wasm.json';
+const wasm = JSON.parse(read(jsonFile));
+const opcodes = wasm.opcode;
+
+// Iterate through opcodes which match filter, and on each iteration yield ret.
+const opcodeIterator = (filter, ret = op => { return {name: op, opcode: opcodes[op]}; }) => {
+ return function*() {
+ for (let op in opcodes)
+ if (filter(opcodes[op]))
+ yield ret(op);
+ };
+};
+
+// WebAssembly opcode name to C++ name suitable for JSC.
+const toCpp = name => {
+ const camelCase = name.replace(/([^a-z0-9].)/g, c => c[1].toUpperCase());
+ const CamelCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+ return CamelCase;
+};
+
+const cppMacro = (wasmOpcode, value, b3Opcode) => " \\\n macro(" + toCpp(wasmOpcode) + ", 0x" + parseInt(value).toString(16) + ", " + b3Opcode + ")";
+
+function* opcodeMacroizer(filter) {
+ for (let op of opcodeIterator(filter)())
+ yield cppMacro(op.name, op.opcode.value, op.opcode.b3op || "Oops");
+}
+
+const defines = [
+ "#define FOR_EACH_WASM_SPECIAL_OP(macro)",
+ ...opcodeMacroizer(op => op.category === "special"),
+ "\n\n#define FOR_EACH_WASM_CONTROL_FLOW_OP(macro)",
+ ...opcodeMacroizer(op => op.category === "control"),
+ "\n\n#define FOR_EACH_WASM_UNARY_OP(macro)",
+ ...opcodeMacroizer(op => op.category === "arithmetic" && op.parameter.length === 1),
+ "\n\n#define FOR_EACH_WASM_BINARY_OP(macro)",
+ ...opcodeMacroizer(op => (op.category === "arithmetic" || op.category === "comparison") && op.parameter.length === 2),
+ "\n\n"].join("");
+
+const opValueSet = new Set(opcodeIterator(op => true, op => opcodes[op].value)());
+const maxOpValue = Math.max(...opValueSet);
+const validOps = (() => {
+ // Create a bitset of valid ops.
+ let v = "";
+ for (let i = 0; i < maxOpValue / 8; ++i) {
+ let entry = 0;
+ for (let j = 0; j < 8; ++j)
+ if (opValueSet.has(i * 8 + j))
+ entry |= 1 << j;
+ v += (i ? ", " : "") + "0x" + entry.toString(16);
+ }
+ return v;
+})();
+
+const template = `/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. \`\`AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// This file is auto-generated using ${jsonFile}.
+
+#pragma once
+
+#if ENABLE(WEBASSEMBLY)
+
+#include <cstdint>
+
+namespace JSC { namespace WASM {
+
+${defines}
+
+#define FOR_EACH_WASM_OP(macro) \\
+ FOR_EACH_WASM_SPECIAL_OP(macro) \\
+ FOR_EACH_WASM_CONTROL_FLOW_OP(macro) \\
+ FOR_EACH_WASM_UNARY_OP(macro) \\
+ FOR_EACH_WASM_BINARY_OP(macro)
+
+#define CREATE_ENUM_VALUE(name, id, b3op) name = id,
+
+enum OpType : uint8_t {
+ FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)
+};
+
+template<typename Int>
+inline bool isValidOpType(Int i)
+{
+ // Bitset of valid ops.
+ static const uint8_t valid[] = { ${validOps} };
+ return 0 <= i && i <= ${maxOpValue} && (valid[i / 8] & (1 << (i % 8)));
+}
+
+enum class BinaryOpType : uint8_t {
+ FOR_EACH_WASM_BINARY_OP(CREATE_ENUM_VALUE)
+};
+
+enum class UnaryOpType : uint8_t {
+ FOR_EACH_WASM_UNARY_OP(CREATE_ENUM_VALUE)
+};
+
+#undef CREATE_ENUM_VALUE
+
+inline bool isControlOp(OpType op)
+{
+ switch (op) {
+#define CREATE_CASE(name, id, b3op) case OpType::name:
+ FOR_EACH_WASM_CONTROL_FLOW_OP(CREATE_CASE)
+ return true;
+#undef CREATE_CASE
+ default:
+ break;
+ }
+ return false;
+}
+
+} } // namespace JSC::WASM
+
+#endif // ENABLE(WEBASSEMBLY)
+`;
+
+print(template);
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_BuilderJSONjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_BuilderJSON.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_BuilderJSON.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_BuilderJSON.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,362 @@
</span><ins>+import * as assert from '../assert.js';
+import Builder from '../Builder.js';
+
+const assertOpThrows = (opFn, message = "") => {
+ let f = (new Builder()).Code().Function();
+ assert.throwsError(opFn, message, f);
+};
+
+(function EmptyModule() {
+ const b = new Builder();
+ const j = JSON.parse(b.json());
+ assert.notUndef(j.preamble);
+ assert.notUndef(j.preamble["magic number"]);
+ assert.notUndef(j.preamble.version);
+ assert.notUndef(j.section);
+ assert.eq(j.section.length, 0);
+})();
+
+(function CustomMagicNumber() {
+ const b = (new Builder()).setPreamble({ "magic number": 1337 });
+ const j = JSON.parse(b.json());
+ assert.eq(j.preamble["magic number"], 1337);
+ assert.notUndef(j.preamble.version);
+})();
+
+(function CustomVersion() {
+ const b = (new Builder()).setPreamble({ "version": 1337 });
+ const j = JSON.parse(b.json());
+ assert.eq(j.preamble["version"], 1337);
+ assert.notUndef(j.preamble.version);
+})();
+
+(function CustomSection() {
+ const b = new Builder();
+ b.Unknown("custom section")
+ .Byte(0x00)
+ .Byte(0x42)
+ .Byte(0xFF);
+ const j = JSON.parse(b.json());
+ assert.eq(j.section.length, 1);
+ assert.eq(j.section[0].name, "custom section");
+ assert.eq(j.section[0].data.length, 3);
+ assert.eq(j.section[0].data[0], 0x00);
+ assert.eq(j.section[0].data[1], 0x42);
+ assert.eq(j.section[0].data[2], 0xFF);
+})();
+
+(function CustomSectionAllBytes() {
+ const b = new Builder();
+ let u = b.Unknown("custom section");
+ for (let i = 0; i !== 0xFF + 1; ++i)
+ u.Byte(i);
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data.length, 256);
+ for (let i = 0; i !== 0xFF + 1; ++i)
+ assert.eq(j.section[0].data[i], i);
+})();
+
+(function CustomSectionInvalidByte() {
+ const b = new Builder();
+ let u = b.Unknown("custom section");
+ try {
+ u.Byte(0xFF + 1);
+ } catch (e) {
+ if (e instanceof RangeError) { return; }
+ throw new Error(`Expected a RangeError, got ${e}`);
+ }
+ throw new Error(`Expected to throw a RangeError`);
+})();
+
+(function TwoCustomSections() {
+ const b = new Builder();
+ b.Unknown("custom section")
+ .Byte(0x00)
+ .Byte(0x42)
+ .Byte(0xFF)
+ .End()
+ .Unknown("☃")
+ .Byte(0x11);
+ const j = JSON.parse(b.json());
+ assert.eq(j.section.length, 2);
+ assert.eq(j.section[0].name, "custom section");
+ assert.eq(j.section[0].data.length, 3);
+ assert.eq(j.section[1].name, "☃");
+ assert.eq(j.section[1].data.length, 1);
+ assert.eq(j.section[1].data[0], 0x11);
+})();
+
+(function EmptyCodeSection() {
+ const b = new Builder();
+ b.Code();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section.length, 1);
+ assert.eq(j.section[0].name, "Code");
+ assert.eq(j.section[0].data.length, 0);
+})();
+
+(function CodeSectionWithEmptyFunction() {
+ const b = new Builder();
+ b.Code()
+ .Function();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section.length, 1);
+ assert.eq(j.section[0].name, "Code");
+ assert.eq(j.section[0].data.length, 1);
+ assert.eq(j.section[0].data[0].parameterCount, 0);
+ assert.eq(j.section[0].data[0].locals.length, 0);
+ assert.eq(j.section[0].data[0].code.length, 0);
+})();
+
+(function CodeSectionWithEmptyFunctionWithParameters() {
+ const b = new Builder();
+ b.Code()
+ .Function(["i32", "i64", "f32", "f64"]);
+ const j = JSON.parse(b.json());
+ assert.eq(j.section.length, 1);
+ assert.eq(j.section[0].name, "Code");
+ assert.eq(j.section[0].data.length, 1);
+ assert.eq(j.section[0].data[0].parameterCount, 4);
+ assert.eq(j.section[0].data[0].locals[0], "i32");
+ assert.eq(j.section[0].data[0].locals[1], "i64");
+ assert.eq(j.section[0].data[0].locals[2], "f32");
+ assert.eq(j.section[0].data[0].locals[3], "f64");
+ assert.eq(j.section[0].data[0].code.length, 0);
+})();
+
+(function InvalidFunctionParameters() {
+ for (let invalid in ["", "void", "bool", "any", "struct"]) {
+ const c = (new Builder()).Code();
+ try {
+ c.Function([invalid]);
+ } catch (e) {
+ if (e instanceof Error) { continue; }
+ throw new Error(`Expected an Error, got ${e}`);
+ }
+ throw new Error(`Expected to throw an Error for ${invalid}`);
+ }
+})();
+
+(function SimpleFunction() {
+ const b = new Builder();
+ b.Code()
+ .Function()
+ .Nop()
+ .Nop()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data.length, 1);
+ assert.eq(j.section[0].data[0].locals.length, 0);
+ assert.eq(j.section[0].data[0].code.length, 3);
+ assert.eq(j.section[0].data[0].code[0].name, "nop");
+ assert.eq(j.section[0].data[0].code[1].name, "nop");
+ assert.eq(j.section[0].data[0].code[2].name, "end");
+})();
+
+(function TwoSimpleFunctions() {
+ const b = new Builder();
+ b.Code()
+ .Function()
+ .Nop()
+ .Nop()
+ .End()
+ .Function()
+ .Return()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data.length, 2);
+ assert.eq(j.section[0].data[0].locals.length, 0);
+ assert.eq(j.section[0].data[0].code.length, 3);
+ assert.eq(j.section[0].data[0].code[0].name, "nop");
+ assert.eq(j.section[0].data[0].code[1].name, "nop");
+ assert.eq(j.section[0].data[0].code[2].name, "end");
+ assert.eq(j.section[0].data[1].locals.length, 0);
+ assert.eq(j.section[0].data[1].code.length, 2);
+ assert.eq(j.section[0].data[1].code[0].name, "return");
+ assert.eq(j.section[0].data[1].code[1].name, "end");
+})();
+
+(function TwoBuildersAtTheSameTime() {
+ const b = [new Builder(), new Builder()];
+ const f = b.map(builder => builder.Code().Function());
+ f[0].Nop();
+ f[1].Return().End().End();
+ f[0].Nop().End().End();
+ const j = b.map(builder => JSON.parse(builder.json()));
+ assert.eq(j[0].section[0].data[0].code.length, 3);
+ assert.eq(j[0].section[0].data[0].code[0].name, "nop");
+ assert.eq(j[0].section[0].data[0].code[1].name, "nop");
+ assert.eq(j[0].section[0].data[0].code[2].name, "end");
+ assert.eq(j[1].section[0].data[0].code.length, 2);
+ assert.eq(j[1].section[0].data[0].code[0].name, "return");
+ assert.eq(j[1].section[0].data[0].code[1].name, "end");
+})();
+
+(function CheckedOpcodeArgumentsTooMany() {
+ assertOpThrows(f => f.Nop("uh-oh!"));
+})();
+
+(function UncheckedOpcodeArgumentsTooMany() {
+ (new Builder()).setChecked(false).Code().Function().Nop("This is fine.", "I'm OK with the events that are unfolding currently.");
+})();
+
+(function CheckedOpcodeArgumentsNotEnough() {
+ assertOpThrows(f => f.I32Const());
+})();
+
+(function UncheckedOpcodeArgumentsNotEnough() {
+ (new Builder()).setChecked(false).Code().Function().I32Const();
+})();
+
+(function CallNoArguments() {
+ const b = (new Builder()).Code().Function().Call(0).End().End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 2);
+ assert.eq(j.section[0].data[0].code[0].name, "call");
+ assert.eq(j.section[0].data[0].code[0].arguments.length, 0);
+ assert.eq(j.section[0].data[0].code[0].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[0].immediates[0], 0);
+ assert.eq(j.section[0].data[0].code[1].name, "end");
+})();
+
+(function CallInvalid() {
+ for (let c of [-1, 0x100000000, "0", {}, Infinity, -Infinity, NaN, -NaN, null])
+ assertOpThrows(f => f.Call(c), c);
+})();
+
+(function I32ConstValid() {
+ for (let c of [0, 1, 2, 42, 1337, 0xFF, 0xFFFF, 0x7FFFFFFF, 0xFFFFFFFE, 0xFFFFFFFF]) {
+ const b = (new Builder()).Code().Function().I32Const(c).Return().End().End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code[0].name, "i32.const");
+ assert.eq(j.section[0].data[0].code[0].arguments.length, 0);
+ assert.eq(j.section[0].data[0].code[0].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[0].immediates[0], c);
+ }
+})();
+
+(function I32ConstInvalid() {
+ for (let c of [-1, 0x100000000, 0.1, -0.1, "0", {}, Infinity, null])
+ assertOpThrows(f => f.I32Const(c), c);
+})();
+
+// FIXME: test i64. https://bugs.webkit.org/show_bug.cgi?id=163420
+
+(function F32ConstValid() {
+ for (let c of [0, -0., 0.2, Math.PI, 0x100000000]) {
+ const b = (new Builder()).Code().Function().F32Const(c).Return().End().End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code[0].name, "f32.const");
+ assert.eq(j.section[0].data[0].code[0].arguments.length, 0);
+ assert.eq(j.section[0].data[0].code[0].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[0].immediates[0], c);
+ }
+})();
+
+(function F32ConstInvalid() {
+ for (let c of ["0", {}, Infinity, -Infinity, NaN, -NaN, null])
+ assertOpThrows(f => f.F32Const(c), c);
+})();
+
+(function F64ConstValid() {
+ for (let c of [0, -0., 0.2, Math.PI, 0x100000000]) {
+ const b = (new Builder()).Code().Function().F64Const(c).Return().End().End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code[0].name, "f64.const");
+ assert.eq(j.section[0].data[0].code[0].arguments.length, 0);
+ assert.eq(j.section[0].data[0].code[0].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[0].immediates[0], c);
+ }
+})();
+
+(function F64ConstInvalid() {
+ for (let c of ["0", {}, Infinity, -Infinity, NaN, -NaN, null])
+ assertOpThrows(f => f.F64Const(c), c);
+})();
+
+(function CallOneFromStack() {
+ const b = (new Builder()).Code()
+ .Function(["i32"])
+ .I32Const(42)
+ .Call(0)
+ .End()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 3);
+ assert.eq(j.section[0].data[0].code[0].name, "i32.const");
+ assert.eq(j.section[0].data[0].code[0].immediates[0], 42);
+ assert.eq(j.section[0].data[0].code[1].name, "call");
+ // FIXME: assert.eq(j.section[0].data[0].code[1].arguments.length, 1); https://bugs.webkit.org/show_bug.cgi?id=163267
+ assert.eq(j.section[0].data[0].code[1].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[1].immediates[0], 0);
+ assert.eq(j.section[0].data[0].code[2].name, "end");
+})();
+
+// FIXME https://bugs.webkit.org/show_bug.cgi?id=163267 all of these:
+// test too many pops.
+// test not enough pops (function has non-empty stack at the end).
+// test mismatched pop types.
+// test mismatched function signature (calling with wrong arg types).
+// test invalid function index.
+// test function names (both setting and calling them).
+
+(function CallManyFromStack() {
+ const b = (new Builder()).Code()
+ .Function(["i32", "i32", "i32", "i32"])
+ .I32Const(42).I32Const(1337).I32Const(0xBEEF).I32Const(0xFFFF)
+ .Call(0)
+ .End()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 6);
+ assert.eq(j.section[0].data[0].code[4].name, "call");
+ // FIXME: assert.eq(j.section[0].data[0].code[4].arguments.length, 4); https://bugs.webkit.org/show_bug.cgi?id=163267
+ assert.eq(j.section[0].data[0].code[4].immediates.length, 1);
+ assert.eq(j.section[0].data[0].code[4].immediates[0], 0);
+})();
+
+(function OpcodeAdd() {
+ const b = (new Builder()).Code()
+ .Function()
+ .I32Const(42).I32Const(1337)
+ .I32Add()
+ .Return()
+ .End()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 5);
+ assert.eq(j.section[0].data[0].code[2].name, "i32.add");
+ // FIXME: assert.eq(j.section[0].data[0].code[2].arguments.length, 2); https://bugs.webkit.org/show_bug.cgi?id=163267
+ assert.eq(j.section[0].data[0].code[3].name, "return");
+ // FIXME check return. https://bugs.webkit.org/show_bug.cgi?id=163267
+})();
+
+(function OpcodeUnreachable() {
+ const b = (new Builder()).Code().Function().Unreachable().End().End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 2);
+ assert.eq(j.section[0].data[0].code[0].name, "unreachable");
+})();
+
+(function OpcodeUnreachableCombinations() {
+ (new Builder()).Code().Function().Nop().Unreachable().End().End();
+ (new Builder()).Code().Function().Unreachable().Nop().End().End();
+ (new Builder()).Code().Function().Return().Unreachable().End().End();
+ (new Builder()).Code().Function().Unreachable().Return().End().End();
+ (new Builder()).Code().Function().Call(0).Unreachable().End().End();
+ (new Builder()).Code().Function().Unreachable().Call(0).End().End();
+})();
+
+(function OpcodeSelect() {
+ const b = (new Builder()).Code().Function()
+ .I32Const(1).I32Const(2).I32Const(0)
+ .Select()
+ .Return()
+ .End()
+ .End();
+ const j = JSON.parse(b.json());
+ assert.eq(j.section[0].data[0].code.length, 6);
+ assert.eq(j.section[0].data[0].code[3].name, "select");
+})();
+
+// FIXME test type mismatch with select. https://bugs.webkit.org/show_bug.cgi?id=163267
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_BuilderWebAssemblyjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_BuilderWebAssembly.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_BuilderWebAssembly.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_BuilderWebAssembly.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,45 @@
</span><ins>+import * as assert from '../assert.js';
+import Builder from '../Builder.js';
+
+(function EmptyModule() {
+ const builder = new Builder();
+ const bin = builder.WebAssembly();
+ // Note: this will change as we update version number.
+ assert.eq(bin.hexdump().trim(),
+ "00000000 00 61 73 6d 0c 00 00 00 |·asm···· |");
+})();
+
+(function EmptyModule() {
+ const bin = (new Builder())
+ .setPreamble({ "magic number": 0x45464F43, version: 0xFFFFFFFF })
+ .WebAssembly();
+ assert.eq(bin.hexdump().trim(),
+ "00000000 43 4f 46 45 ff ff ff ff |COFE···· |");
+})();
+
+(function CustomSection() {
+ const bin = (new Builder())
+ .Unknown("OHHAI")
+ .Byte(0xDE)
+ .Byte(0xAD)
+ .Byte(0xC0)
+ .Byte(0xFE)
+ .End()
+ .WebAssembly();
+ assert.eq(bin.hexdump().trim(),
+ ["00000000 00 61 73 6d 0c 00 00 00 00 0f 0a 4f 00 48 00 48 |·asm·······O·H·H|",
+ "00000010 00 41 00 49 00 de ad c0 fe |·A·I····· |"].join("\n"));
+})();
+
+(function Basic() {
+ const bin = (new Builder())
+ .Code()
+ .Function()
+ .Nop()
+ .Nop()
+ .End()
+ .End()
+ .WebAssembly();
+ assert.eq(bin.hexdump().trim(),
+ "00000000 00 61 73 6d 0c 00 00 00 0a 06 01 04 00 0a 0a 0f |·asm············|");
+})();
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_encodejs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_encode.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_encode.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_encode.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,11 @@
</span><ins>+import LowLevelBinary from '../LowLevelBinary.js';
+
+let b = new LowLevelBinary();
+
+for (let i = 0; i !== 1024 * 3; ++i)
+ b.uint32(i);
+for (let i = 0; i !== 1024 * 3; ++i) {
+ let v = b.getUint32(i * 4);
+ if (v !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_stringjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_string.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_string.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_string.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,21 @@
</span><ins>+import LowLevelBinary from '../LowLevelBinary.js';
+
+const values = [
+ "",
+ "0",
+ "Hello, World!",
+ "Il dit non avec la tête, mais il dit oui avec le cœur",
+ "焼きたて!! ジャぱん",
+ "(╯°□°）╯︵ ┻━┻",
+ "�",
+ // Should we use code points instead of UTF-16?
+ // The following doesn't work: "👨❤️💋👨",
+];
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.string(i);
+ const v = b.getString(0);
+ if (v !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_uint16js"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint16.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint16.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint16.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,12 @@
</span><ins>+import LowLevelBinary from '../LowLevelBinary.js';
+
+let values = [];
+for (let i = 0; i !== 0xFFFF; ++i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.uint16(i);
+ const v = b.getUint16(0);
+ if (v !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_uint32js"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint32.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint32.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint32.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,13 @@
</span><ins>+import LowLevelBinary from '../LowLevelBinary.js';
+
+let values = [];
+for (let i = 0; i !== 0xFFFF + 1; ++i) values.push(i);
+for (let i = 0xFFFFFFFF; i !== 0xFFFFFFFF - 0xFFFF - 1; --i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.uint32(i);
+ const v = b.getUint32(0);
+ if (v !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_uint8js"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint8.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint8.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_uint8.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,12 @@
</span><ins>+import LowLevelBinary from '../LowLevelBinary.js';
+
+let values = [];
+for (let i = 0; i !== 0xFF; ++i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.uint8(i);
+ const v = b.getUint8(0);
+ if (v !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_varintjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_varint.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_varint.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_varint.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,30 @@
</span><ins>+import LowLevelBinary, * as LLB from '../LowLevelBinary.js';
+import * as assert from '../assert.js';
+
+let values = [];
+for (let i = LLB.varintMin; i !== LLB.varintMin + 1024; ++i) values.push(i);
+for (let i = -2048; i !== 2048; ++i) values.push(i);
+for (let i = LLB.varintMax; i !== LLB.varintMax - 1024; --i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.varint(i);
+ const v = b.getVarint(0);
+ if (v.value !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+ if (v.next !== b.getSize())
+ throw new Error(`Size ${v.next}, expected ${b.getSize()}`);
+}
+
+for (let i = 0; i < LLB.varBitsMax + 1; ++i) {
+ let b = new LowLevelBinary();
+ for (let j = 0; j < i; ++j)
+ b.uint8(0x80);
+ assert.throwsRangeError(() => b.getVarint(0));
+}
+
+let b = new LowLevelBinary();
+for (let i = 0; i < LLB.varBitsMax; ++i)
+ b.uint8(0x80);
+b.uint8(0x00);
+assert.throwsRangeError(() => b.getVarint(0));
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_varuintjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,29 @@
</span><ins>+import LowLevelBinary, * as LLB from '../LowLevelBinary.js';
+import * as assert from '../assert.js';
+
+let values = [];
+for (let i = LLB.varuintMin; i !== LLB.varuintMin + 1024; ++i) values.push(i);
+for (let i = LLB.varuintMax; i !== LLB.varuintMax - 1024; --i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.varuint(i);
+ const v = b.getVaruint(0);
+ if (v.value !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+ if (v.next !== b.getSize())
+ throw new Error(`Size ${v.next}, expected ${b.getSize()}`);
+}
+
+for (let i = 0; i < LLB.varBitsMax + 1; ++i) {
+ let b = new LowLevelBinary();
+ for (let j = 0; j < i; ++j)
+ b.uint8(0x80);
+ assert.throwsRangeError(() => b.getVaruint(0));
+}
+
+let b = new LowLevelBinary();
+for (let i = 0; i < LLB.varBitsMax; ++i)
+ b.uint8(0x80);
+b.uint8(0x00);
+assert.throwsRangeError(() => b.getVaruint(0));
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_LowLevelBinary_varuint7js"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint7.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint7.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_LowLevelBinary_varuint7.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,14 @@
</span><ins>+import LowLevelBinary, * as LLB from '../LowLevelBinary.js';
+
+let values = [];
+for (let i = LLB.varuintMin; i <= LLB.varuint7Max; ++i) values.push(i);
+
+for (const i of values) {
+ let b = new LowLevelBinary();
+ b.varuint7(i);
+ const v = b.getVaruint7(0);
+ if (v.value !== i)
+ throw new Error(`Wrote "${i}" and read back "${v}"`);
+ if (v.next !== b.getSize())
+ throw new Error(`Size ${v.next}, expected ${b.getSize()}`);
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmselftesttest_WASMjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/self-test/test_WASM.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/self-test/test_WASM.js (rev 0)
+++ trunk/JSTests/wasm/self-test/test_WASM.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,42 @@
</span><ins>+import * as assert from '../assert.js';
+import * as WASM from '../WASM.js';
+
+assert.notUndef(WASM.description);
+assert.notUndef(WASM.valueType);
+assert.ge(WASM.valueType.length, 4);
+
+for (const v of WASM.valueType)
+ if (!WASM.isValidValueType(v))
+ throw new Error(`Expected value ${v} to be a valid value type`);
+
+const expectedFields = [
+ "preamble",
+ "value_type",
+ "inline_signature_type",
+ "external_kind",
+ "section",
+ "opcode",
+];
+for (const e of expectedFields) {
+ assert.notUndef(WASM.description[e]);
+ if (typeof(WASM.description[e]) !== "object")
+ throw new Error(`Expected description to contain field "${e}"`);
+}
+
+const expectedOpFields = [
+ "category",
+ "value",
+ "return",
+ "parameter",
+ "immediate",
+];
+for (const op in WASM.description.opcode)
+ for (const e of expectedOpFields)
+ assert.notUndef(WASM.description.opcode[op][e]);
+
+// FIXME: test for field "b3op" when all arithmetic/ comparison ops have them. https://bugs.webkit.org/show_bug.cgi?id=146064
+
+assert.notUndef(WASM.sections);
+assert.notUndef(WASM.sectionEncodingType);
+for (const section of WASM.sections)
+ assert.eq(WASM.sectionEncodingType, WASM.description.section[section].type);
</ins></span></pre></div>
<a id="trunkJSTestswasmtestsh"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/test.sh (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/test.sh (rev 0)
+++ trunk/JSTests/wasm/test.sh 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,13 @@
</span><ins>+#!/bin/bash
+
+set -e
+set -u
+set -x
+
+JSSHELL="${JSSHELL:-jsc}"
+find . -name "test_*.js" -type f | sort | \
+ xargs -n1 -t -I{} "$JSSHELL" -m {}
+
+"$JSSHELL" -m generate-wasmops-header.js > /dev/null
+
+echo "All tests passed"
</ins><span class="cx">Property changes on: trunk/JSTests/wasm/test.sh
</span><span class="cx">___________________________________________________________________
</span></span></pre></div>
<a id="svnexecutable"></a>
<div class="addfile"><h4>Added: svn:executable</h4></div>
<ins>+*
</ins><span class="cx">\ No newline at end of property
</span><a id="trunkJSTestswasmutilitiesjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/utilities.js (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/utilities.js (rev 0)
+++ trunk/JSTests/wasm/utilities.js 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,63 @@
</span><ins>+/*
+ * Copyright (C) 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Portable environment: one of ["node", "web", "worker", "shell"].
+const _environment =
+ ((typeof process === "object" && typeof require === "function") ? "node"
+ : (typeof window === "object" ? "web"
+ : (typeof importScripts === "function" ? "worker"
+ : "shell")));
+
+const _eval = x => eval.call(null, x);
+
+const _read = filename => {
+ switch (_environment) {
+ case "node": return read(filename);
+ case "web": // fallthrough
+ case "worker": let xhr = new XMLHttpRequest(); xhr.open("GET", filename, /*async=*/false); return xhr.responseText;
+ case "shell": return read(filename);
+ }
+}
+
+const _load = filename => {
+ switch (_environment) {
+ case "node": // fallthrough
+ case "web": // fallthrough
+ case "shell": return _eval(_read(filename));
+ case "worker": return importScripts(filename);
+ }
+}
+
+const _json = filename => {
+ switch (_environment) {
+ case "node": // fallthrough
+ case "shell": return JSON.parse(_read(filename));
+ case "web": // fallthrough
+ case "worker": let xhr = new XMLHttpRequest(); xhr.overrideMimeType("application/json"); xhr.open("GET", filename, /*async=*/false); return xhr.response;
+ }
+}
+
+// Use underscore names to avoid clashing with builtin names.
+export { _eval as eval, _read as read, _load as load, _json as json };
</ins></span></pre></div>
<a id="trunkJSTestswasmwasmjson"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/wasm.json (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/wasm.json (rev 0)
+++ trunk/JSTests/wasm/wasm.json 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,219 @@
</span><ins>+{
+ "comments": ["This file describes the WebAssembly ISA.",
+ "Scripts in this folder auto-generate C++ code for JavaScriptCore as well as the testing DSL which WebKit's WebAssembly tests use.",
+ "When you update this file you need to re-generate the C++ code: jsc ./JSTests/stress/wasm/generate-wasmops-header.js > ./Source/JavaScriptCore/wasm/WASMOps.h"
+ ],
+ "preamble": [
+ { "name": "magic number", "type": "uint32", "value": 1836278016, "description": "NULL character followed by 'asm'" },
+ { "name": "version", "type": "uint32", "value": 12, "description": "Version number, will be reset to 1 for MVP" }
+ ],
+ "value_type" : {
+ "i32": { "type": "uint8", "value": 1 },
+ "i64": { "type": "uint8", "value": 2 },
+ "f32": { "type": "uint8", "value": 3 },
+ "f64": { "type": "uint8", "value": 4 }
+ },
+ "inline_signature_type" : {
+ "void": { "type": "uint8", "value": 0 },
+ "i32": { "type": "uint8", "value": 1 },
+ "i64": { "type": "uint8", "value": 2 },
+ "f32": { "type": "uint8", "value": 3 },
+ "f64": { "type": "uint8", "value": 4 }
+ },
+ "external_kind": {
+ "Function": { "type": "uint8", "value": 0 },
+ "Table": { "type": "uint8", "value": 1 },
+ "Memory": { "type": "uint8", "value": 2 },
+ "Global": { "type": "uint8", "value": 3 }
+ },
+ "section" : {
+ "Type": { "type": "varuint7", "value": 1, "description": "Function signature declarations" },
+ "Import": { "type": "varuint7", "value": 2, "description": "Import declarations" },
+ "Function": { "type": "varuint7", "value": 3, "description": "Function declarations" },
+ "Table": { "type": "varuint7", "value": 4, "description": "Indirect function table and other tables" },
+ "Memory": { "type": "varuint7", "value": 5, "description": "Memory attributes" },
+ "Global": { "type": "varuint7", "value": 6, "description": "Global declarations" },
+ "Export": { "type": "varuint7", "value": 7, "description": "Exports" },
+ "Start": { "type": "varuint7", "value": 8, "description": "Start function declaration" },
+ "Element": { "type": "varuint7", "value": 9, "description": "Elements section" },
+ "Code": { "type": "varuint7", "value": 10, "description": "Function bodies (code)" },
+ "Data": { "type": "varuint7", "value": 11, "description": "Data segments" }
+ },
+ "opcode": {
+ "unreachable": { "category": "control", "value": 0, "return": [], "parameter": [], "immediate": [], "description": "trap immediately" },
+ "block": { "category": "control", "value": 1, "return": ["control"], "parameter": [], "immediate": [{"name": "sig", "type": "inline_signature_type"}], "description": "begin a sequence of expressions, yielding 0 or 1 values" },
+ "loop": { "category": "control", "value": 2, "return": ["control"], "parameter": [], "immediate": [{"name": "sig", "type": "inline_signature_type"}], "description": "begin a block which can also form control flow loops" },
+ "if": { "category": "control", "value": 3, "return": ["control"], "parameter": ["bool"], "immediate": [{"name": "sig", "type": "inline_signature_type"}], "description": "begin if expression" },
+ "else": { "category": "control", "value": 4, "return": ["control"], "parameter": [], "immediate": [], "description": "begin else expression of if" },
+ "select": { "category": "control", "value": 5, "return": ["prev"], "parameter": ["any", "prev", "bool"], "immediate": [], "description": "select one of two values based on condition" },
+ "br": { "category": "control", "value": 6, "return": [], "parameter": [], "immediate": [{"name": "relative_depth", "type": "varuint32"}], "description": "break that targets an outer nested block" },
+ "br_if": { "category": "control", "value": 7, "return": [], "parameter": [], "immediate": [{"name": "relative_depth", "type": "varuint32"}], "description": "conditional break that targets an outer nested block" },
+ "br_table": { "category": "control", "value": 8, "return": [], "parameter": [], "immediate": [{"name": "target_count", "type": "varuint32", "description": "number of entries in the target_table"},
+ {"name": "target_table", "type": "varuint32*", "description": "target entries that indicate an outer block or loop to which to break"},
+ {"name": "default_target", "type": "varuint32", "description": "an outer block or loop to which to break in the default case"}],
+ "description": "branch table control flow construct" },
+ "return": { "category": "control", "value": 9, "return": [], "parameter": [], "immediate": [], "description": "return zero or one value from this function" },
+ "drop": { "category": "control", "value": 11, "return": [], "parameter": ["any"], "immediate": [], "description": "ignore value" },
+ "nop": { "category": "control", "value": 10, "return": [], "parameter": [], "immediate": [], "description": "no operation" },
+ "end": { "category": "control", "value": 15, "return": [], "parameter": [], "immediate": [], "description": "end a block, loop, or if" },
+ "i32.const": { "category": "special", "value": 16, "return": ["i32"], "parameter": [], "immediate": [{"name": "value", "type": "varint32"}], "description": "a constant value interpreted as i32" },
+ "i64.const": { "category": "special", "value": 17, "return": ["i64"], "parameter": [], "immediate": [{"name": "value", "type": "varint64"}], "description": "a constant value interpreted as i64" },
+ "f64.const": { "category": "special", "value": 18, "return": ["f32"], "parameter": [], "immediate": [{"name": "value", "type": "uint64"}], "description": "a constant value interpreted as f64" },
+ "f32.const": { "category": "special", "value": 19, "return": ["f64"], "parameter": [], "immediate": [{"name": "value", "type": "uint32"}], "description": "a constant value interpreted as f32" },
+ "get_local": { "category": "special", "value": 20, "return": ["local"], "parameter": [], "immediate": [{"name": "local_index", "type": "varuint32"}], "description": "read a local variable or parameter" },
+ "set_local": { "category": "special", "value": 21, "return": [], "parameter": ["local"], "immediate": [{"name": "local_index", "type": "varuint32"}], "description": "write a local variable or parameter" },
+ "tee_local": { "category": "special", "value": 25, "return": ["prev"], "parameter": ["any"], "immediate": [{"name": "local_index", "type": "varuint32"}], "description": "write a local variable or parameter and return the same value" },
+ "get_global": { "category": "special", "value": 187, "return": ["global"], "parameter": [], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "read a global variable" },
+ "set_global": { "category": "special", "value": 188, "return": [""], "parameter": ["global"], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "write a global variable" },
+ "call": { "category": "call", "value": 22, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "function_index", "type": "varuint32"}], "description": "call a function by its index" },
+ "call_indirect": { "category": "call", "value": 23, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "type_index", "type": "varuint32"}], "description": "call a function indirect with an expected signature" },
+ "i32.load8_s": { "category": "memory", "value": 32, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i32.load8_u": { "category": "memory", "value": 33, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i32.load16_s": { "category": "memory", "value": 34, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i32.load16_u": { "category": "memory", "value": 35, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load8_s": { "category": "memory", "value": 36, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load8_u": { "category": "memory", "value": 37, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load16_s": { "category": "memory", "value": 38, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load16_u": { "category": "memory", "value": 39, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load32_s": { "category": "memory", "value": 40, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load32_u": { "category": "memory", "value": 41, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i32.load": { "category": "memory", "value": 42, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i64.load": { "category": "memory", "value": 43, "return": ["i64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "f32.load": { "category": "memory", "value": 44, "return": ["f32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "f64.load": { "category": "memory", "value": 45, "return": ["f64"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },
+ "i32.store8": { "category": "memory", "value": 46, "return": [], "parameter": ["addr", "i32"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i32.store16": { "category": "memory", "value": 47, "return": [], "parameter": ["addr", "i32"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i64.store8": { "category": "memory", "value": 48, "return": [], "parameter": ["addr", "i64"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i64.store16": { "category": "memory", "value": 49, "return": [], "parameter": ["addr", "i64"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i64.store32": { "category": "memory", "value": 50, "return": [], "parameter": ["addr", "i64"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i32.store": { "category": "memory", "value": 51, "return": [], "parameter": ["addr", "i32"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "i64.store": { "category": "memory", "value": 52, "return": [], "parameter": ["addr", "i64"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "f32.store": { "category": "memory", "value": 53, "return": [], "parameter": ["addr", "f32"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "f64.store": { "category": "memory", "value": 54, "return": [], "parameter": ["addr", "f64"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "store to memory" },
+ "current_memory": { "category": "operation", "value": 59, "return": ["size"], "parameter": [], "immediate": [], "description": "query the size of memory" },
+ "grow_memory": { "category": "operation", "value": 57, "return": ["size"], "parameter": ["size"], "immediate": [], "description": "grow the size of memory" },
+ "i32.add": { "category": "arithmetic", "value": 64, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Add" },
+ "i32.sub": { "category": "arithmetic", "value": 65, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Sub" },
+ "i32.mul": { "category": "arithmetic", "value": 66, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Mul" },
+ "i32.div_s": { "category": "arithmetic", "value": 67, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Div" },
+ "i32.div_u": { "category": "arithmetic", "value": 68, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [] },
+ "i32.rem_s": { "category": "arithmetic", "value": 69, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Mod" },
+ "i32.rem_u": { "category": "arithmetic", "value": 70, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [] },
+ "i32.and": { "category": "arithmetic", "value": 71, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "BitAnd" },
+ "i32.or": { "category": "arithmetic", "value": 72, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "BitOr" },
+ "i32.xor": { "category": "arithmetic", "value": 73, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "BitXor" },
+ "i32.shl": { "category": "arithmetic", "value": 74, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Shl" },
+ "i32.shr_u": { "category": "arithmetic", "value": 75, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "SShr" },
+ "i32.shr_s": { "category": "arithmetic", "value": 76, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "ZShr" },
+ "i32.rotr": { "category": "arithmetic", "value": 182, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [] },
+ "i32.rotl": { "category": "arithmetic", "value": 183, "return": ["i32"], "parameter": ["i32", "i32"], "immediate": [] },
+ "i32.eq": { "category": "comparison", "value": 77, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Equal" },
+ "i32.ne": { "category": "comparison", "value": 78, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "NotEqual" },
+ "i32.lt_s": { "category": "comparison", "value": 79, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "LessThan" },
+ "i32.le_s": { "category": "comparison", "value": 80, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "LessEqual" },
+ "i32.lt_u": { "category": "comparison", "value": 81, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Below" },
+ "i32.le_u": { "category": "comparison", "value": 82, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "BelowEqual" },
+ "i32.gt_s": { "category": "comparison", "value": 83, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "GreaterThan" },
+ "i32.ge_s": { "category": "comparison", "value": 84, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "GreaterEqual" },
+ "i32.gt_u": { "category": "comparison", "value": 85, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "Above" },
+ "i32.ge_u": { "category": "comparison", "value": 86, "return": ["bool"], "parameter": ["i32", "i32"], "immediate": [], "b3op": "AboveEqual" },
+ "i32.clz": { "category": "arithmetic", "value": 87, "return": ["i32"], "parameter": ["i32"], "immediate": [], "b3op": "Clz" },
+ "i32.ctz": { "category": "arithmetic", "value": 88, "return": ["i32"], "parameter": ["i32"], "immediate": [] },
+ "i32.popcnt": { "category": "arithmetic", "value": 89, "return": ["i32"], "parameter": ["i32"], "immediate": [] },
+ "i32.eqz": { "category": "comparison", "value": 90, "return": ["bool"], "parameter": ["i32"], "immediate": [] },
+ "i64.add": { "category": "arithmetic", "value": 91, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Add" },
+ "i64.sub": { "category": "arithmetic", "value": 92, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Sub" },
+ "i64.mul": { "category": "arithmetic", "value": 93, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Mul" },
+ "i64.div_s": { "category": "arithmetic", "value": 94, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Div" },
+ "i64.div_u": { "category": "arithmetic", "value": 95, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [] },
+ "i64.rem_s": { "category": "arithmetic", "value": 96, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Mod" },
+ "i64.rem_u": { "category": "arithmetic", "value": 97, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [] },
+ "i64.and": { "category": "arithmetic", "value": 98, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "BitAnd" },
+ "i64.or": { "category": "arithmetic", "value": 99, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "BitOr" },
+ "i64.xor": { "category": "arithmetic", "value": 100, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "BitXor" },
+ "i64.shl": { "category": "arithmetic", "value": 101, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Shl" },
+ "i64.shr_u": { "category": "arithmetic", "value": 102, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "SShr" },
+ "i64.shr_s": { "category": "arithmetic", "value": 103, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "ZShr" },
+ "i64.rotr": { "category": "arithmetic", "value": 184, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [] },
+ "i64.rotl": { "category": "arithmetic", "value": 185, "return": ["i64"], "parameter": ["i64", "i64"], "immediate": [] },
+ "i64.eq": { "category": "comparison", "value": 104, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Equal" },
+ "i64.ne": { "category": "comparison", "value": 105, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "NotEqual" },
+ "i64.lt_s": { "category": "comparison", "value": 106, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "LessThan" },
+ "i64.le_s": { "category": "comparison", "value": 107, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "LessEqual" },
+ "i64.lt_u": { "category": "comparison", "value": 108, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Below" },
+ "i64.le_u": { "category": "comparison", "value": 109, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "BelowEqual" },
+ "i64.gt_s": { "category": "comparison", "value": 110, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "GreaterThan" },
+ "i64.ge_s": { "category": "comparison", "value": 111, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "GreaterEqual" },
+ "i64.gt_u": { "category": "comparison", "value": 112, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "Above" },
+ "i64.ge_u": { "category": "comparison", "value": 113, "return": ["bool"], "parameter": ["i64", "i64"], "immediate": [], "b3op": "AboveEqual" },
+ "i64.clz": { "category": "arithmetic", "value": 114, "return": ["i64"], "parameter": ["i64"], "immediate": [], "b3op": "Clz" },
+ "i64.ctz": { "category": "arithmetic", "value": 115, "return": ["i64"], "parameter": ["i64"], "immediate": [] },
+ "i64.popcnt": { "category": "arithmetic", "value": 116, "return": ["i64"], "parameter": ["i64"], "immediate": [] },
+ "i64.eqz": { "category": "comparison", "value": 186, "return": ["bool"], "parameter": ["i64"], "immediate": [] },
+ "f32.add": { "category": "arithmetic", "value": 117, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.sub": { "category": "arithmetic", "value": 118, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.mul": { "category": "arithmetic", "value": 119, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.div": { "category": "arithmetic", "value": 120, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.min": { "category": "arithmetic", "value": 121, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.max": { "category": "arithmetic", "value": 122, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.abs": { "category": "arithmetic", "value": 123, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.neg": { "category": "arithmetic", "value": 124, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.copysign": { "category": "arithmetic", "value": 125, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.ceil": { "category": "arithmetic", "value": 126, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.floor": { "category": "arithmetic", "value": 127, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.trunc": { "category": "arithmetic", "value": 128, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.nearest": { "category": "arithmetic", "value": 129, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.sqrt": { "category": "arithmetic", "value": 130, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
+ "f32.eq": { "category": "comparison", "value": 131, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.ne": { "category": "comparison", "value": 132, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.lt": { "category": "comparison", "value": 133, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.le": { "category": "comparison", "value": 134, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.gt": { "category": "comparison", "value": 135, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f32.ge": { "category": "comparison", "value": 136, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [] },
+ "f64.add": { "category": "arithmetic", "value": 137, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.sub": { "category": "arithmetic", "value": 138, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.mul": { "category": "arithmetic", "value": 139, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.div": { "category": "arithmetic", "value": 140, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.min": { "category": "arithmetic", "value": 141, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.max": { "category": "arithmetic", "value": 142, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.abs": { "category": "arithmetic", "value": 143, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.neg": { "category": "arithmetic", "value": 144, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.copysign": { "category": "arithmetic", "value": 145, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.ceil": { "category": "arithmetic", "value": 146, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.floor": { "category": "arithmetic", "value": 147, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.trunc": { "category": "arithmetic", "value": 148, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.nearest": { "category": "arithmetic", "value": 149, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.sqrt": { "category": "arithmetic", "value": 150, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
+ "f64.eq": { "category": "comparison", "value": 151, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.ne": { "category": "comparison", "value": 152, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.lt": { "category": "comparison", "value": 153, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.le": { "category": "comparison", "value": 154, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.gt": { "category": "comparison", "value": 155, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "f64.ge": { "category": "comparison", "value": 156, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [] },
+ "i32.trunc_s/f32": { "category": "conversion", "value": 157, "return": ["i32"], "parameter": ["f32"], "immediate": [] },
+ "i32.trunc_s/f64": { "category": "conversion", "value": 158, "return": ["i32"], "parameter": ["f64"], "immediate": [] },
+ "i32.trunc_u/f32": { "category": "conversion", "value": 159, "return": ["i32"], "parameter": ["f32"], "immediate": [] },
+ "i32.trunc_u/f64": { "category": "conversion", "value": 160, "return": ["i32"], "parameter": ["f64"], "immediate": [] },
+ "i32.wrap/i64": { "category": "conversion", "value": 161, "return": ["i32"], "parameter": ["i64"], "immediate": [] },
+ "i64.trunc_s/f32": { "category": "conversion", "value": 162, "return": ["i64"], "parameter": ["f32"], "immediate": [] },
+ "i64.trunc_s/f64": { "category": "conversion", "value": 163, "return": ["i64"], "parameter": ["f64"], "immediate": [] },
+ "i64.trunc_u/f32": { "category": "conversion", "value": 164, "return": ["i64"], "parameter": ["f32"], "immediate": [] },
+ "i64.trunc_u/f64": { "category": "conversion", "value": 165, "return": ["i64"], "parameter": ["f64"], "immediate": [] },
+ "i64.extend_s/i32": { "category": "conversion", "value": 166, "return": ["i64"], "parameter": ["i32"], "immediate": [] },
+ "i64.extend_u/i32": { "category": "conversion", "value": 167, "return": ["i64"], "parameter": ["i32"], "immediate": [] },
+ "f32.convert_s/i32": { "category": "conversion", "value": 168, "return": ["f32"], "parameter": ["i32"], "immediate": [] },
+ "f32.convert_u/i32": { "category": "conversion", "value": 169, "return": ["f32"], "parameter": ["i32"], "immediate": [] },
+ "f32.convert_s/i64": { "category": "conversion", "value": 170, "return": ["f32"], "parameter": ["i64"], "immediate": [] },
+ "f32.convert_u/i64": { "category": "conversion", "value": 171, "return": ["f32"], "parameter": ["i64"], "immediate": [] },
+ "f32.demote/f64": { "category": "conversion", "value": 172, "return": ["f32"], "parameter": ["f64"], "immediate": [] },
+ "f32.reinterpret/i32": { "category": "conversion", "value": 173, "return": ["f32"], "parameter": ["i32"], "immediate": [] },
+ "f64.convert_s/i32": { "category": "conversion", "value": 174, "return": ["f64"], "parameter": ["i32"], "immediate": [] },
+ "f64.convert_u/i32": { "category": "conversion", "value": 175, "return": ["f64"], "parameter": ["i32"], "immediate": [] },
+ "f64.convert_s/i64": { "category": "conversion", "value": 176, "return": ["f64"], "parameter": ["i64"], "immediate": [] },
+ "f64.convert_u/i64": { "category": "conversion", "value": 177, "return": ["f64"], "parameter": ["i64"], "immediate": [] },
+ "f64.promote/f32": { "category": "conversion", "value": 178, "return": ["f64"], "parameter": ["f32"], "immediate": [] },
+ "f64.reinterpret/i64": { "category": "conversion", "value": 179, "return": ["f64"], "parameter": ["i64"], "immediate": [] },
+ "i32.reinterpret/f32": { "category": "conversion", "value": 180, "return": ["i32"], "parameter": ["f32"], "immediate": [] },
+ "i64.reinterpret/f64": { "category": "conversion", "value": 181, "return": ["i64"], "parameter": ["f64"], "immediate": [] }
+ }
+}
</ins></span></pre></div>
<a id="trunkJSTestswasmyaml"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm.yaml (0 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm.yaml (rev 0)
+++ trunk/JSTests/wasm.yaml 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -0,0 +1,25 @@
</span><ins>+# Copyright (C) 2016 Apple Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+- path: wasm/self-test/
+ cmd: runWebAssembly
</ins></span></pre></div>
<a id="trunkToolsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Tools/ChangeLog (207362 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/ChangeLog 2016-10-14 23:56:00 UTC (rev 207362)
+++ trunk/Tools/ChangeLog 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -1,3 +1,23 @@
</span><ins>+2016-10-14 JF Bastien <jfbastien@apple.com>
+
+ Basic WebAssembly testing
+
+ Create a small DSL in JavaScript which can build WebAssembly binary modules based on the JSON description of the format as described in:
+ https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
+
+ This DSL can then be used to write small text description of valid and invalid WebAssembly binaries, making testing the JSC implementation much easier.
+
+ Details and example in README.md.
+
+ Basic WebAssembly testing
+ https://bugs.webkit.org/show_bug.cgi?id=163267
+
+ Reviewed by Keith Miller.
+
+ * Scripts/run-javascriptcore-tests:
+ (runJSCStressTests): run wasm.yaml tests
+ * Scripts/run-jsc-stress-tests: add a WebAssembly-specific runner
+
</ins><span class="cx"> 2016-10-14 Simon Fraser <simon.fraser@apple.com>
</span><span class="cx">
</span><span class="cx"> Annotate bots in contributors.json and don't show them on webkit.org/team
</span></span></pre></div>
<a id="trunkToolsScriptsrunjavascriptcoretests"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/run-javascriptcore-tests (207362 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/run-javascriptcore-tests 2016-10-14 23:56:00 UTC (rev 207362)
+++ trunk/Tools/Scripts/run-javascriptcore-tests 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -282,7 +282,8 @@
</span><span class="cx"> "JSTests/controlFlowProfiler.yaml",
</span><span class="cx"> "JSTests/es6.yaml",
</span><span class="cx"> "JSTests/modules.yaml",
</span><del>- "JSTests/ChakraCore.yaml");
</del><ins>+ "JSTests/ChakraCore.yaml",
+ "JSTests/wasm.yaml");
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ($runMozillaTests) {
</span></span></pre></div>
<a id="trunkToolsScriptsrunjscstresstests"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/run-jsc-stress-tests (207362 => 207363)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/run-jsc-stress-tests 2016-10-14 23:56:00 UTC (rev 207362)
+++ trunk/Tools/Scripts/run-jsc-stress-tests 2016-10-15 00:10:31 UTC (rev 207363)
</span><span class="lines">@@ -47,6 +47,7 @@
</span><span class="cx"> SCRIPTS_PATH = THIS_SCRIPT_PATH.dirname
</span><span class="cx"> WEBKIT_PATH = SCRIPTS_PATH.dirname.dirname
</span><span class="cx"> LAYOUTTESTS_PATH = WEBKIT_PATH + "LayoutTests"
</span><ins>+WASMTESTS_PATH = WEBKIT_PATH + "JSTests/wasm"
</ins><span class="cx"> CHAKRATESTS_PATH = WEBKIT_PATH + "JSTests/ChakraCore/test"
</span><span class="cx"> raise unless SCRIPTS_PATH.basename.to_s == "Scripts"
</span><span class="cx"> raise unless SCRIPTS_PATH.dirname.basename.to_s == "Tools"
</span><span class="lines">@@ -1153,6 +1154,15 @@
</span><span class="cx"> run("ftl-no-cjit-small-pool-modules", "-m", "--jitMemoryReservationSize=50000", *(FTL_OPTIONS + NO_CJIT_OPTIONS))
</span><span class="cx"> end
</span><span class="cx">
</span><ins>+def runWebAssembly
+ return if !$jitTests
+ return if !$isFTLPlatform
+ modules = Dir[WASMTESTS_PATH + "*.js"].map { |f| File.basename(f) }
+ prepareExtraAbsoluteFiles(WASMTESTS_PATH, ["wasm.json"])
+ prepareExtraRelativeFiles(modules.map { |f| "../" + f }, $collection)
+ run("default-wasm", "-m")
+end
+
</ins><span class="cx"> def runChakra(mode, exception, baselineFile, extraFiles)
</span><span class="cx"> raise unless $benchmark.to_s =~ /\.js$/
</span><span class="cx"> failsWithException = exception != "NoException"
</span></span></pre>
</div>
</div>
</body>
</html>