<!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>[207781] 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/207781">207781</a></dd>
<dt>Author</dt> <dd>keith_miller@apple.com</dd>
<dt>Date</dt> <dd>2016-10-24 14:44:34 -0700 (Mon, 24 Oct 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Wasm should support floating point operations.
https://bugs.webkit.org/show_bug.cgi?id=163770
Reviewed by Michael Saboff.
JSTests:
Add appropriate b3op names for floating point wasm bytecodes, where they exist.
Also, fix some WASM => Wasm in WasmOps.h generator script that I missed
the first time I made the change.
* wasm/generate-wasmops-header.js:
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.template.typename.Int.inline.bool.isValidOpType): Deleted.
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.BinaryOpType): Deleted.
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.UnaryOpType): Deleted.
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.LoadOpType): Deleted.
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.StoreOpType): Deleted.
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.undef.CREATE_ENUM_VALUE.inline.bool.isControlOp): Deleted.
* wasm/wasm.json:
Source/JavaScriptCore:
Since we now have a Double => Float Trunc in B3, we can now support calls in Wasm
that take floating point arguments. This patch also enables most of the Wasm
floating point operations, as the associated B3 opcode has been linked via wasm.json.
If there is no direct mapping to a B3 opcode the Wasm is not yet implemented. This
patch also fixes a bug in calls where the arguments would be reversed.
* testWasm.cpp:
(cast):
(invoke):
(boxf):
(boxd):
(runWasmTests):
* wasm/WasmB3IRGenerator.cpp:
(JSC::Wasm::createJSWrapper):
* wasm/WasmCallingConvention.h:
(JSC::Wasm::CallingConvention::loadArguments):
(JSC::Wasm::CallingConvention::setupCall):
* wasm/WasmFunctionParser.h:
(JSC::Wasm::FunctionParser<Context>::parseExpression):
(JSC::Wasm::FunctionParser<Context>::parseUnreachableExpression):
* wasm/WasmOps.h:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJSTestsChangeLog">trunk/JSTests/ChangeLog</a></li>
<li><a href="#trunkJSTestswasmgeneratewasmopsheaderjs">trunk/JSTests/wasm/generate-wasmops-header.js</a></li>
<li><a href="#trunkJSTestswasmwasmjson">trunk/JSTests/wasm/wasm.json</a></li>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoretestWasmcpp">trunk/Source/JavaScriptCore/testWasm.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWasmB3IRGeneratorcpp">trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWasmCallingConventionh">trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWasmFunctionParserh">trunk/Source/JavaScriptCore/wasm/WasmFunctionParser.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWasmOpsh">trunk/Source/JavaScriptCore/wasm/WasmOps.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJSTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/ChangeLog (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/ChangeLog 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/JSTests/ChangeLog 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -1,3 +1,23 @@
</span><ins>+2016-10-24 Keith Miller <keith_miller@apple.com>
+
+ Wasm should support floating point operations.
+ https://bugs.webkit.org/show_bug.cgi?id=163770
+
+ Reviewed by Michael Saboff.
+
+ Add appropriate b3op names for floating point wasm bytecodes, where they exist.
+ Also, fix some WASM => Wasm in WasmOps.h generator script that I missed
+ the first time I made the change.
+
+ * wasm/generate-wasmops-header.js:
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.template.typename.Int.inline.bool.isValidOpType): Deleted.
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.BinaryOpType): Deleted.
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.UnaryOpType): Deleted.
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.LoadOpType): Deleted.
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.enum.StoreOpType): Deleted.
+ (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.WASM.undef.CREATE_ENUM_VALUE.inline.bool.isControlOp): Deleted.
+ * wasm/wasm.json:
+
</ins><span class="cx"> 2016-10-21 Saam Barati <sbarati@apple.com>
</span><span class="cx">
</span><span class="cx"> SpeculativeJIT::compileTryGetById needs to pass in NeedsToSpill along both the cell speculation and untyped speculation path
</span></span></pre></div>
<a id="trunkJSTestswasmgeneratewasmopsheaderjs"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/wasm/generate-wasmops-header.js (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/generate-wasmops-header.js 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/JSTests/wasm/generate-wasmops-header.js 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -1,4 +1,4 @@
</span><del>-// Use the JSON description of WebAssembly to generate the JavaScriptCore's WASMOps.h.
</del><ins>+// Use the JSON description of WebAssembly to generate the JavaScriptCore's WasmOps.h.
</ins><span class="cx">
</span><span class="cx"> const jsonFile = 'wasm.json';
</span><span class="cx"> const wasm = JSON.parse(read(jsonFile));
</span><span class="lines">@@ -90,7 +90,7 @@
</span><span class="cx">
</span><span class="cx"> #include <cstdint>
</span><span class="cx">
</span><del>-namespace JSC { namespace WASM {
</del><ins>+namespace JSC { namespace Wasm {
</ins><span class="cx">
</span><span class="cx"> ${defines}
</span><span class="cx">
</span><span class="lines">@@ -147,7 +147,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-} } // namespace JSC::WASM
</del><ins>+} } // namespace JSC::Wasm
</ins><span class="cx">
</span><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span><span class="cx"> `;
</span></span></pre></div>
<a id="trunkJSTestswasmwasmjson"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/wasm/wasm.json (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/wasm.json 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/JSTests/wasm/wasm.json 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -150,46 +150,46 @@
</span><span class="cx"> "i64.ctz": { "category": "arithmetic", "value": 115, "return": ["i64"], "parameter": ["i64"], "immediate": [] },
</span><span class="cx"> "i64.popcnt": { "category": "arithmetic", "value": 116, "return": ["i64"], "parameter": ["i64"], "immediate": [] },
</span><span class="cx"> "i64.eqz": { "category": "comparison", "value": 186, "return": ["bool"], "parameter": ["i64"], "immediate": [] },
</span><del>- "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": [] },
</del><ins>+ "f32.add": { "category": "arithmetic", "value": 117, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "Add" },
+ "f32.sub": { "category": "arithmetic", "value": 118, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "Sub" },
+ "f32.mul": { "category": "arithmetic", "value": 119, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "Mul" },
+ "f32.div": { "category": "arithmetic", "value": 120, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "Div" },
</ins><span class="cx"> "f32.min": { "category": "arithmetic", "value": 121, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
</span><span class="cx"> "f32.max": { "category": "arithmetic", "value": 122, "return": ["f32"], "parameter": ["f32", "f32"], "immediate": [] },
</span><del>- "f32.abs": { "category": "arithmetic", "value": 123, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</del><ins>+ "f32.abs": { "category": "arithmetic", "value": 123, "return": ["f32"], "parameter": ["f32"], "immediate": [], "b3op": "Abs" },
</ins><span class="cx"> "f32.neg": { "category": "arithmetic", "value": 124, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</span><span class="cx"> "f32.copysign": { "category": "arithmetic", "value": 125, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</span><del>- "f32.ceil": { "category": "arithmetic", "value": 126, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
- "f32.floor": { "category": "arithmetic", "value": 127, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</del><ins>+ "f32.ceil": { "category": "arithmetic", "value": 126, "return": ["f32"], "parameter": ["f32"], "immediate": [], "b3op": "Ceil" },
+ "f32.floor": { "category": "arithmetic", "value": 127, "return": ["f32"], "parameter": ["f32"], "immediate": [], "b3op": "Floor" },
</ins><span class="cx"> "f32.trunc": { "category": "arithmetic", "value": 128, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</span><span class="cx"> "f32.nearest": { "category": "arithmetic", "value": 129, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</span><span class="cx"> "f32.sqrt": { "category": "arithmetic", "value": 130, "return": ["f32"], "parameter": ["f32"], "immediate": [] },
</span><del>- "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": [] },
</del><ins>+ "f32.eq": { "category": "comparison", "value": 131, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "Equal" },
+ "f32.ne": { "category": "comparison", "value": 132, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "NotEqual" },
+ "f32.lt": { "category": "comparison", "value": 133, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "LessThan" },
+ "f32.le": { "category": "comparison", "value": 134, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "LessEqual" },
+ "f32.gt": { "category": "comparison", "value": 135, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "GreaterThan" },
+ "f32.ge": { "category": "comparison", "value": 136, "return": ["bool"], "parameter": ["f32", "f32"], "immediate": [], "b3op": "GreaterEqual" },
+ "f64.add": { "category": "arithmetic", "value": 137, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "Add" },
+ "f64.sub": { "category": "arithmetic", "value": 138, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "Sub" },
+ "f64.mul": { "category": "arithmetic", "value": 139, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "Mul" },
+ "f64.div": { "category": "arithmetic", "value": 140, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "Div" },
</ins><span class="cx"> "f64.min": { "category": "arithmetic", "value": 141, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
</span><span class="cx"> "f64.max": { "category": "arithmetic", "value": 142, "return": ["f64"], "parameter": ["f64", "f64"], "immediate": [] },
</span><del>- "f64.abs": { "category": "arithmetic", "value": 143, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</del><ins>+ "f64.abs": { "category": "arithmetic", "value": 143, "return": ["f64"], "parameter": ["f64"], "immediate": [], "b3op": "Abs" },
</ins><span class="cx"> "f64.neg": { "category": "arithmetic", "value": 144, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</span><span class="cx"> "f64.copysign": { "category": "arithmetic", "value": 145, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</span><del>- "f64.ceil": { "category": "arithmetic", "value": 146, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
- "f64.floor": { "category": "arithmetic", "value": 147, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</del><ins>+ "f64.ceil": { "category": "arithmetic", "value": 146, "return": ["f64"], "parameter": ["f64"], "immediate": [], "b3op": "Ceil" },
+ "f64.floor": { "category": "arithmetic", "value": 147, "return": ["f64"], "parameter": ["f64"], "immediate": [], "b3op": "Floor" },
</ins><span class="cx"> "f64.trunc": { "category": "arithmetic", "value": 148, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</span><span class="cx"> "f64.nearest": { "category": "arithmetic", "value": 149, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</span><span class="cx"> "f64.sqrt": { "category": "arithmetic", "value": 150, "return": ["f64"], "parameter": ["f64"], "immediate": [] },
</span><del>- "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": [] },
</del><ins>+ "f64.eq": { "category": "comparison", "value": 151, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "Equal" },
+ "f64.ne": { "category": "comparison", "value": 152, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "NotEqual" },
+ "f64.lt": { "category": "comparison", "value": 153, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "LessThan" },
+ "f64.le": { "category": "comparison", "value": 154, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "LessEqual" },
+ "f64.gt": { "category": "comparison", "value": 155, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "GreaterThan" },
+ "f64.ge": { "category": "comparison", "value": 156, "return": ["bool"], "parameter": ["f64", "f64"], "immediate": [], "b3op": "GreaterEqual" },
</ins><span class="cx"> "i32.trunc_s/f32": { "category": "conversion", "value": 157, "return": ["i32"], "parameter": ["f32"], "immediate": [] },
</span><span class="cx"> "i32.trunc_s/f64": { "category": "conversion", "value": 158, "return": ["i32"], "parameter": ["f64"], "immediate": [] },
</span><span class="cx"> "i32.trunc_u/f32": { "category": "conversion", "value": 159, "return": ["i32"], "parameter": ["f32"], "immediate": [] },
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -1,3 +1,32 @@
</span><ins>+2016-10-24 Keith Miller <keith_miller@apple.com>
+
+ Wasm should support floating point operations.
+ https://bugs.webkit.org/show_bug.cgi?id=163770
+
+ Reviewed by Michael Saboff.
+
+ Since we now have a Double => Float Trunc in B3, we can now support calls in Wasm
+ that take floating point arguments. This patch also enables most of the Wasm
+ floating point operations, as the associated B3 opcode has been linked via wasm.json.
+ If there is no direct mapping to a B3 opcode the Wasm is not yet implemented. This
+ patch also fixes a bug in calls where the arguments would be reversed.
+
+ * testWasm.cpp:
+ (cast):
+ (invoke):
+ (boxf):
+ (boxd):
+ (runWasmTests):
+ * wasm/WasmB3IRGenerator.cpp:
+ (JSC::Wasm::createJSWrapper):
+ * wasm/WasmCallingConvention.h:
+ (JSC::Wasm::CallingConvention::loadArguments):
+ (JSC::Wasm::CallingConvention::setupCall):
+ * wasm/WasmFunctionParser.h:
+ (JSC::Wasm::FunctionParser<Context>::parseExpression):
+ (JSC::Wasm::FunctionParser<Context>::parseUnreachableExpression):
+ * wasm/WasmOps.h:
+
</ins><span class="cx"> 2016-10-24 Mark Lam <mark.lam@apple.com>
</span><span class="cx">
</span><span class="cx"> Dumping of op_negate bytecode is broken.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoretestWasmcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/testWasm.cpp (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/testWasm.cpp 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/testWasm.cpp 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -25,6 +25,7 @@
</span><span class="cx">
</span><span class="cx"> #include "config.h"
</span><span class="cx">
</span><ins>+#include "B3Common.h"
</ins><span class="cx"> #include "B3Compilation.h"
</span><span class="cx"> #include "InitializeThreading.h"
</span><span class="cx"> #include "JSCJSValueInlines.h"
</span><span class="lines">@@ -96,6 +97,8 @@
</span><span class="cx"> CRASH(); \
</span><span class="cx"> } while (false)
</span><span class="cx">
</span><ins>+#define CHECK(x) CHECK_EQ(x, true)
+
</ins><span class="cx"> #define FOR_EACH_UNSIGNED_LEB_TEST(macro) \
</span><span class="cx"> /* Simple tests that use all the bits in the array */ \
</span><span class="cx"> macro(({ 0x07 }), 0, true, 0x7lu, 1lu) \
</span><span class="lines">@@ -208,6 +211,24 @@
</span><span class="cx"> using namespace B3;
</span><span class="cx">
</span><span class="cx"> template<typename T>
</span><ins>+T cast(EncodedJSValue value)
+{
+ return static_cast<T>(value);
+}
+
+template<>
+double cast(EncodedJSValue value)
+{
+ return bitwise_cast<double>(value);
+}
+
+template<>
+float cast(EncodedJSValue value)
+{
+ return bitwise_cast<float>(static_cast<int>(value));
+}
+
+template<typename T>
</ins><span class="cx"> T invoke(MacroAssemblerCodePtr ptr, std::initializer_list<JSValue> args)
</span><span class="cx"> {
</span><span class="cx"> JSValue firstArgument;
</span><span class="lines">@@ -224,8 +245,7 @@
</span><span class="cx"> ProtoCallFrame protoCallFrame;
</span><span class="cx"> protoCallFrame.init(nullptr, nullptr, firstArgument, argCount, remainingArguments);
</span><span class="cx">
</span><del>- // This won't work for floating point values but we don't have those yet.
- return static_cast<T>(vmEntryToWasm(ptr.executableAddress(), vm, &protoCallFrame));
</del><ins>+ return cast<T>(vmEntryToWasm(ptr.executableAddress(), vm, &protoCallFrame));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename T>
</span><span class="lines">@@ -239,12 +259,81 @@
</span><span class="cx"> return JSValue::decode(value);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+inline JSValue boxf(float value)
+{
+ return box(bitwise_cast<uint32_t>(value));
+}
+
+inline JSValue boxd(double value)
+{
+ return box(bitwise_cast<uint64_t>(value));
+}
+
</ins><span class="cx"> // For now we inline the test files.
</span><span class="cx"> static void runWasmTests()
</span><span class="cx"> {
</span><ins>+
</ins><span class="cx"> {
</span><span class="cx"> // Generated from:
</span><span class="cx"> // (module
</span><ins>+ // (func $f32-sub (export "f32-sub") (param f32) (param f32) (result f32) (return (f32.sub (get_local 0) (get_local 1))))
+ // (func (export "indirect-f32-sub") (param f32) (param f32) (result f32) (return (call $f32-sub (get_local 0) (get_local 1))))
+ // )
+ Vector<uint8_t> vector = {
+ 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40,
+ 0x02, 0x03, 0x03, 0x01, 0x03, 0x03, 0x83, 0x80, 0x80, 0x80, 0x00, 0x02, 0x00, 0x00, 0x07, 0x9e,
+ 0x80, 0x80, 0x80, 0x00, 0x02, 0x07, 0x66, 0x33, 0x32, 0x2d, 0x73, 0x75, 0x62, 0x00, 0x00, 0x10,
+ 0x69, 0x6e, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x2d, 0x66, 0x33, 0x32, 0x2d, 0x73, 0x75, 0x62,
+ 0x00, 0x01, 0x0a, 0x9c, 0x80, 0x80, 0x80, 0x00, 0x02, 0x88, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14,
+ 0x00, 0x14, 0x01, 0x76, 0x09, 0x0f, 0x89, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14, 0x00, 0x14, 0x01,
+ 0x16, 0x00, 0x09, 0x0f
+ };
+
+ Plan plan(*vm, vector);
+ if (plan.result.size() != 2 || !plan.result[0] || !plan.result[1]) {
+ dataLogLn("Module failed to compile correctly.");
+ CRASH();
+ }
+
+ // Test this doesn't crash.
+ CHECK(isIdentical(invoke<float>(*plan.result[1]->jsEntryPoint, { boxf(0.0), boxf(1.5) }), -1.5f));
+ CHECK(isIdentical(invoke<float>(*plan.result[1]->jsEntryPoint, { boxf(100.1234), boxf(12.5) }), 87.6234f));
+ CHECK(isIdentical(invoke<float>(*plan.result[0]->jsEntryPoint, { boxf(0.0), boxf(1.5) }), -1.5f));
+ CHECK(isIdentical(invoke<float>(*plan.result[0]->jsEntryPoint, { boxf(100.1234), boxf(12.5) }), 87.6234f));
+ }
+
+ {
+ // Generated from:
+ // (module
+ // (func $f32-add (export "f32-add") (param f32) (param f32) (result f32) (return (f32.add (get_local 0) (get_local 1))))
+ // (func (export "indirect-f32-add") (param f32) (param f32) (result f32) (return (call $f32-add (get_local 0) (get_local 1))))
+ // )
+ Vector<uint8_t> vector = {
+ 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40,
+ 0x02, 0x03, 0x03, 0x01, 0x03, 0x03, 0x83, 0x80, 0x80, 0x80, 0x00, 0x02, 0x00, 0x00, 0x07, 0x9e,
+ 0x80, 0x80, 0x80, 0x00, 0x02, 0x07, 0x66, 0x33, 0x32, 0x2d, 0x61, 0x64, 0x64, 0x00, 0x00, 0x10,
+ 0x69, 0x6e, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x2d, 0x66, 0x33, 0x32, 0x2d, 0x61, 0x64, 0x64,
+ 0x00, 0x01, 0x0a, 0x9c, 0x80, 0x80, 0x80, 0x00, 0x02, 0x88, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14,
+ 0x00, 0x14, 0x01, 0x75, 0x09, 0x0f, 0x89, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14, 0x00, 0x14, 0x01,
+ 0x16, 0x00, 0x09, 0x0f
+ };
+
+ Plan plan(*vm, vector);
+ if (plan.result.size() != 2 || !plan.result[0] || !plan.result[1]) {
+ dataLogLn("Module failed to compile correctly.");
+ CRASH();
+ }
+
+ // Test this doesn't crash.
+ CHECK(isIdentical(invoke<float>(*plan.result[1]->jsEntryPoint, { boxf(0.0), boxf(1.5) }), 1.5f));
+ CHECK(isIdentical(invoke<float>(*plan.result[1]->jsEntryPoint, { boxf(100.1234), boxf(12.5) }), 112.6234f));
+ CHECK(isIdentical(invoke<float>(*plan.result[0]->jsEntryPoint, { boxf(0.0), boxf(1.5) }), 1.5f));
+ CHECK(isIdentical(invoke<float>(*plan.result[0]->jsEntryPoint, { boxf(100.1234), boxf(12.5) }), 112.6234f));
+ }
+
+ {
+ // Generated from:
+ // (module
</ins><span class="cx"> // (memory 1)
</span><span class="cx"> // (func $sum12 (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32) (return (i32.add (get_local 0) (i32.add (get_local 1) (i32.add (get_local 2) (i32.add (get_local 3) (i32.add (get_local 4) (i32.add (get_local 5) (i32.add (get_local 6) (i32.add (get_local 7) (i32.add (get_local 8) (i32.add (get_local 9) (i32.add (get_local 10) (get_local 11))))))))))))))
</span><span class="cx"> // (func (export "mult12") (param i32) (result i32) (return (call $sum12 (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0) (get_local 0))))
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmB3IRGeneratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -697,10 +697,19 @@
</span><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> // Return the result, if needed.
</span><del>- if (signature->returnType != Void)
</del><ins>+ switch (signature->returnType) {
+ case Void:
+ block->appendNewControlValue(proc, B3::Return, Origin());
+ break;
+ case F32:
+ case F64:
+ result = block->appendNew<Value>(proc, BitwiseCast, Origin(), result);
+ FALLTHROUGH;
+ case I32:
+ case I64:
</ins><span class="cx"> block->appendNewControlValue(proc, B3::Return, Origin(), result);
</span><del>- else
- block->appendNewControlValue(proc, B3::Return, Origin());
</del><ins>+ break;
+ }
</ins><span class="cx">
</span><span class="cx"> return std::make_unique<Compilation>(vm, proc);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmCallingConventionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -98,10 +98,8 @@
</span><span class="cx"> B3::ValueRep rep = marshallArgument(type, gpArgumentCount, fpArgumentCount, stackOffset);
</span><span class="cx"> if (rep.isReg()) {
</span><span class="cx"> argument = block->appendNew<B3::ArgumentRegValue>(proc, origin, rep.reg());
</span><del>- if (type == B3::Int32)
</del><ins>+ if (type == B3::Int32 || type == B3::Float)
</ins><span class="cx"> argument = block->appendNew<B3::Value>(proc, B3::Trunc, origin, argument);
</span><del>- // FIXME: How do I get a float from a FPR? We don't support floating points yet so it's not a big deal... yet.
- // see: https://bugs.webkit.org/show_bug.cgi?id=163770
</del><span class="cx"> } else {
</span><span class="cx"> ASSERT(rep.isStackArgument());
</span><span class="cx"> B3::Value* address = block->appendNew<B3::Value>(proc, B3::Add, origin, framePointer,
</span><span class="lines">@@ -134,10 +132,18 @@
</span><span class="cx"> patchpoint->appendVector(constrainedArguments);
</span><span class="cx"> patchpointFunctor(patchpoint);
</span><span class="cx">
</span><del>- if (returnType == B3::Void)
</del><ins>+ switch (returnType) {
+ case B3::Void:
</ins><span class="cx"> return nullptr;
</span><del>-
- patchpoint->resultConstraint = B3::ValueRep::reg(GPRInfo::returnValueGPR);
</del><ins>+ case B3::Float:
+ case B3::Double:
+ patchpoint->resultConstraint = B3::ValueRep::reg(FPRInfo::returnValueFPR);
+ break;
+ case B3::Int32:
+ case B3::Int64:
+ patchpoint->resultConstraint = B3::ValueRep::reg(GPRInfo::returnValueGPR);
+ break;
+ }
</ins><span class="cx"> return patchpoint;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmFunctionParserh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmFunctionParser.h (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmFunctionParser.h 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/wasm/WasmFunctionParser.h 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -190,6 +190,7 @@
</span><span class="cx"> return m_context.store(static_cast<StoreOpType>(op), pointer, value, offset);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case OpType::F32Const:
</ins><span class="cx"> case OpType::I32Const: {
</span><span class="cx"> uint32_t constant;
</span><span class="cx"> if (!parseVarUInt32(constant))
</span><span class="lines">@@ -198,6 +199,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case OpType::F64Const:
</ins><span class="cx"> case OpType::I64Const: {
</span><span class="cx"> uint64_t constant;
</span><span class="cx"> if (!parseVarUInt64(constant))
</span><span class="lines">@@ -236,9 +238,15 @@
</span><span class="cx">
</span><span class="cx"> const FunctionInformation& info = m_functions[functionIndex];
</span><span class="cx">
</span><ins>+ if (info.signature->arguments.size() > m_expressionStack.size())
+ return false;
+
+ size_t firstArgumentIndex = m_expressionStack.size() - info.signature->arguments.size();
</ins><span class="cx"> Vector<ExpressionType> args;
</span><del>- for (unsigned i = 0; i < info.signature->arguments.size(); ++i)
- args.append(m_expressionStack.takeLast());
</del><ins>+ args.reserveInitialCapacity(info.signature->arguments.size());
+ for (unsigned i = firstArgumentIndex; i < m_expressionStack.size(); ++i)
+ args.append(m_expressionStack[i]);
+ m_expressionStack.shrink(firstArgumentIndex);
</ins><span class="cx">
</span><span class="cx"> ExpressionType result = Context::emptyExpression;
</span><span class="cx"> if (!m_context.addCall(functionIndex, info, args, result))
</span><span class="lines">@@ -318,8 +326,6 @@
</span><span class="cx"> case OpType::BrTable:
</span><span class="cx"> case OpType::Nop:
</span><span class="cx"> case OpType::Drop:
</span><del>- case OpType::F32Const:
- case OpType::F64Const:
</del><span class="cx"> case OpType::TeeLocal:
</span><span class="cx"> case OpType::GetGlobal:
</span><span class="cx"> case OpType::SetGlobal:
</span><span class="lines">@@ -374,7 +380,10 @@
</span><span class="cx">
</span><span class="cx"> // one immediate cases
</span><span class="cx"> case OpType::Return:
</span><ins>+ case OpType::F32Const:
</ins><span class="cx"> case OpType::I32Const:
</span><ins>+ case OpType::F64Const:
+ case OpType::I64Const:
</ins><span class="cx"> case OpType::SetLocal:
</span><span class="cx"> case OpType::GetLocal: {
</span><span class="cx"> uint32_t unused;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmOpsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmOps.h (207780 => 207781)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmOps.h 2016-10-24 21:34:09 UTC (rev 207780)
+++ trunk/Source/JavaScriptCore/wasm/WasmOps.h 2016-10-24 21:44:34 UTC (rev 207781)
</span><span class="lines">@@ -68,19 +68,19 @@
</span><span class="cx"> macro(I64Clz, 0x72, Clz) \
</span><span class="cx"> macro(I64Ctz, 0x73, Oops) \
</span><span class="cx"> macro(I64Popcnt, 0x74, Oops) \
</span><del>- macro(F32Abs, 0x7b, Oops) \
</del><ins>+ macro(F32Abs, 0x7b, Abs) \
</ins><span class="cx"> macro(F32Neg, 0x7c, Oops) \
</span><span class="cx"> macro(F32Copysign, 0x7d, Oops) \
</span><del>- macro(F32Ceil, 0x7e, Oops) \
- macro(F32Floor, 0x7f, Oops) \
</del><ins>+ macro(F32Ceil, 0x7e, Ceil) \
+ macro(F32Floor, 0x7f, Floor) \
</ins><span class="cx"> macro(F32Trunc, 0x80, Oops) \
</span><span class="cx"> macro(F32Nearest, 0x81, Oops) \
</span><span class="cx"> macro(F32Sqrt, 0x82, Oops) \
</span><del>- macro(F64Abs, 0x8f, Oops) \
</del><ins>+ macro(F64Abs, 0x8f, Abs) \
</ins><span class="cx"> macro(F64Neg, 0x90, Oops) \
</span><span class="cx"> macro(F64Copysign, 0x91, Oops) \
</span><del>- macro(F64Ceil, 0x92, Oops) \
- macro(F64Floor, 0x93, Oops) \
</del><ins>+ macro(F64Ceil, 0x92, Ceil) \
+ macro(F64Floor, 0x93, Floor) \
</ins><span class="cx"> macro(F64Trunc, 0x94, Oops) \
</span><span class="cx"> macro(F64Nearest, 0x95, Oops) \
</span><span class="cx"> macro(F64Sqrt, 0x96, Oops)
</span><span class="lines">@@ -136,30 +136,30 @@
</span><span class="cx"> macro(I64GeS, 0x6f, GreaterEqual) \
</span><span class="cx"> macro(I64GtU, 0x70, Above) \
</span><span class="cx"> macro(I64GeU, 0x71, AboveEqual) \
</span><del>- macro(F32Add, 0x75, Oops) \
- macro(F32Sub, 0x76, Oops) \
- macro(F32Mul, 0x77, Oops) \
- macro(F32Div, 0x78, Oops) \
</del><ins>+ macro(F32Add, 0x75, Add) \
+ macro(F32Sub, 0x76, Sub) \
+ macro(F32Mul, 0x77, Mul) \
+ macro(F32Div, 0x78, Div) \
</ins><span class="cx"> macro(F32Min, 0x79, Oops) \
</span><span class="cx"> macro(F32Max, 0x7a, Oops) \
</span><del>- macro(F32Eq, 0x83, Oops) \
- macro(F32Ne, 0x84, Oops) \
- macro(F32Lt, 0x85, Oops) \
- macro(F32Le, 0x86, Oops) \
- macro(F32Gt, 0x87, Oops) \
- macro(F32Ge, 0x88, Oops) \
- macro(F64Add, 0x89, Oops) \
- macro(F64Sub, 0x8a, Oops) \
- macro(F64Mul, 0x8b, Oops) \
- macro(F64Div, 0x8c, Oops) \
</del><ins>+ macro(F32Eq, 0x83, Equal) \
+ macro(F32Ne, 0x84, NotEqual) \
+ macro(F32Lt, 0x85, LessThan) \
+ macro(F32Le, 0x86, LessEqual) \
+ macro(F32Gt, 0x87, GreaterThan) \
+ macro(F32Ge, 0x88, GreaterEqual) \
+ macro(F64Add, 0x89, Add) \
+ macro(F64Sub, 0x8a, Sub) \
+ macro(F64Mul, 0x8b, Mul) \
+ macro(F64Div, 0x8c, Div) \
</ins><span class="cx"> macro(F64Min, 0x8d, Oops) \
</span><span class="cx"> macro(F64Max, 0x8e, Oops) \
</span><del>- macro(F64Eq, 0x97, Oops) \
- macro(F64Ne, 0x98, Oops) \
- macro(F64Lt, 0x99, Oops) \
- macro(F64Le, 0x9a, Oops) \
- macro(F64Gt, 0x9b, Oops) \
- macro(F64Ge, 0x9c, Oops)
</del><ins>+ macro(F64Eq, 0x97, Equal) \
+ macro(F64Ne, 0x98, NotEqual) \
+ macro(F64Lt, 0x99, LessThan) \
+ macro(F64Le, 0x9a, LessEqual) \
+ macro(F64Gt, 0x9b, GreaterThan) \
+ macro(F64Ge, 0x9c, GreaterEqual)
</ins><span class="cx">
</span><span class="cx"> #define FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \
</span><span class="cx"> macro(I32Load8S, 0x20, Oops) \
</span></span></pre>
</div>
</div>
</body>
</html>