Changeset 273813 in webkit

Timestamp:

Mar 3, 2021 4:20:00 AM (17 months ago)

Author:

commit-queue@webkit.org

Message:

[WASM-Function-References] Extend wasm type with type index
​https://bugs.webkit.org/show_bug.cgi?id=222351

Patch by Dmitry Bezhetskov <dbezhetskov> on 2021-03-03
Reviewed by Keith Miller.

Extend wasm type with type index to represent
new reference types from typed function references
proposal: ​https://github.com/WebAssembly/function-references/blob/master/proposals/function-references/Overview.md.

• bytecode/BytecodeDumper.cpp:

(JSC::Wasm::BytecodeDumper::dumpConstants):
(JSC::Wasm::BytecodeDumper::formatConstant const):

• bytecode/BytecodeDumper.h:
• wasm/WasmAirIRGenerator.cpp:

(JSC::Wasm::TypedTmp::TypedTmp):
(JSC::Wasm::TypedTmp::dump const):
(JSC::Wasm::AirIRGenerator::g32):
(JSC::Wasm::AirIRGenerator::g64):
(JSC::Wasm::AirIRGenerator::gExternref):
(JSC::Wasm::AirIRGenerator::gFuncref):
(JSC::Wasm::AirIRGenerator::f32):
(JSC::Wasm::AirIRGenerator::f64):
(JSC::Wasm::AirIRGenerator::tmpForType):
(JSC::Wasm::AirIRGenerator::emitCCall):
(JSC::Wasm::AirIRGenerator::moveOpForValueType):
(JSC::Wasm::AirIRGenerator::AirIRGenerator):
(JSC::Wasm::AirIRGenerator::addLocal):
(JSC::Wasm::AirIRGenerator::addConstant):
(JSC::Wasm::AirIRGenerator::addRefIsNull):
(JSC::Wasm::AirIRGenerator::addRefFunc):
(JSC::Wasm::AirIRGenerator::addTableGet):
(JSC::Wasm::AirIRGenerator::addTableSet):
(JSC::Wasm::AirIRGenerator::addTableInit):
(JSC::Wasm::AirIRGenerator::addElemDrop):
(JSC::Wasm::AirIRGenerator::addTableSize):
(JSC::Wasm::AirIRGenerator::addTableGrow):
(JSC::Wasm::AirIRGenerator::addTableFill):
(JSC::Wasm::AirIRGenerator::addTableCopy):
(JSC::Wasm::AirIRGenerator::addGrowMemory):
(JSC::Wasm::AirIRGenerator::addCurrentMemory):
(JSC::Wasm::AirIRGenerator::addMemoryFill):
(JSC::Wasm::AirIRGenerator::addMemoryCopy):
(JSC::Wasm::AirIRGenerator::addMemoryInit):
(JSC::Wasm::AirIRGenerator::addDataDrop):
(JSC::Wasm::AirIRGenerator::emitCheckAndPreparePointer):
(JSC::Wasm::AirIRGenerator::sanitizeAtomicResult):
(JSC::Wasm::AirIRGenerator::appendGeneralAtomic):
(JSC::Wasm::AirIRGenerator::appendStrongCAS):
(JSC::Wasm::AirIRGenerator::emitAtomicLoadOp):
(JSC::Wasm::AirIRGenerator::atomicLoad):
(JSC::Wasm::AirIRGenerator::emitAtomicStoreOp):
(JSC::Wasm::AirIRGenerator::emitAtomicBinaryRMWOp):
(JSC::Wasm::AirIRGenerator::atomicBinaryRMW):
(JSC::Wasm::AirIRGenerator::emitAtomicCompareExchange):
(JSC::Wasm::AirIRGenerator::atomicCompareExchange):
(JSC::Wasm::AirIRGenerator::atomicWait):
(JSC::Wasm::AirIRGenerator::atomicNotify):
(JSC::Wasm::AirIRGenerator::truncSaturated):
(JSC::Wasm::AirIRGenerator::addReturn):
(JSC::Wasm::AirIRGenerator::addSwitch):
(JSC::Wasm::AirIRGenerator::emitModOrDiv):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncSF64>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncSF32>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncUF64>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncUF32>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncSF64>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF64>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncSF32>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF32>):
(JSC::Wasm::AirIRGenerator::addShift):
(JSC::Wasm::AirIRGenerator::addFloatingPointBinOp):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F32Min>):
(JSC::Wasm::AirIRGenerator::addFloatingPointMinOrMax):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F32Max>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Mul>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F32Div>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Div>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F32Neg>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64Rotr>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64Rotl>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32ShrU>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32ShrS>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32Shl>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Min>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Sub>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64ShrS>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64ShrU>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I64Shl>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32Rotl>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::I32Rotr>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Neg>):
(JSC::Wasm::AirIRGenerator::addOp<OpType::F64Max>):

• wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::B3IRGenerator::addTableGet):
(JSC::Wasm::B3IRGenerator::addRefFunc):
(JSC::Wasm::B3IRGenerator::addTableInit):
(JSC::Wasm::B3IRGenerator::addTableSize):
(JSC::Wasm::B3IRGenerator::addTableGrow):
(JSC::Wasm::B3IRGenerator::addTableFill):
(JSC::Wasm::B3IRGenerator::addTableCopy):
(JSC::Wasm::B3IRGenerator::addMemoryFill):
(JSC::Wasm::B3IRGenerator::addMemoryInit):
(JSC::Wasm::B3IRGenerator::addMemoryCopy):
(JSC::Wasm::B3IRGenerator::sanitizeAtomicResult):
(JSC::Wasm::B3IRGenerator::atomicLoad):
(JSC::Wasm::B3IRGenerator::emitAtomicStoreOp):
(JSC::Wasm::B3IRGenerator::emitAtomicBinaryRMWOp):
(JSC::Wasm::B3IRGenerator::atomicBinaryRMW):
(JSC::Wasm::B3IRGenerator::emitAtomicCompareExchange):
(JSC::Wasm::B3IRGenerator::atomicCompareExchange):

• wasm/WasmCallingConvention.h:

(JSC::Wasm::WasmCallingConvention::marshallLocation const):
(JSC::Wasm::WasmCallingConvention::callInformationFor const):
(JSC::Wasm::JSCallingConvention::marshallLocation const):

• wasm/WasmFormat.h:

(JSC::Wasm::isValueType):
(JSC::Wasm::isRefType):
(JSC::Wasm::TableInformation::wasmType const):

• wasm/WasmFunctionCodeBlock.h:
• wasm/WasmFunctionParser.h:

(JSC::Wasm::FunctionParser::TypedExpression::TypedExpression):
(JSC::Wasm::FunctionParser<Context>::load):
(JSC::Wasm::FunctionParser<Context>::store):
(JSC::Wasm::FunctionParser<Context>::atomicLoad):
(JSC::Wasm::FunctionParser<Context>::atomicStore):
(JSC::Wasm::FunctionParser<Context>::atomicBinaryRMW):
(JSC::Wasm::FunctionParser<Context>::atomicCompareExchange):
(JSC::Wasm::FunctionParser<Context>::atomicWait):
(JSC::Wasm::FunctionParser<Context>::atomicNotify):
(JSC::Wasm::FunctionParser<Context>::checkBranchTarget):
(JSC::Wasm::FunctionParser<Context>::unify):
(JSC::Wasm::FunctionParser<Context>::parseExpression):

• wasm/WasmGlobal.cpp:

(JSC::Wasm::Global::get const):
(JSC::Wasm::Global::set):
(JSC::Wasm::Global::visitAggregateImpl):

• wasm/WasmLLIntGenerator.cpp:

(JSC::Wasm::LLIntGenerator::jsNullConstant):
(JSC::Wasm::LLIntGenerator::zeroConstant):
(JSC::Wasm::LLIntGenerator::callInformationForCaller):
(JSC::Wasm::LLIntGenerator::callInformationForCallee):
(JSC::Wasm::LLIntGenerator::addArguments):
(JSC::Wasm::LLIntGenerator::addLocal):

• wasm/WasmOperations.cpp:

(JSC::Wasm::JSC_DEFINE_JIT_OPERATION):

• wasm/WasmParser.h:

(JSC::Wasm::Parser<SuccessType>::parseBlockSignature):
(JSC::Wasm::Parser<SuccessType>::parseValueType):

• wasm/WasmSectionParser.cpp:

(JSC::Wasm::SectionParser::parseType):
(JSC::Wasm::SectionParser::parseTableHelper):
(JSC::Wasm::SectionParser::parseGlobal):
(JSC::Wasm::SectionParser::parseElement):
(JSC::Wasm::SectionParser::parseInitExpr):
(JSC::Wasm::SectionParser::parseI32InitExpr):
(JSC::Wasm::SectionParser::parseElementSegmentVectorOfExpressions):

• wasm/WasmSignature.cpp:

(JSC::Wasm::Signature::dump const):
(JSC::Wasm::computeHash):
(JSC::Wasm::SignatureInformation::SignatureInformation):

• wasm/WasmSignature.h:

(JSC::Wasm::SignatureInformation::thunkFor const):

• wasm/WasmTable.cpp:

(JSC::Wasm::Table::wasmType const):

• wasm/generateWasmOpsHeader.py:

(TypeKind):

• wasm/js/JSToWasm.cpp:

(JSC::Wasm::marshallJSResult):
(JSC::Wasm::createJSToWasmWrapper):

• wasm/js/JSWebAssemblyHelpers.h:

(JSC::defaultValueForReferenceType):

• wasm/js/WasmToJS.cpp:

(JSC::Wasm::wasmToJS):

• wasm/js/WebAssemblyFunction.cpp:

(JSC::JSC_DEFINE_HOST_FUNCTION):
(JSC::WebAssemblyFunction::jsCallEntrypointSlow):

• wasm/js/WebAssemblyGlobalConstructor.cpp:

(JSC::JSC_DEFINE_HOST_FUNCTION):

• wasm/js/WebAssemblyModuleRecord.cpp:

(JSC::WebAssemblyModuleRecord::linkImpl):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/BytecodeDumper.cpp (modified) (3 diffs)
• bytecode/BytecodeDumper.h (modified) (2 diffs)
• wasm/WasmAirIRGenerator.cpp (modified) (82 diffs)
• wasm/WasmB3IRGenerator.cpp (modified) (19 diffs)
• wasm/WasmCallingConvention.h (modified) (4 diffs)
• wasm/WasmFormat.h (modified) (3 diffs)
• wasm/WasmFunctionCodeBlock.h (modified) (2 diffs)
• wasm/WasmFunctionParser.h (modified) (50 diffs)
• wasm/WasmGlobal.cpp (modified) (7 diffs)
• wasm/WasmLLIntGenerator.cpp (modified) (16 diffs)
• wasm/WasmOperations.cpp (modified) (2 diffs)
• wasm/WasmParser.h (modified) (2 diffs)
• wasm/WasmSectionParser.cpp (modified) (14 diffs)
• wasm/WasmSignature.cpp (modified) (5 diffs)
• wasm/WasmSignature.h (modified) (1 diff)
• wasm/WasmTable.cpp (modified) (1 diff)
• wasm/generateWasmOpsHeader.py (modified) (7 diffs)
• wasm/js/JSToWasm.cpp (modified) (8 diffs)
• wasm/js/JSWebAssemblyHelpers.h (modified) (1 diff)
• wasm/js/WasmToJS.cpp (modified) (11 diffs)
• wasm/js/WebAssemblyFunction.cpp (modified) (7 diffs)
• wasm/js/WebAssemblyGlobalConstructor.cpp (modified) (7 diffs)
• wasm/js/WebAssemblyModuleRecord.cpp (modified) (6 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2021-03-03  Dmitry Bezhetskov  <dbezhetskov@igalia.com>
+
+        [WASM-Function-References] Extend wasm type with type index
+        https://bugs.webkit.org/show_bug.cgi?id=222351
+
+        Reviewed by Keith Miller.
+
+        Extend wasm type with type index to represent
+        new reference types from typed function references
+        proposal: https://github.com/WebAssembly/function-references/blob/master/proposals/function-references/Overview.md.
+
+        * bytecode/BytecodeDumper.cpp:
+        (JSC::Wasm::BytecodeDumper::dumpConstants):
+        (JSC::Wasm::BytecodeDumper::formatConstant const):
+        * bytecode/BytecodeDumper.h:
+        * wasm/WasmAirIRGenerator.cpp:
+        (JSC::Wasm::TypedTmp::TypedTmp):
+        (JSC::Wasm::TypedTmp::dump const):
+        (JSC::Wasm::AirIRGenerator::g32):
+        (JSC::Wasm::AirIRGenerator::g64):
+        (JSC::Wasm::AirIRGenerator::gExternref):
+        (JSC::Wasm::AirIRGenerator::gFuncref):
+        (JSC::Wasm::AirIRGenerator::f32):
+        (JSC::Wasm::AirIRGenerator::f64):
+        (JSC::Wasm::AirIRGenerator::tmpForType):
+        (JSC::Wasm::AirIRGenerator::emitCCall):
+        (JSC::Wasm::AirIRGenerator::moveOpForValueType):
+        (JSC::Wasm::AirIRGenerator::AirIRGenerator):
+        (JSC::Wasm::AirIRGenerator::addLocal):
+        (JSC::Wasm::AirIRGenerator::addConstant):
+        (JSC::Wasm::AirIRGenerator::addRefIsNull):
+        (JSC::Wasm::AirIRGenerator::addRefFunc):
+        (JSC::Wasm::AirIRGenerator::addTableGet):
+        (JSC::Wasm::AirIRGenerator::addTableSet):
+        (JSC::Wasm::AirIRGenerator::addTableInit):
+        (JSC::Wasm::AirIRGenerator::addElemDrop):
+        (JSC::Wasm::AirIRGenerator::addTableSize):
+        (JSC::Wasm::AirIRGenerator::addTableGrow):
+        (JSC::Wasm::AirIRGenerator::addTableFill):
+        (JSC::Wasm::AirIRGenerator::addTableCopy):
+        (JSC::Wasm::AirIRGenerator::addGrowMemory):
+        (JSC::Wasm::AirIRGenerator::addCurrentMemory):
+        (JSC::Wasm::AirIRGenerator::addMemoryFill):
+        (JSC::Wasm::AirIRGenerator::addMemoryCopy):
+        (JSC::Wasm::AirIRGenerator::addMemoryInit):
+        (JSC::Wasm::AirIRGenerator::addDataDrop):
+        (JSC::Wasm::AirIRGenerator::emitCheckAndPreparePointer):
+        (JSC::Wasm::AirIRGenerator::sanitizeAtomicResult):
+        (JSC::Wasm::AirIRGenerator::appendGeneralAtomic):
+        (JSC::Wasm::AirIRGenerator::appendStrongCAS):
+        (JSC::Wasm::AirIRGenerator::emitAtomicLoadOp):
+        (JSC::Wasm::AirIRGenerator::atomicLoad):
+        (JSC::Wasm::AirIRGenerator::emitAtomicStoreOp):
+        (JSC::Wasm::AirIRGenerator::emitAtomicBinaryRMWOp):
+        (JSC::Wasm::AirIRGenerator::atomicBinaryRMW):
+        (JSC::Wasm::AirIRGenerator::emitAtomicCompareExchange):
+        (JSC::Wasm::AirIRGenerator::atomicCompareExchange):
+        (JSC::Wasm::AirIRGenerator::atomicWait):
+        (JSC::Wasm::AirIRGenerator::atomicNotify):
+        (JSC::Wasm::AirIRGenerator::truncSaturated):
+        (JSC::Wasm::AirIRGenerator::addReturn):
+        (JSC::Wasm::AirIRGenerator::addSwitch):
+        (JSC::Wasm::AirIRGenerator::emitModOrDiv):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncSF64>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncSF32>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncUF64>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32TruncUF32>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncSF64>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF64>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncSF32>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64TruncUF32>):
+        (JSC::Wasm::AirIRGenerator::addShift):
+        (JSC::Wasm::AirIRGenerator::addFloatingPointBinOp):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Min>):
+        (JSC::Wasm::AirIRGenerator::addFloatingPointMinOrMax):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Max>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Mul>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Div>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Div>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Neg>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64Rotr>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64Rotl>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32ShrU>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32ShrS>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32Shl>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Min>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Sub>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64ShrS>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64ShrU>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I64Shl>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32Rotl>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::I32Rotr>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Neg>):
+        (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Max>):
+        * wasm/WasmB3IRGenerator.cpp:
+        (JSC::Wasm::B3IRGenerator::addTableGet):
+        (JSC::Wasm::B3IRGenerator::addRefFunc):
+        (JSC::Wasm::B3IRGenerator::addTableInit):
+        (JSC::Wasm::B3IRGenerator::addTableSize):
+        (JSC::Wasm::B3IRGenerator::addTableGrow):
+        (JSC::Wasm::B3IRGenerator::addTableFill):
+        (JSC::Wasm::B3IRGenerator::addTableCopy):
+        (JSC::Wasm::B3IRGenerator::addMemoryFill):
+        (JSC::Wasm::B3IRGenerator::addMemoryInit):
+        (JSC::Wasm::B3IRGenerator::addMemoryCopy):
+        (JSC::Wasm::B3IRGenerator::sanitizeAtomicResult):
+        (JSC::Wasm::B3IRGenerator::atomicLoad):
+        (JSC::Wasm::B3IRGenerator::emitAtomicStoreOp):
+        (JSC::Wasm::B3IRGenerator::emitAtomicBinaryRMWOp):
+        (JSC::Wasm::B3IRGenerator::atomicBinaryRMW):
+        (JSC::Wasm::B3IRGenerator::emitAtomicCompareExchange):
+        (JSC::Wasm::B3IRGenerator::atomicCompareExchange):
+        * wasm/WasmCallingConvention.h:
+        (JSC::Wasm::WasmCallingConvention::marshallLocation const):
+        (JSC::Wasm::WasmCallingConvention::callInformationFor const):
+        (JSC::Wasm::JSCallingConvention::marshallLocation const):
+        * wasm/WasmFormat.h:
+        (JSC::Wasm::isValueType):
+        (JSC::Wasm::isRefType):
+        (JSC::Wasm::TableInformation::wasmType const):
+        * wasm/WasmFunctionCodeBlock.h:
+        * wasm/WasmFunctionParser.h:
+        (JSC::Wasm::FunctionParser::TypedExpression::TypedExpression):
+        (JSC::Wasm::FunctionParser<Context>::load):
+        (JSC::Wasm::FunctionParser<Context>::store):
+        (JSC::Wasm::FunctionParser<Context>::atomicLoad):
+        (JSC::Wasm::FunctionParser<Context>::atomicStore):
+        (JSC::Wasm::FunctionParser<Context>::atomicBinaryRMW):
+        (JSC::Wasm::FunctionParser<Context>::atomicCompareExchange):
+        (JSC::Wasm::FunctionParser<Context>::atomicWait):
+        (JSC::Wasm::FunctionParser<Context>::atomicNotify):
+        (JSC::Wasm::FunctionParser<Context>::checkBranchTarget):
+        (JSC::Wasm::FunctionParser<Context>::unify):
+        (JSC::Wasm::FunctionParser<Context>::parseExpression):
+        * wasm/WasmGlobal.cpp:
+        (JSC::Wasm::Global::get const):
+        (JSC::Wasm::Global::set):
+        (JSC::Wasm::Global::visitAggregateImpl):
+        * wasm/WasmLLIntGenerator.cpp:
+        (JSC::Wasm::LLIntGenerator::jsNullConstant):
+        (JSC::Wasm::LLIntGenerator::zeroConstant):
+        (JSC::Wasm::LLIntGenerator::callInformationForCaller):
+        (JSC::Wasm::LLIntGenerator::callInformationForCallee):
+        (JSC::Wasm::LLIntGenerator::addArguments):
+        (JSC::Wasm::LLIntGenerator::addLocal):
+        * wasm/WasmOperations.cpp:
+        (JSC::Wasm::JSC_DEFINE_JIT_OPERATION):
+        * wasm/WasmParser.h:
+        (JSC::Wasm::Parser<SuccessType>::parseBlockSignature):
+        (JSC::Wasm::Parser<SuccessType>::parseValueType):
+        * wasm/WasmSectionParser.cpp:
+        (JSC::Wasm::SectionParser::parseType):
+        (JSC::Wasm::SectionParser::parseTableHelper):
+        (JSC::Wasm::SectionParser::parseGlobal):
+        (JSC::Wasm::SectionParser::parseElement):
+        (JSC::Wasm::SectionParser::parseInitExpr):
+        (JSC::Wasm::SectionParser::parseI32InitExpr):
+        (JSC::Wasm::SectionParser::parseElementSegmentVectorOfExpressions):
+        * wasm/WasmSignature.cpp:
+        (JSC::Wasm::Signature::dump const):
+        (JSC::Wasm::computeHash):
+        (JSC::Wasm::SignatureInformation::SignatureInformation):
+        * wasm/WasmSignature.h:
+        (JSC::Wasm::SignatureInformation::thunkFor const):
+        * wasm/WasmTable.cpp:
+        (JSC::Wasm::Table::wasmType const):
+        * wasm/generateWasmOpsHeader.py:
+        (TypeKind):
+        * wasm/js/JSToWasm.cpp:
+        (JSC::Wasm::marshallJSResult):
+        (JSC::Wasm::createJSToWasmWrapper):
+        * wasm/js/JSWebAssemblyHelpers.h:
+        (JSC::defaultValueForReferenceType):
+        * wasm/js/WasmToJS.cpp:
+        (JSC::Wasm::wasmToJS):
+        * wasm/js/WebAssemblyFunction.cpp:
+        (JSC::JSC_DEFINE_HOST_FUNCTION):
+        (JSC::WebAssemblyFunction::jsCallEntrypointSlow):
+        * wasm/js/WebAssemblyGlobalConstructor.cpp:
+        (JSC::JSC_DEFINE_HOST_FUNCTION):
+        * wasm/js/WebAssemblyModuleRecord.cpp:
+        (JSC::WebAssemblyModuleRecord::linkImpl):
+
 2021-03-02  Yusuke Suzuki  <ysuzuki@apple.com>
 

