Merge pull request #104 from gahaas/fix-machine-type
Adjustments due to changes of MachineType in V8.
diff --git a/src/wasm/asm-wasm-builder.cc b/src/wasm/asm-wasm-builder.cc
index 4822d04..88ec408 100644
--- a/src/wasm/asm-wasm-builder.cc
+++ b/src/wasm/asm-wasm-builder.cc
@@ -403,31 +403,31 @@
MachineType mtype;
int size;
if (type->Is(cache_.kUint8Array)) {
- mtype = kMachUint8;
+ mtype = MachineType::Uint8();
size = 1;
} else if (type->Is(cache_.kInt8Array)) {
- mtype = kMachInt8;
+ mtype = MachineType::Int8();
size = 1;
} else if (type->Is(cache_.kUint16Array)) {
- mtype = kMachUint16;
+ mtype = MachineType::Uint16();
size = 2;
} else if (type->Is(cache_.kInt16Array)) {
- mtype = kMachInt16;
+ mtype = MachineType::Int16();
size = 2;
} else if (type->Is(cache_.kUint32Array)) {
- mtype = kMachUint32;
+ mtype = MachineType::Uint32();
size = 4;
} else if (type->Is(cache_.kInt32Array)) {
- mtype = kMachInt32;
+ mtype = MachineType::Int32();
size = 4;
} else if (type->Is(cache_.kUint32Array)) {
- mtype = kMachUint32;
+ mtype = MachineType::Uint32();
size = 4;
} else if (type->Is(cache_.kFloat32Array)) {
- mtype = kMachFloat32;
+ mtype = MachineType::Float32();
size = 4;
} else if (type->Is(cache_.kFloat64Array)) {
- mtype = kMachFloat64;
+ mtype = MachineType::Float64();
size = 8;
} else {
UNREACHABLE();
@@ -855,7 +855,8 @@
ZoneHashMap::Entry* entry =
global_variables_.Lookup(v, ComputePointerHash(v));
if (entry == NULL) {
- uint16_t index = builder_->AddGlobal(type, 0);
+ uint16_t index =
+ builder_->AddGlobal(WasmOpcodes::MachineTypeFor(type), 0);
IndexContainer* container = new (zone()) IndexContainer();
container->index = index;
entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v),
diff --git a/src/wasm/ast-decoder.cc b/src/wasm/ast-decoder.cc
index 0ea91ea..c2541d1 100644
--- a/src/wasm/ast-decoder.cc
+++ b/src/wasm/ast-decoder.cc
@@ -918,58 +918,58 @@
}
case kExprI32LoadMem8S:
- return ReduceLoadMem(p, kAstI32, kMachInt8);
+ return ReduceLoadMem(p, kAstI32, MachineType::Int8());
case kExprI32LoadMem8U:
- return ReduceLoadMem(p, kAstI32, kMachUint8);
+ return ReduceLoadMem(p, kAstI32, MachineType::Uint8());
case kExprI32LoadMem16S:
- return ReduceLoadMem(p, kAstI32, kMachInt16);
+ return ReduceLoadMem(p, kAstI32, MachineType::Int16());
case kExprI32LoadMem16U:
- return ReduceLoadMem(p, kAstI32, kMachUint16);
+ return ReduceLoadMem(p, kAstI32, MachineType::Uint16());
case kExprI32LoadMem:
- return ReduceLoadMem(p, kAstI32, kMachInt32);
+ return ReduceLoadMem(p, kAstI32, MachineType::Int32());
case kExprI64LoadMem8S:
- return ReduceLoadMem(p, kAstI64, kMachInt8);
+ return ReduceLoadMem(p, kAstI64, MachineType::Int8());
case kExprI64LoadMem8U:
- return ReduceLoadMem(p, kAstI64, kMachUint8);
+ return ReduceLoadMem(p, kAstI64, MachineType::Uint8());
case kExprI64LoadMem16S:
- return ReduceLoadMem(p, kAstI64, kMachInt16);
+ return ReduceLoadMem(p, kAstI64, MachineType::Int16());
case kExprI64LoadMem16U:
- return ReduceLoadMem(p, kAstI64, kMachUint16);
+ return ReduceLoadMem(p, kAstI64, MachineType::Uint16());
case kExprI64LoadMem32S:
- return ReduceLoadMem(p, kAstI64, kMachInt32);
+ return ReduceLoadMem(p, kAstI64, MachineType::Int32());
case kExprI64LoadMem32U:
- return ReduceLoadMem(p, kAstI64, kMachUint32);
+ return ReduceLoadMem(p, kAstI64, MachineType::Uint32());
case kExprI64LoadMem:
- return ReduceLoadMem(p, kAstI64, kMachInt64);
+ return ReduceLoadMem(p, kAstI64, MachineType::Int64());
case kExprF32LoadMem:
- return ReduceLoadMem(p, kAstF32, kMachFloat32);
+ return ReduceLoadMem(p, kAstF32, MachineType::Float32());
case kExprF64LoadMem:
- return ReduceLoadMem(p, kAstF64, kMachFloat64);
+ return ReduceLoadMem(p, kAstF64, MachineType::Float64());
case kExprI32StoreMem8:
- return ReduceStoreMem(p, kAstI32, kMachInt8);
+ return ReduceStoreMem(p, kAstI32, MachineType::Int8());
case kExprI32StoreMem16:
- return ReduceStoreMem(p, kAstI32, kMachInt16);
+ return ReduceStoreMem(p, kAstI32, MachineType::Int16());
case kExprI32StoreMem:
- return ReduceStoreMem(p, kAstI32, kMachInt32);
+ return ReduceStoreMem(p, kAstI32, MachineType::Int32());
case kExprI64StoreMem8:
- return ReduceStoreMem(p, kAstI64, kMachInt8);
+ return ReduceStoreMem(p, kAstI64, MachineType::Int8());
case kExprI64StoreMem16:
- return ReduceStoreMem(p, kAstI64, kMachInt16);
+ return ReduceStoreMem(p, kAstI64, MachineType::Int16());
case kExprI64StoreMem32:
- return ReduceStoreMem(p, kAstI64, kMachInt32);
+ return ReduceStoreMem(p, kAstI64, MachineType::Int32());
case kExprI64StoreMem:
- return ReduceStoreMem(p, kAstI64, kMachInt64);
+ return ReduceStoreMem(p, kAstI64, MachineType::Int64());
case kExprF32StoreMem:
- return ReduceStoreMem(p, kAstF32, kMachFloat32);
+ return ReduceStoreMem(p, kAstF32, MachineType::Float32());
case kExprF64StoreMem:
- return ReduceStoreMem(p, kAstF64, kMachFloat64);
+ return ReduceStoreMem(p, kAstF64, MachineType::Float64());
case kExprGrowMemory:
TypeCheckLast(p, kAstI32);
diff --git a/src/wasm/module-decoder.cc b/src/wasm/module-decoder.cc
index eef8d71..9c6d40a 100644
--- a/src/wasm/module-decoder.cc
+++ b/src/wasm/module-decoder.cc
@@ -139,7 +139,7 @@
if (failed()) break;
TRACE("DecodeGlobal[%d] module+%d\n", i,
static_cast<int>(pc_ - start_));
- module->globals->push_back({0, kMachInt32, 0, false});
+ module->globals->push_back({0, MachineType::Int32(), 0, false});
WasmGlobal* global = &module->globals->back();
DecodeGlobalInModule(global);
}
@@ -425,28 +425,28 @@
MemTypeCode t = static_cast<MemTypeCode>(val);
switch (t) {
case kMemI8:
- return kMachInt8;
+ return MachineType::Int8();
case kMemU8:
- return kMachUint8;
+ return MachineType::Uint8();
case kMemI16:
- return kMachInt16;
+ return MachineType::Int16();
case kMemU16:
- return kMachUint16;
+ return MachineType::Uint16();
case kMemI32:
- return kMachInt32;
+ return MachineType::Int32();
case kMemU32:
- return kMachUint32;
+ return MachineType::Uint32();
case kMemI64:
- return kMachInt64;
+ return MachineType::Int64();
case kMemU64:
- return kMachUint64;
+ return MachineType::Uint64();
case kMemF32:
- return kMachFloat32;
+ return MachineType::Float32();
case kMemF64:
- return kMachFloat64;
+ return MachineType::Float64();
default:
error(pc_ - 1, "invalid memory type");
- return kMachNone;
+ return MachineType::None();
}
}
diff --git a/src/wasm/wasm-compiler.cc b/src/wasm/wasm-compiler.cc
index 9388b11..c927fc6 100644
--- a/src/wasm/wasm-compiler.cc
+++ b/src/wasm/wasm-compiler.cc
@@ -375,7 +375,7 @@
Node* rem =
graph->graph()->NewNode(m->Int32Mod(), left, right, d.if_false);
- return d.Phi(kMachInt32, graph->Int32Constant(0), rem);
+ return d.Phi(MachineRepresentation::kWord32, graph->Int32Constant(0), rem);
}
case wasm::kExprI32RemU:
op = m->Uint32Mod();
@@ -476,7 +476,7 @@
Node* rem =
graph->graph()->NewNode(m->Int64Mod(), left, right, d.if_false);
- return d.Phi(kMachInt64, graph->Int64Constant(0), rem);
+ return d.Phi(MachineRepresentation::kWord64, graph->Int64Constant(0), rem);
}
case wasm::kExprI64RemU:
op = m->Uint64Mod();
@@ -1215,7 +1215,7 @@
const int fixed_offset = access.header_size - access.tag();
{
Node* load_sig =
- g->NewNode(machine->Load(kMachAnyTagged), table,
+ g->NewNode(machine->Load(MachineType::AnyTagged()), table,
g->NewNode(machine->Int32Add(),
g->NewNode(machine->Word32Shl(), key,
Int32Constant(kPointerSizeLog2)),
@@ -1229,7 +1229,7 @@
// Load code object from the table.
int offset = fixed_offset + kPointerSize * table_size;
Node* load_code =
- g->NewNode(machine->Load(kMachAnyTagged), table,
+ g->NewNode(machine->Load(MachineType::AnyTagged()), table,
g->NewNode(machine->Int32Add(),
g->NewNode(machine->Word32Shl(), key,
Int32Constant(kPointerSizeLog2)),
@@ -1528,9 +1528,9 @@
*effect = load;
- if (type == wasm::kAstI64 && ElementSizeLog2Of(memtype) < 3) {
+ if (type == wasm::kAstI64 && ElementSizeLog2Of(memtype.representation()) < 3) {
// TODO(titzer): TF zeroes the upper bits of 64-bit loads for subword sizes.
- if (TypeOf(memtype) == kTypeInt32) {
+ if (memtype.IsSigned()) {
// sign extend
load = g->NewNode(graph->machine()->ChangeInt32ToInt64(), load);
} else {
@@ -1777,7 +1777,8 @@
Graph graph(&zone);
CommonOperatorBuilder common(&zone);
MachineOperatorBuilder machine(
- &zone, kMachPtr, InstructionSelector::SupportedMachineOperatorFlags());
+ &zone, MachineType::PointerRepresentation(),
+ InstructionSelector::SupportedMachineOperatorFlags());
JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
WasmGraphBuilder builder(&zone, &jsgraph);
wasm::TreeResult result = wasm::BuildTFGraph(
diff --git a/src/wasm/wasm-linkage.cc b/src/wasm/wasm-linkage.cc
index dc57325..ecabb66 100644
--- a/src/wasm/wasm-linkage.cc
+++ b/src/wasm/wasm-linkage.cc
@@ -23,16 +23,16 @@
MachineType MachineTypeFor(LocalType type) {
switch (type) {
case kAstI32:
- return kMachInt32;
+ return MachineType::Int32();
case kAstI64:
- return kMachInt64;
+ return MachineType::Int64();
case kAstF64:
- return kMachFloat64;
+ return MachineType::Float64();
case kAstF32:
- return kMachFloat32;
+ return MachineType::Float32();
default:
UNREACHABLE();
- return kMachAnyTagged;
+ return MachineType::AnyTagged();
}
}
@@ -250,7 +250,7 @@
const RegList kCalleeSaveFPRegisters = 0;
// The target for WASM calls is always a code object.
- MachineType target_type = kMachAnyTagged;
+ MachineType target_type = MachineType::AnyTagged();
LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
return new (zone) CallDescriptor( // --
CallDescriptor::kCallCodeObject, // kind
diff --git a/src/wasm/wasm-opcodes.h b/src/wasm/wasm-opcodes.h
index db835d1..b5a3426 100644
--- a/src/wasm/wasm-opcodes.h
+++ b/src/wasm/wasm-opcodes.h
@@ -37,13 +37,14 @@
// We reuse the internal machine type to represent WebAssembly AST types.
// A typedef improves readability without adding a whole new type system.
-typedef MachineType LocalType;
-const LocalType kAstStmt = kMachNone;
-const LocalType kAstI32 = kMachInt32;
-const LocalType kAstI64 = kMachInt64;
-const LocalType kAstF32 = kMachFloat32;
-const LocalType kAstF64 = kMachFloat64;
-const LocalType kAstEnd = kTypeAny;
+typedef MachineRepresentation LocalType;
+const LocalType kAstStmt = MachineRepresentation::kNone;
+const LocalType kAstI32 = MachineRepresentation::kWord32;
+const LocalType kAstI64 = MachineRepresentation::kWord64;
+const LocalType kAstF32 = MachineRepresentation::kFloat32;
+const LocalType kAstF64 = MachineRepresentation::kFloat64;
+// We use kTagged here because kNone is already used by kAstStmt.
+const LocalType kAstEnd = MachineRepresentation::kTagged;
// Functionality related to encoding memory accesses.
struct MemoryAccess {
@@ -303,7 +304,9 @@
static const char* OpcodeName(WasmOpcode opcode);
static FunctionSig* Signature(WasmOpcode opcode);
- static byte MemSize(MachineType type) { return ElementSizeOf(type); }
+ static byte MemSize(MachineType type) {
+ return 1 << ElementSizeLog2Of(type.representation());
+ }
static LocalTypeCode LocalTypeCodeFor(LocalType type) {
switch (type) {
@@ -324,79 +327,102 @@
}
static MemTypeCode MemTypeCodeFor(MachineType type) {
+ if (type == MachineType::Int8()) {
+ return kMemI8;
+ } else if (type == MachineType::Uint8()) {
+ return kMemU8;
+ } else if (type == MachineType::Int16()) {
+ return kMemI16;
+ } else if (type == MachineType::Uint16()) {
+ return kMemU16;
+ } else if (type == MachineType::Int32()) {
+ return kMemI32;
+ } else if (type == MachineType::Uint32()) {
+ return kMemU32;
+ } else if (type == MachineType::Int64()) {
+ return kMemI64;
+ } else if (type == MachineType::Uint64()) {
+ return kMemU64;
+ } else if (type == MachineType::Float32()) {
+ return kMemF32;
+ } else if (type == MachineType::Float64()) {
+ return kMemF64;
+ } else {
+ UNREACHABLE();
+ return kMemI32;
+ }
+ }
+
+ static MachineType MachineTypeFor(LocalType type) {
switch (type) {
- case kMachInt8:
- return kMemI8;
- case kMachUint8:
- return kMemU8;
- case kMachInt16:
- return kMemI16;
- case kMachUint16:
- return kMemU16;
- case kMachInt32:
- return kMemI32;
- case kMachUint32:
- return kMemU32;
- case kMachInt64:
- return kMemI64;
- case kMachUint64:
- return kMemU64;
- case kMachFloat32:
- return kMemF32;
- case kMachFloat64:
- return kMemF64;
+ case kAstI32:
+ return MachineType::Int32();
+ case kAstI64:
+ return MachineType::Int64();
+ case kAstF32:
+ return MachineType::Float32();
+ case kAstF64:
+ return MachineType::Float64();
+ case kAstStmt:
+ return MachineType::None();
default:
UNREACHABLE();
- return kMemI32;
+ return MachineType::None();
}
}
static LocalType LocalTypeFor(MachineType type) {
- switch (type) {
- case kMachInt8:
- case kMachUint8:
- case kMachInt16:
- case kMachUint16:
- case kMachInt32:
- case kMachUint32:
- return kAstI32;
- case kMachInt64:
- case kMachUint64:
- return kAstI64;
- case kMachFloat32:
- return kAstF32;
- case kMachFloat64:
- return kAstF64;
- default:
- UNREACHABLE();
- return kAstI32;
+ if (type == MachineType::Int8()) {
+ return kAstI32;
+ } else if (type == MachineType::Uint8()) {
+ return kAstI32;
+ } else if (type == MachineType::Int16()) {
+ return kAstI32;
+ } else if (type == MachineType::Uint16()) {
+ return kAstI32;
+ } else if (type == MachineType::Int32()) {
+ return kAstI32;
+ } else if (type == MachineType::Uint32()) {
+ return kAstI32;
+ } else if (type == MachineType::Int64()) {
+ return kAstI64;
+ } else if (type == MachineType::Uint64()) {
+ return kAstI64;
+ } else if (type == MachineType::Float32()) {
+ return kAstF32;
+ } else if (type == MachineType::Float64()) {
+ return kAstF64;
+ } else {
+ UNREACHABLE();
+ return kAstI32;
}
}
// TODO(titzer): remove this method
static WasmOpcode LoadStoreOpcodeOf(MachineType type, bool store) {
- switch (type) {
- case kMachInt8:
- return store ? kExprI32StoreMem8 : kExprI32LoadMem8S;
- case kMachUint8:
- return store ? kExprI32StoreMem8 : kExprI32LoadMem8U;
- case kMachInt16:
- return store ? kExprI32StoreMem16 : kExprI32LoadMem16S;
- case kMachUint16:
- return store ? kExprI32StoreMem16 : kExprI32LoadMem16U;
- case kMachInt32:
- case kMachUint32:
- return store ? kExprI32StoreMem : kExprI32LoadMem;
- case kMachInt64:
- case kMachUint64:
- return store ? kExprI64StoreMem : kExprI64LoadMem;
- case kMachFloat32:
- return store ? kExprF32StoreMem : kExprF32LoadMem;
- case kMachFloat64:
- return store ? kExprF64StoreMem : kExprF64LoadMem;
- default:
- UNREACHABLE();
- return kExprNop;
+ if (type == MachineType::Int8()) {
+ return store ? kExprI32StoreMem8 : kExprI32LoadMem8S;
+ } else if (type == MachineType::Uint8()) {
+ return store ? kExprI32StoreMem8 : kExprI32LoadMem8U;
+ } else if (type == MachineType::Int16()) {
+ return store ? kExprI32StoreMem16 : kExprI32LoadMem16S;
+ } else if (type == MachineType::Uint16()) {
+ return store ? kExprI32StoreMem16 : kExprI32LoadMem16U;
+ } else if (type == MachineType::Int32()) {
+ return store ? kExprI32StoreMem : kExprI32LoadMem;
+ } else if (type == MachineType::Uint32()) {
+ return store ? kExprI32StoreMem : kExprI32LoadMem;
+ } else if (type == MachineType::Int64()) {
+ return store ? kExprI64StoreMem : kExprI64LoadMem;
+ } else if (type == MachineType::Uint64()) {
+ return store ? kExprI64StoreMem : kExprI64LoadMem;
+ } else if (type == MachineType::Float32()) {
+ return store ? kExprF32StoreMem : kExprF32LoadMem;
+ } else if (type == MachineType::Float64()) {
+ return store ? kExprF64StoreMem : kExprF64LoadMem;
+ } else {
+ UNREACHABLE();
+ return kExprNop;
}
}
diff --git a/test/cctest/wasm/test-run-wasm-module.cc b/test/cctest/wasm/test-run-wasm-module.cc
index c5688f9..0d51c78 100644
--- a/test/cctest/wasm/test-run-wasm-module.cc
+++ b/test/cctest/wasm/test-run-wasm-module.cc
@@ -107,7 +107,7 @@
f->ReturnType(kAstI32);
f->Exported(1);
byte code[] = {
- WASM_LOAD_MEM(kMachInt32, WASM_I8(kDataSegmentDest0))};
+ WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kDataSegmentDest0))};
f->EmitCode(code, sizeof(code));
byte data[] = {0xaa, 0xbb, 0xcc, 0xdd};
builder->AddDataSegment(
@@ -131,7 +131,8 @@
WASM_BLOCK(2,
WASM_WHILE(
WASM_I32_LTS(WASM_GET_LOCAL(localIndex), WASM_I32(kCheckSize)),
- WASM_IF_ELSE(WASM_LOAD_MEM(kMachInt32, WASM_GET_LOCAL(localIndex)),
+ WASM_IF_ELSE(WASM_LOAD_MEM(MachineType::Int32(),
+ WASM_GET_LOCAL(localIndex)),
WASM_BRV(2, WASM_I8(-1)),
WASM_INC_LOCAL_BY(localIndex, 4))),
WASM_I8(11))};
@@ -153,11 +154,12 @@
byte code[] = {
WASM_BLOCK(
2,
- WASM_SET_LOCAL(localIndex, WASM_LOAD_MEM(kMachInt32, WASM_ZERO)),
+ WASM_SET_LOCAL(localIndex, WASM_LOAD_MEM(MachineType::Int32(),
+ WASM_ZERO)),
WASM_IF_ELSE(WASM_I32_LTS(WASM_GET_LOCAL(localIndex), WASM_I8(5)),
WASM_BLOCK(2,
- WASM_STORE_MEM(kMachInt32, WASM_ZERO,
- WASM_INC_LOCAL(localIndex)),
+ WASM_STORE_MEM(MachineType::Int32(),
+ WASM_ZERO, WASM_INC_LOCAL(localIndex)),
WASM_BRV(1, WASM_CALL_FUNCTION0(0))),
WASM_BRV(0, WASM_I8(55))))
};
@@ -171,8 +173,8 @@
TEST(Run_WasmModule_Global) {
Zone zone;
WasmModuleBuilder* builder = new(&zone) WasmModuleBuilder(&zone);
- uint32_t global1 = builder->AddGlobal(kMachInt32, 0);
- uint32_t global2 = builder->AddGlobal(kMachInt32, 0);
+ uint32_t global1 = builder->AddGlobal(MachineType::Int32(), 0);
+ uint32_t global2 = builder->AddGlobal(MachineType::Int32(), 0);
uint16_t f1_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f1_index);
f->ReturnType(kAstI32);
diff --git a/test/cctest/wasm/test-run-wasm.cc b/test/cctest/wasm/test-run-wasm.cc
index 2ddbc7f..b87166c 100644
--- a/test/cctest/wasm/test-run-wasm.cc
+++ b/test/cctest/wasm/test-run-wasm.cc
@@ -274,9 +274,11 @@
template <typename ReturnType>
class WasmRunner {
public:
- WasmRunner(MachineType p0 = kMachNone, MachineType p1 = kMachNone,
- MachineType p2 = kMachNone, MachineType p3 = kMachNone) :
- signature_(MachineTypeForC<ReturnType>() == kMachNone ? 0 : 1,
+ WasmRunner(MachineType p0 = MachineType::None(),
+ MachineType p1 = MachineType::None(),
+ MachineType p2 = MachineType::None(),
+ MachineType p3 = MachineType::None()) :
+ signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
GetParameterCount(p0, p1, p2, p3),
storage_),
compiler_(&signature_),
@@ -285,13 +287,17 @@
int index = 0;
MachineType ret = MachineTypeForC<ReturnType>();
- if (ret != kMachNone) {
+ if (ret != MachineType::None()) {
storage_[index++] = WasmOpcodes::LocalTypeFor(ret);
}
- if (p0 != kMachNone) storage_[index++] = WasmOpcodes::LocalTypeFor(p0);
- if (p1 != kMachNone) storage_[index++] = WasmOpcodes::LocalTypeFor(p1);
- if (p2 != kMachNone) storage_[index++] = WasmOpcodes::LocalTypeFor(p2);
- if (p3 != kMachNone) storage_[index++] = WasmOpcodes::LocalTypeFor(p3);
+ if (p0 != MachineType::None())
+ storage_[index++] = WasmOpcodes::LocalTypeFor(p0);
+ if (p1 != MachineType::None())
+ storage_[index++] = WasmOpcodes::LocalTypeFor(p1);
+ if (p2 != MachineType::None())
+ storage_[index++] = WasmOpcodes::LocalTypeFor(p2);
+ if (p3 != MachineType::None())
+ storage_[index++] = WasmOpcodes::LocalTypeFor(p3);
}
@@ -372,10 +378,10 @@
static size_t GetParameterCount(MachineType p0, MachineType p1,
MachineType p2, MachineType p3) {
- if (p0 == kMachNone) return 0;
- if (p1 == kMachNone) return 1;
- if (p2 == kMachNone) return 2;
- if (p3 == kMachNone) return 3;
+ if (p0 == MachineType::None()) return 0;
+ if (p1 == MachineType::None()) return 1;
+ if (p2 == MachineType::None()) return 2;
+ if (p3 == MachineType::None()) return 3;
return 4;
}
};
@@ -480,7 +486,7 @@
TEST(Run_WasmInt32Param0) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// return(local[0])
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
@@ -488,7 +494,7 @@
TEST(Run_WasmInt32Param0_fallthru) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// local[0]
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
@@ -496,7 +502,7 @@
TEST(Run_WasmInt32Param1) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
// local[1]
BUILD(r, WASM_GET_LOCAL(1));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); }
@@ -512,7 +518,7 @@
TEST(Run_WasmInt32Add_P) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// p0 + 13
BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
@@ -520,7 +526,7 @@
TEST(Run_WasmInt32Add_P_fallthru) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// p0 + 13
BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
@@ -528,7 +534,7 @@
TEST(Run_WasmInt32Add_P2) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
// p0 + p1
BUILD(r, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT32_INPUTS(i) {
@@ -567,7 +573,7 @@
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
// a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
@@ -612,7 +618,7 @@
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// return op a
BUILD(r, WASM_UNOP(opcode, WASM_GET_LOCAL(0)));
CHECK_EQ(expected, r.Call(a));
@@ -713,7 +719,7 @@
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
@@ -730,7 +736,7 @@
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
@@ -834,7 +840,7 @@
{63, 0x0000000000000001},
{64, 0x0000000000000000}};
- WasmRunner<int64_t> r(kMachUint64);
+ WasmRunner<int64_t> r(MachineType::Uint64());
BUILD(r, WASM_I64_CLZ(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -912,7 +918,7 @@
{1, 0x000000009afdbc82},
{0, 0x000000009afdbc81}};
- WasmRunner<int64_t> r(kMachUint64);
+ WasmRunner<int64_t> r(MachineType::Uint64());
BUILD(r, WASM_I64_CTZ(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -930,7 +936,7 @@
{26, 0x1123456782345678},
{38, 0xffedcba09edcba09}};
- WasmRunner<int64_t> r(kMachUint64);
+ WasmRunner<int64_t> r(MachineType::Uint64());
BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -941,7 +947,7 @@
#endif
TEST(Run_WASM_Int32DivS_trap) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(0, 100));
CHECK_TRAP(r.Call(100, 0));
@@ -952,7 +958,7 @@
TEST(Run_WASM_Int32RemS_trap) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(33, r.Call(133, 100));
CHECK_EQ(0, r.Call(std::numeric_limits<int32_t>::min(), -1));
@@ -963,7 +969,7 @@
TEST(Run_WASM_Int32DivU_trap) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(0, 100));
CHECK_EQ(0, r.Call(std::numeric_limits<int32_t>::min(), -1));
@@ -974,7 +980,7 @@
TEST(Run_WASM_Int32RemU_trap) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(17, r.Call(217, 100));
CHECK_TRAP(r.Call(100, 0));
@@ -986,7 +992,7 @@
TEST(Run_WASM_Int32DivS_byzero_const) {
for (int8_t denom = -2; denom < 8; denom++) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
for (int32_t val = -7; val < 8; val++) {
if (denom == 0) {
@@ -1001,9 +1007,9 @@
TEST(Run_WASM_Int32DivU_byzero_const) {
for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
- WasmRunner<uint32_t> r(kMachUint32);
+ WasmRunner<uint32_t> r(MachineType::Uint32());
BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32(denom)));
-
+
for (uint32_t val = 0xfffffff0; val < 8; val++) {
if (denom == 0) {
CHECK_TRAP(r.Call(val));
@@ -1016,17 +1022,17 @@
TEST(Run_WASM_Int32DivS_trap_effect) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
TestingModule module;
module.AddMemoryElems<int32_t>(8);
r.env()->module = &module;
-
+
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0),
- WASM_I32_DIVS(WASM_STORE_MEM(kMachInt8, WASM_ZERO,
- WASM_GET_LOCAL(0)),
+ WASM_I32_DIVS(WASM_STORE_MEM(MachineType::Int8(),
+ WASM_ZERO, WASM_GET_LOCAL(0)),
WASM_GET_LOCAL(1)),
- WASM_I32_DIVS(WASM_STORE_MEM(kMachInt8, WASM_ZERO,
- WASM_GET_LOCAL(0)),
+ WASM_I32_DIVS(WASM_STORE_MEM(MachineType::Int8(),
+ WASM_ZERO, WASM_GET_LOCAL(0)),
WASM_GET_LOCAL(1))));
CHECK_EQ(0, r.Call(0, 100));
CHECK_TRAP(r.Call(8, 0));
@@ -1038,7 +1044,7 @@
#if WASM_64
#define as64(x) static_cast<int64_t>(x)
TEST(Run_WASM_Int64DivS_trap) {
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(as64(0), as64(100)));
CHECK_TRAP(r.Call(as64(100), as64(0)));
@@ -1049,7 +1055,7 @@
TEST(Run_WASM_Int64RemS_trap) {
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(33, r.Call(as64(133), as64(100)));
CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
@@ -1060,7 +1066,7 @@
TEST(Run_WASM_Int64DivU_trap) {
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(as64(0), as64(100)));
CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
@@ -1071,7 +1077,7 @@
TEST(Run_WASM_Int64RemU_trap) {
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(17, r.Call(as64(217), as64(100)));
CHECK_TRAP(r.Call(as64(100), as64(0)));
@@ -1084,7 +1090,7 @@
TEST(Run_WASM_Int64DivS_byzero_const) {
for (int8_t denom = -2; denom < 8; denom++) {
- WasmRunner<int64_t> r(kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64(denom)));
for (int64_t val = -7; val < 8; val++) {
if (denom == 0) {
@@ -1099,9 +1105,9 @@
TEST(Run_WASM_Int64DivU_byzero_const) {
for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
- WasmRunner<uint64_t> r(kMachUint64);
+ WasmRunner<uint64_t> r(MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64(denom)));
-
+
for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) {
if (denom == 0) {
CHECK_TRAP(r.Call(val));
@@ -1221,7 +1227,7 @@
TEST(Run_Wasm_IfElse_P) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// if (p0) return 11; else return 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -1260,7 +1266,7 @@
TEST(Run_Wasm_Return_I32) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
@@ -1272,7 +1278,7 @@
#if WASM_64
TEST(Run_Wasm_Return_I64) {
- WasmRunner<int64_t> r(kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64());
BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
@@ -1284,7 +1290,7 @@
TEST(Run_Wasm_Return_F32) {
- WasmRunner<float> r(kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
@@ -1301,7 +1307,7 @@
TEST(Run_Wasm_Return_F64) {
- WasmRunner<double> r(kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
@@ -1318,7 +1324,7 @@
TEST(Run_Wasm_Select) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// return select(a, 11, 22);
BUILD(r, WASM_SELECT(WASM_GET_LOCAL(0), WASM_I8(11), WASM_I8(22)));
FOR_INT32_INPUTS(i) {
@@ -1329,7 +1335,7 @@
TEST(Run_Wasm_Select_strict1) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// select(a, a = 11, 22); return a
BUILD(r, WASM_BLOCK(2, WASM_SELECT(WASM_GET_LOCAL(0),
WASM_SET_LOCAL(0, WASM_I8(11)),
@@ -1342,7 +1348,7 @@
TEST(Run_Wasm_Select_strict2) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// select(a, 11, a = 22); return a;
BUILD(r, WASM_BLOCK(2, WASM_SELECT(WASM_GET_LOCAL(0),
WASM_I8(11),
@@ -1355,7 +1361,7 @@
TEST(Run_Wasm_BrIf_strict) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2,
WASM_BLOCK(1,
WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I8(99)))),
@@ -1368,8 +1374,8 @@
TEST(Run_Wasm_TableSwitch1) {
- WasmRunner<int32_t> r(kMachInt32);
- BUILD(r,
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r,
WASM_TABLESWITCH_OP(1, 1, WASM_CASE(0)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0),
WASM_RETURN(WASM_I8(93))));
@@ -1380,8 +1386,8 @@
TEST(Run_Wasm_TableSwitch_br) {
- WasmRunner<int32_t> r(kMachInt32);
- BUILD(r,
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r,
WASM_TABLESWITCH_OP(1, 2, WASM_CASE_BR(0), WASM_CASE(0)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0),
WASM_RETURN(WASM_I8(91))),
@@ -1394,8 +1400,8 @@
TEST(Run_Wasm_TableSwitch_br2) {
- WasmRunner<int32_t> r(kMachInt32);
- BUILD(r,
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r,
WASM_BLOCK(2,
WASM_BLOCK(2,
WASM_TABLESWITCH_OP(1, 4,
@@ -1418,8 +1424,8 @@
TEST(Run_Wasm_TableSwitch2) {
- WasmRunner<int32_t> r(kMachInt32);
- BUILD(r,
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r,
WASM_TABLESWITCH_OP(2, 2, WASM_CASE(0), WASM_CASE(1)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0),
WASM_RETURN(WASM_I8(91)),
@@ -1432,7 +1438,7 @@
TEST(Run_Wasm_TableSwitch2b) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_TABLESWITCH_OP(2, 2, WASM_CASE(1), WASM_CASE(0)),
WASM_TABLESWITCH_BODY(WASM_GET_LOCAL(0),
@@ -1456,7 +1462,7 @@
i == 3 ? br : c++
};
byte code[] = {
- WASM_BLOCK(1,
+ WASM_BLOCK(1,
WASM_TABLESWITCH_OP(3, 4,
WASM_CASE(cases[0]),
WASM_CASE(cases[1]),
@@ -1469,7 +1475,7 @@
WASM_RETURN(WASM_I8(74))
};
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.Build(code, code + arraysize(code));
FOR_INT32_INPUTS(i) {
@@ -1501,7 +1507,7 @@
WASM_RETURN(WASM_I8(62)))
};
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.Build(code, code + arraysize(code));
CHECK_EQ(61 + a, r.Call(0));
@@ -1531,7 +1537,7 @@
WASM_GET_LOCAL(1)
};
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
r.Build(code, code + arraysize(code));
CHECK_EQ(15, r.Call(0, 0));
@@ -1563,7 +1569,7 @@
WASM_GET_LOCAL(1)
};
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
r.Build(code, code + arraysize(code));
CHECK_EQ(3, r.Call(0, 0));
@@ -1586,7 +1592,7 @@
int32_t* memory = module.AddMemoryElems<int32_t>(8);
r.env()->module = &module;
- BUILD(r, WASM_I32_REINTERPRET_F32(WASM_LOAD_MEM(kMachFloat32, WASM_ZERO)));
+ BUILD(r, WASM_I32_REINTERPRET_F32(WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO)));
FOR_INT32_INPUTS(i) {
int32_t expected = *i;
@@ -1597,13 +1603,13 @@
TEST(Run_Wasm_I32ReinterpretF32) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
r.env()->module = &module;
BUILD(r, WASM_BLOCK(2,
- WASM_STORE_MEM(kMachFloat32,
+ WASM_STORE_MEM(MachineType::Float32(),
WASM_ZERO,
WASM_F32_REINTERPRET_I32(WASM_GET_LOCAL(0))),
WASM_I8(107)));
@@ -1622,7 +1628,8 @@
int32_t* memory = module.AddMemoryElems<int32_t>(8);
r.env()->module = &module;
- BUILD(r, WASM_STORE_MEM(kMachInt32, WASM_ZERO, WASM_LOAD_MEM(kMachInt32, WASM_ZERO)));
+ BUILD(r, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO,
+ WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)));
FOR_INT32_INPUTS(i) {
int32_t expected = *i;
@@ -1647,7 +1654,7 @@
TEST(Run_Wasm_Block_If_P) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) return 51; return 52; }
BUILD(r, WASM_BLOCK(2, // --
WASM_IF(WASM_GET_LOCAL(0), // --
@@ -1661,7 +1668,7 @@
TEST(Run_Wasm_Block_BrIf_P) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2,
WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_I8(51)),
WASM_I8(52)));
@@ -1673,7 +1680,7 @@
TEST(Run_Wasm_Block_IfElse_P_assign) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) p0 = 71; else p0 = 72; return p0; }
BUILD(r, WASM_BLOCK(2, // --
WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1688,7 +1695,7 @@
TEST(Run_Wasm_Block_IfElse_P_return) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// if (p0) return 81; else return 82;
BUILD(r, // --
WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1702,7 +1709,7 @@
TEST(Run_Wasm_Block_If_P_assign) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) p0 = 61; p0; }
BUILD(r, WASM_BLOCK(
2, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I8(61))),
@@ -1715,7 +1722,7 @@
TEST(Run_Wasm_ExprIf_P) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -1728,7 +1735,7 @@
TEST(Run_Wasm_ExprIf_P_fallthru) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -1741,7 +1748,7 @@
TEST(Run_Wasm_CountDown) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(2,
WASM_LOOP(1,
@@ -1756,7 +1763,7 @@
TEST(Run_Wasm_CountDown_fallthru) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(
2, WASM_LOOP(3,
@@ -1772,7 +1779,7 @@
TEST(Run_Wasm_WhileCountDown) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(
2, WASM_WHILE(WASM_GET_LOCAL(0),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
@@ -1785,7 +1792,7 @@
TEST(Run_Wasm_Loop_if_break1) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(0)),
WASM_SET_LOCAL(0, WASM_I8(99))),
WASM_GET_LOCAL(0)));
@@ -1797,7 +1804,7 @@
TEST(Run_Wasm_Loop_if_break2) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2, WASM_LOOP(2, WASM_BR_IF(1, WASM_GET_LOCAL(0)),
WASM_SET_LOCAL(0, WASM_I8(99))),
WASM_GET_LOCAL(0)));
@@ -1809,7 +1816,7 @@
TEST(Run_Wasm_Loop_if_break_fallthru) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(1, WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
WASM_SET_LOCAL(0, WASM_I8(93)))),
WASM_GET_LOCAL(0));
@@ -1821,13 +1828,13 @@
TEST(Run_Wasm_LoadMemI32) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
module.RandomizeMemory(1111);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt32, WASM_I8(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(0)));
memory[0] = 99999999;
CHECK_EQ(99999999, r.Call(0));
@@ -1841,13 +1848,13 @@
TEST(Run_Wasm_LoadMemI32_oob) {
- WasmRunner<int32_t> r(kMachUint32);
+ WasmRunner<int32_t> r(MachineType::Uint32());
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
module.RandomizeMemory(1111);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt32, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
memory[0] = 88888888;
CHECK_EQ(88888888, r.Call(0u));
@@ -1862,14 +1869,14 @@
TEST(Run_Wasm_LoadMemI32_oob_asm) {
- WasmRunner<int32_t> r(kMachUint32);
+ WasmRunner<int32_t> r(MachineType::Uint32());
TestingModule module;
module.asm_js = true;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
module.RandomizeMemory(1112);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt32, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
memory[0] = 999999;
CHECK_EQ(999999, r.Call(0u));
@@ -1888,17 +1895,19 @@
TestingModule module;
module.AddMemoryElems<int32_t>(8);
- static const MachineType kMachineTypes[] = {
- kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32,
- kMachUint32, kMachInt64, kMachUint64, kMachFloat32, kMachFloat64};
+ static const MachineType machineTypes[] = {
+ MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
+ MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
+ MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
+ MachineType::Float64()};
- for (size_t m = 0; m < arraysize(kMachineTypes); m++) {
+ for (size_t m = 0; m < arraysize(machineTypes); m++) {
module.RandomizeMemory(1116 + static_cast<int>(m));
- WasmRunner<int32_t> r(kMachUint32);
+ WasmRunner<int32_t> r(MachineType::Uint32());
r.env()->module = &module;
- uint32_t boundary = 24 - WasmOpcodes::MemSize(kMachineTypes[m]);
-
- BUILD(r, WASM_LOAD_MEM_OFFSET(kMachineTypes[m], 8, WASM_GET_LOCAL(0)), WASM_ZERO);
+ uint32_t boundary = 24 - WasmOpcodes::MemSize(machineTypes[m]);
+
+ BUILD(r, WASM_LOAD_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0)), WASM_ZERO);
CHECK_EQ(0, r.Call(boundary)); // in bounds.
@@ -1910,13 +1919,13 @@
TEST(Run_Wasm_LoadMemI32_offset) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(4);
module.RandomizeMemory(1111);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM_OFFSET(kMachInt32, 4, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0)));
memory[0] = 66666666;
memory[1] = 77777777;
@@ -1947,8 +1956,8 @@
WasmRunner<int32_t> r;
r.env()->module = &module;
module.RandomizeMemory();
-
- BUILD(r, WASM_LOAD_MEM_OFFSET(kMachInt32, offset, WASM_I8(index)));
+
+ BUILD(r, WASM_LOAD_MEM_OFFSET(MachineType::Int32(), offset, WASM_I8(index)));
if ((offset + index) <= (kMemSize - sizeof(int32_t))) {
CHECK_EQ(module.raw_val_at<int32_t>(offset + index), r.Call());
@@ -1961,13 +1970,13 @@
TEST(Run_Wasm_StoreMemI32_offset) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
const int32_t kWritten = 0xaabbccdd;
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(4);
r.env()->module = &module;
- BUILD(r, WASM_STORE_MEM_OFFSET(kMachInt32, 4, WASM_GET_LOCAL(0), WASM_I32(kWritten)));
+ BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0), WASM_I32(kWritten)));
for (int i = 0; i < 2; i++) {
module.RandomizeMemory(1111);
@@ -1989,21 +1998,23 @@
TestingModule module;
byte* memory = module.AddMemoryElems<byte>(32);
- static const MachineType kMachineTypes[] = {
- kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32,
- kMachUint32, kMachInt64, kMachUint64, kMachFloat32, kMachFloat64};
+ static const MachineType machineTypes[] = {
+ MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
+ MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
+ MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
+ MachineType::Float64()};
- for (size_t m = 0; m < arraysize(kMachineTypes); m++) {
+ for (size_t m = 0; m < arraysize(machineTypes); m++) {
module.RandomizeMemory(1119 + static_cast<int>(m));
- WasmRunner<int32_t> r(kMachUint32);
+ WasmRunner<int32_t> r(MachineType::Uint32());
r.env()->module = &module;
BUILD(r,
- WASM_STORE_MEM_OFFSET(kMachineTypes[m], 8, WASM_GET_LOCAL(0),
- WASM_LOAD_MEM(kMachineTypes[m], WASM_ZERO)),
+ WASM_STORE_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0),
+ WASM_LOAD_MEM(machineTypes[m], WASM_ZERO)),
WASM_ZERO);
- byte memsize = WasmOpcodes::MemSize(kMachineTypes[m]);
+ byte memsize = WasmOpcodes::MemSize(machineTypes[m]);
uint32_t boundary = 24 - memsize;
CHECK_EQ(0, r.Call(boundary)); // in bounds.
CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
@@ -2022,7 +2033,7 @@
int64_t* memory = module.AddMemoryElems<int64_t>(8);
r.env()->module = &module;
- BUILD(r, WASM_I64_REINTERPRET_F64(WASM_LOAD_MEM(kMachFloat64, WASM_ZERO)));
+ BUILD(r, WASM_I64_REINTERPRET_F64(WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO)));
FOR_INT32_INPUTS(i) {
int64_t expected = static_cast<int64_t>(*i) * 0x300010001;
@@ -2033,13 +2044,13 @@
TEST(Run_Wasm_I64ReinterpretF64) {
- WasmRunner<int64_t> r(kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64());
TestingModule module;
int64_t* memory = module.AddMemoryElems<int64_t>(8);
r.env()->module = &module;
BUILD(r, WASM_BLOCK(2,
- WASM_STORE_MEM(kMachFloat64,
+ WASM_STORE_MEM(MachineType::Float64(),
WASM_ZERO,
WASM_F64_REINTERPRET_I64(WASM_GET_LOCAL(0))),
WASM_GET_LOCAL(0)));
@@ -2059,7 +2070,7 @@
module.RandomizeMemory(1111);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt64, WASM_I8(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int64(), WASM_I8(0)));
memory[0] = 0xaabbccdd00112233LL;
CHECK_EQ(0xaabbccdd00112233LL, r.Call());
@@ -2075,13 +2086,13 @@
TEST(Run_Wasm_LoadMemI32_P) {
const int kNumElems = 8;
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems);
module.RandomizeMemory(2222);
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt32, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
for (int i = 0; i < kNumElems; i++) {
CHECK_EQ(memory[i], r.Call(i * 4));
@@ -2090,7 +2101,7 @@
TEST(Run_Wasm_MemI32_Sum) {
- WasmRunner<uint32_t> r(kMachInt32);
+ WasmRunner<uint32_t> r(MachineType::Int32());
const int kNumElems = 20;
const byte kSum = r.AllocateLocal(kAstI32);
TestingModule module;
@@ -2105,7 +2116,7 @@
WASM_BLOCK(2, WASM_SET_LOCAL(
kSum, WASM_I32_ADD(
WASM_GET_LOCAL(kSum),
- WASM_LOAD_MEM(kMachInt32,
+ WASM_LOAD_MEM(MachineType::Int32(),
WASM_GET_LOCAL(0)))),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
WASM_I8(4))))),
@@ -2125,7 +2136,7 @@
TEST(Run_Wasm_CheckMachIntsZero) {
- WasmRunner<uint32_t> r(kMachInt32);
+ WasmRunner<uint32_t> r(MachineType::Int32());
const int kNumElems = 55;
TestingModule module;
module.AddMemoryElems<uint32_t>(kNumElems);
@@ -2150,7 +2161,7 @@
TEST(Run_Wasm_MemF32_Sum) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
const byte kSum = r.AllocateLocal(kAstF32);
ModuleEnv module;
const int kSize = 5;
@@ -2167,11 +2178,11 @@
WASM_BLOCK(2, WASM_SET_LOCAL(
kSum, WASM_F32_ADD(
WASM_GET_LOCAL(kSum),
- WASM_LOAD_MEM(kMachFloat32,
+ WASM_LOAD_MEM(MachineType::Float32(),
WASM_GET_LOCAL(0)))),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
WASM_I8(4))))),
- WASM_STORE_MEM(kMachFloat32, WASM_ZERO, WASM_GET_LOCAL(kSum)),
+ WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO, WASM_GET_LOCAL(kSum)),
WASM_GET_LOCAL(0)));
CHECK_EQ(0, r.Call(4 * (kSize - 1)));
@@ -2182,7 +2193,7 @@
#if WASM_64
TEST(Run_Wasm_MemI64_Sum) {
- WasmRunner<uint64_t> r(kMachInt32);
+ WasmRunner<uint64_t> r(MachineType::Int32());
const int kNumElems = 20;
const byte kSum = r.AllocateLocal(kAstI64);
TestingModule module;
@@ -2197,7 +2208,7 @@
WASM_BLOCK(2, WASM_SET_LOCAL(
kSum, WASM_I64_ADD(
WASM_GET_LOCAL(kSum),
- WASM_LOAD_MEM(kMachInt64,
+ WASM_LOAD_MEM(MachineType::Int64(),
WASM_GET_LOCAL(0)))),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
WASM_I8(8))))),
@@ -2220,7 +2231,7 @@
template <typename T>
void GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
LocalType astType, MachineType memType) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
const byte kAccum = r.AllocateLocal(astType);
ModuleEnv module;
module.mem_start = reinterpret_cast<uintptr_t>(buffer);
@@ -2249,31 +2260,31 @@
const size_t kSize = 6;
double buffer[kSize] = {1, 2, 2, 2, 2, 2};
GenerateAndRunFold<double>(kExprF64Mul, buffer, kSize, kAstF64,
- kMachFloat64);
+ MachineType::Float64());
CHECK_EQ(32, buffer[0]);
}
TEST(Build_Wasm_Infinite_Loop) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
// Only build the graph and compile, don't run.
BUILD(r, WASM_INFINITE_LOOP);
}
TEST(Build_Wasm_Infinite_Loop_effect) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestingModule module;
module.AddMemoryElems<int8_t>(16);
r.env()->module = &module;
// Only build the graph and compile, don't run.
- BUILD(r, WASM_LOOP(1, WASM_LOAD_MEM(kMachInt32, WASM_ZERO)));
+ BUILD(r, WASM_LOOP(1, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)));
}
TEST(Run_Wasm_Unreachable0a) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2, WASM_BRV(0, WASM_I8(9)), WASM_RETURN(WASM_GET_LOCAL(0))));
CHECK_EQ(9, r.Call(0));
CHECK_EQ(9, r.Call(1));
@@ -2281,7 +2292,7 @@
TEST(Run_Wasm_Unreachable0b) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2, WASM_BRV(0, WASM_I8(7)), WASM_UNREACHABLE));
CHECK_EQ(7, r.Call(0));
CHECK_EQ(7, r.Call(1));
@@ -2289,31 +2300,31 @@
TEST(Build_Wasm_Unreachable1) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE);
}
TEST(Build_Wasm_Unreachable2) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
TEST(Build_Wasm_Unreachable3) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
TEST(Build_Wasm_UnreachableIf1) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_IF(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
}
TEST(Build_Wasm_UnreachableIf2) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_IF_ELSE(WASM_GET_LOCAL(0),
WASM_GET_LOCAL(0),
WASM_UNREACHABLE));
@@ -2321,17 +2332,17 @@
TEST(Run_Wasm_Unreachable_Load) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2,
WASM_BRV(0, WASM_GET_LOCAL(0)),
- WASM_LOAD_MEM(kMachInt8, WASM_GET_LOCAL(0))));
+ WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0))));
CHECK_EQ(11, r.Call(11));
CHECK_EQ(21, r.Call(21));
}
TEST(Run_Wasm_Infinite_Loop_not_taken1) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2,
WASM_IF(WASM_GET_LOCAL(0), WASM_INFINITE_LOOP),
WASM_I8(45)));
@@ -2341,7 +2352,7 @@
TEST(Run_Wasm_Infinite_Loop_not_taken2) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(1, WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(45)),
WASM_INFINITE_LOOP)));
// Run the code, but don't go into the infinite loop.
@@ -2350,7 +2361,7 @@
TEST(Run_Wasm_Infinite_Loop_not_taken2_brif) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(2,
WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_I8(45)),
WASM_INFINITE_LOOP));
@@ -2360,14 +2371,14 @@
static void TestBuildGraphForUnop(WasmOpcode opcode, FunctionSig* sig) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
init_env(r.env(), sig);
BUILD(r, static_cast<byte>(opcode), kExprGetLocal, 0);
}
static void TestBuildGraphForBinop(WasmOpcode opcode, FunctionSig* sig) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
init_env(r.env(), sig);
BUILD(r, static_cast<byte>(opcode), kExprGetLocal, 0, kExprGetLocal, 1);
}
@@ -2398,9 +2409,9 @@
int8_t* memory = module.AddMemoryElems<int8_t>(kNumElems);
module.RandomizeMemory();
memory[0] = -1;
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt8, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0)));
for (size_t i = 0; i < kNumElems; i++) {
CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
@@ -2414,9 +2425,9 @@
byte* memory = module.AddMemory(kNumElems);
module.RandomizeMemory(77);
memory[0] = 255;
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachUint8, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Uint8(), WASM_GET_LOCAL(0)));
for (size_t i = 0; i < kNumElems; i++) {
CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
@@ -2430,9 +2441,9 @@
byte* memory = module.AddMemory(kNumBytes);
module.RandomizeMemory(888);
memory[1] = 200;
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachInt16, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Int16(), WASM_GET_LOCAL(0)));
for (size_t i = 0; i < kNumBytes; i += 2) {
int32_t expected = memory[i] | (static_cast<int8_t>(memory[i + 1]) << 8);
@@ -2447,9 +2458,9 @@
byte* memory = module.AddMemory(kNumBytes);
module.RandomizeMemory(9999);
memory[1] = 204;
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
- BUILD(r, WASM_LOAD_MEM(kMachUint16, WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_LOAD_MEM(MachineType::Uint16(), WASM_GET_LOCAL(0)));
for (size_t i = 0; i < kNumBytes; i += 2) {
int32_t expected = memory[i] | (memory[i + 1] << 8);
@@ -2460,8 +2471,8 @@
TEST(Run_WasmInt32Global) {
TestingModule module;
- int32_t* global = module.AddGlobal<int32_t>(kMachInt32);
- WasmRunner<int32_t> r(kMachInt32);
+ int32_t* global = module.AddGlobal<int32_t>(MachineType::Int32());
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
// global = global + p0
BUILD(r, WASM_STORE_GLOBAL(
@@ -2479,13 +2490,13 @@
TEST(Run_WasmInt32Globals_DontAlias) {
const int kNumGlobals = 3;
TestingModule module;
- int32_t* globals[] = {module.AddGlobal<int32_t>(kMachInt32),
- module.AddGlobal<int32_t>(kMachInt32),
- module.AddGlobal<int32_t>(kMachInt32)};
+ int32_t* globals[] = {module.AddGlobal<int32_t>(MachineType::Int32()),
+ module.AddGlobal<int32_t>(MachineType::Int32()),
+ module.AddGlobal<int32_t>(MachineType::Int32())};
for (int g = 0; g < kNumGlobals; g++) {
// global = global + p0
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
BUILD(r, WASM_STORE_GLOBAL(
g, WASM_I32_ADD(WASM_LOAD_GLOBAL(g), WASM_GET_LOCAL(0))));
@@ -2509,8 +2520,8 @@
#if WASM_64
TEST(Run_WasmInt64Global) {
TestingModule module;
- int64_t* global = module.AddGlobal<int64_t>(kMachInt64);
- WasmRunner<int32_t> r(kMachInt32);
+ int64_t* global = module.AddGlobal<int64_t>(MachineType::Int64());
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
// global = global + p0
BUILD(r, WASM_BLOCK(
@@ -2531,8 +2542,8 @@
TEST(Run_WasmFloat32Global) {
TestingModule module;
- float* global = module.AddGlobal<float>(kMachFloat32);
- WasmRunner<int32_t> r(kMachInt32);
+ float* global = module.AddGlobal<float>(MachineType::Float32());
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
// global = global + p0
BUILD(r, WASM_BLOCK(2, WASM_STORE_GLOBAL(
@@ -2552,8 +2563,8 @@
TEST(Run_WasmFloat64Global) {
TestingModule module;
- double* global = module.AddGlobal<double>(kMachFloat64);
- WasmRunner<int32_t> r(kMachInt32);
+ double* global = module.AddGlobal<double>(MachineType::Float64());
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
// global = global + p0
BUILD(r, WASM_BLOCK(2, WASM_STORE_GLOBAL(
@@ -2573,30 +2584,38 @@
TEST(Run_WasmMixedGlobals) {
TestingModule module;
- int32_t* unused = module.AddGlobal<int32_t>(kMachInt32);
+ int32_t* unused = module.AddGlobal<int32_t>(MachineType::Int32());
byte* memory = module.AddMemory(32);
- int8_t* var_int8 = module.AddGlobal<int8_t>(kMachInt8);
- uint8_t* var_uint8 = module.AddGlobal<uint8_t>(kMachUint8);
- int16_t* var_int16 = module.AddGlobal<int16_t>(kMachInt16);
- uint16_t* var_uint16 = module.AddGlobal<uint16_t>(kMachUint16);
- int32_t* var_int32 = module.AddGlobal<int32_t>(kMachInt32);
- uint32_t* var_uint32 = module.AddGlobal<uint32_t>(kMachUint32);
- float* var_float = module.AddGlobal<float>(kMachFloat32);
- double* var_double = module.AddGlobal<double>(kMachFloat64);
+ int8_t* var_int8 = module.AddGlobal<int8_t>(MachineType::Int8());
+ uint8_t* var_uint8 = module.AddGlobal<uint8_t>(MachineType::Uint8());
+ int16_t* var_int16 = module.AddGlobal<int16_t>(MachineType::Int16());
+ uint16_t* var_uint16 = module.AddGlobal<uint16_t>(MachineType::Uint16());
+ int32_t* var_int32 = module.AddGlobal<int32_t>(MachineType::Int32());
+ uint32_t* var_uint32 = module.AddGlobal<uint32_t>(MachineType::Uint32());
+ float* var_float = module.AddGlobal<float>(MachineType::Float32());
+ double* var_double = module.AddGlobal<double>(MachineType::Float64());
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
r.env()->module = &module;
BUILD(r,
- WASM_BLOCK(9, WASM_STORE_GLOBAL(1, WASM_LOAD_MEM(kMachInt8, WASM_ZERO)),
- WASM_STORE_GLOBAL(2, WASM_LOAD_MEM(kMachUint8, WASM_ZERO)),
- WASM_STORE_GLOBAL(3, WASM_LOAD_MEM(kMachInt16, WASM_ZERO)),
- WASM_STORE_GLOBAL(4, WASM_LOAD_MEM(kMachUint16, WASM_ZERO)),
- WASM_STORE_GLOBAL(5, WASM_LOAD_MEM(kMachInt32, WASM_ZERO)),
- WASM_STORE_GLOBAL(6, WASM_LOAD_MEM(kMachUint32, WASM_ZERO)),
- WASM_STORE_GLOBAL(7, WASM_LOAD_MEM(kMachFloat32, WASM_ZERO)),
- WASM_STORE_GLOBAL(8, WASM_LOAD_MEM(kMachFloat64, WASM_ZERO)),
+ WASM_BLOCK(9, WASM_STORE_GLOBAL(1, WASM_LOAD_MEM(MachineType::Int8(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(2, WASM_LOAD_MEM(MachineType::Uint8(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(3, WASM_LOAD_MEM(MachineType::Int16(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(4, WASM_LOAD_MEM(MachineType::Uint16(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(5, WASM_LOAD_MEM(MachineType::Int32(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(6, WASM_LOAD_MEM(MachineType::Uint32(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(7, WASM_LOAD_MEM(MachineType::Float32(),
+ WASM_ZERO)),
+ WASM_STORE_GLOBAL(8, WASM_LOAD_MEM(MachineType::Float64(),
+ WASM_ZERO)),
WASM_ZERO));
memory[0] = 0xaa;
@@ -2634,14 +2653,14 @@
}
}
{
- WasmRunner<int64_t> r(kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64());
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT64_INPUTS(i) {
CHECK_EQ(*i, r.Call(*i));
}
}
{
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
@@ -2650,7 +2669,8 @@
}
}
{
- WasmRunner<int64_t> r(kMachInt64, kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0),
WASM_I64_ADD(WASM_GET_LOCAL(1),
WASM_GET_LOCAL(2))));
@@ -2663,7 +2683,8 @@
}
}
{
- WasmRunner<int64_t> r(kMachInt64, kMachInt64, kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(),
+ MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0),
WASM_I64_ADD(WASM_GET_LOCAL(1),
WASM_I64_ADD(WASM_GET_LOCAL(2),
@@ -2711,7 +2732,7 @@
module.RandomizeMemory();
WasmFunctionCompiler t(sigs.v_v());
t.env.module = &module;
- BUILD(t, WASM_STORE_MEM(kMachInt32, WASM_I8(kMemOffset),
+ BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I8(kMemOffset),
WASM_I32(kExpected)));
unsigned index = t.CompileAndAdd(&module);
@@ -2719,7 +2740,7 @@
WasmRunner<int32_t> r;
r.env()->module = &module;
BUILD(r, WASM_CALL_FUNCTION0(index),
- WASM_LOAD_MEM(kMachInt32, WASM_I8(kMemOffset)));
+ WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kMemOffset)));
int32_t result = r.Call();
CHECK_EQ(kExpected, result);
@@ -2736,7 +2757,7 @@
unsigned index = t.CompileAndAdd(&module);
// Build the caller function.
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
r.env()->module = &module;
BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0),
WASM_GET_LOCAL(1)));
@@ -2761,7 +2782,7 @@
unsigned index = t.CompileAndAdd(&module);
// Build the caller function.
- WasmRunner<int64_t> r(kMachInt64, kMachInt64);
+ WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
r.env()->module = &module;
BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0),
WASM_GET_LOCAL(1)));
@@ -2792,7 +2813,7 @@
unsigned index = t.CompileAndAdd(&module);
// Builder the caller function.
- WasmRunner<float> r(kMachFloat32, kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
r.env()->module = &module;
BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2812,11 +2833,11 @@
// TODO(titzer): convert to a binop test.
BUILD(r, WASM_BLOCK(2,
- WASM_STORE_MEM(kMachFloat64,
+ WASM_STORE_MEM(MachineType::Float64(),
WASM_ZERO,
WASM_F64_SUB(
- WASM_LOAD_MEM(kMachFloat64, WASM_ZERO),
- WASM_LOAD_MEM(kMachFloat64, WASM_I8(8)))),
+ WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO),
+ WASM_LOAD_MEM(MachineType::Float64(), WASM_I8(8)))),
WASM_I8(107)));
FOR_FLOAT64_INPUTS(i) {
@@ -2847,14 +2868,20 @@
TestSignatures sigs;
#if WASM_64
- static MachineType mixed[] = {kMachInt32, kMachFloat32, kMachInt64, kMachFloat64,
- kMachFloat32, kMachInt64, kMachInt32, kMachFloat64,
- kMachFloat32, kMachFloat64, kMachInt32, kMachInt64,
- kMachInt32, kMachInt32};
+ static MachineType mixed[] = {MachineType::Int32(), MachineType::Float32(),
+ MachineType::Int64(), MachineType::Float64(),
+ MachineType::Float32(), MachineType::Int64(),
+ MachineType::Int32(), MachineType::Float64(),
+ MachineType::Float32(), MachineType::Float64(),
+ MachineType::Int32(), MachineType::Int64(),
+ MachineType::Int32(), MachineType::Int32()};
#else
- static MachineType mixed[] = {kMachInt32, kMachFloat32, kMachFloat64, kMachFloat32,
- kMachInt32, kMachFloat64, kMachFloat32, kMachFloat64,
- kMachInt32, kMachInt32, kMachInt32};
+ static MachineType mixed[] = {MachineType::Int32(), MachineType::Float32(),
+ MachineType::Float64(), MachineType::Float32(),
+ MachineType::Int32(), MachineType::Float64(),
+ MachineType::Float32(), MachineType::Float64(),
+ MachineType::Int32(), MachineType::Int32(),
+ MachineType::Int32()};
#endif
int num_params = static_cast<int>(arraysize(mixed)) - start;
@@ -2887,7 +2914,7 @@
{
std::vector<byte> code;
- ADD_CODE(code,
+ ADD_CODE(code,
static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
WasmOpcodes::LoadStoreAccessOf(false));
ADD_CODE(code, WASM_ZERO);
@@ -2928,7 +2955,7 @@
TEST(Run_Wasm_CountDown_expr) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_LOOP(3,
WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)),
@@ -2943,7 +2970,7 @@
TEST(Run_Wasm_ExprBlock2a) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(2,
WASM_IF(WASM_GET_LOCAL(0),
@@ -2955,7 +2982,7 @@
TEST(Run_Wasm_ExprBlock2b) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(2,
WASM_IF(WASM_GET_LOCAL(0),
@@ -2967,7 +2994,7 @@
TEST(Run_Wasm_ExprBlock2c) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(2,
WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_I8(1)),
@@ -2978,7 +3005,7 @@
TEST(Run_Wasm_ExprBlock2d) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(2,
WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_I8(1)),
@@ -2989,7 +3016,7 @@
TEST(Run_Wasm_ExprBlock_ManualSwitch) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(6,
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
@@ -3014,7 +3041,7 @@
TEST(Run_Wasm_ExprBlock_ManualSwitch_brif) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(6,
WASM_BRV_IF(0, WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
@@ -3039,7 +3066,7 @@
TEST(Run_Wasm_nested_ifs) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0),
WASM_IF_ELSE(WASM_GET_LOCAL(1),
@@ -3058,7 +3085,7 @@
TEST(Run_Wasm_ExprBlock_if) {
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(1, WASM_IF_ELSE(WASM_GET_LOCAL(0),
WASM_BRV(0, WASM_I8(11)),
@@ -3070,7 +3097,7 @@
TEST(Run_Wasm_ExprBlock_nested_ifs) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_BLOCK(1, WASM_IF_ELSE(WASM_GET_LOCAL(0),
WASM_IF_ELSE(WASM_GET_LOCAL(1),
@@ -3089,7 +3116,7 @@
TEST(Run_Wasm_ExprLoop_nested_ifs) {
- WasmRunner<int32_t> r(kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_LOOP(1, WASM_IF_ELSE(WASM_GET_LOCAL(0),
WASM_IF_ELSE(WASM_GET_LOCAL(1),
@@ -3150,7 +3177,7 @@
TEST(Run_Wasm_SimpleCallIndirect) {
Isolate* isolate = CcTest::InitIsolateOnce();
- WasmRunner<int32_t> r(kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32());
TestSignatures sigs;
TestingModule module;
r.env()->module = &module;
@@ -3194,7 +3221,7 @@
TEST(Run_Wasm_MultipleCallIndirect) {
Isolate* isolate = CcTest::InitIsolateOnce();
- WasmRunner<int32_t> r(kMachInt32, kMachInt32, kMachInt32);
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
TestSignatures sigs;
TestingModule module;
r.env()->module = &module;
@@ -3227,11 +3254,11 @@
module.function_table = fixed;
// Builder the caller function.
- BUILD(r, WASM_I32_ADD(WASM_CALL_INDIRECT(1,
+ BUILD(r, WASM_I32_ADD(WASM_CALL_INDIRECT(1,
WASM_GET_LOCAL(0),
WASM_GET_LOCAL(1),
WASM_GET_LOCAL(2)),
- WASM_CALL_INDIRECT(1,
+ WASM_CALL_INDIRECT(1,
WASM_GET_LOCAL(1),
WASM_GET_LOCAL(2),
WASM_GET_LOCAL(0))));
@@ -3249,7 +3276,7 @@
TEST(Run_Wasm_F32Floor) {
- WasmRunner<float> r(kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -3259,7 +3286,7 @@
TEST(Run_Wasm_F32Ceil) {
- WasmRunner<float> r(kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -3269,7 +3296,7 @@
TEST(Run_Wasm_F32Trunc) {
- WasmRunner<float> r(kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -3279,7 +3306,7 @@
TEST(Run_Wasm_F32NearestInt) {
- WasmRunner<float> r(kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -3289,7 +3316,7 @@
TEST(Run_Wasm_F64Floor) {
- WasmRunner<double> r(kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -3299,7 +3326,7 @@
TEST(Run_Wasm_F64Ceil) {
- WasmRunner<double> r(kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -3309,7 +3336,7 @@
TEST(Run_Wasm_F64Trunc) {
- WasmRunner<double> r(kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -3319,7 +3346,7 @@
TEST(Run_Wasm_F64NearestInt) {
- WasmRunner<double> r(kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -3329,7 +3356,7 @@
TEST(Run_Wasm_F32Min) {
- WasmRunner<float> r(kMachFloat32, kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
@@ -3342,7 +3369,7 @@
TEST(Run_Wasm_F64Min) {
- WasmRunner<double> r(kMachFloat64, kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -3355,7 +3382,7 @@
TEST(Run_Wasm_F32Max) {
- WasmRunner<float> r(kMachFloat32, kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
@@ -3368,7 +3395,7 @@
TEST(Run_Wasm_F64Max) {
- WasmRunner<double> r(kMachFloat64, kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -3382,7 +3409,7 @@
#if WASM_64
TEST(Run_Wasm_F32SConvertI64) {
- WasmRunner<float> r(kMachInt64);
+ WasmRunner<float> r(MachineType::Int64());
BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) {
CHECK_EQ(static_cast<float>(*i), r.Call(*i));
@@ -3391,7 +3418,7 @@
TEST(Run_Wasm_F32UConvertI64) {
- WasmRunner<float> r(kMachUint64);
+ WasmRunner<float> r(MachineType::Uint64());
BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_UINT64_INPUTS(i) {
CHECK_EQ(static_cast<float>(*i), r.Call(*i));
@@ -3400,7 +3427,7 @@
TEST(Run_Wasm_F64SConvertI64) {
- WasmRunner<double> r(kMachInt64);
+ WasmRunner<double> r(MachineType::Int64());
BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) {
CHECK_EQ(static_cast<double>(*i), r.Call(*i));
@@ -3409,7 +3436,7 @@
TEST(Run_Wasm_F64UConvertI64) {
- WasmRunner<double> r(kMachUint64);
+ WasmRunner<double> r(MachineType::Uint64());
BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_UINT64_INPUTS(i) {
CHECK_EQ(static_cast<double>(*i), r.Call(*i));
@@ -3421,7 +3448,7 @@
TEST(Run_Wasm_F64CopySign) {
- WasmRunner<double> r(kMachFloat64, kMachFloat64);
+ WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -3433,7 +3460,7 @@
TEST(Run_Wasm_F32CopySign) {
- WasmRunner<float> r(kMachFloat32, kMachFloat32);
+ WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
diff --git a/test/unittests/wasm/ast-decoder-unittest.cc b/test/unittests/wasm/ast-decoder-unittest.cc
index f152755..b855f56 100644
--- a/test/unittests/wasm/ast-decoder-unittest.cc
+++ b/test/unittests/wasm/ast-decoder-unittest.cc
@@ -24,9 +24,11 @@
static const LocalType kLocalTypes[] = {kAstI32, kAstI64, kAstF32,
kAstF64};
-static const MachineType kMachineTypes[] = {
- kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32,
- kMachUint32, kMachInt64, kMachUint64, kMachFloat32, kMachFloat64};
+static const MachineType machineTypes[] = {
+ MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
+ MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
+ MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
+ MachineType::Float64()};
static const WasmOpcode kInt32BinopOpcodes[] = {
kExprI32Add, kExprI32Sub, kExprI32Mul, kExprI32DivS,
@@ -855,7 +857,7 @@
TEST_F(WasmDecoderTest, MacrosStmt) {
VERIFY(WASM_SET_LOCAL(0, WASM_I32(87348)));
- VERIFY(WASM_STORE_MEM(kMachInt32, WASM_I8(24), WASM_I8(40)));
+ VERIFY(WASM_STORE_MEM(MachineType::Int32(), WASM_I8(24), WASM_I8(40)));
VERIFY(WASM_IF(WASM_GET_LOCAL(0), WASM_NOP));
VERIFY(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_NOP, WASM_NOP));
VERIFY(WASM_NOP);
@@ -1095,8 +1097,8 @@
TEST_F(WasmDecoderTest, AllLoadMemCombinations) {
for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
LocalType local_type = kLocalTypes[i];
- for (size_t j = 0; j < arraysize(kMachineTypes); j++) {
- MachineType mem_type = kMachineTypes[j];
+ for (size_t j = 0; j < arraysize(machineTypes); j++) {
+ MachineType mem_type = machineTypes[j];
byte code[] = {
static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, false)),
WasmOpcodes::LoadStoreAccessOf(false), kExprI8Const, 0};
@@ -1116,8 +1118,8 @@
TEST_F(WasmDecoderTest, AllStoreMemCombinations) {
for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
LocalType local_type = kLocalTypes[i];
- for (size_t j = 0; j < arraysize(kMachineTypes); j++) {
- MachineType mem_type = kMachineTypes[j];
+ for (size_t j = 0; j < arraysize(machineTypes); j++) {
+ MachineType mem_type = machineTypes[j];
byte code[] = {static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(mem_type, true)),
WasmOpcodes::LoadStoreAccessOf(false), kExprI8Const,
0, kExprGetLocal, 0};
@@ -1331,12 +1333,12 @@
TestModuleEnv module_env;
env->module = &module_env;
- module_env.AddGlobal(kMachInt8);
- module_env.AddGlobal(kMachUint8);
- module_env.AddGlobal(kMachInt16);
- module_env.AddGlobal(kMachUint16);
- module_env.AddGlobal(kMachInt32);
- module_env.AddGlobal(kMachUint32);
+ module_env.AddGlobal(MachineType::Int8());
+ module_env.AddGlobal(MachineType::Uint8());
+ module_env.AddGlobal(MachineType::Int16());
+ module_env.AddGlobal(MachineType::Uint16());
+ module_env.AddGlobal(MachineType::Int32());
+ module_env.AddGlobal(MachineType::Uint32());
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0));
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(1));
@@ -1359,10 +1361,10 @@
TestModuleEnv module_env;
env->module = &module_env;
- module_env.AddGlobal(kMachInt64);
- module_env.AddGlobal(kMachUint64);
- module_env.AddGlobal(kMachFloat32);
- module_env.AddGlobal(kMachFloat64);
+ module_env.AddGlobal(MachineType::Int64());
+ module_env.AddGlobal(MachineType::Uint64());
+ module_env.AddGlobal(MachineType::Float32());
+ module_env.AddGlobal(MachineType::Float64());
EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(0));
EXPECT_FAILURE_INLINE(env, WASM_LOAD_GLOBAL(1));
@@ -1381,8 +1383,8 @@
TestModuleEnv module_env;
env->module = &module_env;
- module_env.AddGlobal(kMachInt64);
- module_env.AddGlobal(kMachUint64);
+ module_env.AddGlobal(MachineType::Int64());
+ module_env.AddGlobal(MachineType::Uint64());
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0));
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(1));
@@ -1399,7 +1401,7 @@
TestModuleEnv module_env;
env->module = &module_env;
- module_env.AddGlobal(kMachFloat32);
+ module_env.AddGlobal(MachineType::Float32());
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0));
EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0)));
@@ -1413,7 +1415,7 @@
TestModuleEnv module_env;
env->module = &module_env;
- module_env.AddGlobal(kMachFloat64);
+ module_env.AddGlobal(MachineType::Float64());
EXPECT_VERIFIES_INLINE(env, WASM_LOAD_GLOBAL(0));
EXPECT_VERIFIES_INLINE(env, WASM_STORE_GLOBAL(0, WASM_GET_LOCAL(0)));
@@ -1423,8 +1425,8 @@
TEST_F(WasmDecoderTest, AllLoadGlobalCombinations) {
for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
LocalType local_type = kLocalTypes[i];
- for (size_t j = 0; j < arraysize(kMachineTypes); j++) {
- MachineType mem_type = kMachineTypes[j];
+ for (size_t j = 0; j < arraysize(machineTypes); j++) {
+ MachineType mem_type = machineTypes[j];
FunctionEnv env;
FunctionSig sig(1, 0, &local_type);
TestModuleEnv module_env;
@@ -1444,8 +1446,8 @@
TEST_F(WasmDecoderTest, AllStoreGlobalCombinations) {
for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
LocalType local_type = kLocalTypes[i];
- for (size_t j = 0; j < arraysize(kMachineTypes); j++) {
- MachineType mem_type = kMachineTypes[j];
+ for (size_t j = 0; j < arraysize(machineTypes); j++) {
+ MachineType mem_type = machineTypes[j];
FunctionEnv env;
FunctionSig sig(0, 1, &local_type);
TestModuleEnv module_env;
diff --git a/test/unittests/wasm/module-decoder-unittest.cc b/test/unittests/wasm/module-decoder-unittest.cc
index a4c852e..a176c21 100644
--- a/test/unittests/wasm/module-decoder-unittest.cc
+++ b/test/unittests/wasm/module-decoder-unittest.cc
@@ -77,7 +77,7 @@
WasmGlobal* global = &result.val->globals->back();
EXPECT_EQ(0, global->name_offset);
- EXPECT_EQ(kMachInt32, global->type);
+ EXPECT_EQ(MachineType::Int32(), global->type);
EXPECT_EQ(0, global->offset);
EXPECT_EQ(false, global->exported);
}
@@ -181,12 +181,12 @@
WasmGlobal* g1 = &result.val->globals->at(1);
EXPECT_EQ(0, g0->name_offset);
- EXPECT_EQ(kMachFloat32, g0->type);
+ EXPECT_EQ(MachineType::Float32(), g0->type);
EXPECT_EQ(0, g0->offset);
EXPECT_EQ(false, g0->exported);
EXPECT_EQ(0, g1->name_offset);
- EXPECT_EQ(kMachFloat64, g1->type);
+ EXPECT_EQ(MachineType::Float64(), g1->type);
EXPECT_EQ(0, g1->offset);
EXPECT_EQ(true, g1->exported);
}
@@ -461,7 +461,7 @@
WasmGlobal* global = &result.val->globals->back();
EXPECT_EQ(0, global->name_offset);
- EXPECT_EQ(kMachUint8, global->type);
+ EXPECT_EQ(MachineType::Uint8(), global->type);
EXPECT_EQ(0, global->offset);
EXPECT_EQ(false, global->exported);
diff --git a/test/unittests/wasm/wasm-macro-gen-unittest.cc b/test/unittests/wasm/wasm-macro-gen-unittest.cc
index 0e81afc..56ab454 100644
--- a/test/unittests/wasm/wasm-macro-gen-unittest.cc
+++ b/test/unittests/wasm/wasm-macro-gen-unittest.cc
@@ -52,7 +52,7 @@
EXPECT_SIZE(4, WASM_STORE_GLOBAL(0, WASM_ZERO));
- EXPECT_SIZE(6, WASM_STORE_MEM(kMachInt32, WASM_ZERO, WASM_ZERO));
+ EXPECT_SIZE(6, WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO, WASM_ZERO));
EXPECT_SIZE(4, WASM_IF(WASM_ZERO, WASM_NOP));
@@ -112,9 +112,9 @@
EXPECT_SIZE(2, WASM_LOAD_GLOBAL(0));
EXPECT_SIZE(2, WASM_LOAD_GLOBAL(1));
EXPECT_SIZE(2, WASM_LOAD_GLOBAL(12));
- EXPECT_SIZE(4, WASM_LOAD_MEM(kMachInt32, WASM_ZERO));
- EXPECT_SIZE(4, WASM_LOAD_MEM(kMachFloat64, WASM_ZERO));
- EXPECT_SIZE(4, WASM_LOAD_MEM(kMachFloat32, WASM_ZERO));
+ EXPECT_SIZE(4, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO));
+ EXPECT_SIZE(4, WASM_LOAD_MEM(MachineType::Float64(), WASM_ZERO));
+ EXPECT_SIZE(4, WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO));
EXPECT_SIZE(3, WASM_NOT(WASM_ZERO));
@@ -289,8 +289,10 @@
}
static const MachineType kMemTypes[] = {
- kMachInt8, kMachUint8, kMachInt16, kMachUint16, kMachInt32,
- kMachUint32, kMachInt64, kMachUint64, kMachFloat32, kMachFloat64};
+ MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
+ MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
+ MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
+ MachineType::Float64()};
TEST_F(WasmMacroGenTest, LoadsAndStores) {
for (size_t i = 0; i < arraysize(kMemTypes); i++) {
