b40d44ecc1
Two controls, one for instantiation and one for compilation. They allow
the embedder (e.g. Chrome) check properties of the parameters of those
two operations, and decide if they are allowed to continue.
For example, Chrome may now decline compilation of certain size buffers,
in synchronous cases; same for instantiation (where the buffer size
refers to the size of the buffer containing wasm wire bytes)
BUG=v8:5981
Review-Url: https://codereview.chromium.org/2699843003
Cr-Original-Commit-Position: refs/heads/master@{#43295}
Committed: d9bc0ffb16
Review-Url: https://codereview.chromium.org/2699843003
Cr-Commit-Position: refs/heads/master@{#43336}
119 lines
2.8 KiB
JavaScript
119 lines
2.8 KiB
JavaScript
// Copyright 2017 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// Flags: --allow-natives-syntax --validate-asm
|
|
|
|
load("test/mjsunit/wasm/wasm-constants.js");
|
|
load("test/mjsunit/wasm/wasm-module-builder.js");
|
|
|
|
let buffer = (() => {
|
|
var builder = new WasmModuleBuilder();
|
|
builder.addFunction("f", kSig_i_v)
|
|
.addBody([kExprI32Const, 42])
|
|
.exportAs("f");
|
|
return builder.toBuffer();
|
|
})();
|
|
|
|
// allow up to the buffer size
|
|
%SetWasmCompileControls(buffer.byteLength, true);
|
|
%SetWasmInstantiateControls();
|
|
var m = new WebAssembly.Module(buffer);
|
|
var i = new WebAssembly.Instance(m);
|
|
assertEquals(i.exports.f(), 42);
|
|
|
|
// the buffer can't compile synchronously, but we allow async compile
|
|
%SetWasmCompileControls(buffer.byteLength - 1, true);
|
|
// test first that we can't sync-instantiate this module anymore
|
|
try {
|
|
i = new WebAssembly.Instance(m);
|
|
} catch (e) {
|
|
assertTrue(e instanceof RangeError);
|
|
}
|
|
|
|
//...but we can async-instantiate it
|
|
WebAssembly.instantiate(m)
|
|
.then(instance => i = instance,
|
|
assertUnreachable);
|
|
%RunMicrotasks();
|
|
assertTrue(i instanceof WebAssembly.Instance);
|
|
|
|
try {
|
|
m = new WebAssembly.Module(buffer);
|
|
assertUnreachable();
|
|
} catch (e) {
|
|
assertTrue(e instanceof RangeError);
|
|
}
|
|
|
|
WebAssembly.compile(buffer)
|
|
.then(res => m = res,
|
|
m = null);
|
|
|
|
%RunMicrotasks();
|
|
assertTrue(m instanceof WebAssembly.Module)
|
|
|
|
WebAssembly.instantiate(buffer)
|
|
.then(res => m = res.module,
|
|
m = null);
|
|
|
|
%RunMicrotasks();
|
|
assertTrue(m instanceof WebAssembly.Module);
|
|
|
|
// Async compile works, but using the sync instantiate doesn't
|
|
i = undefined;
|
|
m = undefined;
|
|
var ex = undefined;
|
|
WebAssembly.compile(buffer)
|
|
.then(mod => {
|
|
m = mod;
|
|
try {
|
|
i = new WebAssembly.Instance(m);
|
|
} catch (e) {
|
|
ex = e;
|
|
}
|
|
},
|
|
e => ex = e);
|
|
%RunMicrotasks();
|
|
assertTrue(ex instanceof RangeError);
|
|
assertEquals(i, undefined);
|
|
assertTrue(m instanceof WebAssembly.Module);
|
|
|
|
// Now block async compile works.
|
|
%SetWasmCompileControls(buffer.byteLength - 1, false);
|
|
WebAssembly.compile(buffer)
|
|
.then(ex = null,
|
|
e => ex = e);
|
|
|
|
%RunMicrotasks();
|
|
assertTrue(ex instanceof RangeError);
|
|
|
|
WebAssembly.instantiate(buffer)
|
|
.then(ex = null,
|
|
e => ex = e);
|
|
%RunMicrotasks();
|
|
assertTrue(ex instanceof RangeError);
|
|
|
|
|
|
// Verify that, for asm-wasm, these controls are ignored.
|
|
%SetWasmCompileControls(0, false);
|
|
function assertValidAsm(func) {
|
|
assertTrue(%IsAsmWasmCode(func));
|
|
}
|
|
|
|
function assertWasm(expected, func) {
|
|
assertEquals(
|
|
expected, func(undefined, undefined, new ArrayBuffer(1024)).caller());
|
|
assertValidAsm(func);
|
|
}
|
|
|
|
function TestAsmWasmIsUnaffected() {
|
|
"use asm";
|
|
function caller() {
|
|
return 43;
|
|
}
|
|
|
|
return {caller: caller};
|
|
}
|
|
|
|
assertWasm(43, TestAsmWasmIsUnaffected);
|