trunk/Source/JavaScriptCore/bytecode/BytecodeDumper.cpp

@@ -38 +38 @@
 #include "WasmGeneratorTraits.h"
 #include "WasmModuleInformation.h"
-#include "WasmOps.h"
 #include "WasmSignatureInlines.h"
 
@@ -363 +362 @@
         for (const auto& constant : block->constants()) {
             Type type = block->constantTypes()[i];
-            this->m_out.print("   const", i, " : ", type, " = ", formatConstant(type, constant), "\n");
+            this->m_out.print("   const", i, " : ", type.kind, " = ", formatConstant(type, constant), "\n");
             ++i;
         }
@@ -378 +377 @@
 CString BytecodeDumper::formatConstant(Type type, uint64_t constant) const
 {
-    switch (type) {
-    case Type::I32:
+    switch (type.kind) {
+    case TypeKind::I32:
         return toCString(static_cast<int32_t>(constant));
-    case Type::I64:
+    case TypeKind::I64:
         return toCString(constant);
-    case Type::F32:
+    case TypeKind::F32:
         return toCString(bitwise_cast<float>(static_cast<int32_t>(constant)));
         break;
-    case Type::F64:
+    case TypeKind::F64:
         return toCString(bitwise_cast<double>(constant));
         break;
-    case Type::Externref:
-    case Type::Funcref:
+    case TypeKind::Externref:
+    case TypeKind::Funcref:
         if (JSValue::decode(constant) == jsNull())
             return "null";

trunk/Source/JavaScriptCore/bytecode/BytecodeDumper.h

@@ -32 +32 @@
 #include "InstructionStream.h"
 #include "StructureStubInfo.h"
+#include "WasmOps.h"
 
 namespace JSC {
@@ -131 +132 @@
 class FunctionCodeBlock;
 struct ModuleInformation;
-enum Type : int8_t;
 
 class BytecodeDumper final : public JSC::BytecodeDumper<FunctionCodeBlock> {

trunk/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp

@@ -86 +86 @@
     constexpr TypedTmp()
         : m_tmp()
-        , m_type(Type::Void)
-    { }
+        , m_type(Types::Void)
+    {
+    }
 
     TypedTmp(Tmp tmp, Type type)
@@ -117 +118 @@
     void dump(PrintStream& out) const
     {
-        out.print("(", m_tmp, ", ", m_type, ")");
+        out.print("(", m_tmp, ", ", m_type.kind, ", ", m_type.index, ")");
     }
 
@@ -407 +408 @@
     }
 
-    TypedTmp g32() { return { newTmp(B3::GP), Type::I32 }; }
-    TypedTmp g64() { return { newTmp(B3::GP), Type::I64 }; }
-    TypedTmp gExternref() { return { newTmp(B3::GP), Type::Externref }; }
-    TypedTmp gFuncref() { return { newTmp(B3::GP), Type::Funcref }; }
-    TypedTmp f32() { return { newTmp(B3::FP), Type::F32 }; }
-    TypedTmp f64() { return { newTmp(B3::FP), Type::F64 }; }
+    TypedTmp g32() { return { newTmp(B3::GP), Types::I32 }; }
+    TypedTmp g64() { return { newTmp(B3::GP), Types::I64 }; }
+    TypedTmp gExternref() { return { newTmp(B3::GP), Types::Externref }; }
+    TypedTmp gFuncref() { return { newTmp(B3::GP), Types::Funcref }; }
+    TypedTmp f32() { return { newTmp(B3::FP), Types::F32 }; }
+    TypedTmp f64() { return { newTmp(B3::FP), Types::F64 }; }
 
     TypedTmp tmpForType(Type type)
     {
-        switch (type) {
-        case Type::I32:
+        switch (type.kind) {
+        case TypeKind::I32:
             return g32();
-        case Type::I64:
+        case TypeKind::I64:
             return g64();
-        case Type::Funcref:
+        case TypeKind::Funcref:
             return gFuncref();
-        case Type::Externref:
+        case TypeKind::Externref:
             return gExternref();
-        case Type::F32:
+        case TypeKind::F32:
             return f32();
-        case Type::F64:
+        case TypeKind::F64:
             return f64();
-        case Type::Void:
+        case TypeKind::Void:
             return { };
         default:
@@ -592 +593 @@
         B3::Type resultType = B3::Void;
         if (result) {
-            switch (result.type()) {
-            case Type::I32:
+            switch (result.type().kind) {
+            case TypeKind::I32:
                 resultType = B3::Int32;
                 break;
-            case Type::I64:
-            case Type::Externref:
-            case Type::Funcref:
+            case TypeKind::I64:
+            case TypeKind::Externref:
+            case TypeKind::Funcref:
                 resultType = B3::Int64;
                 break;
-            case Type::F32:
+            case TypeKind::F32:
                 resultType = B3::Float;
                 break;
-            case Type::F64:
+            case TypeKind::F64:
                 resultType = B3::Double;
                 break;
@@ -642 +643 @@
     static B3::Air::Opcode moveOpForValueType(Type type)
     {
-        switch (type) {
-        case Type::I32:
+        switch (type.kind) {
+        case TypeKind::I32:
             return Move32;
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             return Move;
-        case Type::F32:
+        case TypeKind::F32:
             return MoveFloat;
-        case Type::F64:
+        case TypeKind::F64:
             return MoveDouble;
         default:
@@ -884 +885 @@
         append(Move, Tmp(contextInstance), m_instanceValue);
     } else
-        m_instanceValue = { Tmp(contextInstance), Type::I64 };
+        m_instanceValue = { Tmp(contextInstance), Types::I64 };
 
     ASSERT(!m_locals.size());
@@ -898 +899 @@
         B3::ValueRep location = wasmCallInfo.params[i];
         Arg arg = location.isReg() ? Arg(Tmp(location.reg())) : Arg::addr(Tmp(GPRInfo::callFrameRegister), location.offsetFromFP());
-        switch (signature.argument(i)) {
-        case Type::I32:
+        switch (signature.argument(i).kind) {
+        case TypeKind::I32:
             append(Move32, arg, m_locals[i]);
             break;
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             append(Move, arg, m_locals[i]);
             break;
-        case Type::F32:
+        case TypeKind::F32:
             append(MoveFloat, arg, m_locals[i]);
             break;
-        case Type::F64:
+        case TypeKind::F64:
             append(MoveDouble, arg, m_locals[i]);
             break;
@@ -1005 +1006 @@
         auto local = tmpForType(type);
         m_locals.uncheckedAppend(local);
-        switch (type) {
-        case Type::Externref:
-        case Type::Funcref:
+        switch (type.kind) {
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             append(Move, Arg::imm(JSValue::encode(jsNull())), local);
             break;
-        case Type::I32:
-        case Type::I64: {
+        case TypeKind::I32:
+        case TypeKind::I64: {
             append(Xor64, local, local);
             break;
         }
-        case Type::F32:
-        case Type::F64: {
+        case TypeKind::F32:
+        case TypeKind::F64: {
             auto temp = g64();
             // IEEE 754 "0" is just int32/64 zero.
             append(Xor64, temp, temp);
-            append(type == Type::F32 ? Move32ToFloat : Move64ToDouble, temp, local);
+            append(type.isF32() ? Move32ToFloat : Move64ToDouble, temp, local);
             break;
         }
@@ -1038 +1039 @@
 {
     auto result = tmpForType(type);
-    switch (type) {
-    case Type::I32:
-    case Type::I64:
-    case Type::Externref:
-    case Type::Funcref:
+    switch (type.kind) {
+    case TypeKind::I32:
+    case TypeKind::I64:
+    case TypeKind::Externref:
+    case TypeKind::Funcref:
         append(block, Move, Arg::bigImm(value), result);
         break;
-    case Type::F32:
-    case Type::F64: {
+    case TypeKind::F32:
+    case TypeKind::F64: {
         auto tmp = g64();
         append(block, Move, Arg::bigImm(value), tmp);
-        append(block, type == Type::F32 ? Move32ToFloat : Move64ToDouble, tmp, result);
+        append(block, type.isF32() ? Move32ToFloat : Move64ToDouble, tmp, result);
         break;
     }
@@ -1075 +1076 @@
 {
     ASSERT(value.tmp());
-    result = tmpForType(Type::I32);
+    result = tmpForType(Types::I32);
     auto tmp = g64();
 
@@ -1087 +1088 @@
 {
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
-    result = tmpForType(Type::Funcref);
-    emitCCall(&operationWasmRefFunc, result, instanceValue(), addConstant(Type::I32, index));
+    result = tmpForType(Types::Funcref);
+    emitCCall(&operationWasmRefFunc, result, instanceValue(), addConstant(Types::I32, index));
 
     return { };
@@ -1097 +1098 @@
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
     ASSERT(index.tmp());
-    ASSERT(index.type() == Type::I32);
+
+    ASSERT(index.type().isI32());
     result = tmpForType(m_info.tables[tableIndex].wasmType());
 
-    emitCCall(&operationGetWasmTableElement, result, instanceValue(), addConstant(Type::I32, tableIndex), index);
+    emitCCall(&operationGetWasmTableElement, result, instanceValue(), addConstant(Types::I32, tableIndex), index);
     emitCheck([&] {
         return Inst(BranchTest32, nullptr, Arg::resCond(MacroAssembler::Zero), result, result);
@@ -1114 +1116 @@
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
     ASSERT(index.tmp());
-    ASSERT(index.type() == Type::I32);
+    ASSERT(index.type().isI32());
     ASSERT(value.tmp());
 
     auto shouldThrow = g32();
-    emitCCall(&operationSetWasmTableElement, shouldThrow, instanceValue(), addConstant(Type::I32, tableIndex), index, value);
+    emitCCall(&operationSetWasmTableElement, shouldThrow, instanceValue(), addConstant(Types::I32, tableIndex), index, value);
 
     emitCheck([&] {
@@ -1132 +1134 @@
 {
     ASSERT(dstOffset.tmp());
-    ASSERT(dstOffset.type() == Type::I32);
+    ASSERT(dstOffset.type().isI32());
 
     ASSERT(srcOffset.tmp());
-    ASSERT(srcOffset.type() == Type::I32);
+    ASSERT(srcOffset.type().isI32());
 
     ASSERT(length.tmp());
-    ASSERT(length.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
+    ASSERT(length.type().isI32());
+
+    auto result = tmpForType(Types::I32);
     emitCCall(
         &operationWasmTableInit, result, instanceValue(),
-        addConstant(Type::I32, elementIndex),
-        addConstant(Type::I32, tableIndex),
+        addConstant(Types::I32, elementIndex),
+        addConstant(Types::I32, tableIndex),
         dstOffset, srcOffset, length);
 
@@ -1158 +1160 @@
 auto AirIRGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
 {
-    emitCCall(&operationWasmElemDrop, TypedTmp(), instanceValue(), addConstant(Type::I32, elementIndex));
+    emitCCall(&operationWasmElemDrop, TypedTmp(), instanceValue(), addConstant(Types::I32, elementIndex));
     return { };
 }
@@ -1165 +1167 @@
 {
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
-    result = tmpForType(Type::I32);
-
-    emitCCall(&operationGetWasmTableSize, result, instanceValue(), addConstant(Type::I32, tableIndex));
+    result = tmpForType(Types::I32);
+
+    emitCCall(&operationGetWasmTableSize, result, instanceValue(), addConstant(Types::I32, tableIndex));
 
     return { };
@@ -1177 +1179 @@
     ASSERT(fill.type() == m_info.tables[tableIndex].wasmType());
     ASSERT(delta.tmp());
-    ASSERT(delta.type() == Type::I32);
-    result = tmpForType(Type::I32);
-
-    emitCCall(&operationWasmTableGrow, result, instanceValue(), addConstant(Type::I32, tableIndex), fill, delta);
+    ASSERT(delta.type().isI32());
+    result = tmpForType(Types::I32);
+
+    emitCCall(&operationWasmTableGrow, result, instanceValue(), addConstant(Types::I32, tableIndex), fill, delta);
 
     return { };
@@ -1190 +1192 @@
     ASSERT(fill.type() == m_info.tables[tableIndex].wasmType());
     ASSERT(offset.tmp());
-    ASSERT(offset.type() == Type::I32);
+    ASSERT(offset.type().isI32());
     ASSERT(count.tmp());
-    ASSERT(count.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
-    emitCCall(&operationWasmTableFill, result, instanceValue(), addConstant(Type::I32, tableIndex), offset, fill, count);
+    ASSERT(count.type().isI32());
+
+    auto result = tmpForType(Types::I32);
+    emitCCall(&operationWasmTableFill, result, instanceValue(), addConstant(Types::I32, tableIndex), offset, fill, count);
 
     emitCheck([&] {
@@ -1209 +1211 @@
 {
     ASSERT(dstOffset.tmp());
-    ASSERT(dstOffset.type() == Type::I32);
+    ASSERT(dstOffset.type().isI32());
 
     ASSERT(srcOffset.tmp());
-    ASSERT(srcOffset.type() == Type::I32);
+    ASSERT(srcOffset.type().isI32());
 
     ASSERT(length.tmp());
-    ASSERT(length.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
+    ASSERT(length.type().isI32());
+
+    auto result = tmpForType(Types::I32);
     emitCCall(
         &operationWasmTableCopy, result, instanceValue(),
-        addConstant(Type::I32, dstTableIndex),
-        addConstant(Type::I32, srcTableIndex),
+        addConstant(Types::I32, dstTableIndex),
+        addConstant(Types::I32, srcTableIndex),
         dstOffset, srcOffset, length);
 
@@ -1255 +1257 @@
 {
     result = g32();
-    emitCCall(&operationGrowMemory, result, TypedTmp { Tmp(GPRInfo::callFrameRegister), Type::I64 }, instanceValue(), delta);
+    emitCCall(&operationGrowMemory, result, TypedTmp { Tmp(GPRInfo::callFrameRegister), Types::I64 }, instanceValue(), delta);
     restoreWebAssemblyGlobalState(RestoreCachedStackLimit::No, m_info.memory, instanceValue(), m_currentBlock);
 
@@ -1277 +1279 @@
     static_assert(PageCount::pageSize == 1ull << shiftValue, "This must hold for the code below to be correct.");
     append(Move, Arg::imm(16), temp2);
-    addShift(Type::I32, Urshift64, temp1, temp2, result);
+    addShift(Types::I32, Urshift64, temp1, temp2, result);
     append(Move32, result, result);
 
@@ -1286 +1288 @@
 {
     ASSERT(dstAddress.tmp());
-    ASSERT(dstAddress.type() == Type::I32);
+    ASSERT(dstAddress.type().isI32());
 
     ASSERT(targetValue.tmp());
-    ASSERT(targetValue.type() == Type::I32);
+    ASSERT(targetValue.type().isI32());
 
     ASSERT(count.tmp());
-    ASSERT(count.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
+    ASSERT(count.type().isI32());
+
+    auto result = tmpForType(Types::I32);
     emitCCall(
         &operationWasmMemoryFill, result, instanceValue(),
@@ -1311 +1313 @@
 {
     ASSERT(dstAddress.tmp());
-    ASSERT(dstAddress.type() == Type::I32);
+    ASSERT(dstAddress.type().isI32());
 
     ASSERT(srcAddress.tmp());
-    ASSERT(srcAddress.type() == Type::I32);
+    ASSERT(srcAddress.type().isI32());
 
     ASSERT(count.tmp());
-    ASSERT(count.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
+    ASSERT(count.type().isI32());
+
+    auto result = tmpForType(Types::I32);
     emitCCall(
         &operationWasmMemoryCopy, result, instanceValue(),
@@ -1336 +1338 @@
 {
     ASSERT(dstAddress.tmp());
-    ASSERT(dstAddress.type() == Type::I32);
+    ASSERT(dstAddress.type().isI32());
 
     ASSERT(srcAddress.tmp());
-    ASSERT(srcAddress.type() == Type::I32);
+    ASSERT(srcAddress.type().isI32());
 
     ASSERT(length.tmp());
-    ASSERT(length.type() == Type::I32);
-
-    auto result = tmpForType(Type::I32);
+    ASSERT(length.type().isI32());
+
+    auto result = tmpForType(Types::I32);
     emitCCall(
         &operationWasmMemoryInit, result, instanceValue(),
-        addConstant(Type::I32, dataSegmentIndex),
+        addConstant(Types::I32, dataSegmentIndex),
         dstAddress, srcAddress, length);
 
@@ -1361 +1363 @@
 auto AirIRGenerator::addDataDrop(unsigned dataSegmentIndex) -> PartialResult
 {
-    emitCCall(&operationWasmDataDrop, TypedTmp(), instanceValue(), addConstant(Type::I32, dataSegmentIndex));
+    emitCCall(&operationWasmDataDrop, TypedTmp(), instanceValue(), addConstant(Types::I32, dataSegmentIndex));
     return { };
 }
@@ -1581 +1583 @@
             append(Move, Arg::bigImm(static_cast<uint64_t>(sizeOfOperation) + offset - 1), temp);
             append(Add64, result, temp);
-            auto sizeMax = addConstant(Type::I64, maximum);
+            auto sizeMax = addConstant(Types::I64, maximum);
 
             emitCheck([&] {
@@ -1901 +1903 @@
 void AirIRGenerator::sanitizeAtomicResult(ExtAtomicOpType op, Type valueType, Tmp source, Tmp dest)
 {
-    switch (valueType) {
-    case Type::I64: {
+    switch (valueType.kind) {
+    case TypeKind::I64: {
         switch (accessWidth(op)) {
         case B3::Width8:
@@ -1921 +1923 @@
         return;
     }
-    case Type::I32:
+    case TypeKind::I32:
         switch (accessWidth(op)) {
         case B3::Width8:
@@ -1960 +1962 @@
     auto tmp = [&](Arg arg) -> TypedTmp {
         if (arg.isTmp())
-            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Type::I64 : Type::I32);
+            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Types::I64 : Types::I32);
         TypedTmp result = newTmp();
         append(Move, arg, result);
@@ -2071 +2073 @@
     auto tmp = [&](Arg arg) -> TypedTmp {
         if (arg.isTmp())
-            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Type::I64 : Type::I32);
+            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Types::I64 : Types::I32);
         TypedTmp result = newTmp();
         append(Move, arg, result);
@@ -2166 +2168 @@
     B3::Air::Opcode nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Add, accessWidth(op));
 
-    TypedTmp result = valueType == Type::I64 ? g64() : g32();
+    TypedTmp result = valueType.isI64() ? g64() : g32();
 
     if (opcode) {
@@ -2203 +2205 @@
 
         // We won't reach here, so we just pick a random reg.
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = g32();
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = g64();
             break;
@@ -2240 +2242 @@
     if (opcode) {
         if (isValidForm(opcode.value(), Arg::Tmp, addrArg.kind(), Arg::Tmp)) {
-            TypedTmp result = valueType == Type::I64 ? g64() : g32();
+            TypedTmp result = valueType.isI64() ? g64() : g32();
             appendEffectful(opcode.value(), value, addrArg, result);
             return;
@@ -2246 +2248 @@
 
         if (isValidForm(opcode.value(), Arg::Tmp, addrArg.kind())) {
-            TypedTmp result = valueType == Type::I64 ? g64() : g32();
+            TypedTmp result = valueType.isI64() ? g64() : g32();
             append(Move, value, result);
             appendEffectful(opcode.value(), result, addrArg);
@@ -2253 +2255 @@
     }
 
-    appendGeneralAtomic(op, nonAtomicOpcode, B3::Commutative, value, addrArg, valueType == Type::I64 ? g64() : g32());
+    appendGeneralAtomic(op, nonAtomicOpcode, B3::Commutative, value, addrArg, valueType.isI64() ? g64() : g32());
 }
 
@@ -2312 +2314 @@
         if (isX86() || isARM64E()) {
             TypedTmp newValue;
-            if (valueType == Type::I64) {
+            if (valueType.isI64()) {
                 newValue = g64();
                 append(Move, value, newValue);
@@ -2339 +2341 @@
         if (isARM64E()) {
             TypedTmp newValue;
-            if (valueType == Type::I64) {
+            if (valueType.isI64()) {
                 newValue = g64();
                 append(Not64, value, newValue);
@@ -2392 +2394 @@
     }
 
-    TypedTmp result = valueType == Type::I64 ? g64() : g32();
+    TypedTmp result = valueType.isI64() ? g64() : g32();
 
     if (opcode) {
@@ -2427 +2429 @@
         emitPatchpoint(patch, Tmp());
 
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = g32();
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = g64();
             break;
@@ -2459 +2461 @@
     }
 
-    TypedTmp result = valueType == Type::I64 ? g64() : g32();
+    TypedTmp result = valueType.isI64() ? g64() : g32();
 
     if (valueWidth == accessWidth) {
@@ -2471 +2473 @@
     BasicBlock* continuation = m_code.addBlock();
 
-    TypedTmp truncatedExpected = valueType == Type::I64 ? g64() : g32();
+    TypedTmp truncatedExpected = valueType.isI64() ? g64() : g32();
     sanitizeAtomicResult(op, valueType, expected, truncatedExpected);
 
@@ -2526 +2528 @@
 
         // We won't reach here, so we just pick a random reg.
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = g32();
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = g64();
             break;
@@ -2547 +2549 @@
 
     if (op == ExtAtomicOpType::MemoryAtomicWait32)
-        emitCCall(&operationMemoryAtomicWait32, result, instanceValue(), pointer, addConstant(Type::I32, offset), value, timeout);
+        emitCCall(&operationMemoryAtomicWait32, result, instanceValue(), pointer, addConstant(Types::I32, offset), value, timeout);
     else
-        emitCCall(&operationMemoryAtomicWait64, result, instanceValue(), pointer, addConstant(Type::I32, offset), value, timeout);
+        emitCCall(&operationMemoryAtomicWait64, result, instanceValue(), pointer, addConstant(Types::I32, offset), value, timeout);
     emitCheck([&] {
         return Inst(Branch32, nullptr, Arg::relCond(MacroAssembler::LessThan), result, Arg::imm(0));
@@ -2563 +2565 @@
     result = g32();
 
-    emitCCall(&operationMemoryAtomicNotify, result, instanceValue(), pointer, addConstant(Type::I32, offset), count);
+    emitCCall(&operationMemoryAtomicNotify, result, instanceValue(), pointer, addConstant(Types::I32, offset), count);
     emitCheck([&] {
         return Inst(Branch32, nullptr, Arg::relCond(MacroAssembler::LessThan), result, Arg::imm(0));
@@ -2587 +2589 @@
     switch (op) {
     case Ext1OpType::I32TruncSatF32S:
-        maxFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int32_t>::min())));
-        minFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min())));
+        maxFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int32_t>::min())));
+        minFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min())));
         break;
     case Ext1OpType::I32TruncSatF32U:
-        maxFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min()) * static_cast<float>(-2.0)));
-        minFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
+        maxFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min()) * static_cast<float>(-2.0)));
+        minFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
         break;
     case Ext1OpType::I32TruncSatF64S:
-        maxFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int32_t>::min())));
-        minFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) - 1.0));
+        maxFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int32_t>::min())));
+        minFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) - 1.0));
         break;
     case Ext1OpType::I32TruncSatF64U:
-        maxFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) * -2.0));
-        minFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(-1.0));
+        maxFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) * -2.0));
+        minFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(-1.0));
         break;
     case Ext1OpType::I64TruncSatF32S:
-        maxFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int64_t>::min())));
-        minFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min())));
+        maxFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int64_t>::min())));
+        minFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min())));
         break;
     case Ext1OpType::I64TruncSatF32U:
-        maxFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min()) * static_cast<float>(-2.0)));
-        minFloat = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
+        maxFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min()) * static_cast<float>(-2.0)));
+        minFloat = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
         if (isX86())
-            signBitConstant = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
+            signBitConstant = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
         requiresMacroScratchRegisters = true;
         break;
     case Ext1OpType::I64TruncSatF64S:
-        maxFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int64_t>::min())));
-        minFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min())));
+        maxFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int64_t>::min())));
+        minFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min())));
         break;
     case Ext1OpType::I64TruncSatF64U:
-        maxFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min()) * -2.0));
-        minFloat = addConstant(Type::F64, bitwise_cast<uint64_t>(-1.0));
+        maxFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min()) * -2.0));
+        minFloat = addConstant(Types::F64, bitwise_cast<uint64_t>(-1.0));
         if (isX86())
-            signBitConstant = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
+            signBitConstant = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
         requiresMacroScratchRegisters = true;
         break;
@@ -2665 +2667 @@
     BasicBlock* continuation = m_code.addBlock();
 
-    auto branchOp = operandType == Type::F32 ? BranchFloat : BranchDouble;
+    auto branchOp = operandType == Types::F32 ? BranchFloat : BranchDouble;
     append(m_currentBlock, branchOp, Arg::doubleCond(MacroAssembler::DoubleLessThanOrEqualOrUnordered), arg, minFloat);
     m_currentBlock->setSuccessors(minCase, maxCheckCase);
@@ -3001 +3003 @@
 
         ASSERT(rep.isReg());
-        if (data.signature()->returnType(i) == I32)
+        if (data.signature()->returnType(i).isI32())
             append(Move32, tmp, tmp);
         returnConstraints.append(ConstrainedTmp(tmp, wasmCallInfo.results[i]));
@@ -3041 +3043 @@
     successors.append(defaultTarget.targetBlockForBranch());
 
-    ASSERT(condition.type() == Type::I32);
+    ASSERT(condition.type().isI32());
 
     // FIXME: We should consider dynamically switching between a jump table
@@ -3615 +3617 @@
 
         auto temp = sizeof(IntType) == 4 ? g32() : g64();
-        auto one = addConstant(sizeof(IntType) == 4 ? Type::I32 : Type::I64, 1);
+        auto one = addConstant(sizeof(IntType) == 4 ? Types::I32 : Types::I64, 1);
 
         append(sizeof(IntType) == 4 ? Add32 : Add64, rhs, one, temp);
@@ -3625 +3627 @@
         denMayBeBad->setSuccessors(continuation, denNotZero);
 
-        auto min = addConstant(denNotZero, sizeof(IntType) == 4 ? Type::I32 : Type::I64, std::numeric_limits<IntType>::min());
+        auto min = addConstant(denNotZero, sizeof(IntType) == 4 ? Types::I32 : Types::I64, std::numeric_limits<IntType>::min());
         if (isDiv)
             append(denNotZero, sizeof(IntType) == 4 ? Move32 : Move, min, result);
@@ -3888 +3890 @@
 auto AirIRGenerator::addOp<OpType::I32TruncSF64>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int32_t>::min())));
-    auto min = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) - 1.0));
+    auto max = addConstant(Types::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int32_t>::min())));
+    auto min = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) - 1.0));
 
     auto temp1 = g32();
@@ -3917 +3919 @@
 auto AirIRGenerator::addOp<OpType::I32TruncSF32>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int32_t>::min())));
-    auto min = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min())));
+    auto max = addConstant(Types::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int32_t>::min())));
+    auto min = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min())));
 
     auto temp1 = g32();
@@ -3946 +3948 @@
 auto AirIRGenerator::addOp<OpType::I32TruncUF64>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) * -2.0));
-    auto min = addConstant(Type::F64, bitwise_cast<uint64_t>(-1.0));
+    auto max = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int32_t>::min()) * -2.0));
+    auto min = addConstant(Types::F64, bitwise_cast<uint64_t>(-1.0));
 
     auto temp1 = g32();
@@ -3974 +3976 @@
 auto AirIRGenerator::addOp<OpType::I32TruncUF32>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min()) * static_cast<float>(-2.0)));
-    auto min = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
+    auto max = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int32_t>::min()) * static_cast<float>(-2.0)));
+    auto min = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
 
     auto temp1 = g32();
@@ -4002 +4004 @@
 auto AirIRGenerator::addOp<OpType::I64TruncSF64>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int64_t>::min())));
-    auto min = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min())));
+    auto max = addConstant(Types::F64, bitwise_cast<uint64_t>(-static_cast<double>(std::numeric_limits<int64_t>::min())));
+    auto min = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min())));
 
     auto temp1 = g32();
@@ -4031 +4033 @@
 auto AirIRGenerator::addOp<OpType::I64TruncUF64>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min()) * -2.0));
-    auto min = addConstant(Type::F64, bitwise_cast<uint64_t>(-1.0));
+    auto max = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<int64_t>::min()) * -2.0));
+    auto min = addConstant(Types::F64, bitwise_cast<uint64_t>(-1.0));
     
     auto temp1 = g32();
@@ -4048 +4050 @@
     TypedTmp signBitConstant;
     if (isX86())
-        signBitConstant = addConstant(Type::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
+        signBitConstant = addConstant(Types::F64, bitwise_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
 
     Vector<ConstrainedTmp> args;
@@ -4078 +4080 @@
 auto AirIRGenerator::addOp<OpType::I64TruncSF32>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int64_t>::min())));
-    auto min = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min())));
+    auto max = addConstant(Types::F32, bitwise_cast<uint32_t>(-static_cast<float>(std::numeric_limits<int64_t>::min())));
+    auto min = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min())));
 
     auto temp1 = g32();
@@ -4106 +4108 @@
 auto AirIRGenerator::addOp<OpType::I64TruncUF32>(ExpressionType arg, ExpressionType& result) -> PartialResult
 {
-    auto max = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min()) * static_cast<float>(-2.0)));
-    auto min = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
+    auto max = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<int64_t>::min()) * static_cast<float>(-2.0)));
+    auto min = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(-1.0)));
     
     auto temp1 = g32();
@@ -4123 +4125 @@
     TypedTmp signBitConstant;
     if (isX86())
