Skip to content

V
V8
Commit dbc8aa87 authored by Andreas Haas's avatar Andreas Haas Committed by Commit Bot
Browse files
Options

[wasm] Add type immediate to RefNull and RefIsNull instructions 

With recent changes to the anyref proposal, null refs now have a type
immediate which declares the type of a null ref constant. Likewise,
the RefIsNull instruction is type aware now. This CL addresses these
proposal changes now.

R=jkummerow@chromium.org

Bug: v8:10556
Change-Id: I810dfa3a4ab4389afc9639f897cee5d43e9b62cb
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2215172
Commit-Queue: Andreas Haas <ahaas@chromium.org>
Reviewed-by: 's avatarJakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68141}
parent 490f3580
Hide whitespace changes
Inline Side-by-side
Showing with 286 additions and 666 deletions
src/wasm/function-body-decoder-impl.h
View file @ dbc8aa87
......@@ -128,81 +128,6 @@ struct WasmException;
V(I64AtomicStore16U, Uint16) \
V(I64AtomicStore32U, Uint32)
// Helpers for decoding different kinds of immediates which follow bytecodes.
template <Decoder::ValidateFlag validate>
struct LocalIndexImmediate {
uint32_t index;
ValueType type = kWasmStmt;
uint32_t length;
inline LocalIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "local index");
}
};
template <Decoder::ValidateFlag validate>
struct ExceptionIndexImmediate {
uint32_t index;
const WasmException* exception = nullptr;
uint32_t length;
inline ExceptionIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "exception index");
}
};
template <Decoder::ValidateFlag validate>
struct ImmI32Immediate {
int32_t value;
uint32_t length;
inline ImmI32Immediate(Decoder* decoder, const byte* pc) {
value = decoder->read_i32v<validate>(pc + 1, &length, "immi32");
}
};
template <Decoder::ValidateFlag validate>
struct ImmI64Immediate {
int64_t value;
uint32_t length;
inline ImmI64Immediate(Decoder* decoder, const byte* pc) {
value = decoder->read_i64v<validate>(pc + 1, &length, "immi64");
}
};
template <Decoder::ValidateFlag validate>
struct ImmF32Immediate {
float value;
uint32_t length = 4;
inline ImmF32Immediate(Decoder* decoder, const byte* pc) {
// Avoid bit_cast because it might not preserve the signalling bit of a NaN.
uint32_t tmp = decoder->read_u32<validate>(pc + 1, "immf32");
memcpy(&value, &tmp, sizeof(value));
}
};
template <Decoder::ValidateFlag validate>
struct ImmF64Immediate {
double value;
uint32_t length = 8;
inline ImmF64Immediate(Decoder* decoder, const byte* pc) {
// Avoid bit_cast because it might not preserve the signalling bit of a NaN.
uint64_t tmp = decoder->read_u64<validate>(pc + 1, "immf64");
memcpy(&value, &tmp, sizeof(value));
}
};
template <Decoder::ValidateFlag validate>
struct GlobalIndexImmediate {
uint32_t index;
ValueType type = kWasmStmt;
const WasmGlobal* global = nullptr;
uint32_t length;
inline GlobalIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "global index");
}
};
namespace value_type_reader {
// Read a value type starting at address 'pc' in 'decoder'.
......@@ -345,6 +270,94 @@ ValueType read_value_type(Decoder* decoder, const byte* pc,
}
} // namespace value_type_reader
// Helpers for decoding different kinds of immediates which follow bytecodes.
template <Decoder::ValidateFlag validate>
struct LocalIndexImmediate {
uint32_t index;
ValueType type = kWasmStmt;
uint32_t length;
inline LocalIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "local index");
}
};
template <Decoder::ValidateFlag validate>
struct ExceptionIndexImmediate {
uint32_t index;
const WasmException* exception = nullptr;
uint32_t length;
inline ExceptionIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "exception index");
}
};
template <Decoder::ValidateFlag validate>
struct ImmI32Immediate {
int32_t value;
uint32_t length;
inline ImmI32Immediate(Decoder* decoder, const byte* pc) {
value = decoder->read_i32v<validate>(pc + 1, &length, "immi32");
}
};
template <Decoder::ValidateFlag validate>
struct ImmI64Immediate {
int64_t value;
uint32_t length;
inline ImmI64Immediate(Decoder* decoder, const byte* pc) {
value = decoder->read_i64v<validate>(pc + 1, &length, "immi64");
}
};
template <Decoder::ValidateFlag validate>
struct ImmF32Immediate {
float value;
uint32_t length = 4;
inline ImmF32Immediate(Decoder* decoder, const byte* pc) {
// We can't use bit_cast here because calling any helper function that
// returns a float would potentially flip NaN bits per C++ semantics, so we
// have to inline the memcpy call directly.
uint32_t tmp = decoder->read_u32<validate>(pc + 1, "immf32");
memcpy(&value, &tmp, sizeof(value));
}
};
template <Decoder::ValidateFlag validate>
struct ImmF64Immediate {
double value;
uint32_t length = 8;
inline ImmF64Immediate(Decoder* decoder, const byte* pc) {
// Avoid bit_cast because it might not preserve the signalling bit of a NaN.
uint64_t tmp = decoder->read_u64<validate>(pc + 1, "immf64");
memcpy(&value, &tmp, sizeof(value));
}
};
template <Decoder::ValidateFlag validate>
struct RefNullImmediate {
ValueType type;
uint32_t length = 1;
inline RefNullImmediate(const WasmFeatures& enabled, Decoder* decoder,
const byte* pc) {
type = value_type_reader::read_value_type<validate>(decoder, pc + 1,
&length, enabled);
}
};
template <Decoder::ValidateFlag validate>
struct GlobalIndexImmediate {
uint32_t index;
ValueType type = kWasmStmt;
const WasmGlobal* global = nullptr;
uint32_t length;
inline GlobalIndexImmediate(Decoder* decoder, const byte* pc) {
index = decoder->read_u32v<validate>(pc + 1, &length, "global index");
}
};
template <Decoder::ValidateFlag validate>
struct SelectTypeImmediate {
uint32_t length;
......@@ -1109,6 +1122,14 @@ class WasmDecoder : public Decoder {
return true;
}
inline bool Validate(const byte* pc, RefNullImmediate<validate>& imm) {
if (!VALIDATE(imm.type.IsNullable())) {
errorf(pc + 1, "ref.null does not exist for %s", imm.type.type_name());
return false;
}
return true;
}
inline bool Complete(const byte* pc, ExceptionIndexImmediate<validate>& imm) {
if (!VALIDATE(imm.index < module_->exceptions.size())) return false;
imm.exception = &module_->exceptions[imm.index];
......@@ -1483,7 +1504,12 @@ class WasmDecoder : public Decoder {
return 1 + imm.length;
}
case kExprRefNull: {
return 1;
RefNullImmediate<validate> imm(WasmFeatures::All(), decoder, pc);
return 1 + imm.length;
}
case kExprRefIsNull: {
RefNullImmediate<validate> imm(WasmFeatures::All(), decoder, pc);
return 1 + imm.length;
}
case kExprRefFunc: {
FunctionIndexImmediate<validate> imm(decoder, pc);
......@@ -1682,6 +1708,7 @@ class WasmDecoder : public Decoder {
case kExprMemoryGrow:
case kExprRefAsNonNull:
case kExprBrOnNull:
case kExprRefIsNull:
return {1, 1};
case kExprLocalSet:
case kExprGlobalSet:
......@@ -2076,6 +2103,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
for (size_t i = 0; i < value_count; ++i) Push(sig->GetParam(i));
Vector<Value> values(stack_.data() + c->stack_depth, value_count);
TypeCheckBranchResult check_result = TypeCheckBranch(c, true);
if (this->failed()) break;
if (V8_LIKELY(check_result == kReachableBranch)) {
CALL_INTERFACE(BrOnException, exception, imm.index, imm.depth.depth,
values);
......@@ -2415,9 +2443,21 @@ class WasmFullDecoder : public WasmDecoder<validate> {
}
case kExprRefNull: {
CHECK_PROTOTYPE_OPCODE(anyref);
Value* value = Push(kWasmNullRef);
RefNullImmediate<validate> imm(this->enabled_, this, this->pc_);
if (!this->Validate(this->pc_, imm)) break;
Value* value = Push(imm.type);
CALL_INTERFACE_IF_REACHABLE(RefNull, value);
len = 1;
len = 1 + imm.length;
break;
}
case kExprRefIsNull: {
CHECK_PROTOTYPE_OPCODE(anyref);
RefNullImmediate<validate> imm(this->enabled_, this, this->pc_);
if (!this->Validate(this->pc_, imm)) break;
Value value = Pop(0, imm.type);
Value* result = Push(kWasmI32);
CALL_INTERFACE_IF_REACHABLE(UnOp, opcode, value, result);
len = 1 + imm.length;
break;
}
case kExprRefFunc: {
......@@ -3697,9 +3737,7 @@ class WasmFullDecoder : public WasmDecoder<validate> {
}
void BuildSimplePrototypeOperator(WasmOpcode opcode) {
if (opcode == kExprRefIsNull) {
RET_ON_PROTOTYPE_OPCODE(anyref);
} else if (opcode == kExprRefEq) {
if (opcode == kExprRefEq) {
RET_ON_PROTOTYPE_OPCODE(gc);
}
const FunctionSig* sig = WasmOpcodes::Signature(opcode);
......
src/wasm/module-decoder.cc
View file @ dbc8aa87
......@@ -122,12 +122,15 @@ ValueType TypeOf(const WasmModule* module, const WasmInitExpr& expr) {
return kWasmF32;
case WasmInitExpr::kF64Const:
return kWasmF64;
case WasmInitExpr::kRefNullConst:
return kWasmNullRef;
case WasmInitExpr::kRefFuncConst:
return kWasmFuncRef;
case WasmInitExpr::kRefNullConst:
// It is not possible to retrieve the full {ValueType} of a {WasmInitExpr}
// of kind {kRefNullConst}. As WasmInitExpr of kind {krefNullConst} is
// only valid in globals, the {ValueType} has to be retrieved from the
// global definition itself.
UNREACHABLE();
}
UNREACHABLE();
}
// Reads a length-prefixed string, checking that it is within bounds. Returns
......@@ -1423,7 +1426,7 @@ class ModuleDecoderImpl : public Decoder {
global->type = consume_value_type();
global->mutability = consume_mutability();
const byte* pos = pc();
global->init = consume_init_expr(module, kWasmStmt);
global->init = consume_init_expr(module, global->type);
if (global->init.kind == WasmInitExpr::kGlobalIndex) {
uint32_t other_index = global->init.val.global_index;
if (other_index >= index) {
......@@ -1438,12 +1441,6 @@ class ModuleDecoderImpl : public Decoder {
other_index, global->type.type_name(),
module->globals[other_index].type.type_name());
}
} else {
if (!TypeOf(module, global->init).IsSubTypeOf(global->type)) {
errorf(pos, "type error in global initialization, expected %s, got %s",
global->type.type_name(),
TypeOf(module, global->init).type_name());
}
}
}
......@@ -1698,8 +1695,19 @@ class ModuleDecoderImpl : public Decoder {
}
case kExprRefNull: {
if (enabled_features_.has_anyref() || enabled_features_.has_eh()) {
RefNullImmediate<Decoder::kValidate> imm(WasmFeatures::All(), this,
pc() - 1);
if (!imm.type.IsReferenceType()) {
errorf(pc() - 1, "ref.null is not supported for %s",
imm.type.type_name());
break;
}
expr.kind = WasmInitExpr::kRefNullConst;
len = 0;
len = imm.length;
if (expected != kWasmStmt && !imm.type.IsSubTypeOf(expected)) {
errorf(pos, "type error in init expression, expected %s, got %s",
expected.type_name(), imm.type.type_name());
}
break;
}
V8_FALLTHROUGH;
......@@ -1730,7 +1738,10 @@ class ModuleDecoderImpl : public Decoder {
if (!expect_u8("end opcode", kExprEnd)) {
expr.kind = WasmInitExpr::kNone;
}
if (expected != kWasmStmt && TypeOf(module, expr) != kWasmI32) {
// The type check of ref.null is special, and already done above.
if (expected != kWasmStmt && opcode != kExprRefNull &&
TypeOf(module, expr) != expected) {
errorf(pos, "type error in init expression, expected %s, got %s",
expected.type_name(), TypeOf(module, expr).type_name());
}
......@@ -2049,9 +2060,13 @@ class ModuleDecoderImpl : public Decoder {
uint8_t opcode = consume_u8("element opcode");
if (failed()) return index;
switch (opcode) {
case kExprRefNull:
case kExprRefNull: {
RefNullImmediate<kValidate> imm(WasmFeatures::All(), this,
this->pc() - 1);
consume_bytes(imm.length, "ref.null immediate");
index = WasmElemSegment::kNullIndex;
break;
}
case kExprRefFunc:
index = consume_element_func_index();
if (failed()) return index;
......
src/wasm/value-type.h
View file @ dbc8aa87
......@@ -134,6 +134,11 @@ class ValueType {
return kAnyRef <= kind() && kind() <= kEqRef;
}
constexpr bool IsNullable() const {
return kind() == kAnyRef || kind() == kFuncRef || kind() == kExnRef ||
kind() == kOptRef;
}
// TODO(7748): Extend this with struct and function subtyping.
// Keep up to date with funcref vs. anyref subtyping.
static ValueType CommonSubType(ValueType a, ValueType b) {
......
src/wasm/wasm-interpreter.cc
View file @ dbc8aa87
......@@ -3183,6 +3183,9 @@ class ThreadImpl {
break;
}
case kExprRefNull: {
RefNullImmediate<Decoder::kNoValidate> imm(WasmFeatures::All(),
&decoder, code->at(pc));
len = 1 + imm.length;
Push(WasmValue(isolate_->factory()->null_value()));
break;
}
......@@ -3519,6 +3522,9 @@ class ThreadImpl {
SIGN_EXTENSION_CASE(I64SExtendI32, int64_t, int32_t);
#undef SIGN_EXTENSION_CASE
case kExprRefIsNull: {
RefNullImmediate<Decoder::kNoValidate> imm(WasmFeatures::All(),
&decoder, code->at(pc));
len = 1 + imm.length;
HandleScope handle_scope(isolate_); // Avoid leaking handles.
uint32_t result = Pop().to_anyref()->IsNull() ? 1 : 0;
Push(WasmValue(result));
......
src/wasm/wasm-module-builder.cc
View file @ dbc8aa87
......@@ -566,6 +566,7 @@ void WasmModuleBuilder::WriteTo(ZoneBuffer* buffer) const {
break;
case WasmInitExpr::kRefNullConst:
buffer->write_u8(kExprRefNull);
WriteValueType(buffer, global.type);
break;
case WasmInitExpr::kRefFuncConst:
UNIMPLEMENTED();
......
src/wasm/wasm-opcodes.h
View file @ dbc8aa87
......@@ -62,6 +62,7 @@ bool IsJSCompatibleSignature(const FunctionSig* sig, const WasmFeatures&);
V(F32Const, 0x43, _) \
V(F64Const, 0x44, _) \
V(RefNull, 0xd0, _) \
V(RefIsNull, 0xd1, _) \
V(RefFunc, 0xd2, _) \
V(RefAsNonNull, 0xd3, _)
......@@ -231,7 +232,6 @@ bool IsJSCompatibleSignature(const FunctionSig* sig, const WasmFeatures&);
V(I64SExtendI32, 0xc4, l_l)
#define FOREACH_SIMPLE_PROTOTYPE_OPCODE(V) \
V(RefIsNull, 0xd1, i_r) \
V(RefEq, 0xd5, i_rr) // made-up opcode, guessing future spec (GC)
// For compatibility with Asm.js.
......@@ -765,13 +765,16 @@ struct WasmInitExpr {
explicit WasmInitExpr(int64_t v) : kind(kI64Const) { val.i64_const = v; }
explicit WasmInitExpr(float v) : kind(kF32Const) { val.f32_const = v; }
explicit WasmInitExpr(double v) : kind(kF64Const) { val.f64_const = v; }
explicit WasmInitExpr(WasmInitKind kind) : kind(kind) {
DCHECK_EQ(kind, kRefNullConst);
}
WasmInitExpr(WasmInitKind kind, uint32_t index) : kind(kind) {
if (kind == kGlobalIndex) {
val.global_index = index;
} else if (kind == kRefFuncConst) {
val.function_index = index;
} else if (kind == kRefNullConst) {
// Nothing to do.
} else {
// For the other types, the other initializers should be used.
UNREACHABLE();
......
test/cctest/wasm/test-gc.cc
View file @ dbc8aa87
......@@ -85,17 +85,19 @@ WASM_EXEC_TEST(BasicStruct) {
// Test struct.set, ref.as_non_null,
// struct refs types in globals and if-results.
uint32_t k_global_index = builder->AddGlobal(kOptRefType, true);
uint32_t k_global_index = builder->AddGlobal(
kOptRefType, true, WasmInitExpr(WasmInitExpr::kRefNullConst));
WasmFunctionBuilder* k = builder->AddFunction(sigs.i_v());
uint32_t k_field_index = 0;
k->builder()->AddExport(CStrVector("k"), k);
byte k_code[] = {
WASM_SET_GLOBAL(k_global_index, WASM_STRUCT_NEW(type_index, WASM_I32V(55),
WASM_I32V(66))),
WASM_STRUCT_GET(type_index, k_field_index,
WASM_REF_AS_NON_NULL(WASM_IF_ELSE_R(
kOptRefType, WASM_I32V(1),
WASM_GET_GLOBAL(k_global_index), WASM_REF_NULL))),
WASM_STRUCT_GET(
type_index, k_field_index,
WASM_REF_AS_NON_NULL(WASM_IF_ELSE_R(kOptRefType, WASM_I32V(1),
WASM_GET_GLOBAL(k_global_index),
WASM_REF_NULL_GC(type_index)))),
kExprEnd};
k->EmitCode(k_code, sizeof(k_code));
......@@ -147,13 +149,14 @@ WASM_EXEC_TEST(BasicStruct) {
WASM_STRUCT_NEW(type_index, WASM_I32V(55),
WASM_I32V(66))),
WASM_I32V(1)),
WASM_I32_ADD(
WASM_I32_SHL( // false
WASM_REF_EQ(WASM_GET_LOCAL(n_local_index), WASM_REF_NULL),
WASM_I32V(2)),
WASM_I32_SHL(WASM_REF_EQ( // true
WASM_REF_NULL, WASM_REF_NULL),
WASM_I32V(3))))),
WASM_I32_ADD(WASM_I32_SHL( // false
WASM_REF_EQ(WASM_GET_LOCAL(n_local_index),
WASM_REF_NULL_GC(type_index)),
WASM_I32V(2)),
WASM_I32_SHL(WASM_REF_EQ( // true
WASM_REF_NULL_GC(type_index),
WASM_REF_NULL_GC(type_index)),
WASM_I32V(3))))),
kExprEnd};
n->EmitCode(n_code, sizeof(n_code));
// Result: 0b1001
......
test/cctest/wasm/test-run-wasm-interpreter.cc
View file @ dbc8aa87
......@@ -348,19 +348,20 @@ TEST(MemoryGrowInvalidSize) {
TEST(ReferenceTypeLocals) {
{
WasmRunner<int32_t> r(ExecutionTier::kInterpreter);
BUILD(r, WASM_REF_IS_NULL(WASM_REF_NULL));
BUILD(r, WASM_REF_IS_NULL(kLocalAnyRef, WASM_REF_NULL(kLocalAnyRef)));
CHECK_EQ(1, r.Call());
}
{
WasmRunner<int32_t> r(ExecutionTier::kInterpreter);
r.AllocateLocal(kWasmAnyRef);
BUILD(r, WASM_REF_IS_NULL(WASM_GET_LOCAL(0)));
BUILD(r, WASM_REF_IS_NULL(kLocalAnyRef, WASM_GET_LOCAL(0)));
CHECK_EQ(1, r.Call());
}
{
WasmRunner<int32_t> r(ExecutionTier::kInterpreter);
r.AllocateLocal(kWasmAnyRef);
BUILD(r, WASM_REF_IS_NULL(WASM_TEE_LOCAL(0, WASM_REF_NULL)));
BUILD(r, WASM_REF_IS_NULL(kLocalAnyRef,
WASM_TEE_LOCAL(0, WASM_REF_NULL(kLocalAnyRef))));
CHECK_EQ(1, r.Call());
}
}
......
test/common/wasm/wasm-macro-gen.h
View file @ dbc8aa87
......@@ -432,9 +432,11 @@ inline WasmOpcode LoadStoreOpcodeOf(MachineType type, bool store) {
#define WASM_STRUCT_SET(typeidx, fieldidx, struct_obj, value) \
struct_obj, value, WASM_GC_OP(kExprStructSet), static_cast<byte>(typeidx), \
static_cast<byte>(fieldidx)
#define WASM_REF_NULL kExprRefNull
#define WASM_REF_NULL(type) kExprRefNull, static_cast<byte>(type)
#define WASM_REF_NULL_GC(type) \
kExprRefNull, kLocalOptRef, static_cast<byte>(type)
#define WASM_REF_FUNC(val) kExprRefFunc, val
#define WASM_REF_IS_NULL(val) val, kExprRefIsNull
#define WASM_REF_IS_NULL(type, val) val, kExprRefIsNull, static_cast<byte>(type)
#define WASM_REF_AS_NON_NULL(val) val, kExprRefAsNonNull
#define WASM_REF_EQ(lhs, rhs) lhs, rhs, kExprRefEq
......
test/debugger/debug/wasm/debug-enabled-tier-down-wasm-unsupported-liftoff.js
View file @ dbc8aa87
......@@ -13,11 +13,11 @@ load('test/mjsunit/wasm/wasm-module-builder.js');
function create_builder(i) {
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_i_r)
.addBody([
kExprLocalGet, 0, kExprRefIsNull,
...wasmI32Const(i),
kExprI32Add])
.exportFunc();
.addBody([
kExprLocalGet, 0, kExprRefIsNull, kWasmAnyRef, ...wasmI32Const(i),
kExprI32Add
])
.exportFunc();
return builder;
}
......
test/mjsunit/regress/regress-9165.js
View file @ dbc8aa87
......@@ -36,7 +36,7 @@ let kSig_r_i = makeSig([kWasmI32], [kWasmAnyRef]);
kExprLocalGet, 0,
kExprI32Eqz,
kExprIf, kWasmAnyRef,
kExprRefNull,
kExprRefNull, kWasmAnyRef,
kExprElse,
kExprLocalGet, 1,
kExprEnd,
......
test/mjsunit/regress/wasm/regress-7785.js
View file @ dbc8aa87
......@@ -9,7 +9,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
(function testAnyRefNull() {
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_r_v)
.addBody([kExprRefNull])
.addBody([kExprRefNull, kWasmAnyRef])
.exportFunc();
var wire_bytes = builder.toBuffer();
......@@ -24,7 +24,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
(function testAnyRefIsNull() {
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_i_r)
.addBody([kExprLocalGet, 0, kExprRefIsNull])
.addBody([kExprLocalGet, 0, kExprRefIsNull, kWasmAnyRef])
.exportFunc();
var wire_bytes = builder.toBuffer();
......
test/mjsunit/wasm/anyfunc.js
View file @ dbc8aa87
......@@ -152,7 +152,7 @@ load('test/mjsunit/wasm/wasm-module-builder.js');
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_a_a);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kExprLocalSet, 0, kExprLocalGet, 0])
.addBody([kExprRefNull, kWasmAnyFunc, kExprLocalSet, 0, kExprLocalGet, 0])
.exportFunc();
const main = builder.instantiate().exports.main;
......@@ -163,7 +163,9 @@ load('test/mjsunit/wasm/wasm-module-builder.js');
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_a_v);
builder.addFunction('main', sig_index).addBody([kExprRefNull]).exportFunc();
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kWasmAnyFunc])
.exportFunc();
const main = builder.instantiate().exports.main;
assertEquals(null, main());
......@@ -174,7 +176,7 @@ load('test/mjsunit/wasm/wasm-module-builder.js');
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_a_v);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kExprReturn])
.addBody([kExprRefNull, kWasmAnyFunc, kExprReturn])
.exportFunc();
const main = builder.instantiate().exports.main;
......
test/mjsunit/wasm/anyref-globals.js
View file @ dbc8aa87
......@@ -560,21 +560,14 @@ function dummy_func() {
(function TestRefFuncGlobalInit() {
print(arguments.callee.name);
let builder = new WasmModuleBuilder();
const g_ref = builder.addGlobal(kWasmAnyRef, true);
const g_func = builder.addGlobal(kWasmAnyFunc, true);
const f_ref = builder.addFunction('get_anyref_global', kSig_r_v)
.addBody([kExprGlobalGet, g_ref.index])
.exportAs('get_anyref_global');
const f_func = builder.addFunction('get_anyfunc_global', kSig_a_v)
.addBody([kExprGlobalGet, g_func.index])
.exportAs('get_anyfunc_global');
builder.addDeclarativeElementSegment([f_ref.index, f_func.index]);
g_ref.function_index = f_ref.index;
builder.addDeclarativeElementSegment([f_func.index]);
g_func.function_index = f_func.index;
const instance = builder.instantiate();
assertEquals(
instance.exports.get_anyref_global, instance.exports.get_anyref_global());
assertEquals(
instance.exports.get_anyfunc_global,
instance.exports.get_anyfunc_global());
......
test/mjsunit/wasm/anyref.js
View file @ dbc8aa87
......@@ -165,7 +165,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_r_v)
.addBody([kExprRefNull])
.addBody([kExprRefNull, kWasmAnyRef])
.exportFunc();
const instance = builder.instantiate();
......@@ -177,7 +177,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_i_r)
.addBody([kExprLocalGet, 0, kExprRefIsNull])
.addBody([kExprLocalGet, 0, kExprRefIsNull, kWasmAnyRef])
.exportFunc();
const instance = builder.instantiate();
......@@ -196,7 +196,10 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
const builder = new WasmModuleBuilder();
builder.addFunction('main', kSig_i_v)
.addBody([kExprRefNull, kExprRefIsNull])
.addBody([
kExprRefNull, kWasmAnyRef, // --
kExprRefIsNull, kWasmAnyRef // --
])
.exportFunc();
const instance = builder.instantiate();
......@@ -222,7 +225,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_r_v);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull])
.addBody([kExprRefNull, kWasmAnyRef])
.exportFunc();
const main = builder.instantiate().exports.main;
......@@ -234,7 +237,7 @@ load("test/mjsunit/wasm/wasm-module-builder.js");
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_r_v);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kExprReturn])
.addBody([kExprRefNull, kWasmAnyRef, kExprReturn])
.exportFunc();
const main = builder.instantiate().exports.main;
......
test/mjsunit/wasm/exceptions-anyref.js
View file @ dbc8aa87
......@@ -14,7 +14,7 @@ load("test/mjsunit/wasm/exceptions-utils.js");
let except = builder.addException(kSig_v_r);
builder.addFunction("throw_null", kSig_v_v)
.addBody([
kExprRefNull,
kExprRefNull, kWasmAnyRef,
kExprThrow, except,
]).exportFunc();
let instance = builder.instantiate();
......@@ -33,7 +33,7 @@ load("test/mjsunit/wasm/exceptions-utils.js");
kExprLocalGet, 0,
kExprI32Eqz,
kExprIf, kWasmAnyRef,
kExprRefNull,
kExprRefNull, kWasmAnyRef,
kExprThrow, except,
kExprElse,
kExprI32Const, 42,
......@@ -43,7 +43,7 @@ load("test/mjsunit/wasm/exceptions-utils.js");
kExprBrOnExn, 0, except,
kExprRethrow,
kExprEnd,
kExprRefIsNull,
kExprRefIsNull, kWasmAnyRef,
kExprIf, kWasmI32,
kExprI32Const, 23,
kExprElse,
......@@ -191,7 +191,7 @@ load("test/mjsunit/wasm/exceptions-utils.js");
let except = builder.addException(kSig_v_r);
builder.addFunction('br_on_exn_nullref', kSig_v_v)
.addBody([
kExprRefNull,
kExprRefNull, kWasmExnRef,
kExprBrOnExn, 0, except,
kExprDrop
]).exportFunc();
......@@ -240,7 +240,7 @@ load("test/mjsunit/wasm/exceptions-utils.js");
let except = builder.addException(kSig_v_r);
builder.addFunction('rethrow_nullref', kSig_v_v)
.addBody([
kExprRefNull,
kExprRefNull, kWasmExnRef,
kExprRethrow
]).exportFunc();
let instance = builder.instantiate();
......
test/mjsunit/wasm/nullref.js deleted 100644 → 0
View file @ 490f3580
// Copyright 2020 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: --experimental-wasm-anyref --experimental-wasm-eh
load('test/mjsunit/wasm/wasm-module-builder.js');
let kSig_n_n = makeSig([kWasmNullRef], [kWasmNullRef]);
let kSig_r_n = makeSig([kWasmNullRef], [kWasmAnyRef]);
let kSig_a_n = makeSig([kWasmNullRef], [kWasmAnyFunc]);
let kSig_e_n = makeSig([kWasmNullRef], [kWasmExnRef]);
let kSig_n_v = makeSig([], [kWasmNullRef]);
let kSig_n_r = makeSig([kWasmAnyRef], [kWasmNullRef]);
let kSig_n_a = makeSig([kWasmAnyFunc], [kWasmNullRef]);
let kSig_n_e = makeSig([kWasmExnRef], [kWasmNullRef]);
let kSig_v_n = makeSig([kWasmNullRef], []);
let kSig_v_in = makeSig([kWasmI32, kWasmNullRef], []);
let kSig_n_i = makeSig([kWasmI32], [kWasmNullRef]);
let kSig_r_i = makeSig([kWasmI32], [kWasmAnyRef]);
let kSig_e_i = makeSig([kWasmI32], [kWasmExnRef]);
let kSig_n_nni = makeSig([kWasmNullRef, kWasmNullRef, kWasmI32], [kWasmNullRef]);
let kSig_r_nni = makeSig([kWasmNullRef, kWasmNullRef, kWasmI32], [kWasmAnyRef]);
let kSig_a_nni = makeSig([kWasmNullRef, kWasmNullRef, kWasmI32], [kWasmAnyFunc]);
let kSig_e_nni = makeSig([kWasmNullRef, kWasmNullRef, kWasmI32], [kWasmExnRef]);
(function testNullRefIdentityFunction() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
builder.addFunction('nullRef', kSig_n_n)
.addBody([kExprLocalGet, 0])
.exportFunc();
builder.addFunction('anyRef', kSig_r_n)
.addBody([kExprLocalGet, 0])
.exportFunc();
builder.addFunction('funcRef', kSig_a_n)
.addBody([kExprLocalGet, 0])
.exportFunc();
builder.addFunction('exnRef', kSig_e_n)
.addBody([kExprLocalGet, 0])
.exportFunc();
const instance = builder.instantiate();
assertThrows(() => instance.exports.nullRef(a => a), TypeError);
assertThrows(() => instance.exports.nullRef(print), TypeError);
assertThrows(() => instance.exports.nullRef({'hello': 'world'}), TypeError);
assertEquals(null, instance.exports.nullRef(null));
assertEquals(null, instance.exports.anyRef(null));
assertEquals(null, instance.exports.funcRef(null));
assertEquals(null, instance.exports.exnRef(null));
})();
(function testNullRefFromAnyRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_r);
builder.addFunction('main', sig_index)
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testNullRefFromFuncRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_a);
builder.addFunction('main', sig_index)
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testNullRefFromExnRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_e);
builder.addFunction('main', sig_index)
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testNullRefDefaultValue() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addLocals({nullref_count: 1})
.addBody([kExprLocalGet, 0])
.exportFunc();
const main = builder.instantiate().exports.main;
assertEquals(null, main());
})();
(function testNullRefFromAnyRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addLocals({anyref_count: 1})
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testNullRefFromFuncRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addLocals({anyfunc_count: 1})
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testNullRefFromExnRefFail() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addLocals({exnref_count: 1})
.addBody([kExprLocalGet, 0])
.exportFunc();
assertThrows(() => builder.instantiate(), WebAssembly.CompileError);
})();
(function testAssignNullRefToNullRefLocal() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_n);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kExprLocalSet, 0, kExprLocalGet, 0])
.exportFunc();
const main = builder.instantiate().exports.main;
assertEquals(null, main(null));
})();
(function testImplicitReturnNullRefAsNullRef() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull])
.exportFunc();
const main = builder.instantiate().exports.main;
assertEquals(null, main());
})();
(function testExplicitReturnNullRefAsNullRef() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const sig_index = builder.addType(kSig_n_v);
builder.addFunction('main', sig_index)
.addBody([kExprRefNull, kExprReturn])
.exportFunc();
const main = builder.instantiate().exports.main;
assertEquals(null, main());
})();
(function testGetNullRefGlobal() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const initialized = builder.addGlobal(kWasmNullRef, true)
.exportAs('initialized');
initialized.init = null;
const uninitialized = builder.addGlobal(kWasmNullRef, true)
.exportAs('uninitialized');
const sig_n_v = builder.addType(kSig_n_v);
const sig_v_n = builder.addType(kSig_v_n);
const sig_v_v = builder.addType(kSig_v_v);
builder.addFunction('get_initialized', sig_n_v)
.addBody([kExprGlobalGet, initialized.index])
.exportFunc();
builder.addFunction('get_uninitialized', sig_n_v)
.addBody([kExprGlobalGet, initialized.index])
.exportFunc();
builder.addFunction('set_initialized', sig_v_n)
.addBody([kExprLocalGet, 0, kExprGlobalSet, initialized.index])
.exportFunc();
builder.addFunction('reset_initialized', sig_v_v)
.addBody([kExprRefNull, kExprGlobalSet, initialized.index])
.exportFunc();
const instance = builder.instantiate();
assertTrue(instance.exports.initialized instanceof WebAssembly.Global);
assertTrue(instance.exports.uninitialized instanceof WebAssembly.Global);
assertEquals(instance.exports.initialized.value, null);
assertEquals(instance.exports.uninitialized.value, null);
assertEquals(null, instance.exports.get_initialized());
assertEquals(null, instance.exports.get_uninitialized());
instance.exports.set_initialized(null);
assertEquals(instance.exports.initialized.value, null);
assertEquals(null, instance.exports.get_initialized());
instance.exports.reset_initialized();
assertEquals(instance.exports.initialized.value, null);
assertEquals(null, instance.exports.get_initialized());
})();
(function testGetNullRefImportedGlobal() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const global_index = builder.addImportedGlobal("foo", "bar",
kWasmNullRef);
const sig_n_v = builder.addType(kSig_n_v);
const sig_v_n = builder.addType(kSig_v_n);
const sig_v_v = builder.addType(kSig_v_v);
builder.addFunction('get', sig_n_v)
.addBody([kExprGlobalGet, global_index])
.exportFunc();
assertThrows(() => builder.instantiate(), TypeError);
assertThrows(() => builder.instantiate({foo: {}}), WebAssembly.LinkError);
assertThrows(() => builder.instantiate({foo: {bar: {}}}),
WebAssembly.LinkError);
assertThrows(() => builder.instantiate({foo: {bar: a => a}}),
WebAssembly.LinkError);
const instance = builder.instantiate({foo: {bar: null}});
assertEquals(null, instance.exports.get());
})();
(function testNullRefTable() {
print(arguments.callee.name);
let table = new WebAssembly.Table({element: "nullref", initial: 2});
assertEquals(null, table.get(0));
table.set(1, null);
assertEquals(null, table.get(1));
assertThrows(() => table.set(2, null), RangeError);
table.grow(2);
assertEquals(null, table.get(2));
table.set(3, null);
assertEquals(null, table.get(3));
assertThrows(() => table.set(4, null), RangeError);
assertThrows(() => table.set(0, {}), TypeError);
assertThrows(() => table.set(0, a => a), TypeError);
})();
(function testAddNullRefTable() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const table = builder.addTable(kWasmNullRef, 3, 10);
builder.addFunction('set_null', kSig_v_i)
.addBody([kExprLocalGet, 0, kExprRefNull, kExprTableSet, table.index])
.exportFunc();
builder.addFunction('set', kSig_v_in)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprTableSet, table.index])
.exportFunc();
builder.addFunction('get_null', kSig_n_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table.index])
.exportFunc();
builder.addFunction('get_any', kSig_r_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table.index])
.exportFunc();
builder.addFunction('get_func', kSig_a_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table.index])
.exportFunc();
builder.addFunction('get_exn', kSig_e_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table.index])
.exportFunc();
const instance = builder.instantiate();
instance.exports.set_null(1);
instance.exports.set(2, null);
assertEquals(null, instance.exports.get_null(0));
assertEquals(null, instance.exports.get_null(1));
assertEquals(null, instance.exports.get_null(2));
assertEquals(null, instance.exports.get_any(0));
assertEquals(null, instance.exports.get_any(1));
assertEquals(null, instance.exports.get_any(2));
assertEquals(null, instance.exports.get_func(0));
assertEquals(null, instance.exports.get_func(1));
assertEquals(null, instance.exports.get_func(2));
assertEquals(null, instance.exports.get_exn(0));
assertEquals(null, instance.exports.get_exn(1));
assertEquals(null, instance.exports.get_exn(2));
})();
(function testImportNullRefTable() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const table_index = builder.addImportedTable("imp", "table", 2, 10,
kWasmNullRef);
builder.addFunction('get_null', kSig_n_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table_index])
.exportFunc();
builder.addFunction('get_any', kSig_r_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table_index])
.exportFunc();
builder.addFunction('get_func', kSig_a_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table_index])
.exportFunc();
builder.addFunction('get_exn', kSig_e_i)
.addBody([kExprLocalGet, 0, kExprTableGet, table_index])
.exportFunc();
let table_func = new WebAssembly.Table({element: "anyfunc", initial: 2,
maximum: 10});
assertThrows(() => builder.instantiate({imp: {table: table_func}}),
WebAssembly.LinkError, /imported table does not match the expected type/);
let table_any = new WebAssembly.Table({element: "anyref", initial: 2,
maximum: 10});
assertThrows(() => builder.instantiate({imp: {table: table_any}}),
WebAssembly.LinkError, /imported table does not match the expected type/);
let table_null = new WebAssembly.Table({element: "nullref", initial: 2,
maximum: 10});
table_null.set(1, null);
const instance = builder.instantiate({imp: {table: table_null}});
assertEquals(null, instance.exports.get_null(0));
assertEquals(null, instance.exports.get_null(1));
assertEquals(null, instance.exports.get_any(0));
assertEquals(null, instance.exports.get_any(1));
assertEquals(null, instance.exports.get_func(0));
assertEquals(null, instance.exports.get_func(1));
assertEquals(null, instance.exports.get_exn(0));
assertEquals(null, instance.exports.get_exn(1));
assertThrows(() => instance.exports.get_null(2), WebAssembly.RuntimeError);
table_null.grow(1);
assertEquals(null, instance.exports.get_null(2));
})();
(function testImportNullRefTableIntoAnyRefTable() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
const table_index = builder.addImportedTable("imp", "table", 2, 10,
kWasmAnyRef);
builder.addFunction('get', kSig_r_v)
.addBody([kExprI32Const, 0, kExprTableGet, table_index])
.exportFunc();
let table_null = new WebAssembly.Table({element: "nullref", initial: 2,
maximum: 10});
assertThrows(() => builder.instantiate({imp: {table: table_null}}),
WebAssembly.LinkError, /imported table does not match the expected type/);
})();
(function testSelectNullRef() {
print(arguments.callee.name);
const builder = new WasmModuleBuilder();
builder.addFunction('select_null', kSig_n_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmNullRef])
.exportFunc();
builder.addFunction('select_any', kSig_r_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmAnyRef])
.exportFunc();
builder.addFunction('select_func', kSig_a_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmAnyFunc])
.exportFunc();
builder.addFunction('select_exn', kSig_e_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmExnRef])
.exportFunc();
builder.addFunction('select_null_as_any', kSig_r_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmNullRef])
.exportFunc();
builder.addFunction('select_null_as_func', kSig_a_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmNullRef])
.exportFunc();
builder.addFunction('select_null_as_exn', kSig_e_nni)
.addBody([kExprLocalGet, 0, kExprLocalGet, 1, kExprLocalGet, 2,
kExprSelectWithType, 1, kWasmNullRef])
.exportFunc();
const instance = builder.instantiate();
assertEquals(null, instance.exports.select_null(null, null, 0));
assertEquals(null, instance.exports.select_any(null, null, 0));
assertEquals(null, instance.exports.select_func(null, null, 0));
assertEquals(null, instance.exports.select_exn(null, null, 0));
assertEquals(null, instance.exports.select_null_as_any(null, null, 0));
assertEquals(null, instance.exports.select_null_as_func(null, null, 0));
assertEquals(null, instance.exports.select_null_as_exn(null, null, 0));
})();
test/mjsunit/wasm/wasm-module-builder.js
View file @ dbc8aa87
......@@ -1126,18 +1126,23 @@ class WasmModuleBuilder {
data_view.setFloat64(0, global.init, true);
section.emit_bytes(byte_view);
break;
case kWasmAnyFunc:
case kWasmAnyRef:
case kWasmNullRef:
section.emit_u8(kExprRefNull);
section.emit_u8(kWasmAnyRef);
assertEquals(global.function_index, undefined);
break;
case kWasmAnyFunc:
if (global.function_index !== undefined) {
section.emit_u8(kExprRefFunc);
section.emit_u32v(global.function_index);
} else {
section.emit_u8(kExprRefNull);
section.emit_u8(kWasmAnyFunc);
}
break;
case kWasmExnRef:
section.emit_u8(kExprRefNull);
section.emit_u8(kWasmExnRef);
break;
}
} else {
......@@ -1227,6 +1232,7 @@ class WasmModuleBuilder {
for (let index of init.array) {
if (index === null) {
section.emit_u8(kExprRefNull);
section.emit_u8(kWasmAnyFunc);
section.emit_u8(kExprEnd);
} else {
section.emit_u8(kExprRefFunc);
......
test/unittests/wasm/function-body-decoder-unittest.cc
View file @ dbc8aa87
......@@ -306,8 +306,7 @@ TEST_F(FunctionBodyDecoderTest, Int32Const1) {
TEST_F(FunctionBodyDecoderTest, RefNull) {
WASM_FEATURE_SCOPE(anyref);
ExpectValidates(sigs.r_v(), {kExprRefNull});
ExpectValidates(sigs.n_v(), {kExprRefNull});
ExpectValidates(sigs.r_v(), {kExprRefNull, kLocalAnyRef});
}
TEST_F(FunctionBodyDecoderTest, RefFunc) {
......@@ -2667,9 +2666,11 @@ TEST_F(FunctionBodyDecoderTest, SelectWithType) {
ExpectValidates(sigs.l_l(),
{WASM_SELECT_L(WASM_I64V_1(0), WASM_I64V_1(0), WASM_ZERO)});
ExpectValidates(sigs.r_r(),
{WASM_SELECT_R(WASM_REF_NULL, WASM_REF_NULL, WASM_ZERO)});
{WASM_SELECT_R(WASM_REF_NULL(kLocalAnyRef),
WASM_REF_NULL(kLocalAnyRef), WASM_ZERO)});
ExpectValidates(sigs.a_a(),
{WASM_SELECT_A(WASM_REF_NULL, WASM_REF_NULL, WASM_ZERO)});
{WASM_SELECT_A(WASM_REF_NULL(kLocalFuncRef),
WASM_REF_NULL(kLocalFuncRef), WASM_ZERO)});
}
TEST_F(FunctionBodyDecoderTest, SelectWithType_fail) {
......@@ -3209,17 +3210,16 @@ TEST_F(FunctionBodyDecoderTest, TableGrow) {
byte tab_ref = builder.AddTable(kWasmAnyRef, 10, true, 20);
byte tab_null = builder.AddTable(kWasmNullRef, 10, true, 20);
ExpectFailure(sigs.i_a(),
{WASM_TABLE_GROW(tab_func, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(sigs.i_n(),
{WASM_TABLE_GROW(tab_null, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(
sigs.i_a(),
{WASM_TABLE_GROW(tab_func, WASM_REF_NULL(kLocalFuncRef), WASM_ONE)});
WASM_FEATURE_SCOPE(anyref);
ExpectValidates(sigs.i_a(),
{WASM_TABLE_GROW(tab_func, WASM_REF_NULL, WASM_ONE)});
ExpectValidates(sigs.i_r(),
{WASM_TABLE_GROW(tab_ref, WASM_REF_NULL, WASM_ONE)});
ExpectValidates(sigs.i_n(),
{WASM_TABLE_GROW(tab_null, WASM_REF_NULL, WASM_ONE)});
ExpectValidates(
sigs.i_a(),
{WASM_TABLE_GROW(tab_func, WASM_REF_NULL(kLocalFuncRef), WASM_ONE)});
ExpectValidates(
sigs.i_r(),
{WASM_TABLE_GROW(tab_ref, WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
// FuncRef table cannot be initialized with an anyref value.
ExpectFailure(sigs.i_r(),
{WASM_TABLE_GROW(tab_func, WASM_GET_LOCAL(0), WASM_ONE)});
......@@ -3237,8 +3237,9 @@ TEST_F(FunctionBodyDecoderTest, TableGrow) {
ExpectFailure(sigs.i_r(),
{WASM_TABLE_GROW(tab_null, WASM_GET_LOCAL(0), WASM_ONE)});
// Check that the table index gets verified.
ExpectFailure(sigs.i_r(),
{WASM_TABLE_GROW(tab_ref + 2, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(
sigs.i_r(),
{WASM_TABLE_GROW(tab_ref + 2, WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
}
TEST_F(FunctionBodyDecoderTest, TableSize) {
......@@ -3253,19 +3254,17 @@ TEST_F(FunctionBodyDecoderTest, TableSize) {
TEST_F(FunctionBodyDecoderTest, TableFill) {
byte tab_func = builder.AddTable(kWasmFuncRef, 10, true, 20);
byte tab_ref = builder.AddTable(kWasmAnyRef, 10, true, 20);
byte tab_null = builder.AddTable(kWasmNullRef, 10, true, 20);
ExpectFailure(sigs.v_a(),
{WASM_TABLE_FILL(tab_func, WASM_ONE, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(sigs.v_n(),
{WASM_TABLE_FILL(tab_null, WASM_ONE, WASM_REF_NULL, WASM_ONE)});
{WASM_TABLE_FILL(tab_func, WASM_ONE,
WASM_REF_NULL(kLocalFuncRef), WASM_ONE)});
WASM_FEATURE_SCOPE(anyref);
ExpectValidates(sigs.v_a(), {WASM_TABLE_FILL(tab_func, WASM_ONE,
WASM_REF_NULL, WASM_ONE)});
ExpectValidates(sigs.v_r(), {WASM_TABLE_FILL(tab_ref, WASM_ONE, WASM_REF_NULL,
WASM_ONE)});
ExpectValidates(sigs.v_n(), {WASM_TABLE_FILL(tab_null, WASM_ONE,
WASM_REF_NULL, WASM_ONE)});
ExpectValidates(sigs.v_a(),
{WASM_TABLE_FILL(tab_func, WASM_ONE,
WASM_REF_NULL(kLocalFuncRef), WASM_ONE)});
ExpectValidates(sigs.v_r(),
{WASM_TABLE_FILL(tab_ref, WASM_ONE,
WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
// FuncRef table cannot be initialized with an anyref value.
ExpectFailure(sigs.v_r(), {WASM_TABLE_FILL(tab_func, WASM_ONE,
WASM_GET_LOCAL(0), WASM_ONE)});
......@@ -3278,17 +3277,20 @@ TEST_F(FunctionBodyDecoderTest, TableFill) {
ExpectValidates(sigs.v_n(), {WASM_TABLE_FILL(tab_ref, WASM_ONE,
WASM_GET_LOCAL(0), WASM_ONE)});
// Check that the table index gets verified.
ExpectFailure(sigs.v_r(), {WASM_TABLE_FILL(tab_ref + 2, WASM_ONE,
WASM_REF_NULL, WASM_ONE)});
ExpectFailure(sigs.v_r(),
{WASM_TABLE_FILL(tab_ref + 2, WASM_ONE,
WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
}
TEST_F(FunctionBodyDecoderTest, TableOpsWithoutTable) {
{
WASM_FEATURE_SCOPE(anyref);
ExpectFailure(sigs.i_v(), {WASM_TABLE_GROW(0, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(sigs.i_v(),
{WASM_TABLE_GROW(0, WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
ExpectFailure(sigs.i_v(), {WASM_TABLE_SIZE(0)});
ExpectFailure(sigs.i_r(),
{WASM_TABLE_FILL(0, WASM_ONE, WASM_REF_NULL, WASM_ONE)});
ExpectFailure(
sigs.i_r(),
{WASM_TABLE_FILL(0, WASM_ONE, WASM_REF_NULL(kLocalAnyRef), WASM_ONE)});
}
{
WASM_FEATURE_SCOPE(bulk_memory);
......@@ -3519,7 +3521,7 @@ TEST_F(WasmOpcodeLengthTest, Statements) {
TEST_F(WasmOpcodeLengthTest, MiscExpressions) {
ExpectLength(5, kExprF32Const);
ExpectLength(9, kExprF64Const);
ExpectLength(1, kExprRefNull);
ExpectLength(2, kExprRefNull);
ExpectLength(2, kExprLocalGet);
ExpectLength(2, kExprLocalSet);
ExpectLength(2, kExprGlobalGet);
......
test/unittests/wasm/module-decoder-unittest.cc
View file @ dbc8aa87
......@@ -29,11 +29,12 @@ namespace module_decoder_unittest {
#define WASM_INIT_EXPR_F32(val) WASM_F32(val), kExprEnd
#define WASM_INIT_EXPR_I64(val) WASM_I64(val), kExprEnd
#define WASM_INIT_EXPR_F64(val) WASM_F64(val), kExprEnd
#define WASM_INIT_EXPR_REF_NULL WASM_REF_NULL, kExprEnd
#define WASM_INIT_EXPR_ANY_REF_NULL WASM_REF_NULL(kLocalAnyRef), kExprEnd
#define WASM_INIT_EXPR_FUNC_REF_NULL WASM_REF_NULL(kLocalFuncRef), kExprEnd
#define WASM_INIT_EXPR_REF_FUNC(val) WASM_REF_FUNC(val), kExprEnd
#define WASM_INIT_EXPR_GLOBAL(index) WASM_GET_GLOBAL(index), kExprEnd
#define REF_NULL_ELEMENT kExprRefNull, kExprEnd
#define REF_NULL_ELEMENT kExprRefNull, kLocalFuncRef, kExprEnd
#define REF_FUNC_ELEMENT(v) kExprRefFunc, U32V_1(v), kExprEnd
#define EMPTY_BODY 0
......@@ -269,8 +270,8 @@ TEST_F(WasmModuleVerifyTest, AnyRefGlobal) {
ENTRY_COUNT(2), // --
kLocalAnyRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_NULL, // init
kLocalAnyRef, // local type
WASM_INIT_EXPR_ANY_REF_NULL, // init
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_FUNC(1)), // init
SECTION(Element, // section name
......@@ -299,7 +300,7 @@ TEST_F(WasmModuleVerifyTest, AnyRefGlobal) {
EXPECT_EQ(WasmInitExpr::kRefNullConst, global->init.kind);
global = &result.value()->globals[1];
EXPECT_EQ(kWasmAnyRef, global->type);
EXPECT_EQ(kWasmFuncRef, global->type);
EXPECT_FALSE(global->mutability);
EXPECT_EQ(WasmInitExpr::kRefFuncConst, global->init.kind);
EXPECT_EQ(uint32_t{1}, global->init.val.function_index);
......@@ -314,24 +315,24 @@ TEST_F(WasmModuleVerifyTest, FuncRefGlobal) {
SIGNATURES_SECTION_VOID_VOID,
// funcs ---------------------------------------------------------------
TWO_EMPTY_FUNCTIONS(SIG_INDEX(0)),
SECTION(Global, // --
ENTRY_COUNT(2), // --
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_NULL, // init
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_FUNC(1)), // init
SECTION(Element, // section name
ENTRY_COUNT(2), // entry count
DECLARATIVE, // flags 0
kExternalFunction, // type
ENTRY_COUNT(1), // func entry count
FUNC_INDEX(0), // func index
DECLARATIVE_WITH_ELEMENTS, // flags 1
kLocalFuncRef, // local type
ENTRY_COUNT(1), // func ref count
REF_FUNC_ELEMENT(1)), // func ref
SECTION(Global, // --
ENTRY_COUNT(2), // --
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_FUNC_REF_NULL, // init
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_FUNC(1)), // init
SECTION(Element, // section name
ENTRY_COUNT(2), // entry count
DECLARATIVE, // flags 0
kExternalFunction, // type
ENTRY_COUNT(1), // func entry count
FUNC_INDEX(0), // func index
DECLARATIVE_WITH_ELEMENTS, // flags 1
kLocalFuncRef, // local type
ENTRY_COUNT(1), // func ref count
REF_FUNC_ELEMENT(1)), // func ref
TWO_EMPTY_BODIES};
{
// Should decode to two globals.
......@@ -354,34 +355,6 @@ TEST_F(WasmModuleVerifyTest, FuncRefGlobal) {
}
}
TEST_F(WasmModuleVerifyTest, NullRefGlobal) {
WASM_FEATURE_SCOPE(anyref);
static const byte data[] = {
// sig#0 ---------------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// funcs ---------------------------------------------------------------
TWO_EMPTY_FUNCTIONS(SIG_INDEX(0)),
SECTION(Global, // --
ENTRY_COUNT(1), // --
kLocalNullRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_NULL), // init
TWO_EMPTY_BODIES};
{
// Should decode to one global.
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_OK(result);
EXPECT_EQ(1u, result.value()->globals.size());
EXPECT_EQ(2u, result.value()->functions.size());
EXPECT_EQ(0u, result.value()->data_segments.size());
const WasmGlobal* global = &result.value()->globals[0];
EXPECT_EQ(kWasmNullRef, global->type);
EXPECT_FALSE(global->mutability);
EXPECT_EQ(WasmInitExpr::kRefNullConst, global->init.kind);
}
}
TEST_F(WasmModuleVerifyTest, InvalidFuncRefGlobal) {
WASM_FEATURE_SCOPE(anyref);
static const byte data[] = {
......@@ -398,27 +371,6 @@ TEST_F(WasmModuleVerifyTest, InvalidFuncRefGlobal) {
EXPECT_FAILURE(data);
}
TEST_F(WasmModuleVerifyTest, InvalidNullRefGlobal) {
WASM_FEATURE_SCOPE(anyref);
// Initialize nullref from funcref
static const byte data[] = {
// sig#0 ---------------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// funcs ---------------------------------------------------------------
TWO_EMPTY_FUNCTIONS(SIG_INDEX(0)),
SECTION(Global, // --
ENTRY_COUNT(1), // --
kLocalNullRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_FUNC(1)), // init
TWO_EMPTY_BODIES};
ModuleResult result = DecodeModule(data, data + sizeof(data));
EXPECT_NOT_OK(
result,
"type error in global initialization, expected nullref, got funcref");
}
TEST_F(WasmModuleVerifyTest, AnyRefGlobalWithGlobalInit) {
WASM_FEATURE_SCOPE(anyref);
static const byte data[] = {
......@@ -2337,7 +2289,7 @@ TEST_F(WasmInitExprDecodeTest, InitExpr_f64) {
TEST_F(WasmInitExprDecodeTest, InitExpr_AnyRef) {
WASM_FEATURE_SCOPE(anyref);
static const byte data[] = {kExprRefNull, kExprEnd};
static const byte data[] = {kExprRefNull, kLocalAnyRef, kExprEnd};
WasmInitExpr expr = DecodeInitExpr(data, data + sizeof(data));
EXPECT_EQ(WasmInitExpr::kRefNullConst, expr.kind);
}
......@@ -2623,7 +2575,7 @@ TEST_F(WasmModuleVerifyTest, DeclarativeElementSegmentMissingForGlobal) {
// global definitions ----------------------------------------------------
SECTION(Global, // section name
ENTRY_COUNT(1), // entry count
kLocalAnyRef, // local type
kLocalFuncRef, // local type
0, // immutable
WASM_INIT_EXPR_REF_FUNC(0)), // init
// code ------------------------------------------------------------------
......@@ -2734,7 +2686,8 @@ TEST_F(WasmModuleVerifyTest, DataCountSegmentCount_omitted) {
#undef WASM_INIT_EXPR_F32
#undef WASM_INIT_EXPR_I64
#undef WASM_INIT_EXPR_F64
#undef WASM_INIT_EXPR_REF_NULL
#undef WASM_INIT_EXPR_ANY_REF_NULL
#undef WASM_INIT_EXPR_FUNC_REF_NULL
#undef WASM_INIT_EXPR_REF_FUNC
#undef WASM_INIT_EXPR_GLOBAL
#undef REF_NULL_ELEMENT
......
test/wasm-api-tests/hostref.cc
View file @ dbc8aa87
......@@ -34,7 +34,7 @@ TEST_F(WasmCapiTest, HostRef) {
FunctionSig r_i_sig(1, 1, ri_reps);
uint32_t func_index = builder()->AddImport(CStrVector("f"), &r_r_sig);
const bool kMutable = true;
const WasmInitExpr global_init(WasmInitExpr::kRefNullConst, 0);
const WasmInitExpr global_init(WasmInitExpr::kRefNullConst);
uint32_t global_index = builder()->AddExportedGlobal(
kWasmAnyRef, kMutable, global_init, CStrVector("global"));
uint32_t table_index = builder()->AddTable(kWasmAnyRef, 10);
......
test/wasm-spec-tests/wasm-spec-tests.status
View file @ dbc8aa87
......@@ -21,23 +21,10 @@
'proposals/js-types/linking': [FAIL],
# TODO(v8:10556): Remove sub-typing in the reference-types implementation
'proposals/bulk-memory-operations/binary': [FAIL],
'proposals/bulk-memory-operations/bulk': [FAIL],
'proposals/bulk-memory-operations/elem': [FAIL],
'proposals/bulk-memory-operations/imports': [FAIL],
'proposals/reference-types/binary': [FAIL],
'proposals/reference-types/bulk': [FAIL],
'proposals/reference-types/elem': [FAIL],
'proposals/reference-types/global': [FAIL],
'proposals/reference-types/linking': [FAIL],
'proposals/reference-types/ref_func': [FAIL],
'proposals/reference-types/ref_is_null': [FAIL],
'proposals/reference-types/ref_null': [FAIL],
'proposals/reference-types/table_get': [FAIL],
'proposals/reference-types/table_grow': [FAIL],
'proposals/reference-types/table_set': [FAIL],
'proposals/reference-types/table_size': [FAIL],
'proposals/reference-types/unreached-invalid': [FAIL],
# TODO(wasm): This test declares a table larger than allowed by the spec.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment