<!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>[213745] 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/213745">213745</a></dd>
<dt>Author</dt> <dd>sbarati@apple.com</dd>
<dt>Date</dt> <dd>2017-03-10 18:04:37 -0800 (Fri, 10 Mar 2017)</dd>
</dl>
<h3>Log Message</h3>
<pre>WebAssembly: Make more demos run
https://bugs.webkit.org/show_bug.cgi?id=165510
<rdar://problem/29760310>
Reviewed by Keith Miller.
JSTests:
* wasm/Builder.js:
(export.default.Builder.prototype._registerSectionBuilders.const.section.in.WASM.description.section.switch.section.case.string_appeared_here.this.section):
* wasm/js-api/wrapper-function.js: Added.
(exportImport):
(return.new.WebAssembly.Module):
(assert.throws.makeInstance):
(assert.throws.Bar):
(assert.throws):
Source/JavaScriptCore:
This patch makes another Wasm demo run:
https://kripken.github.io/BananaBread/cube2/bb.html
This patch fixes two bugs:
1. When WebAssemblyFunctionType was added, we did not properly
update the last JS type value.
2. Our code for our JS -> Wasm entrypoint was wrong. It lead to bad
code generation where we would emit B3 that would write over <a href="http://trac.webkit.org/projects/webkit/changeset/12">r12</a>
and rbx (on x86) which is invalid since those are our pinned registers.
This patch just rewrites the entrypoint to use hand written assembler
code. I was planning on doing this anyways because it's a compile
time speed boost.
Also, this patch adds support for some new API features:
We can now export an import, either via a direct export, or via a Table and the
Element section. I've added a new class called WebAssemblyWrapperFunction that
just wraps over a JSObject that is a function. Wrapper functions have types
associated with them, so if they're re-imported, or called via call_indirect,
they can be type checked.
* CMakeLists.txt:
* JavaScriptCore.xcodeproj/project.pbxproj:
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::init):
(JSC::JSGlobalObject::visitChildren):
* runtime/JSGlobalObject.h:
(JSC::JSGlobalObject::webAssemblyWrapperFunctionStructure):
* runtime/JSType.h:
* wasm/JSWebAssemblyCodeBlock.h:
(JSC::JSWebAssemblyCodeBlock::wasmToJsCallStubForImport):
* wasm/WasmB3IRGenerator.cpp:
(JSC::Wasm::createJSToWasmWrapper):
* wasm/WasmCallingConvention.h:
(JSC::Wasm::CallingConvention::headerSizeInBytes):
* wasm/js/JSWebAssemblyHelpers.h:
(JSC::isWebAssemblyHostFunction):
* wasm/js/JSWebAssemblyInstance.cpp:
(JSC::JSWebAssemblyInstance::JSWebAssemblyInstance):
* wasm/js/JSWebAssemblyInstance.h:
(JSC::JSWebAssemblyInstance::importFunction):
(JSC::JSWebAssemblyInstance::importFunctions):
(JSC::JSWebAssemblyInstance::setImportFunction):
* wasm/js/JSWebAssemblyTable.cpp:
(JSC::JSWebAssemblyTable::JSWebAssemblyTable):
(JSC::JSWebAssemblyTable::grow):
(JSC::JSWebAssemblyTable::clearFunction):
(JSC::JSWebAssemblyTable::setFunction):
* wasm/js/JSWebAssemblyTable.h:
(JSC::JSWebAssemblyTable::getFunction):
* wasm/js/WebAssemblyFunction.cpp:
(JSC::callWebAssemblyFunction):
* wasm/js/WebAssemblyInstanceConstructor.cpp:
(JSC::WebAssemblyInstanceConstructor::createInstance):
* wasm/js/WebAssemblyModuleRecord.cpp:
(JSC::WebAssemblyModuleRecord::link):
(JSC::WebAssemblyModuleRecord::evaluate):
* wasm/js/WebAssemblyModuleRecord.h:
* wasm/js/WebAssemblyTablePrototype.cpp:
(JSC::webAssemblyTableProtoFuncGet):
(JSC::webAssemblyTableProtoFuncSet):
* wasm/js/WebAssemblyWrapperFunction.cpp: Added.
(JSC::callWebAssemblyWrapperFunction):
(JSC::WebAssemblyWrapperFunction::WebAssemblyWrapperFunction):
(JSC::WebAssemblyWrapperFunction::create):
(JSC::WebAssemblyWrapperFunction::finishCreation):
(JSC::WebAssemblyWrapperFunction::createStructure):
(JSC::WebAssemblyWrapperFunction::visitChildren):
* wasm/js/WebAssemblyWrapperFunction.h: Added.
(JSC::WebAssemblyWrapperFunction::signatureIndex):
(JSC::WebAssemblyWrapperFunction::wasmEntrypoint):
(JSC::WebAssemblyWrapperFunction::function):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJSTestsChangeLog">trunk/JSTests/ChangeLog</a></li>
<li><a href="#trunkJSTestswasmBuilderjs">trunk/JSTests/wasm/Builder.js</a></li>
<li><a href="#trunkSourceJavaScriptCoreCMakeListstxt">trunk/Source/JavaScriptCore/CMakeLists.txt</a></li>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj">trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeJSGlobalObjectcpp">trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeJSGlobalObjecth">trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeJSTypeh">trunk/Source/JavaScriptCore/runtime/JSType.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmJSWebAssemblyCodeBlockh">trunk/Source/JavaScriptCore/wasm/JSWebAssemblyCodeBlock.h</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="#trunkSourceJavaScriptCorewasmjsJSWebAssemblyHelpersh">trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyHelpers.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsJSWebAssemblyInstancecpp">trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsJSWebAssemblyInstanceh">trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsJSWebAssemblyTablecpp">trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsJSWebAssemblyTableh">trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyInstanceConstructorcpp">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyModuleRecordcpp">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyModuleRecordh">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.h</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyTablePrototypecpp">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyTablePrototype.cpp</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkJSTestswasmjsapiwrapperfunctionjs">trunk/JSTests/wasm/js-api/wrapper-function.js</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyWrapperFunctioncpp">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmjsWebAssemblyWrapperFunctionh">trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJSTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/ChangeLog (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/ChangeLog 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/JSTests/ChangeLog 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -1,3 +1,20 @@
</span><ins>+2017-03-10 Saam Barati <sbarati@apple.com>
+
+ WebAssembly: Make more demos run
+ https://bugs.webkit.org/show_bug.cgi?id=165510
+ <rdar://problem/29760310>
+
+ Reviewed by Keith Miller.
+
+ * wasm/Builder.js:
+ (export.default.Builder.prototype._registerSectionBuilders.const.section.in.WASM.description.section.switch.section.case.string_appeared_here.this.section):
+ * wasm/js-api/wrapper-function.js: Added.
+ (exportImport):
+ (return.new.WebAssembly.Module):
+ (assert.throws.makeInstance):
+ (assert.throws.Bar):
+ (assert.throws):
+
</ins><span class="cx"> 2017-03-10 Mark Lam <mark.lam@apple.com>
</span><span class="cx">
</span><span class="cx"> JSC: BindingNode::bindValue doesn't increase the scope's reference count.
</span></span></pre></div>
<a id="trunkJSTestswasmBuilderjs"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/wasm/Builder.js (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/Builder.js 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/JSTests/wasm/Builder.js 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -579,7 +579,10 @@
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case "Element":
</span><del>- this[section] = function() {
</del><ins>+ this[section] = function(...args) {
+ if (args.length !== 0)
+ throw new Error("You're doing it wrong. This element does not take arguments. You must chain the call with another Element()");
+
</ins><span class="cx"> const s = this._addSection(section);
</span><span class="cx"> const elementBuilder = {
</span><span class="cx"> End: () => this,
</span></span></pre></div>
<a id="trunkJSTestswasmjsapiwrapperfunctionjs"></a>
<div class="addfile"><h4>Added: trunk/JSTests/wasm/js-api/wrapper-function.js (0 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/wasm/js-api/wrapper-function.js (rev 0)
+++ trunk/JSTests/wasm/js-api/wrapper-function.js 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -0,0 +1,146 @@
</span><ins>+import Builder from '../Builder.js';
+import * as assert from '../assert.js';
+
+
+function exportImport(type) {
+ let builder = (new Builder())
+ .Type().End()
+ .Import()
+ .Function("imp", "f", type)
+ .End()
+ .Function().End()
+ .Export()
+ .Function("func", {module: "imp", field: "f"})
+ .End()
+ .Code().End();
+ return new WebAssembly.Module(builder.WebAssembly().get());
+}
+
+{
+ let type = { params: ["i32"], ret: "i32" };
+ let module = exportImport(type);
+ let called = false;
+ let foo = (i) => {
+ called = true;
+ return i + 42;
+ };
+ let instance = new WebAssembly.Instance(module, {imp: {f: foo}});
+ assert.truthy(instance.exports.func !== foo);
+ for (let i = 0; i < 100; i++) {
+ let r1 = instance.exports.func(i);
+ assert.truthy(called);
+ called = false;
+ let r2 = foo(i);
+ called = false;
+ assert.eq(r1, r2);
+ }
+
+ {
+ let builder = (new Builder())
+ .Type().End()
+ .Import()
+ .Function("imp", "f", {params: []})
+ .End()
+ .Function().End()
+ .Code().End();
+ let module = new WebAssembly.Module(builder.WebAssembly().get());
+ // This should not type check.
+ assert.throws(() => new WebAssembly.Instance(module, {imp: {f: instance.exports.func}}), WebAssembly.LinkError, "imported function's signature doesn't match the provided WebAssembly function's signature");
+ }
+
+}
+
+{
+ const tableDescription = {element: "anyfunc", initial: 2};
+ function makeInstance(type, imp) {
+ const builder = new Builder()
+ .Type()
+ .Func(["i32"], "i32")
+ .Func(["i32", "i32"], "i32")
+ .End()
+ .Import()
+ .Table("imp", "table", tableDescription)
+ .Function("imp", "f1", {params: ["i32"], ret:"i32"})
+ .Function("imp", "f2", {params: ["i32", "i32"], ret:"i32"})
+ .End()
+ .Function().End()
+ .Export()
+ .Function("foo")
+ .End()
+ .Element()
+ .Element({offset: 0, functionIndices: [0, 1]})
+ .End()
+ .Code()
+ .Function("foo", 1)
+ .GetLocal(1) // parameter to call
+ .GetLocal(0) // call index
+ .CallIndirect(0, 0) // calling function of type ['i32'] => 'i32'
+ .Return()
+ .End()
+ .End();
+ let module = new WebAssembly.Module(builder.WebAssembly().get());
+ return new WebAssembly.Instance(module, imp);
+ }
+
+ function Bar(){};
+ noInline(Bar);
+ let called = false;
+ let foo = (i) => {
+ called = true;
+ new Bar;
+ return i*42;
+ }
+ let table = new WebAssembly.Table(tableDescription);
+ let inst = makeInstance({params:['i32'], ret:"i32"}, {imp: {f1: foo, f2:foo, table}});
+ for (let i = 0; i < 1000; i++) {
+ let r1 = inst.exports.foo(0, i);
+ assert.truthy(called);
+ called = false;
+ let r2 = foo(i);
+ assert.truthy(called);
+ called = false;
+ assert.eq(r1, r2);
+ }
+ for (let i = 0; i < 1000; i++) {
+ assert.throws(() => inst.exports.foo(1, i), WebAssembly.RuntimeError, "call_indirect to a signature that does not match");
+ assert.truthy(!called);
+ }
+ for (let i = 0; i < 1000; i++) {
+ let r1 = table.get(0)(i);
+ table.set(0, table.get(0)); // just make sure setting a wrapper function works.
+ assert.truthy(called);
+ called = false;
+ let r2 = table.get(1)(i);
+ assert.truthy(called);
+ called = false;
+ assert.eq(r1, r2);
+ }
+
+ {
+ let nextInst = makeInstance({params:['i32'], ret:"i32"}, {imp: {f1: table.get(0), f2:inst.exports.foo, table}});
+ for (let i = 0; i < 1000; i++) {
+ let r1 = nextInst.exports.foo(0, i);
+ assert.truthy(called);
+ called = false;
+ let r2 = foo(i);
+ assert.truthy(called);
+ called = false;
+ assert.eq(r1, r2);
+ }
+
+ for (let i = 0; i < 1000; i++) {
+ assert.throws(() => nextInst.exports.foo(1, i), WebAssembly.RuntimeError, "call_indirect to a signature that does not match");
+ assert.truthy(!called);
+ }
+
+ for (let i = 0; i < 1000; i++) {
+ let r1 = table.get(1)(0, i);
+ assert.truthy(called);
+ called = false;
+ let r2 = foo(i);
+ assert.truthy(called);
+ called = false;
+ assert.eq(r1, r2);
+ }
+ }
+}
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreCMakeListstxt"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/CMakeLists.txt (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/CMakeLists.txt 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/CMakeLists.txt 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -968,6 +968,7 @@
</span><span class="cx"> wasm/js/WebAssemblyTableConstructor.cpp
</span><span class="cx"> wasm/js/WebAssemblyTablePrototype.cpp
</span><span class="cx"> wasm/js/WebAssemblyToJSCallee.cpp
</span><ins>+ wasm/js/WebAssemblyWrapperFunction.cpp
</ins><span class="cx">
</span><span class="cx"> yarr/RegularExpression.cpp
</span><span class="cx"> yarr/YarrCanonicalizeUCS2.cpp
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/ChangeLog 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -1,3 +1,83 @@
</span><ins>+2017-03-10 Saam Barati <sbarati@apple.com>
+
+ WebAssembly: Make more demos run
+ https://bugs.webkit.org/show_bug.cgi?id=165510
+ <rdar://problem/29760310>
+
+ Reviewed by Keith Miller.
+
+ This patch makes another Wasm demo run:
+ https://kripken.github.io/BananaBread/cube2/bb.html
+
+ This patch fixes two bugs:
+ 1. When WebAssemblyFunctionType was added, we did not properly
+ update the last JS type value.
+ 2. Our code for our JS -> Wasm entrypoint was wrong. It lead to bad
+ code generation where we would emit B3 that would write over r12
+ and rbx (on x86) which is invalid since those are our pinned registers.
+ This patch just rewrites the entrypoint to use hand written assembler
+ code. I was planning on doing this anyways because it's a compile
+ time speed boost.
+
+ Also, this patch adds support for some new API features:
+ We can now export an import, either via a direct export, or via a Table and the
+ Element section. I've added a new class called WebAssemblyWrapperFunction that
+ just wraps over a JSObject that is a function. Wrapper functions have types
+ associated with them, so if they're re-imported, or called via call_indirect,
+ they can be type checked.
+
+ * CMakeLists.txt:
+ * JavaScriptCore.xcodeproj/project.pbxproj:
+ * runtime/JSGlobalObject.cpp:
+ (JSC::JSGlobalObject::init):
+ (JSC::JSGlobalObject::visitChildren):
+ * runtime/JSGlobalObject.h:
+ (JSC::JSGlobalObject::webAssemblyWrapperFunctionStructure):
+ * runtime/JSType.h:
+ * wasm/JSWebAssemblyCodeBlock.h:
+ (JSC::JSWebAssemblyCodeBlock::wasmToJsCallStubForImport):
+ * wasm/WasmB3IRGenerator.cpp:
+ (JSC::Wasm::createJSToWasmWrapper):
+ * wasm/WasmCallingConvention.h:
+ (JSC::Wasm::CallingConvention::headerSizeInBytes):
+ * wasm/js/JSWebAssemblyHelpers.h:
+ (JSC::isWebAssemblyHostFunction):
+ * wasm/js/JSWebAssemblyInstance.cpp:
+ (JSC::JSWebAssemblyInstance::JSWebAssemblyInstance):
+ * wasm/js/JSWebAssemblyInstance.h:
+ (JSC::JSWebAssemblyInstance::importFunction):
+ (JSC::JSWebAssemblyInstance::importFunctions):
+ (JSC::JSWebAssemblyInstance::setImportFunction):
+ * wasm/js/JSWebAssemblyTable.cpp:
+ (JSC::JSWebAssemblyTable::JSWebAssemblyTable):
+ (JSC::JSWebAssemblyTable::grow):
+ (JSC::JSWebAssemblyTable::clearFunction):
+ (JSC::JSWebAssemblyTable::setFunction):
+ * wasm/js/JSWebAssemblyTable.h:
+ (JSC::JSWebAssemblyTable::getFunction):
+ * wasm/js/WebAssemblyFunction.cpp:
+ (JSC::callWebAssemblyFunction):
+ * wasm/js/WebAssemblyInstanceConstructor.cpp:
+ (JSC::WebAssemblyInstanceConstructor::createInstance):
+ * wasm/js/WebAssemblyModuleRecord.cpp:
+ (JSC::WebAssemblyModuleRecord::link):
+ (JSC::WebAssemblyModuleRecord::evaluate):
+ * wasm/js/WebAssemblyModuleRecord.h:
+ * wasm/js/WebAssemblyTablePrototype.cpp:
+ (JSC::webAssemblyTableProtoFuncGet):
+ (JSC::webAssemblyTableProtoFuncSet):
+ * wasm/js/WebAssemblyWrapperFunction.cpp: Added.
+ (JSC::callWebAssemblyWrapperFunction):
+ (JSC::WebAssemblyWrapperFunction::WebAssemblyWrapperFunction):
+ (JSC::WebAssemblyWrapperFunction::create):
+ (JSC::WebAssemblyWrapperFunction::finishCreation):
+ (JSC::WebAssemblyWrapperFunction::createStructure):
+ (JSC::WebAssemblyWrapperFunction::visitChildren):
+ * wasm/js/WebAssemblyWrapperFunction.h: Added.
+ (JSC::WebAssemblyWrapperFunction::signatureIndex):
+ (JSC::WebAssemblyWrapperFunction::wasmEntrypoint):
+ (JSC::WebAssemblyWrapperFunction::function):
+
</ins><span class="cx"> 2017-03-10 Mark Lam <mark.lam@apple.com>
</span><span class="cx">
</span><span class="cx"> JSC: BindingNode::bindValue doesn't increase the scope's reference count.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -1312,6 +1312,8 @@
</span><span class="cx"> 52C0611F1AA51E1C00B4ADBA /* RuntimeType.h in Headers */ = {isa = PBXBuildFile; fileRef = 52C0611D1AA51E1B00B4ADBA /* RuntimeType.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx"> 52C952B719A289850069B386 /* TypeProfiler.h in Headers */ = {isa = PBXBuildFile; fileRef = 52C952B619A289850069B386 /* TypeProfiler.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx"> 52C952B919A28A1C0069B386 /* TypeProfiler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 52C952B819A28A1C0069B386 /* TypeProfiler.cpp */; };
</span><ins>+ 52F6C35D1E71EB080081F4CC /* WebAssemblyWrapperFunction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 52F6C35B1E71EB080081F4CC /* WebAssemblyWrapperFunction.cpp */; };
+ 52F6C35E1E71EB080081F4CC /* WebAssemblyWrapperFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 52F6C35C1E71EB080081F4CC /* WebAssemblyWrapperFunction.h */; settings = {ATTRIBUTES = (Private, ); }; };
</ins><span class="cx"> 531374BD1D5CE67600AF7A0B /* WasmPlan.h in Headers */ = {isa = PBXBuildFile; fileRef = 531374BC1D5CE67600AF7A0B /* WasmPlan.h */; };
</span><span class="cx"> 531374BF1D5CE95000AF7A0B /* WasmPlan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 531374BE1D5CE95000AF7A0B /* WasmPlan.cpp */; };
</span><span class="cx"> 533B15DF1DC7F463004D500A /* WasmOps.h in Headers */ = {isa = PBXBuildFile; fileRef = 533B15DE1DC7F463004D500A /* WasmOps.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="lines">@@ -3789,6 +3791,8 @@
</span><span class="cx"> 52C0611D1AA51E1B00B4ADBA /* RuntimeType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RuntimeType.h; sourceTree = "<group>"; };
</span><span class="cx"> 52C952B619A289850069B386 /* TypeProfiler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TypeProfiler.h; sourceTree = "<group>"; };
</span><span class="cx"> 52C952B819A28A1C0069B386 /* TypeProfiler.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = TypeProfiler.cpp; sourceTree = "<group>"; };
</span><ins>+ 52F6C35B1E71EB080081F4CC /* WebAssemblyWrapperFunction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebAssemblyWrapperFunction.cpp; path = js/WebAssemblyWrapperFunction.cpp; sourceTree = "<group>"; };
+ 52F6C35C1E71EB080081F4CC /* WebAssemblyWrapperFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebAssemblyWrapperFunction.h; path = js/WebAssemblyWrapperFunction.h; sourceTree = "<group>"; };
</ins><span class="cx"> 531374BC1D5CE67600AF7A0B /* WasmPlan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmPlan.h; sourceTree = "<group>"; };
</span><span class="cx"> 531374BE1D5CE95000AF7A0B /* WasmPlan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WasmPlan.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 533B15DE1DC7F463004D500A /* WasmOps.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmOps.h; sourceTree = "<group>"; };
</span><span class="lines">@@ -7908,6 +7912,8 @@
</span><span class="cx"> AD2FCBC31DB58DA400B3E736 /* WebAssemblyTablePrototype.h */,
</span><span class="cx"> ADBC54D21DF8EA00005BF738 /* WebAssemblyToJSCallee.cpp */,
</span><span class="cx"> ADBC54D31DF8EA00005BF738 /* WebAssemblyToJSCallee.h */,
</span><ins>+ 52F6C35B1E71EB080081F4CC /* WebAssemblyWrapperFunction.cpp */,
+ 52F6C35C1E71EB080081F4CC /* WebAssemblyWrapperFunction.h */,
</ins><span class="cx"> );
</span><span class="cx"> name = js;
</span><span class="cx"> sourceTree = "<group>";
</span><span class="lines">@@ -8245,6 +8251,7 @@
</span><span class="cx"> 0F21C27D14BE727A00ADC64B /* CodeSpecializationKind.h in Headers */,
</span><span class="cx"> 0F0B83A714BCF50700885B4F /* CodeType.h in Headers */,
</span><span class="cx"> 0FA762051DB9242900B7A2FD /* CollectionScope.h in Headers */,
</span><ins>+ 52F6C35E1E71EB080081F4CC /* WebAssemblyWrapperFunction.h in Headers */,
</ins><span class="cx"> A53243981856A489002ED692 /* CombinedDomains.json in Headers */,
</span><span class="cx"> BC18C3F30E16F5CD00B34460 /* CommonIdentifiers.h in Headers */,
</span><span class="cx"> 0F15F15F14B7A73E005DE37D /* CommonSlowPaths.h in Headers */,
</span><span class="lines">@@ -10358,6 +10365,7 @@
</span><span class="cx"> A503FA19188E0FB000110F14 /* JavaScriptCallFrame.cpp in Sources */,
</span><span class="cx"> 1429D92F0ED22D7000B89619 /* JIT.cpp in Sources */,
</span><span class="cx"> FE1220281BE7F5910039E6F2 /* JITAddGenerator.cpp in Sources */,
</span><ins>+ 52F6C35D1E71EB080081F4CC /* WebAssemblyWrapperFunction.cpp in Sources */,
</ins><span class="cx"> 86A90ED00EE7D51F00AB350D /* JITArithmetic.cpp in Sources */,
</span><span class="cx"> A75706DE118A2BCF0057F88F /* JITArithmetic32_64.cpp in Sources */,
</span><span class="cx"> FE3A06B11C10CB8400390FDD /* JITBitAndGenerator.cpp in Sources */,
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeJSGlobalObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -892,6 +892,7 @@
</span><span class="cx"> m_webAssemblyStructure.set(vm, this, JSWebAssembly::createStructure(vm, this, webAssemblyPrototype));
</span><span class="cx"> m_webAssemblyModuleRecordStructure.set(vm, this, WebAssemblyModuleRecord::createStructure(vm, this, m_objectPrototype.get()));
</span><span class="cx"> m_webAssemblyFunctionStructure.set(vm, this, WebAssemblyFunction::createStructure(vm, this, m_functionPrototype.get()));
</span><ins>+ m_webAssemblyWrapperFunctionStructure.set(vm, this, WebAssemblyWrapperFunction::createStructure(vm, this, m_functionPrototype.get()));
</ins><span class="cx"> auto* webAssembly = JSWebAssembly::create(vm, this, m_webAssemblyStructure.get());
</span><span class="cx"> putDirectWithoutTransition(vm, Identifier::fromString(exec, "WebAssembly"), webAssembly, DontEnum);
</span><span class="cx">
</span><span class="lines">@@ -1272,6 +1273,7 @@
</span><span class="cx"> visitor.append(thisObject->m_webAssemblyStructure);
</span><span class="cx"> visitor.append(thisObject->m_webAssemblyModuleRecordStructure);
</span><span class="cx"> visitor.append(thisObject->m_webAssemblyFunctionStructure);
</span><ins>+ visitor.append(thisObject->m_webAssemblyWrapperFunctionStructure);
</ins><span class="cx"> FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(VISIT_SIMPLE_TYPE)
</span><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeJSGlobalObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -345,6 +345,7 @@
</span><span class="cx"> WriteBarrier<Structure> m_webAssemblyStructure;
</span><span class="cx"> WriteBarrier<Structure> m_webAssemblyModuleRecordStructure;
</span><span class="cx"> WriteBarrier<Structure> m_webAssemblyFunctionStructure;
</span><ins>+ WriteBarrier<Structure> m_webAssemblyWrapperFunctionStructure;
</ins><span class="cx"> FOR_EACH_WEBASSEMBLY_CONSTRUCTOR_TYPE(DEFINE_STORAGE_FOR_SIMPLE_TYPE)
</span><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span><span class="cx">
</span><span class="lines">@@ -612,6 +613,7 @@
</span><span class="cx"> #if ENABLE(WEBASSEMBLY)
</span><span class="cx"> Structure* webAssemblyModuleRecordStructure() const { return m_webAssemblyModuleRecordStructure.get(); }
</span><span class="cx"> Structure* webAssemblyFunctionStructure() const { return m_webAssemblyFunctionStructure.get(); }
</span><ins>+ Structure* webAssemblyWrapperFunctionStructure() const { return m_webAssemblyWrapperFunctionStructure.get(); }
</ins><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span><span class="cx">
</span><span class="cx"> JS_EXPORT_PRIVATE void setRemoteDebuggingEnabled(bool);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeJSTypeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/JSType.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/JSType.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/runtime/JSType.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -97,7 +97,7 @@
</span><span class="cx">
</span><span class="cx"> WebAssemblyFunctionType,
</span><span class="cx">
</span><del>- LastJSCObjectType = JSSetType,
</del><ins>+ LastJSCObjectType = WebAssemblyFunctionType,
</ins><span class="cx"> MaxJSType = 0b11111111,
</span><span class="cx"> };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmJSWebAssemblyCodeBlockh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/JSWebAssemblyCodeBlock.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/JSWebAssemblyCodeBlock.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/JSWebAssemblyCodeBlock.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -94,6 +94,12 @@
</span><span class="cx"> return bitwise_cast<WriteBarrier<JSWebAssemblyCallee>*>(bitwise_cast<char*>(this) + offsetOfCallees());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void* wasmToJsCallStubForImport(unsigned importIndex)
+ {
+ RELEASE_ASSERT(importIndex < m_wasmExitStubs.size());
+ return m_wasmExitStubs[importIndex].wasmToJs.code().executableAddress();
+ }
+
</ins><span class="cx"> private:
</span><span class="cx"> JSWebAssemblyCodeBlock(VM&, JSWebAssemblyModule*, Bag<CallLinkInfo>&&, Vector<Wasm::WasmExitStubs>&&, Wasm::Memory::Mode, unsigned calleeCount);
</span><span class="cx"> DECLARE_EXPORT_INFO;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmB3IRGeneratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -1039,85 +1039,165 @@
</span><span class="cx">
</span><span class="cx"> static void createJSToWasmWrapper(VM& vm, CompilationContext& compilationContext, WasmInternalFunction& function, const Signature* signature, const ModuleInformation& info)
</span><span class="cx"> {
</span><del>- Procedure proc;
- BasicBlock* block = proc.addBlock();
</del><ins>+ CCallHelpers& jit = *compilationContext.jsEntrypointJIT;
</ins><span class="cx">
</span><del>- Origin origin;
</del><ins>+ jit.emitFunctionPrologue();
</ins><span class="cx">
</span><del>- jscCallingConvention().setupFrameInPrologue(&function.jsToWasmCalleeMoveLocation, proc, origin, block);
</del><ins>+ // FIXME Stop using 0 as codeBlocks. https://bugs.webkit.org/show_bug.cgi?id=165321
+ jit.store64(CCallHelpers::TrustedImm64(0), CCallHelpers::Address(GPRInfo::callFrameRegister, CallFrameSlot::codeBlock * static_cast<int>(sizeof(Register))));
+ MacroAssembler::DataLabelPtr calleeMoveLocation = jit.moveWithPatch(MacroAssembler::TrustedImmPtr(nullptr), GPRInfo::nonPreservedNonReturnGPR);
+ jit.storePtr(GPRInfo::nonPreservedNonReturnGPR, CCallHelpers::Address(GPRInfo::callFrameRegister, CallFrameSlot::callee * static_cast<int>(sizeof(Register))));
+ CodeLocationDataLabelPtr* linkedCalleeMove = &function.jsToWasmCalleeMoveLocation;
+ jit.addLinkTask([=] (LinkBuffer& linkBuffer) {
+ *linkedCalleeMove = linkBuffer.locationOf(calleeMoveLocation);
+ });
</ins><span class="cx">
</span><del>- if (!ASSERT_DISABLED) {
- // This should be guaranteed by our JS wrapper that handles calls to us.
- // Just prevent against crazy when ASSERT is enabled.
- Value* framePointer = block->appendNew<B3::Value>(proc, B3::FramePointer, origin);
- Value* offSetOfArgumentCount = block->appendNew<Const64Value>(proc, origin, CallFrameSlot::argumentCount * sizeof(Register));
- Value* argumentCount = block->appendNew<MemoryValue>(proc, Load, Int32, origin,
- block->appendNew<Value>(proc, Add, origin, framePointer, offSetOfArgumentCount));
</del><ins>+ RegisterSet toSave;
+ const PinnedRegisterInfo& pinnedRegs = PinnedRegisterInfo::get();
+ toSave.set(pinnedRegs.baseMemoryPointer);
+ for (const PinnedSizeRegisterInfo& regInfo : pinnedRegs.sizeRegisters)
+ toSave.set(regInfo.sizeRegister);
</ins><span class="cx">
</span><del>- Value* expectedArgumentCount = block->appendNew<Const32Value>(proc, origin, signature->argumentCount());
</del><ins>+#if !ASSERT_DISABLED
+ unsigned toSaveSize = toSave.numberOfSetGPRs();
+ // They should all be callee saves.
+ toSave.filter(RegisterSet::calleeSaveRegisters());
+ ASSERT(toSave.numberOfSetGPRs() == toSaveSize);
+#endif
</ins><span class="cx">
</span><del>- CheckValue* argumentCountCheck = block->appendNew<CheckValue>(proc, Check, origin,
- block->appendNew<Value>(proc, Above, origin, expectedArgumentCount, argumentCount));
</del><ins>+ RegisterAtOffsetList registersToSpill(toSave, RegisterAtOffsetList::OffsetBaseType::FramePointerBased);
+ function.jsToWasmEntrypoint.calleeSaveRegisters = registersToSpill;
</ins><span class="cx">
</span><del>- argumentCountCheck->setGenerator([] (CCallHelpers& jit, const StackmapGenerationParams&) {
- jit.breakpoint();
- });
</del><ins>+ unsigned totalFrameSize = registersToSpill.size() * sizeof(void*);
+ totalFrameSize += WasmCallingConvention::headerSizeInBytes();
+ totalFrameSize -= sizeof(CallerFrameAndPC);
+ unsigned numGPRs = 0;
+ unsigned numFPRs = 0;
+ for (unsigned i = 0; i < signature->argumentCount(); i++) {
+ switch (signature->argument(i)) {
+ case Wasm::I64:
+ case Wasm::I32:
+ if (numGPRs >= wasmCallingConvention().m_gprArgs.size())
+ totalFrameSize += sizeof(void*);
+ ++numGPRs;
+ break;
+ case Wasm::F32:
+ case Wasm::F64:
+ if (numFPRs >= wasmCallingConvention().m_fprArgs.size())
+ totalFrameSize += sizeof(void*);
+ ++numFPRs;
+ break;
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- // FIXME The instance is currently set by the C++ code in WebAssemblyFunction::call. We shouldn't go through the extra C++ hoop. https://bugs.webkit.org/show_bug.cgi?id=166486
- Value* instance = block->appendNew<MemoryValue>(proc, Load, pointerType(), Origin(),
- block->appendNew<ConstPtrValue>(proc, Origin(), &vm.topJSWebAssemblyInstance));
- restoreWebAssemblyGlobalState(vm, info.memory, instance, proc, block);
</del><ins>+ totalFrameSize = WTF::roundUpToMultipleOf(stackAlignmentBytes(), totalFrameSize);
+ jit.subPtr(MacroAssembler::TrustedImm32(totalFrameSize), MacroAssembler::stackPointerRegister);
</ins><span class="cx">
</span><del>- // Get our arguments.
- Vector<Value*> arguments;
- jscCallingConvention().loadArguments(signature, proc, block, origin, [&] (Value* argument, unsigned) {
- arguments.append(argument);
- });
</del><ins>+ // We save all these registers regardless of having a memory or not.
+ // The reason is that we use one of these as a scratch. That said,
+ // almost all real wasm programs use memory, so it's not really
+ // worth optimizing for the case that they don't.
+ for (const RegisterAtOffset& regAtOffset : registersToSpill) {
+ GPRReg reg = regAtOffset.reg().gpr();
+ ptrdiff_t offset = regAtOffset.offset();
+ jit.storePtr(reg, CCallHelpers::Address(GPRInfo::callFrameRegister, offset));
+ }
</ins><span class="cx">
</span><del>- // Move the arguments into place.
- Value* result = wasmCallingConvention().setupCall(proc, block, origin, arguments, toB3Type(signature->returnType()), [&] (PatchpointValue* patchpoint) {
- CompilationContext* context = &compilationContext;
</del><ins>+ {
+ CCallHelpers::Address calleeFrame = CCallHelpers::Address(MacroAssembler::stackPointerRegister, -static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC)));
+ numGPRs = 0;
+ numFPRs = 0;
+ // We're going to set the pinned registers after this. So
+ // we can use this as a scratch for now since we saved it above.
+ GPRReg scratchReg = pinnedRegs.baseMemoryPointer;
</ins><span class="cx">
</span><del>- // wasm -> wasm calls clobber pinned registers unconditionally. This JS -> wasm transition must therefore restore these pinned registers (which are usually callee-saved) to account for this.
- const PinnedRegisterInfo* pinnedRegs = &PinnedRegisterInfo::get();
- RegisterSet clobbers;
- clobbers.set(pinnedRegs->baseMemoryPointer);
- for (auto info : pinnedRegs->sizeRegisters)
- clobbers.set(info.sizeRegister);
- patchpoint->effects.writesPinned = true;
- patchpoint->clobber(clobbers);
</del><ins>+ ptrdiff_t jsOffset = CallFrameSlot::thisArgument * sizeof(void*);
+ ptrdiff_t wasmOffset = CallFrame::headerSizeInRegisters * sizeof(void*);
+ for (unsigned i = 0; i < signature->argumentCount(); i++) {
+ switch (signature->argument(i)) {
+ case Wasm::I32:
+ case Wasm::I64:
+ if (numGPRs >= wasmCallingConvention().m_gprArgs.size()) {
+ if (signature->argument(i) == Wasm::I32) {
+ jit.load32(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), scratchReg);
+ jit.store32(scratchReg, calleeFrame.withOffset(wasmOffset));
+ } else {
+ jit.load64(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), scratchReg);
+ jit.store64(scratchReg, calleeFrame.withOffset(wasmOffset));
+ }
+ wasmOffset += sizeof(void*);
+ } else {
+ if (signature->argument(i) == Wasm::I32)
+ jit.load32(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), wasmCallingConvention().m_gprArgs[numGPRs].gpr());
+ else
+ jit.load64(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), wasmCallingConvention().m_gprArgs[numGPRs].gpr());
+ }
+ ++numGPRs;
+ break;
+ case Wasm::F32:
+ case Wasm::F64:
+ if (numFPRs >= wasmCallingConvention().m_fprArgs.size()) {
+ if (signature->argument(i) == Wasm::F32) {
+ jit.load32(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), scratchReg);
+ jit.store32(scratchReg, calleeFrame.withOffset(wasmOffset));
+ } else {
+ jit.load64(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), scratchReg);
+ jit.store64(scratchReg, calleeFrame.withOffset(wasmOffset));
+ }
+ wasmOffset += sizeof(void*);
+ } else {
+ if (signature->argument(i) == Wasm::F32)
+ jit.loadFloat(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), wasmCallingConvention().m_fprArgs[numFPRs].fpr());
+ else
+ jit.loadDouble(CCallHelpers::Address(GPRInfo::callFrameRegister, jsOffset), wasmCallingConvention().m_fprArgs[numFPRs].fpr());
+ }
+ ++numFPRs;
+ break;
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ }
</ins><span class="cx">
</span><del>- patchpoint->setGenerator([context] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
- AllowMacroScratchRegisterUsage allowScratch(jit);
</del><ins>+ jsOffset += sizeof(void*);
+ }
+ }
</ins><span class="cx">
</span><del>- CCallHelpers::Call call = jit.call();
- context->jsEntrypointToWasmEntrypointCall = call;
- });
- });
</del><ins>+ if (!!info.memory) {
+ GPRReg baseMemory = pinnedRegs.baseMemoryPointer;
+ jit.loadPtr(&vm.topJSWebAssemblyInstance, baseMemory);
+ jit.loadPtr(CCallHelpers::Address(baseMemory, JSWebAssemblyInstance::offsetOfMemory()), baseMemory);
+ const auto& sizeRegs = pinnedRegs.sizeRegisters;
+ ASSERT(sizeRegs.size() >= 1);
+ ASSERT(!sizeRegs[0].sizeOffset); // The following code assumes we start at 0, and calculates subsequent size registers relative to 0.
+ jit.loadPtr(CCallHelpers::Address(baseMemory, JSWebAssemblyMemory::offsetOfSize()), sizeRegs[0].sizeRegister);
+ jit.loadPtr(CCallHelpers::Address(baseMemory, JSWebAssemblyMemory::offsetOfMemory()), baseMemory);
+ for (unsigned i = 1; i < sizeRegs.size(); ++i)
+ jit.add64(CCallHelpers::TrustedImm32(-sizeRegs[i].sizeOffset), sizeRegs[0].sizeRegister, sizeRegs[i].sizeRegister);
+ }
</ins><span class="cx">
</span><del>- // Return the result, if needed.
</del><ins>+ compilationContext.jsEntrypointToWasmEntrypointCall = jit.call();
+
+ for (const RegisterAtOffset& regAtOffset : registersToSpill) {
+ GPRReg reg = regAtOffset.reg().gpr();
+ ASSERT(reg != GPRInfo::returnValueGPR);
+ ptrdiff_t offset = regAtOffset.offset();
+ jit.loadPtr(CCallHelpers::Address(GPRInfo::callFrameRegister, offset), reg);
+ }
+
</ins><span class="cx"> switch (signature->returnType()) {
</span><del>- case Wasm::Void:
- block->appendNewControlValue(proc, B3::Return, origin);
</del><ins>+ case Wasm::F32:
+ jit.moveFloatTo32(FPRInfo::returnValueFPR, GPRInfo::returnValueGPR);
</ins><span class="cx"> break;
</span><del>- case Wasm::F32:
</del><span class="cx"> case Wasm::F64:
</span><del>- result = block->appendNew<Value>(proc, BitwiseCast, origin, result);
- FALLTHROUGH;
- case Wasm::I32:
- case Wasm::I64:
- block->appendNewControlValue(proc, B3::Return, origin, result);
</del><ins>+ jit.moveDoubleTo64(FPRInfo::returnValueFPR, GPRInfo::returnValueGPR);
</ins><span class="cx"> break;
</span><del>- case Wasm::Func:
- case Wasm::Anyfunc:
- RELEASE_ASSERT_NOT_REACHED();
</del><ins>+ default:
+ break;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- B3::prepareForGeneration(proc);
- B3::generate(proc, *compilationContext.jsEntrypointJIT);
- compilationContext.jsEntrypointByproducts = proc.releaseByproducts();
- function.jsToWasmEntrypoint.calleeSaveRegisters = proc.calleeSaveRegisters();
</del><ins>+ jit.emitFunctionEpilogue();
+ jit.ret();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Expected<std::unique_ptr<WasmInternalFunction>, String> parseAndCompile(VM& vm, CompilationContext& compilationContext, const uint8_t* functionStart, size_t functionLength, const Signature* signature, Vector<UnlinkedWasmToWasmCall>& unlinkedWasmToWasmCalls, const ModuleInformation& info, const Vector<SignatureIndex>& moduleSignatureIndicesToUniquedSignatureIndices, unsigned optLevel)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWasmCallingConventionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -84,6 +84,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> public:
</span><ins>+ static unsigned headerSizeInBytes() { return headerSize; }
</ins><span class="cx"> void setupFrameInPrologue(CodeLocationDataLabelPtr* calleeMoveLocation, B3::Procedure& proc, B3::Origin origin, B3::BasicBlock* block) const
</span><span class="cx"> {
</span><span class="cx"> static_assert(CallFrameSlot::callee * sizeof(Register) < headerSize, "We rely on this here for now.");
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsJSWebAssemblyHelpersh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyHelpers.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyHelpers.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyHelpers.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -29,6 +29,8 @@
</span><span class="cx">
</span><span class="cx"> #include "JSArrayBuffer.h"
</span><span class="cx"> #include "JSCJSValue.h"
</span><ins>+#include "WebAssemblyFunction.h"
+#include "WebAssemblyWrapperFunction.h"
</ins><span class="cx">
</span><span class="cx"> namespace JSC {
</span><span class="cx">
</span><span class="lines">@@ -71,6 +73,36 @@
</span><span class="cx"> return arrayBufferView ? static_cast<uint8_t*>(arrayBufferView->vector()) : static_cast<uint8_t*>(arrayBuffer->impl()->data());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ALWAYS_INLINE bool isWebAssemblyHostFunction(VM& vm, JSObject* object, WebAssemblyFunction*& wasmFunction, WebAssemblyWrapperFunction*& wasmWrapperFunction)
+{
+ if (object->inherits(vm, WebAssemblyFunction::info())) {
+ wasmFunction = jsCast<WebAssemblyFunction*>(object);
+ wasmWrapperFunction = nullptr;
+ return true;
+ }
+ if (object->inherits(vm, WebAssemblyWrapperFunction::info())) {
+ wasmWrapperFunction = jsCast<WebAssemblyWrapperFunction*>(object);
+ wasmFunction = nullptr;
+ return true;
+ }
+ return false;
+}
+
+ALWAYS_INLINE bool isWebAssemblyHostFunction(VM& vm, JSValue value, WebAssemblyFunction*& wasmFunction, WebAssemblyWrapperFunction*& wasmWrapperFunction)
+{
+ if (!value.isObject())
+ return false;
+ return isWebAssemblyHostFunction(vm, jsCast<JSObject*>(value), wasmFunction, wasmWrapperFunction);
+}
+
+
+ALWAYS_INLINE bool isWebAssemblyHostFunction(VM& vm, JSObject* object)
+{
+ WebAssemblyFunction* unused;
+ WebAssemblyWrapperFunction* unused2;
+ return isWebAssemblyHostFunction(vm, object, unused, unused2);
+}
+
</ins><span class="cx"> } // namespace JSC
</span><span class="cx">
</span><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsJSWebAssemblyInstancecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -67,7 +67,7 @@
</span><span class="cx"> : Base(vm, structure)
</span><span class="cx"> , m_numImportFunctions(numImportFunctions)
</span><span class="cx"> {
</span><del>- memset(importFunctions(), 0, m_numImportFunctions * sizeof(WriteBarrier<JSCell>));
</del><ins>+ memset(importFunctions(), 0, m_numImportFunctions * sizeof(WriteBarrier<JSObject>));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JSWebAssemblyInstance::finishCreation(VM& vm, JSWebAssemblyModule* module, JSModuleNamespaceObject* moduleNamespaceObject)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsJSWebAssemblyInstanceh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -60,18 +60,18 @@
</span><span class="cx"> return m_codeBlock.get();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- WriteBarrier<JSCell>* importFunction(unsigned idx)
</del><ins>+ WriteBarrier<JSObject>* importFunction(unsigned idx)
</ins><span class="cx"> {
</span><span class="cx"> RELEASE_ASSERT(idx < m_numImportFunctions);
</span><span class="cx"> return &importFunctions()[idx];
</span><span class="cx"> }
</span><span class="cx">
</span><del>- WriteBarrier<JSCell>* importFunctions()
</del><ins>+ WriteBarrier<JSObject>* importFunctions()
</ins><span class="cx"> {
</span><del>- return bitwise_cast<WriteBarrier<JSCell>*>(bitwise_cast<char*>(this) + offsetOfImportFunctions());
</del><ins>+ return bitwise_cast<WriteBarrier<JSObject>*>(bitwise_cast<char*>(this) + offsetOfImportFunctions());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- void setImportFunction(VM& vm, JSCell* value, unsigned idx)
</del><ins>+ void setImportFunction(VM& vm, JSObject* value, unsigned idx)
</ins><span class="cx"> {
</span><span class="cx"> importFunction(idx)->set(vm, this, value);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsJSWebAssemblyTablecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -64,11 +64,11 @@
</span><span class="cx"> // FIXME: It might be worth trying to pre-allocate maximum here. The spec recommends doing so.
</span><span class="cx"> // But for now, we're not doing that.
</span><span class="cx"> m_functions = MallocPtr<Wasm::CallableFunction>::malloc(sizeof(Wasm::CallableFunction) * static_cast<size_t>(m_size));
</span><del>- m_jsFunctions = MallocPtr<WriteBarrier<WebAssemblyFunction>>::malloc(sizeof(WriteBarrier<WebAssemblyFunction>) * static_cast<size_t>(m_size));
</del><ins>+ m_jsFunctions = MallocPtr<WriteBarrier<JSObject>>::malloc(sizeof(WriteBarrier<JSObject>) * static_cast<size_t>(m_size));
</ins><span class="cx"> for (uint32_t i = 0; i < m_size; ++i) {
</span><span class="cx"> new (&m_functions.get()[i]) Wasm::CallableFunction();
</span><span class="cx"> ASSERT(m_functions.get()[i].signatureIndex == Wasm::Signature::invalidIndex); // We rely on this in compiled code.
</span><del>- new (&m_jsFunctions.get()[i]) WriteBarrier<WebAssemblyFunction>();
</del><ins>+ new (&m_jsFunctions.get()[i]) WriteBarrier<JSObject>();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -106,11 +106,11 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> m_functions.realloc(sizeof(Wasm::CallableFunction) * static_cast<size_t>(newSize));
</span><del>- m_jsFunctions.realloc(sizeof(WriteBarrier<WebAssemblyFunction>) * static_cast<size_t>(newSize));
</del><ins>+ m_jsFunctions.realloc(sizeof(WriteBarrier<JSObject>) * static_cast<size_t>(newSize));
</ins><span class="cx">
</span><span class="cx"> for (uint32_t i = m_size; i < newSize; ++i) {
</span><span class="cx"> new (&m_functions.get()[i]) Wasm::CallableFunction();
</span><del>- new (&m_jsFunctions.get()[i]) WriteBarrier<WebAssemblyFunction>();
</del><ins>+ new (&m_jsFunctions.get()[i]) WriteBarrier<JSObject>();
</ins><span class="cx"> }
</span><span class="cx"> m_size = newSize;
</span><span class="cx"> return true;
</span><span class="lines">@@ -119,7 +119,7 @@
</span><span class="cx"> void JSWebAssemblyTable::clearFunction(uint32_t index)
</span><span class="cx"> {
</span><span class="cx"> RELEASE_ASSERT(index < m_size);
</span><del>- m_jsFunctions.get()[index] = WriteBarrier<WebAssemblyFunction>();
</del><ins>+ m_jsFunctions.get()[index] = WriteBarrier<JSObject>();
</ins><span class="cx"> m_functions.get()[index] = Wasm::CallableFunction();
</span><span class="cx"> ASSERT(m_functions.get()[index].signatureIndex == Wasm::Signature::invalidIndex); // We rely on this in compiled code.
</span><span class="cx"> }
</span><span class="lines">@@ -131,6 +131,13 @@
</span><span class="cx"> m_functions.get()[index] = Wasm::CallableFunction(function->signatureIndex(), function->wasmEntrypoint());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void JSWebAssemblyTable::setFunction(VM& vm, uint32_t index, WebAssemblyWrapperFunction* function)
+{
+ RELEASE_ASSERT(index < m_size);
+ m_jsFunctions.get()[index].set(vm, this, function);
+ m_functions.get()[index] = Wasm::CallableFunction(function->signatureIndex(), function->wasmEntrypoint());
+}
+
</ins><span class="cx"> } // namespace JSC
</span><span class="cx">
</span><span class="cx"> #endif // ENABLE(WEBASSEMBLY)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsJSWebAssemblyTableh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -29,6 +29,7 @@
</span><span class="cx">
</span><span class="cx"> #include "JSDestructibleObject.h"
</span><span class="cx"> #include "JSObject.h"
</span><ins>+#include "WebAssemblyWrapperFunction.h"
</ins><span class="cx"> #include "WebAssemblyFunction.h"
</span><span class="cx"> #include <wtf/MallocPtr.h>
</span><span class="cx">
</span><span class="lines">@@ -50,7 +51,7 @@
</span><span class="cx"> std::optional<uint32_t> maximum() const { return m_maximum; }
</span><span class="cx"> uint32_t size() const { return m_size; }
</span><span class="cx"> bool grow(uint32_t newSize) WARN_UNUSED_RETURN;
</span><del>- WebAssemblyFunction* getFunction(uint32_t index)
</del><ins>+ JSObject* getFunction(uint32_t index)
</ins><span class="cx"> {
</span><span class="cx"> RELEASE_ASSERT(index < m_size);
</span><span class="cx"> return m_jsFunctions.get()[index].get();
</span><span class="lines">@@ -57,6 +58,7 @@
</span><span class="cx"> }
</span><span class="cx"> void clearFunction(uint32_t index);
</span><span class="cx"> void setFunction(VM&, uint32_t index, WebAssemblyFunction*);
</span><ins>+ void setFunction(VM&, uint32_t index, WebAssemblyWrapperFunction*);
</ins><span class="cx">
</span><span class="cx"> static ptrdiff_t offsetOfSize() { return OBJECT_OFFSETOF(JSWebAssemblyTable, m_size); }
</span><span class="cx"> static ptrdiff_t offsetOfFunctions() { return OBJECT_OFFSETOF(JSWebAssemblyTable, m_functions); }
</span><span class="lines">@@ -74,7 +76,7 @@
</span><span class="cx"> static void visitChildren(JSCell*, SlotVisitor&);
</span><span class="cx">
</span><span class="cx"> MallocPtr<Wasm::CallableFunction> m_functions;
</span><del>- MallocPtr<WriteBarrier<WebAssemblyFunction>> m_jsFunctions;
</del><ins>+ MallocPtr<WriteBarrier<JSObject>> m_jsFunctions;
</ins><span class="cx"> std::optional<uint32_t> m_maximum;
</span><span class="cx"> uint32_t m_size;
</span><span class="cx"> };
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyInstanceConstructorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -32,6 +32,7 @@
</span><span class="cx"> #include "JSCInlines.h"
</span><span class="cx"> #include "JSModuleEnvironment.h"
</span><span class="cx"> #include "JSModuleNamespaceObject.h"
</span><ins>+#include "JSWebAssemblyHelpers.h"
</ins><span class="cx"> #include "JSWebAssemblyInstance.h"
</span><span class="cx"> #include "JSWebAssemblyLinkError.h"
</span><span class="cx"> #include "JSWebAssemblyMemory.h"
</span><span class="lines">@@ -129,15 +130,23 @@
</span><span class="cx"> if (!value.isFunction())
</span><span class="cx"> return exception(createJSWebAssemblyLinkError(exec, vm, ASCIILiteral("import function must be callable")));
</span><span class="cx">
</span><del>- JSCell* cell = value.asCell();
</del><ins>+ JSObject* function = jsCast<JSObject*>(value);
</ins><span class="cx"> // ii. If v is an Exported Function Exotic Object:
</span><del>- if (WebAssemblyFunction* importedExport = jsDynamicCast<WebAssemblyFunction*>(vm, cell)) {
</del><ins>+ WebAssemblyFunction* wasmFunction;
+ WebAssemblyWrapperFunction* wasmWrapperFunction;
+ if (isWebAssemblyHostFunction(vm, function, wasmFunction, wasmWrapperFunction)) {
</ins><span class="cx"> // a. If the signature of v does not match the signature of i, throw a WebAssembly.LinkError.
</span><del>- Wasm::SignatureIndex importedSignatureIndex = importedExport->signatureIndex();
</del><ins>+ Wasm::SignatureIndex importedSignatureIndex;
+ if (wasmFunction)
+ importedSignatureIndex = wasmFunction->signatureIndex();
+ else {
+ importedSignatureIndex = wasmWrapperFunction->signatureIndex();
+ // b. Let closure be v.[[Closure]].
+ function = wasmWrapperFunction->function();
+ }
</ins><span class="cx"> Wasm::SignatureIndex expectedSignatureIndex = moduleInformation.importFunctionSignatureIndices[import.kindIndex];
</span><span class="cx"> if (importedSignatureIndex != expectedSignatureIndex)
</span><span class="cx"> return exception(createJSWebAssemblyLinkError(exec, vm, ASCIILiteral("imported function's signature doesn't match the provided WebAssembly function's signature")));
</span><del>- // b. Let closure be v.[[Closure]].
</del><span class="cx"> }
</span><span class="cx"> // iii. Otherwise:
</span><span class="cx"> // a. Let closure be a new host function of the given signature which calls v by coercing WebAssembly arguments to JavaScript arguments via ToJSValue and returns the result, if any, by coercing via ToWebAssemblyValue.
</span><span class="lines">@@ -146,7 +155,7 @@
</span><span class="cx"> // Note: adding the JSCell to the instance list fulfills closure requirements b. above (the WebAssembly.Instance wil be kept alive) and v. below (the JSFunction).
</span><span class="cx">
</span><span class="cx"> ASSERT(numImportFunctions == import.kindIndex);
</span><del>- instance->setImportFunction(vm, cell, numImportFunctions++);
</del><ins>+ instance->setImportFunction(vm, function, numImportFunctions++);
</ins><span class="cx"> // v. Append closure to imports.
</span><span class="cx"> break;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyModuleRecordcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -32,6 +32,7 @@
</span><span class="cx"> #include "JSCInlines.h"
</span><span class="cx"> #include "JSLexicalEnvironment.h"
</span><span class="cx"> #include "JSModuleEnvironment.h"
</span><ins>+#include "JSWebAssemblyHelpers.h"
</ins><span class="cx"> #include "JSWebAssemblyInstance.h"
</span><span class="cx"> #include "JSWebAssemblyLinkError.h"
</span><span class="cx"> #include "JSWebAssemblyModule.h"
</span><span class="lines">@@ -110,19 +111,26 @@
</span><span class="cx"> // i. If there is an Exported Function Exotic Object func in funcs whose func.[[Closure]] equals c, then return func.
</span><span class="cx"> // ii. (Note: At most one wrapper is created for any closure, so func is unique, even if there are multiple occurrances in the list. Moreover, if the item was an import that is already an Exported Function Exotic Object, then the original function object will be found. For imports that are regular JS functions, a new wrapper will be created.)
</span><span class="cx"> if (exp.kindIndex < functionImportCount) {
</span><del>- // FIXME Implement re-exporting an import. https://bugs.webkit.org/show_bug.cgi?id=165510
- RELEASE_ASSERT_NOT_REACHED();
</del><ins>+ unsigned functionIndex = exp.kindIndex;
+ JSObject* functionImport = instance->importFunction(functionIndex)->get();
+ if (isWebAssemblyHostFunction(vm, functionImport))
+ exportedValue = functionImport;
+ else {
+ Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(functionIndex);
+ exportedValue = WebAssemblyWrapperFunction::create(vm, globalObject, functionImport, functionIndex, codeBlock, signatureIndex);
+ }
+ } else {
+ // iii. Otherwise:
+ // a. Let func be an Exported Function Exotic Object created from c.
+ // b. Append func to funcs.
+ // c. Return func.
+ JSWebAssemblyCallee* jsEntrypointCallee = codeBlock->jsEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);
+ JSWebAssemblyCallee* wasmEntrypointCallee = codeBlock->wasmEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);
+ Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(exp.kindIndex);
+ const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);
+ WebAssemblyFunction* function = WebAssemblyFunction::create(vm, globalObject, signature->argumentCount(), exp.field.string(), instance, jsEntrypointCallee, wasmEntrypointCallee, signatureIndex);
+ exportedValue = function;
</ins><span class="cx"> }
</span><del>- // iii. Otherwise:
- // a. Let func be an Exported Function Exotic Object created from c.
- // b. Append func to funcs.
- // c. Return func.
- JSWebAssemblyCallee* jsEntrypointCallee = codeBlock->jsEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);
- JSWebAssemblyCallee* wasmEntrypointCallee = codeBlock->wasmEntrypointCalleeFromFunctionIndexSpace(exp.kindIndex);
- Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(exp.kindIndex);
- const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);
- WebAssemblyFunction* function = WebAssemblyFunction::create(vm, globalObject, signature->argumentCount(), exp.field.string(), instance, jsEntrypointCallee, wasmEntrypointCallee, signatureIndex);
- exportedValue = function;
</del><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case Wasm::ExternalKind::Table: {
</span><span class="lines">@@ -184,7 +192,7 @@
</span><span class="cx"> ASSERT(!signature->argumentCount());
</span><span class="cx"> ASSERT(signature->returnType() == Wasm::Void);
</span><span class="cx"> if (startFunctionIndexSpace < codeBlock->functionImportCount()) {
</span><del>- JSCell* startFunction = instance->importFunction(startFunctionIndexSpace)->get();
</del><ins>+ JSObject* startFunction = instance->importFunction(startFunctionIndexSpace)->get();
</ins><span class="cx"> m_startFunction.set(vm, this, startFunction);
</span><span class="cx"> } else {
</span><span class="cx"> JSWebAssemblyCallee* jsEntrypointCallee = codeBlock->jsEntrypointCalleeFromFunctionIndexSpace(startFunctionIndexSpace);
</span><span class="lines">@@ -241,14 +249,28 @@
</span><span class="cx"> // for the import.
</span><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=165510
</span><span class="cx"> uint32_t functionIndex = element.functionIndices[i];
</span><ins>+ Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(functionIndex);
</ins><span class="cx"> if (functionIndex < codeBlock->functionImportCount()) {
</span><del>- return JSValue::decode(
- throwVMRangeError(state, scope, ASCIILiteral("Element is setting the table value with an import. This is not yet implemented. FIXME.")));
</del><ins>+ JSObject* functionImport = jsCast<JSObject*>(m_instance->importFunction(functionIndex)->get());
+ if (isWebAssemblyHostFunction(vm, functionImport)) {
+ WebAssemblyFunction* wasmFunction = jsDynamicCast<WebAssemblyFunction*>(vm, functionImport);
+ // If we ever import a WebAssemblyWrapperFunction, we set the import as the unwrapped value.
+ // Because a WebAssemblyWrapperFunction can never wrap another WebAssemblyWrapperFunction,
+ // the only type this could be is WebAssemblyFunction.
+ RELEASE_ASSERT(wasmFunction);
+ table->setFunction(vm, tableIndex, wasmFunction);
+ ++tableIndex;
+ continue;
+ }
+
+ table->setFunction(vm, tableIndex,
+ WebAssemblyWrapperFunction::create(vm, m_instance->globalObject(), functionImport, functionIndex, codeBlock, signatureIndex));
+ ++tableIndex;
+ continue;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> JSWebAssemblyCallee* jsEntrypointCallee = codeBlock->jsEntrypointCalleeFromFunctionIndexSpace(functionIndex);
</span><span class="cx"> JSWebAssemblyCallee* wasmEntrypointCallee = codeBlock->wasmEntrypointCalleeFromFunctionIndexSpace(functionIndex);
</span><del>- Wasm::SignatureIndex signatureIndex = module->signatureIndexFromFunctionIndexSpace(functionIndex);
</del><span class="cx"> const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);
</span><span class="cx"> // FIXME: Say we export local function "foo" at function index 0.
</span><span class="cx"> // What if we also set it to the table an Element w/ index 0.
</span><span class="lines">@@ -288,7 +310,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (JSCell* startFunction = m_startFunction.get()) {
</del><ins>+ if (JSObject* startFunction = m_startFunction.get()) {
</ins><span class="cx"> CallData callData;
</span><span class="cx"> CallType callType = JSC::getCallData(startFunction, callData);
</span><span class="cx"> call(state, startFunction, callType, callData, jsUndefined(), state->emptyList());
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyModuleRecordh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.h (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.h 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -59,7 +59,7 @@
</span><span class="cx"> static void visitChildren(JSCell*, SlotVisitor&);
</span><span class="cx">
</span><span class="cx"> WriteBarrier<JSWebAssemblyInstance> m_instance;
</span><del>- WriteBarrier<JSCell> m_startFunction;
</del><ins>+ WriteBarrier<JSObject> m_startFunction;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyTablePrototypecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyTablePrototype.cpp (213744 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyTablePrototype.cpp 2017-03-11 01:56:08 UTC (rev 213744)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyTablePrototype.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -106,7 +106,7 @@
</span><span class="cx"> return { };
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (WebAssemblyFunction* result = table->getFunction(index))
</del><ins>+ if (JSObject* result = table->getFunction(index))
</ins><span class="cx"> return JSValue::encode(result);
</span><span class="cx"> return JSValue::encode(jsNull());
</span><span class="cx"> }
</span><span class="lines">@@ -120,8 +120,9 @@
</span><span class="cx"> RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
</span><span class="cx">
</span><span class="cx"> JSValue value = exec->argument(1);
</span><del>- WebAssemblyFunction* function = jsDynamicCast<WebAssemblyFunction*>(vm, value);
- if (!value.isNull() && !function) {
</del><ins>+ WebAssemblyFunction* wasmFunction;
+ WebAssemblyWrapperFunction* wasmWrapperFunction;
+ if (!value.isNull() && !isWebAssemblyHostFunction(vm, value, wasmFunction, wasmWrapperFunction)) {
</ins><span class="cx"> throwException(exec, throwScope,
</span><span class="cx"> createTypeError(exec, ASCIILiteral("WebAssembly.Table.prototype.set expects the second argument to be null or an instance of WebAssembly.Function")));
</span><span class="cx"> return { };
</span><span class="lines">@@ -139,8 +140,12 @@
</span><span class="cx"> if (value.isNull())
</span><span class="cx"> table->clearFunction(index);
</span><span class="cx"> else {
</span><del>- ASSERT(!!function);
- table->setFunction(vm, index, function);
</del><ins>+ ASSERT(value.isObject() && isWebAssemblyHostFunction(vm, jsCast<JSObject*>(value), wasmFunction, wasmWrapperFunction));
+ ASSERT(!!wasmFunction || !!wasmWrapperFunction);
+ if (wasmFunction)
+ table->setFunction(vm, index, wasmFunction);
+ else
+ table->setFunction(vm, index, wasmWrapperFunction);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return JSValue::encode(jsUndefined());
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyWrapperFunctioncpp"></a>
<div class="addfile"><h4>Added: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp (0 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp (rev 0)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -0,0 +1,98 @@
</span><ins>+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "config.h"
+#include "WebAssemblyWrapperFunction.h"
+
+#if ENABLE(WEBASSEMBLY)
+
+#include "Error.h"
+#include "FunctionPrototype.h"
+#include "JSCInlines.h"
+
+namespace JSC {
+
+const ClassInfo WebAssemblyWrapperFunction::s_info = { "WebAssemblyWrapperFunction", &Base::s_info, nullptr, CREATE_METHOD_TABLE(WebAssemblyWrapperFunction) };
+
+static EncodedJSValue JSC_HOST_CALL callWebAssemblyWrapperFunction(ExecState* exec)
+{
+ VM& vm = exec->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+ WebAssemblyWrapperFunction* wasmFunction = jsDynamicCast<WebAssemblyWrapperFunction*>(vm, exec->jsCallee());
+ if (!wasmFunction)
+ return JSValue::encode(throwException(exec, scope, createTypeError(exec, "expected a WebAssembly function")));
+
+ CallData callData;
+ JSObject* function = wasmFunction->function();
+ CallType callType = function->methodTable(vm)->getCallData(function, callData);
+ RELEASE_ASSERT(callType != CallType::None);
+ scope.release();
+ return JSValue::encode(call(exec, function, callType, callData, jsUndefined(), ArgList(exec)));
+}
+
+WebAssemblyWrapperFunction::WebAssemblyWrapperFunction(VM& vm, JSGlobalObject* globalObject, Structure* structure, Wasm::SignatureIndex signatureIndex, void* wasmEntrypointCode)
+ : Base(vm, globalObject, structure)
+ , m_wasmEntrypointCode(wasmEntrypointCode)
+ , m_signatureIndex(signatureIndex)
+{ }
+
+WebAssemblyWrapperFunction* WebAssemblyWrapperFunction::create(VM& vm, JSGlobalObject* globalObject, JSObject* function, unsigned importIndex, JSWebAssemblyCodeBlock* codeBlock, Wasm::SignatureIndex signatureIndex)
+{
+ ASSERT_WITH_MESSAGE(!function->inherits(vm, WebAssemblyWrapperFunction::info()), "We should never double wrap a wrapper function.");
+ String name = "";
+ NativeExecutable* executable = vm.getHostFunction(callWebAssemblyWrapperFunction, NoIntrinsic, callHostFunctionAsConstructor, nullptr, name);
+ WebAssemblyWrapperFunction* result = new (NotNull, allocateCell<WebAssemblyWrapperFunction>(vm.heap)) WebAssemblyWrapperFunction(vm, globalObject, globalObject->webAssemblyWrapperFunctionStructure(), signatureIndex, codeBlock->wasmToJsCallStubForImport(importIndex));
+ const Wasm::Signature* signature = Wasm::SignatureInformation::get(&vm, signatureIndex);
+ result->finishCreation(vm, executable, signature->argumentCount(), name, function, codeBlock);
+ return result;
+}
+
+void WebAssemblyWrapperFunction::finishCreation(VM& vm, NativeExecutable* executable, unsigned length, const String& name, JSObject* function, JSWebAssemblyCodeBlock* codeBlock)
+{
+ Base::finishCreation(vm, executable, length, name);
+ RELEASE_ASSERT(JSValue(function).isFunction());
+ m_function.set(vm, this, function);
+ m_codeBlock.set(vm, this, codeBlock);
+}
+
+Structure* WebAssemblyWrapperFunction::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
+{
+ ASSERT(globalObject);
+ return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
+}
+
+void WebAssemblyWrapperFunction::visitChildren(JSCell* cell, SlotVisitor& visitor)
+{
+ WebAssemblyWrapperFunction* thisObject = jsCast<WebAssemblyWrapperFunction*>(cell);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ Base::visitChildren(thisObject, visitor);
+
+ visitor.append(thisObject->m_codeBlock);
+ visitor.append(thisObject->m_function);
+}
+
+} // namespace JSC
+
+#endif // ENABLE(WEBASSEMBLY)
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmjsWebAssemblyWrapperFunctionhfromrev213744trunkSourceJavaScriptCorewasmjsWebAssemblyModuleRecordh"></a>
<div class="copfile"><h4>Copied: trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.h (from rev 213744, trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.h) (0 => 213745)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.h (rev 0)
+++ trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.h 2017-03-11 02:04:37 UTC (rev 213745)
</span><span class="lines">@@ -0,0 +1,68 @@
</span><ins>+/*
+ * Copyright (C) 2017 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.
+ */
+
+#pragma once
+
+#if ENABLE(WEBASSEMBLY)
+
+#include "JSFunction.h"
+#include "JSWebAssemblyCodeBlock.h"
+
+namespace JSC {
+
+class WebAssemblyWrapperFunction : public JSFunction {
+public:
+ typedef JSFunction Base;
+
+ const static unsigned StructureFlags = Base::StructureFlags;
+
+ DECLARE_INFO;
+
+ static WebAssemblyWrapperFunction* create(VM&, JSGlobalObject*, JSObject*, unsigned importIndex, JSWebAssemblyCodeBlock*, Wasm::SignatureIndex);
+ static Structure* createStructure(VM&, JSGlobalObject*, JSValue);
+
+ Wasm::SignatureIndex signatureIndex() const { return m_signatureIndex; }
+ void* wasmEntrypoint() { return m_wasmEntrypointCode; }
+ JSObject* function() { return m_function.get(); }
+
+protected:
+ static void visitChildren(JSCell*, SlotVisitor&);
+
+ void finishCreation(VM&, NativeExecutable*, unsigned length, const String& name, JSObject*, JSWebAssemblyCodeBlock*);
+
+private:
+ WebAssemblyWrapperFunction(VM&, JSGlobalObject*, Structure*, Wasm::SignatureIndex, void* wasmEntrypointCode);
+
+ // We keep a reference to our CodeBlock because we have a raw
+ // pointer to asm code that it owns.
+ WriteBarrier<JSWebAssemblyCodeBlock> m_codeBlock;
+ WriteBarrier<JSObject> m_function;
+ void* m_wasmEntrypointCode;
+ Wasm::SignatureIndex m_signatureIndex;
+};
+
+} // namespace JSC
+
+#endif // ENABLE(WEBASSEMBLY)
</ins></span></pre>
</div>
</div>
</body>
</html>