-        signBitConstant = addConstant(Type::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
+        signBitConstant = addConstant(Types::F32, bitwise_cast<uint32_t>(static_cast<float>(std::numeric_limits<uint64_t>::max() - std::numeric_limits<int64_t>::max())));
 
     auto* patchpoint = addPatchpoint(B3::Int64);
@@ -4153 +4155 @@
 auto AirIRGenerator::addShift(Type type, B3::Air::Opcode op, ExpressionType value, ExpressionType shift, ExpressionType& result) -> PartialResult
 {
-    ASSERT(type == Type::I64 || type == Type::I32);
+    ASSERT(type.isI64() || type.isI32());
     result = tmpForType(type);
 
@@ -4221 +4223 @@
 auto AirIRGenerator::addFloatingPointBinOp(Type type, B3::Air::Opcode op, ExpressionType lhs, ExpressionType rhs, ExpressionType& result) -> PartialResult
 {
-    ASSERT(type == Type::F32 || type == Type::F64);
+    ASSERT(type.isF32() || type.isF64());
     result = tmpForType(type);
 
@@ -4274 +4276 @@
 template<> auto AirIRGenerator::addOp<OpType::F32Min>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointMinOrMax(F32, MinOrMax::Min, arg0, arg1, result);
+    return addFloatingPointMinOrMax(Types::F32, MinOrMax::Min, arg0, arg1, result);
 }
 
@@ -4293 +4295 @@
 auto AirIRGenerator::addFloatingPointMinOrMax(Type floatType, MinOrMax minOrMax, ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    ASSERT(floatType == F32 || floatType == F64);
+    ASSERT(floatType.isF32() || floatType.isF64());
     result = tmpForType(floatType);
 
@@ -4304 +4306 @@
     BasicBlock* continuation = m_code.addBlock();
 
-    auto branchOp = floatType == F32 ? BranchFloat : BranchDouble;
+    auto branchOp = floatType.isF32() ? BranchFloat : BranchDouble;
     append(m_currentBlock, branchOp, Arg::doubleCond(MacroAssembler::DoubleEqualAndOrdered), arg0, arg1);
     m_currentBlock->setSuccessors(isEqual, notEqual);
@@ -4314 +4316 @@
     notLessThan->setSuccessors(isGreaterThan, isNaN);
 
-    auto andOp = floatType == F32 ? AndFloat : AndDouble;
-    auto orOp = floatType == F32 ? OrFloat : OrDouble;
+    auto andOp = floatType.isF32() ? AndFloat : AndDouble;
+    auto orOp = floatType.isF32() ? OrFloat : OrDouble;
     append(isEqual, minOrMax == MinOrMax::Max ? andOp : orOp, arg0, arg1, result);
     append(isEqual, Jump);
@@ -4330 +4332 @@
     isGreaterThan->setSuccessors(continuation);
 
-    auto addOp = floatType == F32 ? AddFloat : AddDouble;
+    auto addOp = floatType.isF32() ? AddFloat : AddDouble;
     append(isNaN, addOp, arg0, arg1, result);
     append(isNaN, Jump);
@@ -4342 +4344 @@
 template<> auto AirIRGenerator::addOp<OpType::F32Max>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointMinOrMax(F32, MinOrMax::Max, arg0, arg1, result);
+    return addFloatingPointMinOrMax(Types::F32, MinOrMax::Max, arg0, arg1, result);
 }
 
 template<> auto AirIRGenerator::addOp<OpType::F64Mul>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointBinOp(Type::F64, MulDouble, arg0, arg1, result);
+    return addFloatingPointBinOp(Types::F64, MulDouble, arg0, arg1, result);
 }
 
 template<> auto AirIRGenerator::addOp<OpType::F32Div>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointBinOp(Type::F32, DivFloat, arg0, arg1, result);
+    return addFloatingPointBinOp(Types::F32, DivFloat, arg0, arg1, result);
 }
 
@@ -4461 +4463 @@
 template<> auto AirIRGenerator::addOp<OpType::F64Div>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointBinOp(Type::F64, DivDouble, arg0, arg1, result);
+    return addFloatingPointBinOp(Types::F64, DivDouble, arg0, arg1, result);
 }
 
@@ -4512 +4514 @@
         append(NegateFloat, arg0, result);
     else {
-        auto constant = addConstant(Type::I32, bitwise_cast<uint32_t>(static_cast<float>(-0.0)));
+        auto constant = addConstant(Types::I32, bitwise_cast<uint32_t>(static_cast<float>(-0.0)));
         auto temp = g32();
         append(MoveFloatTo32, arg0, temp);
@@ -4537 +4539 @@
 template<> auto AirIRGenerator::addOp<OpType::I64Rotr>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I64, RotateRight64, arg0, arg1, result);
+    return addShift(Types::I64, RotateRight64, arg0, arg1, result);
 }
 
@@ -4596 +4598 @@
         append(Move, arg1, newShift);
         append(Neg64, newShift);
-        return addShift(Type::I64, RotateRight64, arg0, newShift, result);
+        return addShift(Types::I64, RotateRight64, arg0, newShift, result);
     } else
-        return addShift(Type::I64, RotateLeft64, arg0, arg1, result);
+        return addShift(Types::I64, RotateLeft64, arg0, arg1, result);
 }
 
@@ -4638 +4640 @@
 template<> auto AirIRGenerator::addOp<OpType::I32ShrU>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I32, Urshift32, arg0, arg1, result);
+    return addShift(Types::I32, Urshift32, arg0, arg1, result);
 }
 
@@ -4652 +4654 @@
 template<> auto AirIRGenerator::addOp<OpType::I32ShrS>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I32, Rshift32, arg0, arg1, result);
+    return addShift(Types::I32, Rshift32, arg0, arg1, result);
 }
 
@@ -4678 +4680 @@
 template<> auto AirIRGenerator::addOp<OpType::I32Shl>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I32, Lshift32, arg0, arg1, result);
+    return addShift(Types::I32, Lshift32, arg0, arg1, result);
 }
 
@@ -4702 +4704 @@
 template<> auto AirIRGenerator::addOp<OpType::F64Min>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointMinOrMax(F64, MinOrMax::Min, arg0, arg1, result);
+    return addFloatingPointMinOrMax(Types::F64, MinOrMax::Min, arg0, arg1, result);
 }
 
@@ -4733 +4735 @@
 template<> auto AirIRGenerator::addOp<OpType::F64Sub>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointBinOp(Type::F64, SubDouble, arg0, arg1, result);
+    return addFloatingPointBinOp(Types::F64, SubDouble, arg0, arg1, result);
 }
 
@@ -4885 +4887 @@
 template<> auto AirIRGenerator::addOp<OpType::I64ShrS>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I64, Rshift64, arg0, arg1, result);
+    return addShift(Types::I64, Rshift64, arg0, arg1, result);
 }
 
 template<> auto AirIRGenerator::addOp<OpType::I64ShrU>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I64, Urshift64, arg0, arg1, result);
+    return addShift(Types::I64, Urshift64, arg0, arg1, result);
 }
 
@@ -4902 +4904 @@
 template<> auto AirIRGenerator::addOp<OpType::I64Shl>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I64, Lshift64, arg0, arg1, result);
+    return addShift(Types::I64, Lshift64, arg0, arg1, result);
 }
 
@@ -4926 +4928 @@
         append(Move, arg1, newShift);
         append(Neg64, newShift);
-        return addShift(Type::I32, RotateRight32, arg0, newShift, result);
+        return addShift(Types::I32, RotateRight32, arg0, newShift, result);
     } else
-        return addShift(Type::I32, RotateLeft32, arg0, arg1, result);
+        return addShift(Types::I32, RotateLeft32, arg0, arg1, result);
 }
 
 template<> auto AirIRGenerator::addOp<OpType::I32Rotr>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addShift(Type::I32, RotateRight32, arg0, arg1, result);
+    return addShift(Types::I32, RotateRight32, arg0, arg1, result);
 }
 
@@ -5006 +5008 @@
         append(NegateDouble, arg0, result);
     else {
-        auto constant = addConstant(Type::I64, bitwise_cast<uint64_t>(static_cast<double>(-0.0)));
+        auto constant = addConstant(Types::I64, bitwise_cast<uint64_t>(static_cast<double>(-0.0)));
         auto temp = g64();
         append(MoveDoubleTo64, arg0, temp);
@@ -5017 +5019 @@
 template<> auto AirIRGenerator::addOp<OpType::F64Max>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
 {
-    return addFloatingPointMinOrMax(F64, MinOrMax::Max, arg0, arg1, result);
+    return addFloatingPointMinOrMax(Types::F64, MinOrMax::Max, arg0, arg1, result);
 }
 

trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp

@@ -713 +713 @@
 {
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
-    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(Externref), origin(),
+    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(Types::Externref), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationGetWasmTableElement)),
         instanceValue(), m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex), index);
@@ -754 +754 @@
     result = m_currentBlock->appendNew<CCallValue>(m_proc, B3::Int64, origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmRefFunc)),
-        instanceValue(), addConstant(Type::I32, index));
+        instanceValue(), addConstant(Types::I32, index));
 
     return { };
@@ -762 +762 @@
 {
     auto result = m_currentBlock->appendNew<CCallValue>(
-        m_proc, toB3Type(I32), origin(),
+        m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableInit)),
         instanceValue(),
@@ -795 +795 @@
 {
     // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.
-    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(I32), origin(),
+    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationGetWasmTableSize)),
         instanceValue(), m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex));
@@ -804 +804 @@
 auto B3IRGenerator::addTableGrow(unsigned tableIndex, ExpressionType fill, ExpressionType delta, ExpressionType& result) -> PartialResult
 {
-    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(I32), origin(),
+    result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableGrow)),
         instanceValue(), m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex), fill, delta);
@@ -813 +813 @@
 auto B3IRGenerator::addTableFill(unsigned tableIndex, ExpressionType offset, ExpressionType fill, ExpressionType count) -> PartialResult
 {
-    auto result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(I32), origin(),
+    auto result = m_currentBlock->appendNew<CCallValue>(m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableFill)),
         instanceValue(), m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex), offset, fill, count);
@@ -832 +832 @@
 {
     auto result = m_currentBlock->appendNew<CCallValue>(
-        m_proc, toB3Type(I32), origin(),
+        m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableCopy)),
         instanceValue(),
@@ -899 +899 @@
 {
     auto result = m_currentBlock->appendNew<CCallValue>(
-        m_proc, toB3Type(I32), origin(),
+        m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmMemoryFill)),
         instanceValue(),
@@ -919 +919 @@
 {
     auto result = m_currentBlock->appendNew<CCallValue>(
-        m_proc, toB3Type(I32), origin(),
+        m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmMemoryInit)),
         instanceValue(),
@@ -940 +940 @@
 {
     auto result = m_currentBlock->appendNew<CCallValue>(
-        m_proc, toB3Type(I32), origin(),
+        m_proc, toB3Type(Types::I32), origin(),
         m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmMemoryCopy)),
         instanceValue(),
@@ -1388 +1388 @@
     };
 
-    switch (valueType) {
-    case Type::I64: {
+    switch (valueType.kind) {
+    case TypeKind::I64: {
         if (accessWidth(op) == B3::Width64)
             return result;
         return m_currentBlock->appendNew<Value>(m_proc, ZExt32, origin(), sanitize32(result));
     }
-    case Type::I32:
+    case TypeKind::I32:
         return sanitize32(result);
     default:
@@ -1446 +1446 @@
         });
 
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = constant(Int32, 0);
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = constant(Int64, 0);
             break;
@@ -1467 +1467 @@
     pointer = fixupPointerPlusOffsetForAtomicOps(op, pointer, uoffset);
 
-    if (valueType == Type::I64 && accessWidth(op) != B3::Width64)
+    if (valueType.isI64() && accessWidth(op) != B3::Width64)
         value = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
     m_currentBlock->appendNew<AtomicValue>(m_proc, memoryKind(AtomicXchg), origin(), accessWidth(op), value, pointer);
@@ -1554 +1554 @@
     }
 
-    if (valueType == Type::I64 && accessWidth(op) != B3::Width64)
+    if (valueType.isI64() && accessWidth(op) != B3::Width64)
         value = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
 
@@ -1572 +1572 @@
         });
 
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = constant(Int32, 0);
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = constant(Int64, 0);
             break;
@@ -1599 +1599 @@
 
     Value* maximum = nullptr;
-    switch (valueType) {
-    case Type::I64: {
+    switch (valueType.kind) {
+    case TypeKind::I64: {
         switch (accessWidth) {
         case B3::Width8:
@@ -1616 +1616 @@
         break;
     }
-    case Type::I32:
+    case TypeKind::I32:
         switch (accessWidth) {
         case B3::Width8:
@@ -1647 +1647 @@
         auto truncatedExpected = expected;
         auto truncatedValue = value;
-        if (valueType == Type::I64) {
+        if (valueType.isI64()) {
             truncatedExpected = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), expected);
             truncatedValue = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
@@ -1697 +1697 @@
         });
 
-        switch (valueType) {
-        case Type::I32:
+        switch (valueType.kind) {
+        case TypeKind::I32:
             result = constant(Int32, 0);
             break;
-        case Type::I64:
+        case TypeKind::I64:
             result = constant(Int64, 0);
             break;

trunk/Source/JavaScriptCore/wasm/WasmCallingConvention.h

@@ -103 +103 @@
     {
         ASSERT(isValueType(valueType));
-        switch (valueType) {
-        case I32:
-        case I64:
-        case Funcref:
-        case Externref:
+        switch (valueType.kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Funcref:
+        case TypeKind::Externref:
             return marshallLocationImpl(role, gprArgs, gpArgumentCount, stackOffset);
-        case F32:
-        case F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             return marshallLocationImpl(role, fprArgs, fpArgumentCount, stackOffset);
         default:
@@ -131 +131 @@
         Vector<ArgumentLocation> params(signature.argumentCount());
         for (size_t i = 0; i < signature.argumentCount(); ++i) {
-            argumentsIncludeI64 |= signature.argument(i) == I64;
+            argumentsIncludeI64 |= signature.argument(i).isI64();
             params[i] = marshallLocation(role, signature.argument(i), gpArgumentCount, fpArgumentCount, argStackOffset);
         }
@@ -142 +142 @@
         Vector<ArgumentLocation, 1> results(signature.returnCount());
         for (size_t i = 0; i < signature.returnCount(); ++i) {
-            resultsIncludeI64 |= signature.returnType(i) == I64;
+            resultsIncludeI64 |= signature.returnType(i).isI64();
             results[i] = marshallLocation(role, signature.returnType(i), gpArgumentCount, fpArgumentCount, resultStackOffset);
         }
@@ -191 +191 @@
     {
         ASSERT(isValueType(valueType));
-        switch (valueType) {
-        case I32:
-        case I64:
-        case Funcref:
-        case Externref:
+        switch (valueType.kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Funcref:
+        case TypeKind::Externref:
             return marshallLocationImpl(role, gprArgs, gpArgumentCount, stackOffset);
-        case F32:
-        case F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             return marshallLocationImpl(role, fprArgs, fpArgumentCount, stackOffset);
         default:

trunk/Source/JavaScriptCore/wasm/WasmFormat.h

@@ -62 +62 @@
 inline bool isValueType(Type type)
 {
-    switch (type) {
-    case I32:
-    case I64:
-    case F32:
-    case F64:
+    switch (type.kind) {
+    case TypeKind::I32:
+    case TypeKind::I64:
+    case TypeKind::F32:
+    case TypeKind::F64:
         return true;
-    case Externref:
-    case Funcref:
+    case TypeKind::Externref:
+    case TypeKind::Funcref:
         return Options::useWebAssemblyReferences();
     default:
@@ -79 +79 @@
 inline bool isRefType(Type type)
 {
-    return type == Externref || type == Funcref;
+    return type.isFuncref() || type.isExternref();
 }
     
@@ -296 +296 @@
     Optional<uint32_t> maximum() const { return m_maximum; }
     TableElementType type() const { return m_type; }
-    Wasm::Type wasmType() const { return m_type == TableElementType::Funcref ? Type::Funcref : Type::Externref; }
+    Type wasmType() const { return m_type == TableElementType::Funcref ? Types::Funcref : Types::Externref; }
 
 private:

trunk/Source/JavaScriptCore/wasm/WasmFunctionCodeBlock.h

@@ -32 +32 @@
 #include "MacroAssemblerCodeRef.h"
 #include "WasmLLIntTierUpCounter.h"
+#include "WasmOps.h"
 #include <wtf/HashMap.h>
 #include <wtf/Vector.h>
@@ -47 +48 @@
 class Signature;
 struct GeneratorTraits;
-enum Type : int8_t;
 
 // FIXME: Consider merging this with LLIntCallee

trunk/Source/JavaScriptCore/wasm/WasmFunctionParser.h

@@ -62 +62 @@
     class TypedExpression {
     public:
-        TypedExpression() = default;
+        TypedExpression()
+            : m_type(Types::Void)
+        {
+        }
 
         TypedExpression(Type type, ExpressionType value)
@@ -333 +336 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "load pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, m_currentOpcode, " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch");
 
     ExpressionType result;
@@ -356 +359 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "store pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, m_currentOpcode, " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch");
     WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, m_currentOpcode, " value type mismatch");
 
@@ -390 +393 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "load pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch");
 
     ExpressionType result;
@@ -413 +416 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "store pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, m_currentOpcode, " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch");
     WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, m_currentOpcode, " value type mismatch");
 
@@ -435 +438 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch");
     WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
 
@@ -461 +464 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch");
     WASM_VALIDATOR_FAIL_IF(expected.type() != memoryType, static_cast<unsigned>(op), " expected type mismatch");
     WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
@@ -488 +491 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch");
     WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
-    WASM_VALIDATOR_FAIL_IF(timeout.type() != I64, static_cast<unsigned>(op), " timeout type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!timeout.type().isI64(), static_cast<unsigned>(op), " timeout type mismatch");
 
     ExpressionType result;
     WASM_TRY_ADD_TO_CONTEXT(atomicWait(op, pointer, value, timeout, result, offset));
-    m_expressionStack.constructAndAppend(I32, result);
+    m_expressionStack.constructAndAppend(Types::I32, result);
     return { };
 }
@@ -513 +516 @@
     WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
 
-    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
-    WASM_VALIDATOR_FAIL_IF(count.type() != I32, static_cast<unsigned>(op), " count type mismatch"); // The spec's definition is saying i64, but all implementations (including tests) are using i32. So looks like the spec is wrong.
+    WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch");
+    WASM_VALIDATOR_FAIL_IF(!count.type().isI32(), static_cast<unsigned>(op), " count type mismatch"); // The spec's definition is saying i64, but all implementations (including tests) are using i32. So looks like the spec is wrong.
 
     ExpressionType result;
     WASM_TRY_ADD_TO_CONTEXT(atomicNotify(op, pointer, count, result, offset));
-    m_expressionStack.constructAndAppend(I32, result);
+    m_expressionStack.constructAndAppend(Types::I32, result);
     return { };
 }
@@ -697 +700 @@
     unsigned offset = m_expressionStack.size() - target.branchTargetArity();
     for (unsigned i = 0; i < target.branchTargetArity(); ++i)
-        WASM_VALIDATOR_FAIL_IF(target.branchTargetType(i) != m_expressionStack[offset + i].type(), "branch's stack type is not a block's type branch target type. Stack value has type", m_expressionStack[offset + i].type(), " but branch target expects a value of ", target.branchTargetType(i), " at index ", i);
+        WASM_VALIDATOR_FAIL_IF(target.branchTargetType(i) != m_expressionStack[offset + i].type(), "branch's stack type is not a block's type branch target type. Stack value has type", m_expressionStack[offset + i].type().kind, " but branch target expects a value of ", target.branchTargetType(i).kind, " at index ", i);
 
     return { };
@@ -707 +710 @@
     WASM_VALIDATOR_FAIL_IF(controlData.signature()->returnCount() != m_expressionStack.size(), " block with type: ", controlData.signature()->toString(), " returns: ", controlData.signature()->returnCount(), " but stack has: ", m_expressionStack.size(), " values");
     for (unsigned i = 0; i < controlData.signature()->returnCount(); ++i)
-        WASM_VALIDATOR_FAIL_IF(m_expressionStack[i].type() != controlData.signature()->returnType(i), "control flow returns with unexpected type. ", m_expressionStack[i].type(), " is not a ", controlData.signature()->returnType(i));
+        WASM_VALIDATOR_FAIL_IF(m_expressionStack[i].type() != controlData.signature()->returnType(i), "control flow returns with unexpected type. ", m_expressionStack[i].type().kind, " is not a ", controlData.signature()->returnType(i).kind);
 
     return { };
@@ -716 +719 @@
 {
     switch (m_currentOpcode) {
-#define CREATE_CASE(name, id, b3op, inc, lhsType, rhsType, returnType) case OpType::name: return binaryCase<OpType::name>(returnType, lhsType, rhsType);
+#define CREATE_CASE(name, id, b3op, inc, lhsType, rhsType, returnType) case OpType::name: return binaryCase<OpType::name>(Types::returnType, Types::lhsType, Types::rhsType);
     FOR_EACH_WASM_BINARY_OP(CREATE_CASE)
 #undef CREATE_CASE
 
-#define CREATE_CASE(name, id, b3op, inc, operandType, returnType) case OpType::name: return unaryCase<OpType::name>(returnType, operandType);
+#define CREATE_CASE(name, id, b3op, inc, operandType, returnType) case OpType::name: return unaryCase<OpType::name>(Types::returnType, Types::operandType);
     FOR_EACH_WASM_UNARY_OP(CREATE_CASE)
 #undef CREATE_CASE
@@ -736 +739 @@
             WASM_PARSER_FAIL_IF(isRefType(nonZero.type()) || isRefType(nonZero.type()), "can't use ref-types with unannotated select");
 
-        WASM_VALIDATOR_FAIL_IF(condition.type() != I32, "select condition must be i32, got ", condition.type());
-        WASM_VALIDATOR_FAIL_IF(nonZero.type() != zero.type(), "select result types must match, got ", nonZero.type(), " and ", zero.type());
+        WASM_VALIDATOR_FAIL_IF(!condition.type().isI32(), "select condition must be i32, got ", condition.type().kind);
+        WASM_VALIDATOR_FAIL_IF(nonZero.type() != zero.type(), "select result types must match, got ", nonZero.type().kind, " and ", zero.type().kind);
 
         ExpressionType result;
@@ -760 +763 @@
         WASM_TRY_POP_EXPRESSION_STACK_INTO(nonZero, "select non-zero");
 
-        WASM_VALIDATOR_FAIL_IF(condition.type() != I32, "select condition must be i32, got ", condition.type());
-        WASM_VALIDATOR_FAIL_IF(nonZero.type() != immediates.targetType, "select result types must match, got ", nonZero.type(), " and ", immediates.targetType);
-        WASM_VALIDATOR_FAIL_IF(zero.type() != immediates.targetType, "select result types must match, got ", zero.type(), " and ", immediates.targetType);
+        WASM_VALIDATOR_FAIL_IF(!condition.type().isI32(), "select condition must be i32, got ", condition.type().kind);
+        WASM_VALIDATOR_FAIL_IF(nonZero.type() != immediates.targetType, "select result types must match, got ", nonZero.type().kind, " and ", immediates.targetType.kind);
+        WASM_VALIDATOR_FAIL_IF(zero.type() != immediates.targetType, "select result types must match, got ", zero.type().kind, " and ", immediates.targetType.kind);
 
         ExpressionType result;
@@ -771 +774 @@
     }
 
-#define CREATE_CASE(name, id, b3op, inc, memoryType) case OpType::name: return load(memoryType);
+#define CREATE_CASE(name, id, b3op, inc, memoryType) case OpType::name: return load(Types::memoryType);
 FOR_EACH_WASM_MEMORY_LOAD_OP(CREATE_CASE)
 #undef CREATE_CASE
 
-#define CREATE_CASE(name, id, b3op, inc, memoryType) case OpType::name: return store(memoryType);
+#define CREATE_CASE(name, id, b3op, inc, memoryType) case OpType::name: return store(Types::memoryType);
 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE)
 #undef CREATE_CASE
@@ -782 +785 @@
         uint32_t constant;
         WASM_PARSER_FAIL_IF(!parseUInt32(constant), "can't parse 32-bit floating-point constant");
-        m_expressionStack.constructAndAppend(F32, m_context.addConstant(F32, constant));
+        m_expressionStack.constructAndAppend(Types::F32, m_context.addConstant(Types::F32, constant));
         return { };
     }
@@ -789 +792 @@
         int32_t constant;
         WASM_PARSER_FAIL_IF(!parseVarInt32(constant), "can't parse 32-bit constant");
-        m_expressionStack.constructAndAppend(I32, m_context.addConstant(I32, constant));
+        m_expressionStack.constructAndAppend(Types::I32, m_context.addConstant(Types::I32, constant));
         return { };
     }
@@ -796 +799 @@
         uint64_t constant;
         WASM_PARSER_FAIL_IF(!parseUInt64(constant), "can't parse 64-bit floating-point constant");
-        m_expressionStack.constructAndAppend(F64, m_context.addConstant(F64, constant));
+        m_expressionStack.constructAndAppend(Types::F64, m_context.addConstant(Types::F64, constant));
         return { };
     }
@@ -803 +806 @@
         int64_t constant;
         WASM_PARSER_FAIL_IF(!parseVarInt64(constant), "can't parse 64-bit constant");
-        m_expressionStack.constructAndAppend(I64, m_context.addConstant(I64, constant));
+        m_expressionStack.constructAndAppend(Types::I64, m_context.addConstant(Types::I64, constant));
         return { };
     }
@@ -815 +818 @@
         TypedExpression index;
         WASM_TRY_POP_EXPRESSION_STACK_INTO(index, "table.get");
-        WASM_VALIDATOR_FAIL_IF(I32 != index.type(), "table.get index to type ", index.type(), " expected ", I32);
+        WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != index.type().kind, "table.get index to type ", index.type().kind, " expected ", TypeKind::I32);
 
         ExpressionType result;
@@ -832 +835 @@
         WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "table.set");
         WASM_TRY_POP_EXPRESSION_STACK_INTO(index, "table.set");
-        WASM_VALIDATOR_FAIL_IF(I32 != index.type(), "table.set index to type ", index.type(), " expected ", I32);
+        WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != index.type().kind, "table.set index to type ", index.type().kind, " expected ", TypeKind::I32);
         Type type = m_info.tables[tableIndex].wasmType();
-        WASM_VALIDATOR_FAIL_IF(value.type() != type, "table.set value to type ", value.type(), " expected ", type);
+        WASM_VALIDATOR_FAIL_IF(value.type() != type, "table.set value to type ", value.type().kind, " expected ", type.kind);
         RELEASE_ASSERT(m_info.tables[tableIndex].type() == TableElementType::Externref || m_info.tables[tableIndex].type() == TableElementType::Funcref);
         WASM_TRY_ADD_TO_CONTEXT(addTableSet(tableIndex, index, value));
@@ -859 +862 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(dstOffset, "table.init");
 
-            WASM_VALIDATOR_FAIL_IF(I32 != dstOffset.type(), "table.init dst_offset to type ", dstOffset.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.init src_offset to type ", srcOffset.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != lenght.type(), "table.init length to type ", lenght.type(), " expected ", I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != dstOffset.type().kind, "table.init dst_offset to type ", dstOffset.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != srcOffset.type().kind, "table.init src_offset to type ", srcOffset.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != lenght.type().kind, "table.init length to type ", lenght.type().kind, " expected ", TypeKind::I32);
 
             WASM_TRY_ADD_TO_CONTEXT(addTableInit(immediates.elementIndex, immediates.tableIndex, dstOffset, srcOffset, lenght));
@@ -883 +886 @@
             ExpressionType result;
             WASM_TRY_ADD_TO_CONTEXT(addTableSize(tableIndex, result));
-            m_expressionStack.constructAndAppend(I32, result);
+            m_expressionStack.constructAndAppend(Types::I32, result);
             break;
         }
@@ -897 +900 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(fill, "table.grow");
 
-            WASM_VALIDATOR_FAIL_IF(fill.type() != m_info.tables[tableIndex].wasmType(), "table.grow expects fill value of type ", m_info.tables[tableIndex].wasmType(), " got ", fill.type());
-            WASM_VALIDATOR_FAIL_IF(I32 != delta.type(), "table.grow expects an i32 delta value, got ", delta.type());
+            WASM_VALIDATOR_FAIL_IF(fill.type() != m_info.tables[tableIndex].wasmType(), "table.grow expects fill value of type ", m_info.tables[tableIndex].wasmType().kind, " got ", fill.type().kind);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != delta.type().kind, "table.grow expects an i32 delta value, got ", delta.type().kind);
 
             ExpressionType result;
             WASM_TRY_ADD_TO_CONTEXT(addTableGrow(tableIndex, fill, delta, result));
-            m_expressionStack.constructAndAppend(I32, result);
+            m_expressionStack.constructAndAppend(Types::I32, result);
             break;
         }
@@ -916 +919 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(offset, "table.fill");
 
-            WASM_VALIDATOR_FAIL_IF(fill.type() != m_info.tables[tableIndex].wasmType(), "table.fill expects fill value of type ", m_info.tables[tableIndex].wasmType(), " got ", fill.type());
-            WASM_VALIDATOR_FAIL_IF(I32 != offset.type(), "table.fill expects an i32 offset value, got ", offset.type());
-            WASM_VALIDATOR_FAIL_IF(I32 != count.type(), "table.fill expects an i32 count value, got ", count.type());
+            WASM_VALIDATOR_FAIL_IF(fill.type() != m_info.tables[tableIndex].wasmType(), "table.fill expects fill value of type ", m_info.tables[tableIndex].wasmType().kind, " got ", fill.type().kind);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != offset.type().kind, "table.fill expects an i32 offset value, got ", offset.type().kind);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != count.type().kind, "table.fill expects an i32 count value, got ", count.type().kind);
 
             WASM_TRY_ADD_TO_CONTEXT(addTableFill(tableIndex, offset, fill, count));
@@ -931 +934 @@
             const auto srcType = m_info.table(immediates.srcTableIndex).wasmType();
             const auto dstType = m_info.table(immediates.dstTableIndex).wasmType();
-            WASM_VALIDATOR_FAIL_IF(srcType != dstType, "type mismatch at table.copy. got ", srcType, " and ", dstType);
+            WASM_VALIDATOR_FAIL_IF(srcType != dstType, "type mismatch at table.copy. got ", srcType.kind, " and ", dstType.kind);
 
             TypedExpression dstOffset;
@@ -940 +943 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(dstOffset, "table.copy");
 
-            WASM_VALIDATOR_FAIL_IF(I32 != dstOffset.type(), "table.copy dst_offset to type ", dstOffset.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.copy src_offset to type ", srcOffset.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != length.type(), "table.copy length to type ", length.type(), " expected ", I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != dstOffset.type().kind, "table.copy dst_offset to type ", dstOffset.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != srcOffset.type().kind, "table.copy src_offset to type ", srcOffset.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != length.type().kind, "table.copy length to type ", length.type().kind, " expected ", TypeKind::I32);
 
             WASM_TRY_ADD_TO_CONTEXT(addTableCopy(immediates.dstTableIndex, immediates.srcTableIndex, dstOffset, srcOffset, length));
@@ -962 +965 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(dstAddress, "memory.fill");
 
-            WASM_VALIDATOR_FAIL_IF(I32 != dstAddress.type(), "memory.fill dstAddress to type ", dstAddress.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != targetValue.type(), "memory.fill targetValue to type ", targetValue.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != count.type(), "memory.fill size to type ", count.type(), " expected ", I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != dstAddress.type().kind, "memory.fill dstAddress to type ", dstAddress.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != targetValue.type().kind, "memory.fill targetValue to type ", targetValue.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != count.type().kind, "memory.fill size to type ", count.type().kind, " expected ", TypeKind::I32);
 
             WASM_TRY_ADD_TO_CONTEXT(addMemoryFill(dstAddress, targetValue, count));
@@ -984 +987 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(dstAddress, "memory.copy");
 
-            WASM_VALIDATOR_FAIL_IF(I32 != dstAddress.type(), "memory.copy dstAddress to type ", dstAddress.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != srcAddress.type(), "memory.copy targetValue to type ", srcAddress.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != count.type(), "memory.copy size to type ", count.type(), " expected ", I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != dstAddress.type().kind, "memory.copy dstAddress to type ", dstAddress.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != srcAddress.type().kind, "memory.copy targetValue to type ", srcAddress.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != count.type().kind, "memory.copy size to type ", count.type().kind, " expected ", TypeKind::I32);
 
             WASM_TRY_ADD_TO_CONTEXT(addMemoryCopy(dstAddress, srcAddress, count));
@@ -1004 +1007 @@
             WASM_TRY_POP_EXPRESSION_STACK_INTO(dstAddress, "memory.init");
 
-            WASM_VALIDATOR_FAIL_IF(I32 != dstAddress.type(), "memory.init dst address to type ", dstAddress.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != srcAddress.type(), "memory.init src address to type ", srcAddress.type(), " expected ", I32);
-            WASM_VALIDATOR_FAIL_IF(I32 != length.type(), "memory.init length to type ", length.type(), " expected ", I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != dstAddress.type().kind, "memory.init dst address to type ", dstAddress.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != srcAddress.type().kind, "memory.init src address to type ", srcAddress.type().kind, " expected ", TypeKind::I32);
+            WASM_VALIDATOR_FAIL_IF(TypeKind::I32 != length.type().kind, "memory.init length to type ", length.type().kind, " expected ", TypeKind::I32);
 
             WASM_TRY_ADD_TO_CONTEXT(addMemoryInit(immediates.dataSegmentIndex, dstAddress, srcAddress, length));
@@ -1021 +1024 @@
         }
 
-#define CREATE_CASE(name, id, b3op, inc, operandType, returnType) case Ext1OpType::name: return truncSaturated(op, returnType, operandType);
+#define CREATE_CASE(name, id, b3op, inc, operandType, returnType) case Ext1OpType::name: return truncSaturated(op, Types::returnType, Types::operandType);
         FOR_EACH_WASM_TRUNC_SATURATED_OP(CREATE_CASE)
 #undef CREATE_CASE
@@ -1039 +1042 @@
         ExtAtomicOpType op = static_cast<ExtAtomicOpType>(extOp);
         switch (op) {
-#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicLoad(op, memoryType);
+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicLoad(op, Types::memoryType);
         FOR_EACH_WASM_EXT_ATOMIC_LOAD_OP(CREATE_CASE)
 #undef CREATE_CASE
-#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicStore(op, memoryType);
+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicStore(op, Types::memoryType);
         FOR_EACH_WASM_EXT_ATOMIC_STORE_OP(CREATE_CASE)
 #undef CREATE_CASE
-#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicBinaryRMW(op, memoryType);
+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicBinaryRMW(op, Types::memoryType);
         FOR_EACH_WASM_EXT_ATOMIC_BINARY_RMW_OP(CREATE_CASE)
 #undef CREATE_CASE
         case ExtAtomicOpType::MemoryAtomicWait64:
-            return atomicWait(op, I64);
+            return atomicWait(op, Types::I64);
         case ExtAtomicOpType::MemoryAtomicWait32:
-            return atomicWait(op, I32);
+            return atomicWait(op, Types::I32);
         case ExtAtomicOpType::MemoryAtomicNotify:
             return atomicNotify(op);
@@ -1059 +1062 @@
         case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
         case ExtAtomicOpType::I32AtomicRmwCmpxchg:
-            return atomicCompareExchange(op, I32);
+            return atomicCompareExchange(op, Types::I32);
         case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
         case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
         case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
         case ExtAtomicOpType::I64AtomicRmwCmpxchg:
-            return atomicCompareExchange(op, I64);
+            return atomicCompareExchange(op, Types::I64);
         default:
             WASM_PARSER_FAIL_IF(true, "invalid extended atomic op ", extOp);
@@ -1084 +1087 @@
         TypedExpression value;
         WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "ref.is_null");
-        WASM_VALIDATOR_FAIL_IF(!isRefType(value.type()), "ref.is_null to type ", value.type(), " expected a reference type");
+        WASM_VALIDATOR_FAIL_IF(!isRefType(value.type()), "ref.is_null to type ", value.type().kind, " expected a reference type");
         ExpressionType result;
         WASM_TRY_ADD_TO_CONTEXT(addRefIsNull(value, result));
-        m_expressionStack.constructAndAppend(I32, result);
+        m_expressionStack.constructAndAppend(Types::I32, result);
         return { };
     }
@@ -1102 +1105 @@
         ExpressionType result;
         WASM_TRY_ADD_TO_CONTEXT(addRefFunc(index, result));
-        m_expressionStack.constructAndAppend(Funcref, result);
+        m_expressionStack.constructAndAppend(Types::Funcref, result);
         return { };
     }
@@ -1123 +1126 @@
         WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "set_local");
         WASM_VALIDATOR_FAIL_IF(index >= m_locals.size(), "attempt to set unknown local ", index, " last one is ", m_locals.size());
-        WASM_VALIDATOR_FAIL_IF(value.type() != m_locals[index], "set_local to type ", value.type(), " expected ", m_locals[index]);
+        WASM_VALIDATOR_FAIL_IF(value.type() != m_locals[index], "set_local to type ", value.type().kind, " expected ", m_locals[index].kind);
         WASM_TRY_ADD_TO_CONTEXT(setLocal(index, value));
         return { };
@@ -1135 +1138 @@
         TypedExpression value = m_expressionStack.last();
         WASM_VALIDATOR_FAIL_IF(index >= m_locals.size(), "attempt to tee unknown local ", index, " last one is ", m_locals.size());
-        WASM_VALIDATOR_FAIL_IF(value.type() != m_locals[index], "set_local to type ", value.type(), " expected ", m_locals[index]);
+        WASM_VALIDATOR_FAIL_IF(value.type() != m_locals[index], "set_local to type ", value.type().kind, " expected ", m_locals[index].kind);
         WASM_TRY_ADD_TO_CONTEXT(setLocal(index, value));
         return { };
@@ -1163 +1166 @@
         Type globalType = m_info.globals[index].type;
         ASSERT(isValueType(globalType));
-        WASM_VALIDATOR_FAIL_IF(globalType != value.type(), "set_global ", index, " with type ", globalType, " with a variable of type ", value.type());
+        WASM_VALIDATOR_FAIL_IF(globalType != value.type(), "set_global ", index, " with type ", globalType.kind, " with a variable of type ", value.type().kind);
 
         WASM_TRY_ADD_TO_CONTEXT(setGlobal(index, value));
@@ -1182 +1185 @@
         for (size_t i = firstArgumentIndex; i < m_expressionStack.size(); ++i) {
             TypedExpression arg = m_expressionStack.at(i);
-            WASM_VALIDATOR_FAIL_IF(arg.type() != calleeSignature.argument(i - firstArgumentIndex), "argument type mismatch in call, got ", arg.type(), ", expected ", calleeSignature.argument(i - firstArgumentIndex));
+            WASM_VALIDATOR_FAIL_IF(arg.type() != calleeSignature.argument(i - firstArgumentIndex), "argument type mismatch in call, got ", arg.type().kind, ", expected ", calleeSignature.argument(i - firstArgumentIndex).kind);
             args.uncheckedAppend(arg);
             m_context.didPopValueFromStack();
@@ -1215 +1218 @@
         WASM_PARSER_FAIL_IF(argumentCount > m_expressionStack.size(), "call_indirect expects ", argumentCount, " arguments, but the expression stack currently holds ", m_expressionStack.size(), " values");
 
-        WASM_VALIDATOR_FAIL_IF(m_expressionStack.last().type() != I32, "non-i32 call_indirect index ", m_expressionStack.last().type());
+        WASM_VALIDATOR_FAIL_IF(!m_expressionStack.last().type().isI32(), "non-i32 call_indirect index ", m_expressionStack.last().type().kind);
 
         Vector<ExpressionType> args;
@@ -1223 +1226 @@
             TypedExpression arg = m_expressionStack.at(i);
             if (i < m_expressionStack.size() - 1)
-                WASM_VALIDATOR_FAIL_IF(arg.type() != calleeSignature.argument(i - firstArgumentIndex), "argument type mismatch in call_indirect, got ", arg.type(), ", expected ", calleeSignature.argument(i - firstArgumentIndex));
+                WASM_VALIDATOR_FAIL_IF(arg.type() != calleeSignature.argument(i - firstArgumentIndex), "argument type mismatch in call_indirect, got ", arg.type().kind, ", expected ", calleeSignature.argument(i - firstArgumentIndex).kind);
             args.uncheckedAppend(arg);
             m_context.didPopValueFromStack();
@@ -1237 +1240 @@
         return { };
     }
-
     case Block: {
         BlockSignature inlineSignature;
@@ -1246 +1248 @@
         for (unsigned i = 0; i < inlineSignature->argumentCount(); ++i) {
             Type type = m_expressionStack.at(offset + i).type();
-            WASM_VALIDATOR_FAIL_IF(type != inlineSignature->argument(i), "Block expects the argument at index", i, " to be ", inlineSignature->argument(i), " but argument has type ", type);
+            WASM_VALIDATOR_FAIL_IF(type != inlineSignature->argument(i), "Block expects the argument at index", i, " to be ", inlineSignature->argument(i).kind, " but argument has type ", type.kind);
         }
 
@@ -1269 +1271 @@
         for (unsigned i = 0; i < inlineSignature->argumentCount(); ++i) {
             Type type = m_expressionStack.at(offset + i).type();
-            WASM_VALIDATOR_FAIL_IF(type != inlineSignature->argument(i), "Loop expects the argument at index", i, " to be ", inlineSignature->argument(i), " but argument has type ", type);
+            WASM_VALIDATOR_FAIL_IF(type != inlineSignature->argument(i), "Loop expects the argument at index", i, " to be ", inlineSignature->argument(i).kind, " but argument has type ", type.kind);
         }
 
@@ -1290 +1292 @@
         WASM_TRY_POP_EXPRESSION_STACK_INTO(condition, "if condition");
 
-        WASM_VALIDATOR_FAIL_IF(condition.type() != I32, "if condition must be i32, got ", condition.type());
+        WASM_VALIDATOR_FAIL_IF(!condition.type().isI32(), "if condition must be i32, got ", condition.type().kind);
         WASM_VALIDATOR_FAIL_IF(m_expressionStack.size() < inlineSignature->argumentCount(), "Too few arguments on stack for if block. If expects ", inlineSignature->argumentCount(), ", but only ", m_expressionStack.size(), " were present. If block has signature: ", inlineSignature->toString());
         unsigned offset = m_expressionStack.size() - inlineSignature->argumentCount();
         for (unsigned i = 0; i < inlineSignature->argumentCount(); ++i)
-            WASM_VALIDATOR_FAIL_IF(m_expressionStack[offset + i].type() != inlineSignature->argument(i), "Loop expects the argument at index", i, " to be ", inlineSignature->argument(i), " but argument has type ", m_expressionStack[i].type());
+            WASM_VALIDATOR_FAIL_IF(m_expressionStack[offset + i].type() != inlineSignature->argument(i), "Loop expects the argument at index", i, " to be ", inlineSignature->argument(i).kind, " but argument has type ", m_expressionStack[i].type().kind);
 
         int64_t oldSize = m_expressionStack.size();
@@ -1328 +1330 @@
         if (m_currentOpcode == BrIf) {
             WASM_TRY_POP_EXPRESSION_STACK_INTO(condition, "br / br_if condition");
-            WASM_VALIDATOR_FAIL_IF(condition.type() != I32, "conditional branch with non-i32 condition ", condition.type());
+            WASM_VALIDATOR_FAIL_IF(!condition.type().isI32(), "conditional branch with non-i32 condition ", condition.type().kind);
         } else {
             m_unreachableBlocks = 1;
-            condition = TypedExpression { Void, Context::emptyExpression() };
+            condition = TypedExpression { Types::Void, Context::emptyExpression() };
         }
 
@@ -1362 +1364 @@
 
         WASM_TRY_POP_EXPRESSION_STACK_INTO(condition, "br_table condition");
-        WASM_VALIDATOR_FAIL_IF(condition.type() != I32, "br_table with non-i32 condition ", condition.type());
+        WASM_VALIDATOR_FAIL_IF(!condition.type().isI32(), "br_table with non-i32 condition ", condition.type().kind);
 
         for (unsigned i = 0; i < targets.size(); ++i) {
@@ -1368 +1370 @@
             WASM_VALIDATOR_FAIL_IF(defaultTarget.branchTargetArity() != target->branchTargetArity(), "br_table target type size mismatch. Default has size: ", defaultTarget.branchTargetArity(), "but target: ", i, " has size: ", target->branchTargetArity());
             for (unsigned type = 0; type < defaultTarget.branchTargetArity(); ++type)
-                WASM_VALIDATOR_FAIL_IF(defaultTarget.branchTargetType(type) != target->branchTargetType(type), "br_table target type mismatch at offset ", type, " expected: ", defaultTarget.branchTargetType(type), " but saw: ", target->branchTargetType(type), " when targeting block: ", target->signature()->toString());
+                WASM_VALIDATOR_FAIL_IF(defaultTarget.branchTargetType(type) != target->branchTargetType(type), "br_table target type mismatch at offset ", type, " expected: ", defaultTarget.branchTargetType(type).kind, " but saw: ", target->branchTargetType(type).kind, " when targeting block: ", target->signature()->toString());
         }
 
@@ -1427 +1429 @@
         TypedExpression delta;
         WASM_TRY_POP_EXPRESSION_STACK_INTO(delta, "expect an i32 argument to grow_memory on the stack");
-        WASM_VALIDATOR_FAIL_IF(delta.type() != I32, "grow_memory with non-i32 delta argument has type: ", delta.type());
+        WASM_VALIDATOR_FAIL_IF(!delta.type().isI32(), "grow_memory with non-i32 delta argument has type: ", delta.type().kind);
 
         ExpressionType result;
         WASM_TRY_ADD_TO_CONTEXT(addGrowMemory(delta, result));
-        m_expressionStack.constructAndAppend(I32, result);
+        m_expressionStack.constructAndAppend(Types::I32, result);
 
         return { };
@@ -1445 +1447 @@
         ExpressionType result;
         WASM_TRY_ADD_TO_CONTEXT(addCurrentMemory(result));
-        m_expressionStack.constructAndAppend(I32, result);
+        m_expressionStack.constructAndAppend(Types::I32, result);
 
         return { };

trunk/Source/JavaScriptCore/wasm/WasmGlobal.cpp

@@ -38 +38 @@
 JSValue Global::get(JSGlobalObject* globalObject) const
 {
-    switch (m_type) {
-    case Wasm::Type::I32:
+    switch (m_type.kind) {
+    case TypeKind::I32:
         return jsNumber(bitwise_cast<int32_t>(static_cast<uint32_t>(m_value.m_primitive)));
-    case Wasm::Type::I64:
+    case TypeKind::I64:
         return JSBigInt::makeHeapBigIntOrBigInt32(globalObject, static_cast<int64_t>(m_value.m_primitive));
-    case Wasm::Type::F32:
+    case TypeKind::F32:
         return jsNumber(purifyNaN(static_cast<double>(bitwise_cast<float>(static_cast<uint32_t>(m_value.m_primitive)))));
-    case Wasm::Type::F64:
+    case TypeKind::F64:
         return jsNumber(purifyNaN(bitwise_cast<double>(m_value.m_primitive)));
-    case Wasm::Externref:
-    case Wasm::Funcref:
+    case TypeKind::Externref:
+    case TypeKind::Funcref:
         return m_value.m_externref.get();
     default:
@@ -60 +60 @@
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     ASSERT(m_mutability != Wasm::GlobalInformation::Immutable);
-    switch (m_type) {
-    case Wasm::Type::I32: {
+    switch (m_type.kind) {
+    case TypeKind::I32: {
         int32_t value = argument.toInt32(globalObject);
         RETURN_IF_EXCEPTION(throwScope, void());
@@ -67 +67 @@
         break;
     }
-    case Wasm::Type::I64: {
+    case TypeKind::I64: {
         int64_t value = argument.toBigInt64(globalObject);
         RETURN_IF_EXCEPTION(throwScope, void());
@@ -73 +73 @@
         break;
     }
-    case Wasm::Type::F32: {
+    case TypeKind::F32: {
         float value = argument.toFloat(globalObject);
         RETURN_IF_EXCEPTION(throwScope, void());
@@ -79 +79 @@
         break;
     }
-    case Wasm::Type::F64: {
+    case TypeKind::F64: {
         double value = argument.toNumber(globalObject);
         RETURN_IF_EXCEPTION(throwScope, void());
@@ -85 +85 @@
         break;
     }
-    case Wasm::Externref: {
+    case TypeKind::Externref: {
         RELEASE_ASSERT(m_owner);
         m_value.m_externref.set(m_owner->vm(), m_owner, argument);
         break;
     }
-    case Wasm::Funcref: {
+    case TypeKind::Funcref: {
         RELEASE_ASSERT(m_owner);
         if (!isWebAssemblyHostFunction(vm, argument) && !argument.isNull()) {
@@ -107 +107 @@
 void Global::visitAggregateImpl(Visitor& visitor)
 {
-    switch (m_type) {
-    case Wasm::Type::Externref:
-    case Wasm::Type::Funcref: {
+    switch (m_type.kind) {
+    case TypeKind::Externref:
+    case TypeKind::Funcref: {
         RELEASE_ASSERT(m_owner);
         visitor.append(m_value.m_externref);

trunk/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp

@@ -296 +296 @@
             m_codeBlock->m_constants.append(JSValue::encode(jsNull()));
             if (UNLIKELY(Options::dumpGeneratedWasmBytecodes()))
-                m_codeBlock->m_constantTypes.append(Type::Externref);
+                m_codeBlock->m_constantTypes.append(Types::Externref);
         }
         return m_jsNullConstant;
@@ -307 +307 @@
             m_codeBlock->m_constants.append(0);
             if (UNLIKELY(Options::dumpGeneratedWasmBytecodes()))
-                m_codeBlock->m_constantTypes.append(Type::I32);
+                m_codeBlock->m_constantTypes.append(Types::I32);
         }
         return m_zeroConstant;
@@ -535 +535 @@
 
     auto allocateStackRegister = [&](Type type) {
-        switch (type) {
-        case Type::I32:
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        switch (type.kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             if (gprIndex < gprCount)
                 ++gprIndex;
@@ -545 +545 @@
                 ++stackCount;
             break;
-        case Type::F32:
-        case Type::F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             if (fprIndex < fprCount)
                 ++fprIndex;
@@ -552 +552 @@
                 ++stackCount;
             break;
-        case Void:
-        case Func:
+        case TypeKind::Void:
+        case TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -590 +590 @@
     fprIndex = gprIndex - gprCount;
     for (uint32_t i = 0; i < signature.argumentCount(); i++) {
-        switch (signature.argument(i)) {
-        case Type::I32:
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        switch (signature.argument(i).kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             if (gprIndex > gprLimit)
                 arguments[i] = virtualRegisterForLocal(--gprIndex);
@@ -600 +600 @@
                 arguments[i] = virtualRegisterForLocal(--stackIndex);
             break;
-        case Type::F32:
-        case Type::F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             if (fprIndex > fprLimit)
                 arguments[i] = virtualRegisterForLocal(--fprIndex);
@@ -607 +607 @@
                 arguments[i] = virtualRegisterForLocal(--stackIndex);
             break;
-        case Void:
-        case Func:
+        case TypeKind::Void:
+        case TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -617 +617 @@
     fprIndex = gprIndex - gprCount;
     for (uint32_t i = 0; i < signature.returnCount(); i++) {
-        switch (signature.returnType(i)) {
-        case Type::I32:
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        switch (signature.returnType(i).kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             if (gprIndex > gprLimit)
                 temporaryResults[i] = virtualRegisterForLocal(--gprIndex);
@@ -627 +627 @@
                 temporaryResults[i] = virtualRegisterForLocal(--stackIndex);
             break;
-        case Type::F32:
-        case Type::F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             if (fprIndex > fprLimit)
                 temporaryResults[i] = virtualRegisterForLocal(--fprIndex);
@@ -634 +634 @@
                 temporaryResults[i] = virtualRegisterForLocal(--stackIndex);
             break;
-        case Void:
-        case Func:
+        case TypeKind::Void:
+        case TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -672 +672 @@
 
     for (uint32_t i = 0; i < signature.returnCount(); i++) {
-        switch (signature.returnType(i)) {
-        case Type::I32:
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        switch (signature.returnType(i).kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             if (gprIndex < maxGPRIndex)
                 m_results.append(virtualRegisterForLocal(numberOfLLIntCalleeSaveRegisters + gprIndex++));
@@ -682 +682 @@
                 m_results.append(virtualRegisterForArgumentIncludingThis(stackIndex++));
             break;
-        case Type::F32:
-        case Type::F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             if (fprIndex < maxFPRIndex)
                 m_results.append(virtualRegisterForLocal(numberOfLLIntCalleeSaveRegisters + fprIndex++));
@@ -689 +689 @@
                 m_results.append(virtualRegisterForArgumentIncludingThis(stackIndex++));
             break;
-        case Void:
-        case Func:
+        case TypeKind::Void:
+        case TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -726 +726 @@
 
     for (uint32_t i = 0; i < signature.argumentCount(); i++) {
-        switch (signature.argument(i)) {
-        case Type::I32:
-        case Type::I64:
-        case Type::Externref:
-        case Type::Funcref:
+        switch (signature.argument(i).kind) {
+        case TypeKind::I32:
+        case TypeKind::I64:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             addArgument(i, gprIndex, maxGPRIndex);
             break;
-        case Type::F32:
-        case Type::F64:
+        case TypeKind::F32:
+        case TypeKind::F64:
             addArgument(i, fprIndex, maxFPRIndex);
             break;
-        case Void:
-        case Func:
+        case TypeKind::Void:
+        case TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -753 +753 @@
 
     m_codeBlock->m_numVars += count;
-    switch (type) {
-    case Type::Externref:
-    case Type::Funcref:
+    switch (type.kind) {
+    case TypeKind::Externref:
+    case TypeKind::Funcref:
         while (count--)
             m_unitializedLocals.append(push(NoConsistencyCheck));

trunk/Source/JavaScriptCore/wasm/WasmOperations.cpp

@@ -549 +549 @@
 
         uint64_t unboxedValue = 0;
-        switch (signature->returnType(index)) {
-        case I32:
+        switch (signature->returnType(index).kind) {
+        case TypeKind::I32:
             unboxedValue = value.toInt32(globalObject);
             break;
-        case I64:
+        case TypeKind::I64:
             unboxedValue = value.toBigInt64(globalObject);
             break;
-        case F32:
+        case TypeKind::F32:
             unboxedValue = bitwise_cast<uint32_t>(value.toFloat(globalObject));
             break;
-        case F64:
+        case TypeKind::F64:
             unboxedValue = bitwise_cast<uint64_t>(value.toNumber(globalObject));
             break;
-        case Funcref:
+        case TypeKind::Funcref:
             if (!value.isCallable(vm)) {
                 throwTypeError(globalObject, scope, "Funcref value is not a function"_s);
@@ -568 +568 @@
             }
             FALLTHROUGH;
-        case Externref:
+        case TypeKind::Externref:
             unboxedValue = bitwise_cast<uint64_t>(value);
             RELEASE_ASSERT(Options::useWebAssemblyReferences());

trunk/Source/JavaScriptCore/wasm/WasmParser.h

@@ -276 +276 @@
 ALWAYS_INLINE typename Parser<SuccessType>::PartialResult Parser<SuccessType>::parseBlockSignature(const ModuleInformation& info, BlockSignature& result)
 {
-    int8_t value;
-    if (peekInt7(value) && isValidType(value)) {
-        Type type = static_cast<Type>(value);
-        WASM_PARSER_FAIL_IF(!(isValueType(type) || type == Void), "result type of block: ", makeString(type), " is not a value type or Void");
+    int8_t typeKind;
+    if (peekInt7(typeKind) && isValidTypeKind(typeKind)) {
+        Type type = {static_cast<TypeKind>(typeKind), 0};
+        WASM_PARSER_FAIL_IF(!(isValueType(type) || type.isVoid()), "result type of block: ", makeString(type.kind), " is not a value type or Void");
         result = m_signatureInformation.thunkFor(type);
         m_offset++;
@@ -299 +299 @@
 ALWAYS_INLINE bool Parser<SuccessType>::parseValueType(Type& result)
 {
-    int8_t value;
-    if (!parseInt7(value))
-        return false;
-    if (!isValidType(value) || !isValueType(static_cast<Type>(value)))
-        return false;
-    result = static_cast<Type>(value);
+    int8_t kind;
+    if (!parseInt7(kind))
+        return false;
+    Type type = {static_cast<TypeKind>(kind), 0};
+    if (!isValidTypeKind(kind) || !isValueType(type))
+        return false;
+    result = type;
     return true;
 }

trunk/Source/JavaScriptCore/wasm/WasmSectionParser.cpp

@@ -54 +54 @@
 
         WASM_PARSER_FAIL_IF(!parseInt7(type), "can't get ", i, "th Type's type");
-        WASM_PARSER_FAIL_IF(type != Func, i, "th Type is non-Func ", type);
+        WASM_PARSER_FAIL_IF(type != static_cast<int8_t>(TypeKind::Func), i, "th Type is non-Func ", type);
         WASM_PARSER_FAIL_IF(!parseVarUInt32(argumentCount), "can't get ", i, "th Type's argument count");
         WASM_PARSER_FAIL_IF(argumentCount > maxFunctionParams, i, "th argument count is too big ", argumentCount, " maximum ", maxFunctionParams);
@@ -207 +207 @@
     int8_t type;
     WASM_PARSER_FAIL_IF(!parseInt7(type), "can't parse Table type");
-    WASM_PARSER_FAIL_IF(type != Wasm::Funcref && type != Wasm::Externref, "Table type should be funcref or anyref, got ", type);
+    WASM_PARSER_FAIL_IF(type != static_cast<int8_t>(TypeKind::Funcref) && type != static_cast<int8_t>(TypeKind::Externref), "Table type should be funcref or anyref, got ", type);
 
     uint32_t initial;
@@ -219 +219 @@
     ASSERT(!maximum || *maximum >= initial);
 
-    TableElementType tableType = type == Wasm::Funcref ? TableElementType::Funcref : TableElementType::Externref;
+    TableElementType tableType = type == static_cast<int8_t>(TypeKind::Funcref) ? TableElementType::Funcref : TableElementType::Externref;
     m_info->tables.append(TableInformation(initial, maximum, isImport, tableType));
 
@@ -305 +305 @@
         else
             global.initializationType = GlobalInformation::FromExpression;
-        WASM_PARSER_FAIL_IF(typeForInitOpcode != global.type, "Global init_expr opcode of type ", typeForInitOpcode, " doesn't match global's type ", global.type);
+        WASM_PARSER_FAIL_IF(typeForInitOpcode != global.type, "Global init_expr opcode of type ", typeForInitOpcode.kind, " doesn't match global's type ", global.type.kind);
 
         if (initOpcode == RefFunc)
@@ -486 +486 @@
             Type refType;
             WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
-            WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");
+            WASM_PARSER_FAIL_IF(!refType.isFuncref(), "reftype in element section should be funcref");
 
             uint32_t indexCount;
@@ -510 +510 @@
             Type refType;
             WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
-            WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");
+            WASM_PARSER_FAIL_IF(!refType.isFuncref(), "reftype in element section should be funcref");
 
             uint32_t indexCount;
@@ -528 +528 @@
             Type refType;
             WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
-            WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");
+            WASM_PARSER_FAIL_IF(!refType.isFuncref(), "reftype in element section should be funcref");
 
             uint32_t indexCount;
@@ -564 +564 @@
         WASM_PARSER_FAIL_IF(!parseVarInt32(constant), "can't get constant value for init_expr's i32.const");
         bitsOrImportNumber = static_cast<uint64_t>(constant);
-        resultType = I32;
+        resultType = Types::I32;
         break;
     }
@@ -572 +572 @@
         WASM_PARSER_FAIL_IF(!parseVarInt64(constant), "can't get constant value for init_expr's i64.const");
         bitsOrImportNumber = constant;
-        resultType = I64;
+        resultType = Types::I64;
         break;
     }
@@ -580 +580 @@
         WASM_PARSER_FAIL_IF(!parseUInt32(constant), "can't get constant value for init_expr's f32.const");
         bitsOrImportNumber = constant;
-        resultType = F32;
+        resultType = Types::F32;
         break;
     }
@@ -588 +588 @@
         WASM_PARSER_FAIL_IF(!parseUInt64(constant), "can't get constant value for init_expr's f64.const");
         bitsOrImportNumber = constant;
-        resultType = F64;
+        resultType = Types::F64;
         break;
     }
@@ -618 +618 @@
         WASM_PARSER_FAIL_IF(index >= m_info->functions.size(), "ref.func index", index, " exceeds the number of functions ", m_info->functions.size());
 
-        resultType = Funcref;
+        resultType = Types::Funcref;
         bitsOrImportNumber = index;
         break;
@@ -648 +648 @@
     Type initExprType;
     WASM_FAIL_IF_HELPER_FAILS(parseInitExpr(initOpcode, initExprBits, initExprType));
-    WASM_PARSER_FAIL_IF(initExprType != I32, failMessage);
+    WASM_PARSER_FAIL_IF(!initExprType.isI32(), failMessage);
     initExpr = makeI32InitExpr(initOpcode, initExprBits);
 
@@ -694 +694 @@
             Type typeOfNull;
             WASM_PARSER_FAIL_IF(!parseRefType(typeOfNull), "ref.null type must be a func type in elem section");
-            WASM_PARSER_FAIL_IF(typeOfNull != Funcref, "ref.null extern is forbidden in element section's, ", elementNum, "th element's ", index, "th index");
+            WASM_PARSER_FAIL_IF(!typeOfNull.isFuncref(), "ref.null extern is forbidden in element section's, ", elementNum, "th element's ", index, "th index");
             functionIndex = Element::nullFuncIndex;
         }

trunk/Source/JavaScriptCore/wasm/WasmSignature.cpp

@@ -53 +53 @@
         CommaPrinter comma;
         for (SignatureArgCount arg = 0; arg < argumentCount(); ++arg)
-            out.print(comma, makeString(argument(arg)));
+            out.print(comma, makeString(argument(arg).kind));
         out.print(")");
     }
@@ -61 +61 @@
         out.print(" -> [");
         for (SignatureArgCount ret = 0; ret < returnCount(); ++ret)
-            out.print(comma, makeString(returnType(ret)));
+            out.print(comma, makeString(returnType(ret).kind));
         out.print("]");
     }
@@ -69 +69 @@
 {
     unsigned accumulator = 0xa1bcedd8u;
-    for (uint32_t i = 0; i < argumentCount; ++i)
-        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<uint8_t>::hash(static_cast<uint8_t>(argumentTypes[i])));
-    for (uint32_t i = 0; i < returnCount; ++i)
-        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<uint8_t>::hash(static_cast<uint8_t>(returnTypes[i])));
+    for (uint32_t i = 0; i < argumentCount; ++i) {
+        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<uint8_t>::hash(static_cast<uint8_t>(argumentTypes[i].kind)));
+        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<unsigned>::hash(argumentTypes[i].index));
+    }
+    for (uint32_t i = 0; i < returnCount; ++i) {
+        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<uint8_t>::hash(static_cast<uint8_t>(returnTypes[i].kind)));
+        accumulator = WTF::pairIntHash(accumulator, WTF::IntHash<unsigned>::hash(returnTypes[i].index));
+    }
     return accumulator;
 }
@@ -96 +100 @@
 #define MAKE_THUNK_SIGNATURE(type, enc, str, val)                          \
     do {                                                                   \
-        if (type != Void) {                                                \
+        if (TypeKind::type != TypeKind::Void) {                            \
             RefPtr<Signature> sig = Signature::tryCreate(1, 0);            \
             sig->ref();                                                    \
-            sig->getReturnType(0) = type;                                  \
-            thunkSignatures[linearizeType(type)] = sig.get();              \
+            sig->getReturnType(0) = Types::type;                           \
+            thunkSignatures[linearizeType(TypeKind::type)] = sig.get();    \
             m_signatureSet.add(SignatureHash { sig.releaseNonNull() });    \
         }                                                                  \
@@ -111 +115 @@
         RefPtr<Signature> sig = Signature::tryCreate(0, 0);
         sig->ref();
-        thunkSignatures[linearizeType(Void)] = sig.get();
+        thunkSignatures[linearizeType(TypeKind::Void)] = sig.get();
         m_signatureSet.add(SignatureHash { sig.releaseNonNull() });
     }

trunk/Source/JavaScriptCore/wasm/WasmSignature.h

@@ -143 +143 @@
 
     static RefPtr<Signature> signatureFor(const Vector<Type, 1>& returnTypes, const Vector<Type>& argumentTypes);
-    ALWAYS_INLINE const Signature* thunkFor(Type type) const { return thunkSignatures[linearizeType(type)]; }
+    ALWAYS_INLINE const Signature* thunkFor(Type type) const { return thunkSignatures[linearizeType(type.kind)]; }
 
     static const Signature& get(SignatureIndex);

trunk/Source/JavaScriptCore/wasm/WasmTable.cpp

@@ -181 +181 @@
 {
     if (isExternrefTable())
-        return Type::Externref;
+        return Types::Externref;
     ASSERT(isFuncrefTable());
-    return Type::Funcref;
+    return Types::Funcref;
 }
 

trunk/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py

@@ -208 +208 @@
 """ + type_definitions + """
 #define CREATE_ENUM_VALUE(name, id, ...) name = id,
-enum Type : int8_t {
+enum class TypeKind : int8_t {
     FOR_EACH_WASM_TYPE(CREATE_ENUM_VALUE)
 };
 #undef CREATE_ENUM_VALUE
+
+struct Type {
+    TypeKind kind;
+    unsigned index;
+
+    bool operator==(const Type& other) const
+    {
+        return other.kind == kind && other.index == index;
+    }
+
+    bool operator!=(const Type& other) const
+    {
+        return !(other == *this);
+    }
+
+    #define CREATE_PREDICATE(name, ...) bool is ## name() const { return kind == TypeKind::name; }
+    FOR_EACH_WASM_TYPE(CREATE_PREDICATE)
+    #undef CREATE_PREDICATE
+};
+
+namespace Types
+{
+#define CREATE_CONSTANT(name, id, ...) constexpr Type name = Type{TypeKind::name, 0u};
+FOR_EACH_WASM_TYPE(CREATE_CONSTANT)
+#undef CREATE_CONSTANT
+} // namespace Types
 
 #define CREATE_CASE(name, id, ...) case id: return true;
 template <typename Int>
-inline bool isValidType(Int i)
+inline bool isValidTypeKind(Int i)
 {
     switch (i) {
@@ -227 +253 @@
 
 #if ENABLE(WEBASSEMBLY_B3JIT)
-#define CREATE_CASE(name, id, b3type, ...) case name: return b3type;
+#define CREATE_CASE(name, id, b3type, ...) case TypeKind::name: return b3type;
 inline B3::Type toB3Type(Type type)
 {
-    switch (type) {
+    switch (type.kind) {
     FOR_EACH_WASM_TYPE(CREATE_CASE)
     }
@@ -239 +265 @@
 #endif
 
-#define CREATE_CASE(name, ...) case name: return #name;
-inline const char* makeString(Type type)
-{
-    switch (type) {
+#define CREATE_CASE(name, ...) case TypeKind::name: return #name;
+inline const char* makeString(TypeKind kind)
+{
+    switch (kind) {
     FOR_EACH_WASM_TYPE(CREATE_CASE)
     }
@@ -250 +276 @@
 #undef CREATE_CASE
 
-#define CREATE_CASE(name, id, b3type, inc, ...) case id: return inc;
-inline int linearizeType(Type type)
-{
-    switch (type) {
+#define CREATE_CASE(name, id, b3type, inc, ...) case TypeKind::name: return inc;
+inline int linearizeType(TypeKind kind)
+{
+    switch (kind) {
     FOR_EACH_WASM_TYPE(CREATE_CASE)
     }
@@ -261 +287 @@
 #undef CREATE_CASE
 
-#define CREATE_CASE(name, id, b3type, inc, ...) case inc: return name;
-inline Type linearizedToType(int i)
+#define CREATE_CASE(name, id, b3type, inc, ...) case inc: return TypeKind::name;
+inline TypeKind linearizedToType(int i)
 {
     switch (i) {
@@ -268 +294 @@
     }
     RELEASE_ASSERT_NOT_REACHED();
-    return Void;
+    return TypeKind::Void;
 }
 #undef CREATE_CASE
@@ -405 +431 @@
 namespace WTF {
 
-inline void printInternal(PrintStream& out, JSC::Wasm::Type type)
-{
-    out.print(JSC::Wasm::makeString(type));
+inline void printInternal(PrintStream& out, JSC::Wasm::TypeKind kind)
+{
+    out.print(JSC::Wasm::makeString(kind));
 }
 

trunk/Source/JavaScriptCore/wasm/js/JSToWasm.cpp

@@ -41 +41 @@
 void marshallJSResult(CCallHelpers& jit, const Signature& signature, const CallInformation& wasmFrameConvention, const RegisterAtOffsetList& savedResultRegisters)
 {
-    auto boxWasmResult = [](CCallHelpers& jit, Wasm::Type type, Reg src, JSValueRegs dst) {
-        switch (type) {
-        case Wasm::Void:
+    auto boxWasmResult = [](CCallHelpers& jit, Type type, Reg src, JSValueRegs dst) {
+        switch (type.kind) {
+        case TypeKind::Void:
             jit.moveTrustedValue(jsUndefined(), dst);
             break;
-        case Wasm::Externref:
-        case Wasm::Funcref:
+        case TypeKind::Externref:
+        case TypeKind::Funcref:
             jit.move(src.gpr(), dst.payloadGPR());
             break;
-        case Wasm::I32:
+        case TypeKind::I32:
             jit.zeroExtend32ToWord(src.gpr(), dst.payloadGPR());
             jit.boxInt32(dst.payloadGPR(), dst, DoNotHaveTagRegisters);
             break;
-        case Wasm::F32:
+        case TypeKind::F32:
             jit.convertFloatToDouble(src.fpr(), src.fpr());
             FALLTHROUGH;
-        case Wasm::F64: {
+        case TypeKind::F64: {
             jit.moveTrustedValue(jsNumber(pureNaN()), dst);
             auto isNaN = jit.branchIfNaN(src.fpr());
@@ -73 +73 @@
         jit.moveTrustedValue(jsUndefined(), JSValueRegs { GPRInfo::returnValueGPR });
     else if (signature.returnCount() == 1) {
-        if (signature.returnType(0) == Wasm::I64) {
+        if (signature.returnType(0).isI64()) {
             GPRReg inputGPR = wasmFrameConvention.results[0].reg().gpr();
             GPRReg wasmContextInstanceGPR = PinnedRegisterInfo::get().wasmContextInstancePointer;
@@ -95 +95 @@
             Type type = signature.returnType(i);
 
-            hasI64 |= type == Wasm::I64;
+            hasI64 |= type.isI64();
             if (loc.isReg()) {
-                if (type != Wasm::I64) {
+                if (!type.isI64()) {
                     boxWasmResult(jit, signature.returnType(i), loc.reg(), scratch);
                     jit.storeValue(scratch, CCallHelpers::Address(CCallHelpers::stackPointerRegister, savedResultRegisters.find(loc.reg())->offset() + wasmFrameConvention.headerAndArgumentStackSizeInBytes));
@@ -103 +103 @@
                     jit.storeValue(JSValueRegs { loc.reg().gpr() }, CCallHelpers::Address(CCallHelpers::stackPointerRegister, savedResultRegisters.find(loc.reg())->offset() + wasmFrameConvention.headerAndArgumentStackSizeInBytes));
             } else {
-                if (type != Wasm::I64) {
+                if (!type.isI64()) {
                     auto location = CCallHelpers::Address(CCallHelpers::stackPointerRegister, loc.offsetFromSP());
-                    Reg tmp = type == F32 || type == F64 ? Reg(fprScratch) : Reg(scratch.gpr());
+                    Reg tmp = (type.isF32() || type.isF64()) ? Reg(fprScratch) : Reg(scratch.gpr());
                     jit.load64ToReg(location, tmp);
                     boxWasmResult(jit, signature.returnType(i), tmp, scratch);
@@ -112 +112 @@
             }
 
-            switch (type) {
-            case Wasm::I32:
+            switch (type.kind) {
+            case TypeKind::I32:
                 indexingType = leastUpperBoundOfIndexingTypes(indexingType, ArrayWithInt32);
                 break;
-            case Wasm::F32:
-            case Wasm::F64:
+            case TypeKind::F32:
+            case TypeKind::F64:
                 indexingType = leastUpperBoundOfIndexingTypes(indexingType, ArrayWithDouble);
                 break;
@@ -132 +132 @@
                 ValueLocation loc = wasmFrameConvention.results[i];
                 Type type = signature.returnType(i);
-                if (type != Wasm::I64)
+                if (!type.isI64())
                     continue;
 
@@ -239 +239 @@
             CCallHelpers::Address jsParam(GPRInfo::callFrameRegister, jsFrameConvention.params[i].offsetFromFP());
             if (wasmFrameConvention.params[i].isStackArgument()) {
-                if (type == Wasm::I32 || type == Wasm::F32) {
+                if (type.isI32() || type.isF32()) {
                     jit.load32(jsParam, scratchReg);
                     jit.store32(scratchReg, calleeFrame.withOffset(wasmFrameConvention.params[i].offsetFromSP()));
@@ -247 +247 @@
                 }
             } else {
-                if (type == Wasm::I32 || type == Wasm::F32)
+                if (type.isI32() || type.isF32())
                     jit.load32ToReg(jsParam, wasmFrameConvention.params[i].reg());
                 else

trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyHelpers.h

@@ -139 +139 @@
 {
     ASSERT(Wasm::isRefType(type));
-    if (type == Wasm::Type::Externref)
+    if (type.isExternref())
         return jsUndefined();
-    ASSERT(type == Wasm::Type::Funcref);
+    ASSERT(type.isFuncref());
     return jsNull();
 }

trunk/Source/JavaScriptCore/wasm/js/WasmToJS.cpp

@@ -102 +102 @@
         for (unsigned argNum = 0; argNum < argCount; ++argNum) {
             Type argType = signature.argument(argNum);
-            switch (argType) {
-            case Void:
-            case Func:
+            switch (argType.kind) {
+            case TypeKind::Void:
+            case TypeKind::Func:
                 RELEASE_ASSERT_NOT_REACHED(); // Handled above.
-            case Externref:
-            case Funcref:
-            case I32:
-            case I64: {
+            case TypeKind::Externref:
+            case TypeKind::Funcref:
+            case TypeKind::I32:
+            case TypeKind::I64: {
                 GPRReg gprReg;
                 if (marshalledGPRs < wasmCC.gprArgs.size())
@@ -120 +120 @@
                 }
                 ++marshalledGPRs;
-                if (argType == I32) {
+                if (argType.isI32()) {
                     jit.zeroExtend32ToWord(gprReg, gprReg); // Clear non-int32 and non-tag bits.
                     jit.boxInt32(gprReg, JSValueRegs(gprReg), DoNotHaveTagRegisters);
@@ -128 +128 @@
                 break;
             }
-            case F32:
-            case F64:
+            case TypeKind::F32:
+            case TypeKind::F64:
                 // Skipped: handled below.
                 if (marshalledFPRs >= wasmCC.fprArgs.size())
@@ -174 +174 @@
         for (unsigned argNum = 0; argNum < argCount; ++argNum) {
             Type argType = signature.argument(argNum);
-            switch (argType) {
-            case Void:
-            case Func:
+            switch (argType.kind) {
+            case TypeKind::Void:
+            case TypeKind::Func:
                 RELEASE_ASSERT_NOT_REACHED(); // Handled above.
-            case Externref:
-            case Funcref:
-            case I32:
-            case I64: {
+            case TypeKind::Externref:
+            case TypeKind::Funcref:
+            case TypeKind::I32:
+            case TypeKind::I64: {
                 // Skipped: handled above.
                 if (marshalledGPRs >= wasmCC.gprArgs.size())
@@ -189 +189 @@
                 break;
             }
-            case F32: {
+            case TypeKind::F32: {
                 FPRReg fprReg;
                 if (marshalledFPRs < wasmCC.fprArgs.size())
@@ -203 +203 @@
                 break;
             }
-            case F64: {
+            case TypeKind::F64: {
                 FPRReg fprReg;
                 if (marshalledFPRs < wasmCC.fprArgs.size())
@@ -227 +227 @@
         unsigned calleeFrameOffset = CallFrameSlot::firstArgument * static_cast<int>(sizeof(Register));
         for (unsigned argNum = 0; argNum < argCount; ++argNum) {
-            if (signature.argument(argNum) == I64) {
+            if (signature.argument(argNum).isI64()) {
                 jit.loadWasmContextInstance(GPRInfo::argumentGPR0);
                 jit.load64(calleeFrame.withOffset(calleeFrameOffset), GPRInfo::argumentGPR1);
@@ -275 +275 @@
 
     if (signature.returnCount() == 1) {
-        switch (signature.returnType(0)) {
-        case Void:
-        case Func:
+        switch (signature.returnType(0).kind) {
+        case TypeKind::Void:
+        case TypeKind::Func:
             // For the JavaScript embedding, imports with these types in their signature return are a WebAssembly.Module validation error.
             RELEASE_ASSERT_NOT_REACHED();
             break;
-        case I64: {
+        case TypeKind::I64: {
             // FIXME: Optimize I64 extraction from BigInt.
             // https://bugs.webkit.org/show_bug.cgi?id=220053
@@ -295 +295 @@
             break;
         }
-        case I32: {
+        case TypeKind::I32: {
             CCallHelpers::JumpList done;
             CCallHelpers::JumpList slowPath;
@@ -318 +318 @@
             break;
         }
-        case Funcref:
-        case Externref:
+        case TypeKind::Funcref:
+        case TypeKind::Externref:
             jit.move(GPRInfo::returnValueGPR, wasmCallInfo.results[0].gpr());
             break;
-        case F32: {
+        case TypeKind::F32: {
             CCallHelpers::JumpList done;
             FPRReg dest = wasmCallInfo.results[0].fpr();
@@ -353 +353 @@
             break;
         }
-        case F64: {
+        case TypeKind::F64: {
             CCallHelpers::JumpList done;
             FPRReg dest = wasmCallInfo.results[0].fpr();

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp

@@ -80 +80 @@
     for (unsigned argIndex = 0; argIndex < signature.argumentCount(); ++argIndex) {
         JSValue arg = callFrame->argument(argIndex);
-        switch (signature.argument(argIndex)) {
-        case Wasm::I32:
+        switch (signature.argument(argIndex).kind) {
+        case Wasm::TypeKind::I32:
             arg = JSValue::decode(arg.toInt32(globalObject));
             break;
-        case Wasm::Funcref: {
+        case Wasm::TypeKind::Funcref: {
             if (!isWebAssemblyHostFunction(vm, arg) && !arg.isNull())
                 return JSValue::encode(throwException(globalObject, scope, createJSWebAssemblyRuntimeError(globalObject, vm, "Funcref must be an exported wasm function")));
             break;
         }
-        case Wasm::Externref:
-            break;
-        case Wasm::I64:
+        case Wasm::TypeKind::Externref:
+            break;
+        case Wasm::TypeKind::I64:
             arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toBigInt64(globalObject)));
             break;
-        case Wasm::F32:
+        case Wasm::TypeKind::F32:
             arg = JSValue::decode(bitwise_cast<uint32_t>(arg.toFloat(globalObject)));
             break;
-        case Wasm::F64:
+        case Wasm::TypeKind::F64:
             arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toNumber(globalObject)));
             break;
-        case Wasm::Void:
-        case Wasm::Func:
+        case Wasm::TypeKind::Void:
+        case Wasm::TypeKind::Func:
             RELEASE_ASSERT_NOT_REACHED();
         }
@@ -261 +261 @@
 
         auto type = signature.argument(i);
-        switch (type) {
-        case Wasm::I32: {
+        switch (type.kind) {
+        case Wasm::TypeKind::I32: {
             jit.load64(jsParam, scratchGPR);
             slowPath.append(jit.branchIfNotInt32(scratchGPR));
@@ -271 +271 @@
             break;
         }
-        case Wasm::Funcref: {
+        case Wasm::TypeKind::Funcref: {
             // Ensure we have a WASM exported function.
             jit.load64(jsParam, scratchGPR);
@@ -291 +291 @@
             FALLTHROUGH;
         }
-        case Wasm::Externref: {
+        case Wasm::TypeKind::Externref: {
             if (isStack) {
                 jit.load64(jsParam, scratchGPR);
@@ -299 +299 @@
             break;
         }
-        case Wasm::F32:
-        case Wasm::F64: {
+        case Wasm::TypeKind::F32:
+        case Wasm::TypeKind::F64: {
             if (!isStack)
                 scratchFPR = wasmCallInfo.params[i].fpr();
             auto moveToDestination = [&] () {
                 if (isStack) {
-                    if (signature.argument(i) == Wasm::F32)
+                    if (signature.argument(i).isF32())
                         jit.storeFloat(scratchFPR, calleeFrame.withOffset(wasmCallInfo.params[i].offsetFromSP()));
                     else
@@ -317 +317 @@
 
             jit.unboxDouble(scratchGPR, scratchGPR, scratchFPR);
-            if (signature.argument(i) == Wasm::F32)
+            if (signature.argument(i).isF32())
                 jit.convertDoubleToFloat(scratchFPR, scratchFPR);
             moveToDestination();
@@ -323 +323 @@
 
             isInt32.link(&jit);
-            if (signature.argument(i) == Wasm::F32) {
+            if (signature.argument(i).isF32()) {
                 jit.convertInt32ToFloat(scratchGPR, scratchFPR);
                 moveToDestination();

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyGlobalConstructor.cpp

@@ -88 +88 @@
         RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
         if (valueString == "i32"_s)
-            type = Wasm::Type::I32;
+            type = Wasm::Types::I32;
         else if (valueString == "i64"_s)
-            type = Wasm::Type::I64;
+            type = Wasm::Types::I64;
         else if (valueString == "f32"_s)
-            type = Wasm::Type::F32;
+            type = Wasm::Types::F32;
         else if (valueString == "f64"_s)
-            type = Wasm::Type::F64;
+            type = Wasm::Types::F64;
         else if (Options::useWebAssemblyReferences() && (valueString == "anyfunc"_s || valueString == "funcref"_s))
-            type = Wasm::Type::Funcref;
+            type = Wasm::Types::Funcref;
         else if (Options::useWebAssemblyReferences() && valueString == "externref"_s)
-            type = Wasm::Type::Externref;
+            type = Wasm::Types::Externref;
         else
             return JSValue::encode(throwException(globalObject, throwScope, createTypeError(globalObject, "WebAssembly.Global expects its 'value' field to be the string 'i32', 'i64', 'f32', 'f64', 'anyfunc', 'funcref', or 'externref'"_s)));
@@ -105 +105 @@
     uint64_t initialValue = 0;
     JSValue argument = callFrame->argument(1);
-    switch (type) {
-    case Wasm::Type::I32: {
+    switch (type.kind) {
+    case Wasm::TypeKind::I32: {
         if (!argument.isUndefined()) {
             int32_t value = argument.toInt32(globalObject);
@@ -114 +114 @@
         break;
     }
-    case Wasm::Type::I64: {
+    case Wasm::TypeKind::I64: {
         if (!argument.isUndefined()) {
             int64_t value = argument.toBigInt64(globalObject);
@@ -122 +122 @@
         break;
     }
-    case Wasm::Type::F32: {
+    case Wasm::TypeKind::F32: {
         if (!argument.isUndefined()) {
             float value = argument.toFloat(globalObject);
@@ -130 +130 @@
         break;
     }
-    case Wasm::Type::F64: {
+    case Wasm::TypeKind::F64: {
         if (!argument.isUndefined()) {
             double value = argument.toNumber(globalObject);
@@ -138 +138 @@
         break;
     }
-    case Wasm::Type::Funcref: {
+    case Wasm::TypeKind::Funcref: {
         ASSERT(Options::useWebAssemblyReferences());
         if (argument.isUndefined())
@@ -149 +149 @@
         break;
     }
-    case Wasm::Type::Externref: {
+    case Wasm::TypeKind::Externref: {
         ASSERT(Options::useWebAssemblyReferences());
         if (argument.isUndefined())

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp

@@ -247 +247 @@
                     if (globalValue->global()->mutability() != Wasm::GlobalInformation::Immutable)
                         return exception(createJSWebAssemblyLinkError(globalObject, vm, importFailMessage(import, "imported global", "must be a same mutability")));
-                    switch (moduleInformation.globals[import.kindIndex].type) {
-                    case Wasm::Funcref:
+                    switch (moduleInformation.globals[import.kindIndex].type.kind) {
+                    case Wasm::TypeKind::Funcref:
                         value = globalValue->global()->get(globalObject);
                         RETURN_IF_EXCEPTION(scope, void());
@@ -255 +255 @@
                         m_instance->instance().setGlobal(import.kindIndex, value);
                         break;
-                    case Wasm::Externref:
+                    case Wasm::TypeKind::Externref:
                         value = globalValue->global()->get(globalObject);
                         RETURN_IF_EXCEPTION(scope, void());
                         m_instance->instance().setGlobal(import.kindIndex, value);
                         break;
-                    case Wasm::I32:
-                    case Wasm::I64:
-                    case Wasm::F32:
-                    case Wasm::F64:
+                    case Wasm::TypeKind::I32:
+                    case Wasm::TypeKind::I64:
+                    case Wasm::TypeKind::F32:
+                    case Wasm::TypeKind::F64:
                         m_instance->instance().setGlobal(import.kindIndex, globalValue->global()->getPrimitive());
                         break;
@@ -273 +273 @@
                     if (!isRefType(globalType)) {
                         // ii. If the global_type of i is i64 or Type(v) is Number, throw a WebAssembly.LinkError.
-                        if (globalType == Wasm::I64) {
+                        if (globalType.isI64()) {
                             if (!value.isBigInt())
                                 return exception(createJSWebAssemblyLinkError(globalObject, vm, importFailMessage(import, "imported global", "must be a BigInt")));
@@ -283 +283 @@
 
                     // iii. Append ToWebAssemblyValue(v) to imports.
-                    switch (globalType) {
-                    case Wasm::Funcref:
+                    switch (globalType.kind) {
+                    case Wasm::TypeKind::Funcref:
                         if (!isWebAssemblyHostFunction(vm, value) && !value.isNull())
                             return exception(createJSWebAssemblyLinkError(globalObject, vm, importFailMessage(import, "imported global", "must be a wasm exported function or null")));
                         m_instance->instance().setGlobal(import.kindIndex, value);
                         break;
-                    case Wasm::Externref:
+                    case Wasm::TypeKind::Externref:
                         m_instance->instance().setGlobal(import.kindIndex, value);
                         break;
-                    case Wasm::I32:
+                    case Wasm::TypeKind::I32:
                         m_instance->instance().setGlobal(import.kindIndex, value.toInt32(globalObject));
                         break;
-                    case Wasm::I64: {
+                    case Wasm::TypeKind::I64: {
                         int64_t bits = value.toBigInt64(globalObject);
                         RETURN_IF_EXCEPTION(scope, void());
@@ -301 +301 @@
                         break;
                     }
-                    case Wasm::F32:
+                    case Wasm::TypeKind::F32:
                         m_instance->instance().setGlobal(import.kindIndex, bitwise_cast<uint32_t>(value.toFloat(globalObject)));
                         break;
-                    case Wasm::F64:
+                    case Wasm::TypeKind::F64:
                         m_instance->instance().setGlobal(import.kindIndex, bitwise_cast<uint64_t>(value.asNumber()));
                         break;
@@ -488 +488 @@
         case Wasm::ExternalKind::Global: {
             const Wasm::GlobalInformation& global = moduleInformation.globals[exp.kindIndex];
-            switch (global.type) {
-            case Wasm::Externref:
-            case Wasm::Funcref:
-            case Wasm::I32:
-            case Wasm::I64:
-            case Wasm::F32:
-            case Wasm::F64: {
+            switch (global.type.kind) {
+            case Wasm::TypeKind::Externref:
+            case Wasm::TypeKind::Funcref:
+            case Wasm::TypeKind::I32:
+            case Wasm::TypeKind::I64:
+            case Wasm::TypeKind::F32:
+            case Wasm::TypeKind::F64: {
                 // If global is immutable, we are not creating a binding internally.
                 // But we need to create a binding just to export it. This binding is not actually connected. But this is OK since it is immutable.