Attachment #256765 for bug #146064

View Details Raw Unified Return to Bug 146064

| Differences between

and this patch



2015-07-14  Sukolsak Sakshuwong  <sukolsak@gmail.com>

        JSC should natively support WebAssembly
        https://bugs.webkit.org/show_bug.cgi?id=146064

        Reviewed by NOBODY (OOPS!).

        * JavaScriptCore.xcodeproj/project.pbxproj:
        * bytecode/CodeBlock.cpp:
        (JSC::CodeBlock::inferredName):
        (JSC::CodeBlock::CodeBlock):
        (JSC::WebAssemblyCodeBlock::replacement):
        (JSC::WebAssemblyCodeBlock::capabilityLevelInternal):
        * bytecode/CodeBlock.h:
        (JSC::CodeBlock::codeType):
        (JSC::WebAssemblyCodeBlock::WebAssemblyCodeBlock):
        * jit/JITOperations.cpp:
        * jsc.cpp:
        (GlobalObject::finishCreation):
        (functionLoadWebAssembly):
        * llint/LLIntSlowPaths.cpp:
        (JSC::LLInt::setUpCall):
        * runtime/Executable.cpp:
        (JSC::ScriptExecutable::installCode):
        (JSC::ScriptExecutable::newCodeBlockFor):
        (JSC::ScriptExecutable::prepareForExecutionImpl):
        (JSC::WebAssemblyExecutable::WebAssemblyExecutable):
        (JSC::WebAssemblyExecutable::finishCreation):
        (JSC::WebAssemblyExecutable::destroy):
        (JSC::WebAssemblyExecutable::baselineCodeBlockFor):
        (JSC::WebAssemblyExecutable::visitChildren):
        (JSC::WebAssemblyExecutable::symbolTable):
        (JSC::WebAssemblyExecutable::clearCode):
        (JSC::WebAssemblyExecutable::unlinkCalls):
        * runtime/Executable.h:
        (JSC::ExecutableBase::isWebAssemblyExecutable):
        (JSC::ExecutableBase::clearCodeVirtual):
        * runtime/JSFunction.cpp:
        (JSC::JSFunction::create):
        * runtime/JSFunction.h:
        (JSC::JSFunction::createImpl):
        * runtime/JSFunctionInlines.h:
        (JSC::JSFunction::JSFunction):
        (JSC::JSFunction::isHostFunction):
        * runtime/JSType.h:
        * runtime/VM.cpp:
        (JSC::VM::VM):
        * runtime/VM.h:
        * wasm/WasmJITCompiler.cpp: Added.
        (JSC::Wasm::JumpScope::JumpScope):
        (JSC::Wasm::JumpScope::jump):
        (JSC::Wasm::JumpScope::link):
        (JSC::Wasm::JITCompiler::compileFunction):
        (JSC::Wasm::JITCompiler::allocateSpaceOnStack):
        (JSC::Wasm::JITCompiler::deallocateSpaceOnStack):
        (JSC::Wasm::JITCompiler::parseArguments):
        (JSC::Wasm::JITCompiler::parseVars):
        (JSC::Wasm::JITCompiler::parseStmt):
        (JSC::Wasm::JITCompiler::parseGetLocal):
        (JSC::Wasm::JITCompiler::parseSetLocal):
        (JSC::Wasm::getArrayBufferData):
        (JSC::Wasm::JITCompiler::parseArrayBufferOffset):
        (JSC::Wasm::JITCompiler::parseLoad):
        (JSC::Wasm::JITCompiler::parseStore):
        (JSC::Wasm::JITCompiler::parseReturnStmt):
        (JSC::Wasm::JITCompiler::parseStmtList):
        (JSC::Wasm::JITCompiler::parseBlockStmt):
        (JSC::Wasm::JITCompiler::parseIfStmt):
        (JSC::Wasm::JITCompiler::parseIfElseStmt):
        (JSC::Wasm::JITCompiler::parseWhileStmt):
        (JSC::Wasm::JITCompiler::parseDoStmt):
        (JSC::Wasm::JITCompiler::parseLabelStmt):
        (JSC::Wasm::JITCompiler::parseBreakStmt):
        (JSC::Wasm::JITCompiler::parseBreakLabelStmt):
        (JSC::Wasm::JITCompiler::parseContinueStmt):
        (JSC::Wasm::JITCompiler::parseContinueLabelStmt):
        (JSC::Wasm::JITCompiler::parseSwitchStmt):
        (JSC::Wasm::JITCompiler::parseExpr):
        (JSC::Wasm::JITCompiler::parseExprI32):
        (JSC::Wasm::JITCompiler::parseExprF64):
        (JSC::Wasm::JITCompiler::parseExprVoid):
        (JSC::Wasm::getInternalFunction):
        (JSC::Wasm::JITCompiler::parseCallInternal):
        (JSC::Wasm::getImportedFunction):
        (JSC::Wasm::JITCompiler::parseCallImport):
        (JSC::Wasm::JITCompiler::callFunctionSlowCase):
        (JSC::Wasm::JITCompiler::parseCallArguments):
        (JSC::Wasm::JITCompiler::callDoubleFunction):
        (JSC::Wasm::JITCompiler::parseUnaryOp):
        (JSC::Wasm::JITCompiler::parseBinaryOp):
        (JSC::Wasm::JITCompiler::parseRelationalOpI32):
        (JSC::Wasm::JITCompiler::parseRelationalOpF64):
        (JSC::Wasm::JITCompiler::parseComma):
        (JSC::Wasm::JITCompiler::parseCond):
        (JSC::Wasm::JITCompiler::parseMinMaxI32):
        * wasm/WasmJITCompiler.h: Added.
        (JSC::Wasm::JITCompiler::JITCompiler):
        (JSC::Wasm::JITCompiler::stackAddress):
        (JSC::Wasm::JITCompiler::temporaryAddress):
        (JSC::Wasm::JITCompiler::pushContinueLabelLabel):
        (JSC::Wasm::JITCompiler::popContinueLabelLabel):
        (JSC::Wasm::JITCompiler::continueLabelLabel):
        (JSC::Wasm::JITCompiler::pushBreakLabelJumpList):
        (JSC::Wasm::JITCompiler::popBreakLabelJumpList):
        (JSC::Wasm::JITCompiler::breakLabelJumpList):
        (JSC::Wasm::JITCompiler::pushContinueJumpScope):
        (JSC::Wasm::JITCompiler::popContinueJumpScope):
        (JSC::Wasm::JITCompiler::topContinueJumpScope):
        (JSC::Wasm::JITCompiler::pushBreakJumpList):
        (JSC::Wasm::JITCompiler::popBreakJumpList):
        (JSC::Wasm::JITCompiler::topBreakJumpList):
        * wasm/WasmModule.cpp: Added.
        (JSC::Wasm::Module::finishCreation):
        (JSC::Wasm::Module::parseConstantPoolSection):
        (JSC::Wasm::Module::parseSignatureSection):
        (JSC::Wasm::Module::parseFunctionImportSection):
        (JSC::Wasm::Module::parseGlobalSection):
        (JSC::Wasm::Module::parseFunctionDeclarationSection):
        (JSC::Wasm::Module::parseFunctionPointerTables):
        (JSC::Wasm::Module::parseFunctionDefinitionSection):
        (JSC::Wasm::Module::parseExportSection):
        (JSC::Wasm::Module::parseFunctionDefinition):
        (JSC::Wasm::Module::function):
        (JSC::Wasm::Module::arrayBufferData):
        (JSC::Wasm::Module::visitChildren):
        (JSC::Wasm::Module::getOwnPropertySlot):
        (JSC::Wasm::Module::put):
        (JSC::Wasm::Module::defineOwnProperty):
        (JSC::Wasm::Module::deleteProperty):
        (JSC::Wasm::Module::getOwnNonIndexPropertyNames):
        (JSC::Wasm::compile):
        * wasm/WasmModule.h: Added.
        (JSC::Wasm::Module::create):
        (JSC::Wasm::Module::createStructure):
        (JSC::Wasm::Module::functionImportName):
        (JSC::Wasm::Module::Module):
        * wasm/WasmOpcodes.h: Added.
        (JSC::Wasm::operator| ):
        (JSC::Wasm::operator&):
        (JSC::Wasm::Expr::Expr):
        (JSC::Wasm::Expr::type):
        (JSC::Wasm::Expr::i32):
        (JSC::Wasm::Expr::f32):
        (JSC::Wasm::Expr::f64):
        (JSC::Wasm::Expr::operator==):
        (JSC::Wasm::Expr::operator!=):
        (JSC::Wasm::PackOpWithImm):
        (JSC::Wasm::UnpackOpWithImm):
        (JSC::Wasm::ExprWithImm::ExprWithImm):
        (JSC::Wasm::ExprWithImm::type):
        (JSC::Wasm::ExprWithImm::i32):
        (JSC::Wasm::ExprWithImm::f32):
        (JSC::Wasm::ExprWithImm::f64):
        (JSC::Wasm::Signature::Signature):
        (JSC::Wasm::Signature::operator==):
        (JSC::Wasm::Signature::operator!=):
        (JSC::Wasm::Signature::Hash::operator()):
        (JSC::Wasm::Reader::Reader):
        (JSC::Wasm::Reader::stmt):
        (JSC::Wasm::Reader::switchCase):
        (JSC::Wasm::Reader::voidExpr):
        (JSC::Wasm::Reader::exportFormat):
        (JSC::Wasm::Reader::type):
        (JSC::Wasm::Reader::returnType):
        (JSC::Wasm::Reader::singleChar):
        (JSC::Wasm::Reader::u8):
        (JSC::Wasm::Reader::fixedWidth<uint32_t>):
        (JSC::Wasm::Reader::fixedWidth<float>):
        (JSC::Wasm::Reader::fixedWidth<double>):
        (JSC::Wasm::Reader::code):
        (JSC::Wasm::Reader::immU32):
        (JSC::Wasm::Reader::immS32):
        (JSC::Wasm::Reader::ifI32Lit):

2015-07-08  Joseph Pecoraro  <pecoraro@apple.com>

        Fix grammar issue in TypeError attempting to change an unconfigurable property

Lines 1020-1025 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec1
- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj +28 lines
1020	70ECA6071AFDBEA200449739 /* TemplateRegistry.cpp in Sources / = {isa = PBXBuildFile; fileRef = 70ECA6021AFDBEA200449739 / TemplateRegistry.cpp */; };	1020	70ECA6071AFDBEA200449739 /* TemplateRegistry.cpp in Sources / = {isa = PBXBuildFile; fileRef = 70ECA6021AFDBEA200449739 / TemplateRegistry.cpp */; };
1021	70ECA6081AFDBEA200449739 /* TemplateRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = 70ECA6031AFDBEA200449739 / TemplateRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };	1021	70ECA6081AFDBEA200449739 /* TemplateRegistry.h in Headers / = {isa = PBXBuildFile; fileRef = 70ECA6031AFDBEA200449739 / TemplateRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };
1022	70ECA6091AFDBEA200449739 /* TemplateRegistryKey.h in Headers / = {isa = PBXBuildFile; fileRef = 70ECA6041AFDBEA200449739 / TemplateRegistryKey.h */; settings = {ATTRIBUTES = (Private, ); }; };	1022	70ECA6091AFDBEA200449739 /* TemplateRegistryKey.h in Headers / = {isa = PBXBuildFile; fileRef = 70ECA6041AFDBEA200449739 / TemplateRegistryKey.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1023	7BD10C421B4ED43C00BD541A /* WasmJITCompiler.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7BD10C3D1B4ED43900BD541A / WasmJITCompiler.cpp */; };
		1024	7BD10C431B4ED44000BD541A /* WasmJITCompiler.h in Headers / = {isa = PBXBuildFile; fileRef = 7BD10C3E1B4ED43900BD541A / WasmJITCompiler.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1025	7BD10C441B4ED44500BD541A /* WasmModule.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7BD10C3F1B4ED43900BD541A / WasmModule.cpp */; };
		1026	7BD10C451B4ED44900BD541A /* WasmModule.h in Headers / = {isa = PBXBuildFile; fileRef = 7BD10C401B4ED43900BD541A / WasmModule.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1027	7BD10C461B4ED44E00BD541A /* WasmOpcodes.h in Headers / = {isa = PBXBuildFile; fileRef = 7BD10C411B4ED43900BD541A / WasmOpcodes.h */; settings = {ATTRIBUTES = (Private, ); }; };
1023	7C008CDA187124BB00955C24 /* JSPromiseDeferred.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7C008CD8187124BB00955C24 / JSPromiseDeferred.cpp */; };	1028	7C008CDA187124BB00955C24 /* JSPromiseDeferred.cpp in Sources / = {isa = PBXBuildFile; fileRef = 7C008CD8187124BB00955C24 / JSPromiseDeferred.cpp */; };
1024	7C008CDB187124BB00955C24 /* JSPromiseDeferred.h in Headers / = {isa = PBXBuildFile; fileRef = 7C008CD9187124BB00955C24 / JSPromiseDeferred.h */; settings = {ATTRIBUTES = (Private, ); }; };	1029	7C008CDB187124BB00955C24 /* JSPromiseDeferred.h in Headers / = {isa = PBXBuildFile; fileRef = 7C008CD9187124BB00955C24 / JSPromiseDeferred.h */; settings = {ATTRIBUTES = (Private, ); }; };
1025	7C008CE7187631B600955C24 /* Microtask.h in Headers / = {isa = PBXBuildFile; fileRef = 7C008CE5187631B600955C24 / Microtask.h */; settings = {ATTRIBUTES = (Private, ); }; };	1030	7C008CE7187631B600955C24 /* Microtask.h in Headers / = {isa = PBXBuildFile; fileRef = 7C008CE5187631B600955C24 / Microtask.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 2762-2767 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec2
2762	70ECA6021AFDBEA200449739 /* TemplateRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TemplateRegistry.cpp; sourceTree = "<group>"; };	2767	70ECA6021AFDBEA200449739 /* TemplateRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TemplateRegistry.cpp; sourceTree = "<group>"; };
2763	70ECA6031AFDBEA200449739 /* TemplateRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TemplateRegistry.h; sourceTree = "<group>"; };	2768	70ECA6031AFDBEA200449739 /* TemplateRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TemplateRegistry.h; sourceTree = "<group>"; };
2764	70ECA6041AFDBEA200449739 /* TemplateRegistryKey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TemplateRegistryKey.h; sourceTree = "<group>"; };	2769	70ECA6041AFDBEA200449739 /* TemplateRegistryKey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TemplateRegistryKey.h; sourceTree = "<group>"; };
		2770	7BD10C3D1B4ED43900BD541A /* WasmJITCompiler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WasmJITCompiler.cpp; sourceTree = "<group>"; };
		2771	7BD10C3E1B4ED43900BD541A /* WasmJITCompiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmJITCompiler.h; sourceTree = "<group>"; };
		2772	7BD10C3F1B4ED43900BD541A /* WasmModule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WasmModule.cpp; sourceTree = "<group>"; };
		2773	7BD10C401B4ED43900BD541A /* WasmModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmModule.h; sourceTree = "<group>"; };
		2774	7BD10C411B4ED43900BD541A /* WasmOpcodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmOpcodes.h; sourceTree = "<group>"; };
2765	7C008CD8187124BB00955C24 /* JSPromiseDeferred.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPromiseDeferred.cpp; sourceTree = "<group>"; };	2775	7C008CD8187124BB00955C24 /* JSPromiseDeferred.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPromiseDeferred.cpp; sourceTree = "<group>"; };
2766	7C008CD9187124BB00955C24 /* JSPromiseDeferred.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSPromiseDeferred.h; sourceTree = "<group>"; };	2776	7C008CD9187124BB00955C24 /* JSPromiseDeferred.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSPromiseDeferred.h; sourceTree = "<group>"; };
2767	7C008CE5187631B600955C24 /* Microtask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Microtask.h; sourceTree = "<group>"; };	2777	7C008CE5187631B600955C24 /* Microtask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Microtask.h; sourceTree = "<group>"; };
Lines 3617-3622 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec3
3617	7EF6E0BB0EB7A1EC0079AFAF /* runtime */,	3627	7EF6E0BB0EB7A1EC0079AFAF /* runtime */,
3618	141211000A48772600480255 /* tests */,	3628	141211000A48772600480255 /* tests */,
3619	8603CEF014C753EF00AE59E3 /* tools */,	3629	8603CEF014C753EF00AE59E3 /* tools */,
		3630	7BD10C3C1B4ED41D00BD541A /* wasm */,
3620	86EAC48C0F93E8B9008EC948 /* yarr */,	3631	86EAC48C0F93E8B9008EC948 /* yarr */,
3621	);	3632	);
3622	name = JavaScriptCore;	3633	name = JavaScriptCore;
Lines 4279-4284 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec4
4279	path = disassembler/ARMv7;	4290	path = disassembler/ARMv7;
4280	sourceTree = "<group>";	4291	sourceTree = "<group>";
4281	};	4292	};
		4293	7BD10C3C1B4ED41D00BD541A /* wasm */ = {
		4294	isa = PBXGroup;
		4295	children = (
		4296	7BD10C3D1B4ED43900BD541A /* WasmJITCompiler.cpp */,
		4297	7BD10C3E1B4ED43900BD541A /* WasmJITCompiler.h */,
		4298	7BD10C3F1B4ED43900BD541A /* WasmModule.cpp */,
		4299	7BD10C401B4ED43900BD541A /* WasmModule.h */,
		4300	7BD10C411B4ED43900BD541A /* WasmOpcodes.h */,
		4301	);
		4302	path = wasm;
		4303	sourceTree = "<group>";
		4304	};
4282	7E39D81D0EC38EFA003AF11A /* bytecompiler */ = {	4305	7E39D81D0EC38EFA003AF11A /* bytecompiler */ = {
4283	isa = PBXGroup;	4306	isa = PBXGroup;
4284	children = (	4307	children = (
Lines 6011-6016 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec5
6011	BC18C4050E16F5CD00B34460 /* FunctionPrototype.h in Headers */,	6034	BC18C4050E16F5CD00B34460 /* FunctionPrototype.h in Headers */,
6012	BCBE2CAE14E985AA000593AD /* GCAssertions.h in Headers */,	6035	BCBE2CAE14E985AA000593AD /* GCAssertions.h in Headers */,
6013	0F766D3015A8DCE2008F363E /* GCAwareJITStubRoutine.h in Headers */,	6036	0F766D3015A8DCE2008F363E /* GCAwareJITStubRoutine.h in Headers */,
		6037	7BD10C451B4ED44900BD541A /* WasmModule.h in Headers */,
6014	70EC0EC71AA0D7DA00B6AAFA /* StringIteratorPrototype.h in Headers */,	6038	70EC0EC71AA0D7DA00B6AAFA /* StringIteratorPrototype.h in Headers */,
6015	0F2B66AC17B6B53F00A7AE3F /* GCIncomingRefCounted.h in Headers */,	6039	0F2B66AC17B6B53F00A7AE3F /* GCIncomingRefCounted.h in Headers */,
6016	0F2B66AD17B6B54500A7AE3F /* GCIncomingRefCountedInlines.h in Headers */,	6040	0F2B66AD17B6B54500A7AE3F /* GCIncomingRefCountedInlines.h in Headers */,
Lines 6145-6150 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec6
6145	BC18C41D0E16F5CD00B34460 /* JSClassRef.h in Headers */,	6169	BC18C41D0E16F5CD00B34460 /* JSClassRef.h in Headers */,
6146	86E3C613167BABD7006D760A /* JSContext.h in Headers */,	6170	86E3C613167BABD7006D760A /* JSContext.h in Headers */,
6147	86E3C617167BABEE006D760A /* JSContextInternal.h in Headers */,	6171	86E3C617167BABEE006D760A /* JSContextInternal.h in Headers */,
		6172	7BD10C431B4ED44000BD541A /* WasmJITCompiler.h in Headers */,
6148	BC18C41E0E16F5CD00B34460 /* JSContextRef.h in Headers */,	6173	BC18C41E0E16F5CD00B34460 /* JSContextRef.h in Headers */,
6149	148CD1D8108CF902008163C6 /* JSContextRefPrivate.h in Headers */,	6174	148CD1D8108CF902008163C6 /* JSContextRefPrivate.h in Headers */,
6150	A72028B81797601E0098028C /* JSCTestRunnerUtils.h in Headers */,	6175	A72028B81797601E0098028C /* JSCTestRunnerUtils.h in Headers */,
Lines 6154-6159 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec7
6154	978801411471AD920041B016 /* JSDateMath.h in Headers */,	6179	978801411471AD920041B016 /* JSDateMath.h in Headers */,
6155	C2A7F688160432D400F76B98 /* JSDestructibleObject.h in Headers */,	6180	C2A7F688160432D400F76B98 /* JSDestructibleObject.h in Headers */,
6156	86E3C614167BABD7006D760A /* JSExport.h in Headers */,	6181	86E3C614167BABD7006D760A /* JSExport.h in Headers */,
		6182	7BD10C461B4ED44E00BD541A /* WasmOpcodes.h in Headers */,
6157	A7B4ACAF1484C9CE00B38A36 /* JSExportMacros.h in Headers */,	6183	A7B4ACAF1484C9CE00B38A36 /* JSExportMacros.h in Headers */,
6158	0F2B66EF17B6B5AB00A7AE3F /* JSFloat32Array.h in Headers */,	6184	0F2B66EF17B6B5AB00A7AE3F /* JSFloat32Array.h in Headers */,
6159	0F2B66F017B6B5AB00A7AE3F /* JSFloat64Array.h in Headers */,	6185	0F2B66F017B6B5AB00A7AE3F /* JSFloat64Array.h in Headers */,
Lines 7152-7157 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec8
7152	0FA581BA150E952C00B9A2D9 /* DFGNodeFlags.cpp in Sources */,	7178	0FA581BA150E952C00B9A2D9 /* DFGNodeFlags.cpp in Sources */,
7153	86EC9DCF1328DF82002B2AD7 /* DFGOperations.cpp in Sources */,	7179	86EC9DCF1328DF82002B2AD7 /* DFGOperations.cpp in Sources */,
7154	A7D89CFD17A0B8CC00773AD8 /* DFGOSRAvailabilityAnalysisPhase.cpp in Sources */,	7180	A7D89CFD17A0B8CC00773AD8 /* DFGOSRAvailabilityAnalysisPhase.cpp in Sources */,
		7181	7BD10C421B4ED43C00BD541A /* WasmJITCompiler.cpp in Sources */,
7155	0FD82E56141DAF0800179C94 /* DFGOSREntry.cpp in Sources */,	7182	0FD82E56141DAF0800179C94 /* DFGOSREntry.cpp in Sources */,
7156	0FD8A32517D51F5700CA2C40 /* DFGOSREntrypointCreationPhase.cpp in Sources */,	7183	0FD8A32517D51F5700CA2C40 /* DFGOSREntrypointCreationPhase.cpp in Sources */,
7157	FE5068671AE25E280009DAB7 /* DeferredSourceDump.cpp in Sources */,	7184	FE5068671AE25E280009DAB7 /* DeferredSourceDump.cpp in Sources */,
Lines 7188-7193 a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj_sec9
7188	0FC097A1146B28CA00CF2442 /* DFGThunks.cpp in Sources */,	7215	0FC097A1146B28CA00CF2442 /* DFGThunks.cpp in Sources */,
7189	0F93B4A918B92C4D00178A3F /* PutByIdVariant.cpp in Sources */,	7216	0F93B4A918B92C4D00178A3F /* PutByIdVariant.cpp in Sources */,
7190	709FB8671AE335C60039D069 /* JSWeakSet.cpp in Sources */,	7217	709FB8671AE335C60039D069 /* JSWeakSet.cpp in Sources */,
		7218	7BD10C441B4ED44500BD541A /* WasmModule.cpp in Sources */,
7191	0FD8A32717D51F5700CA2C40 /* DFGTierUpCheckInjectionPhase.cpp in Sources */,	7219	0FD8A32717D51F5700CA2C40 /* DFGTierUpCheckInjectionPhase.cpp in Sources */,
7192	0FD8A32917D51F5700CA2C40 /* DFGToFTLDeferredCompilationCallback.cpp in Sources */,	7220	0FD8A32917D51F5700CA2C40 /* DFGToFTLDeferredCompilationCallback.cpp in Sources */,
7193	0FB17662196B8F9E0091052A /* DFGPureValue.cpp in Sources */,	7221	0FB17662196B8F9E0091052A /* DFGPureValue.cpp in Sources */,



    case EvalCode:
        return "<eval>";
    case FunctionCode:
        // FIXME: hacky
        if (ownerExecutable()->isWebAssemblyExecutable())
            return "<webassembly>";
        return jsCast<FunctionExecutable*>(ownerExecutable())->inferredName().utf8();
    default:
        CRASH();

    m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock) + m_instructions.size() * sizeof(Instruction));
}

CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, JSGlobalObject* globalObject)
    : m_globalObject(globalObject->vm(), ownerExecutable, globalObject)
    , m_heap(&m_globalObject->vm().heap)
    , m_numCalleeRegisters(0) // FIXME
    , m_numVars(0) // FIXME
    , m_isConstructor(false) // FIXME
    , m_shouldAlwaysBeInlined(true)
    , m_didFailFTLCompilation(false)
    , m_hasBeenCompiledWithFTL(false)
    // , m_unlinkedCode(m_globalObject->vm(), ownerExecutable, unlinkedCodeBlock)
    , m_hasDebuggerStatement(false)
    , m_steppingMode(SteppingModeDisabled)
    , m_numBreakpoints(0)
    , m_ownerExecutable(m_globalObject->vm(), ownerExecutable, ownerExecutable)
    , m_vm(&m_globalObject->vm()) // FIXME
    , m_thisRegister(VirtualRegister()) // FIXME
    , m_scopeRegister(VirtualRegister()) // FIXME
    , m_lexicalEnvironmentRegister(VirtualRegister()) // FIXME
    , m_isStrictMode(false) // FIXME
    , m_needsActivation(false)
    , m_mayBeExecuting(false)
    , m_source(nullptr)
    , m_sourceOffset(0)
    , m_firstLineColumnOffset(0)
    , m_codeType(FunctionCode) // FIXME
    , m_osrExitCounter(0)
    , m_optimizationDelayCounter(0)
    , m_reoptimizationRetryCounter(0)
#if ENABLE(JIT)
    , m_capabilityLevelState(DFG::CapabilityLevelNotSet)
#endif
{
    m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed);

    ASSERT(m_heap->isDeferred());

    /*
    ASSERT(m_scopeRegister.isLocal());

    bool didCloneSymbolTable = false;

    if (SymbolTable* symbolTable = unlinkedCodeBlock->symbolTable()) {
        if (m_vm->typeProfiler()) {
            ConcurrentJITLocker locker(symbolTable->m_lock);
            symbolTable->prepareForTypeProfiling(locker);
        }

        if (codeType() == FunctionCode && symbolTable->scopeSize()) {
            m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable->cloneScopePart(*m_vm));
            didCloneSymbolTable = true;
        } else
            m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable);
    }
    */

    // FIXME:
    setNumParameters(0);

    m_heap->m_codeBlocks.add(this);
    m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock));
}

CodeBlock::~CodeBlock()
{
    if (m_vm->m_perBytecodeProfiler)

    return jsCast<FunctionExecutable*>(ownerExecutable())->codeBlockFor(m_isConstructor ? CodeForConstruct : CodeForCall);
}

CodeBlock* WebAssemblyCodeBlock::replacement()
{
    return jsCast<WebAssemblyExecutable*>(ownerExecutable())->codeBlockFor(m_isConstructor ? CodeForConstruct : CodeForCall);
}

DFG::CapabilityLevel ProgramCodeBlock::capabilityLevelInternal()
{
    return DFG::programCapabilityLevel(this);

        return DFG::functionForConstructCapabilityLevel(this);
    return DFG::functionForCallCapabilityLevel(this);
}

DFG::CapabilityLevel WebAssemblyCodeBlock::capabilityLevelInternal()
{
    return DFG::CannotCompile;
}
#endif

void CodeBlock::jettison(Profiler::JettisonReason reason, ReoptimizationMode mode, const FireDetail* detail)

Lines 97-102 protected: a/Source/JavaScriptCore/bytecode/CodeBlock.h_sec1
- a/Source/JavaScriptCore/bytecode/CodeBlock.h -1 / +31 lines
97		97
98	CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock, JSScope, PassRefPtr<SourceProvider>, unsigned sourceOffset, unsigned firstLineColumnOffset);	98	CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock, JSScope, PassRefPtr<SourceProvider>, unsigned sourceOffset, unsigned firstLineColumnOffset);
99		99
		100	CodeBlock(ScriptExecutable* ownerExecutable, JSGlobalObject*);
		101
100	WriteBarrier<JSGlobalObject> m_globalObject;	102	WriteBarrier<JSGlobalObject> m_globalObject;
101	Heap* m_heap;	103	Heap* m_heap;
102		104
Lines 348-354 public: a/Source/JavaScriptCore/bytecode/CodeBlock.h_sec2
348	return m_needsActivation;	350	return m_needsActivation;
349	}	351	}
350		352
351	CodeType codeType() const { return m_unlinkedCode->codeType(); }	353	CodeType codeType() const
		354	{
		355	// FIXME: hacky
		356	if (ownerExecutable()->isWebAssemblyExecutable())
		357	return FunctionCode;
		358	return m_unlinkedCode->codeType();
		359	}
		360
352	PutPropertySlot::Context putByIdContext() const	361	PutPropertySlot::Context putByIdContext() const
353	{	362	{
354	if (codeType() == EvalCode)	363	if (codeType() == EvalCode)
Lines 1142-1147 protected: a/Source/JavaScriptCore/bytecode/CodeBlock.h_sec3
1142	#endif	1151	#endif
1143	};	1152	};
1144		1153
		1154	class WebAssemblyCodeBlock : public CodeBlock {
		1155	public:
		1156	WebAssemblyCodeBlock(CopyParsedBlockTag, WebAssemblyCodeBlock& other)
		1157	: CodeBlock(CopyParsedBlock, other)
		1158	{
		1159	}
		1160
		1161	WebAssemblyCodeBlock(WebAssemblyExecutable* ownerExecutable, JSGlobalObject* globalObject)
		1162	: CodeBlock(ownerExecutable, globalObject)
		1163	{
		1164	}
		1165
		1166	protected:
		1167	virtual void finalizeUnconditionally() override { };
		1168
		1169	#if ENABLE(JIT)
		1170	virtual CodeBlock* replacement() override;
		1171	virtual DFG::CapabilityLevel capabilityLevelInternal() override;
		1172	#endif
		1173	};
		1174
1145	inline CodeBlock* baselineCodeBlockForInlineCallFrame(InlineCallFrame* inlineCallFrame)	1175	inline CodeBlock* baselineCodeBlockForInlineCallFrame(InlineCallFrame* inlineCallFrame)
1146	{	1176	{
1147	RELEASE_ASSERT(inlineCallFrame);	1177	RELEASE_ASSERT(inlineCallFrame);

Lines 778-784 inline char* linkFor( a/Source/JavaScriptCore/jit/JITOperations.cpp_sec1
- a/Source/JavaScriptCore/jit/JITOperations.cpp -6 / +12 lines
778		778
779	MacroAssemblerCodePtr codePtr;	779	MacroAssemblerCodePtr codePtr;
780	CodeBlock* codeBlock = 0;	780	CodeBlock* codeBlock = 0;
781	if (executable->isHostFunction())	781	if (executable->isWebAssemblyExecutable()) {
		782	// FIXME: Should we really use RegisterPreservationNotRequired?
		783	codePtr = executable->entrypointFor(*vm, kind, ArityCheckNotRequired, RegisterPreservationNotRequired);
		784	} else if (executable->isHostFunction())
782	codePtr = executable->entrypointFor(*vm, kind, MustCheckArity, registers);	785	codePtr = executable->entrypointFor(*vm, kind, MustCheckArity, registers);
783	else {	786	else {
784	FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);	787	FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
Lines 795-810 inline char* linkFor( a/Source/JavaScriptCore/jit/JITOperations.cpp_sec2
795	}	798	}
796	codeBlock = functionExecutable->codeBlockFor(kind);	799	codeBlock = functionExecutable->codeBlockFor(kind);
797	ArityCheckMode arity;	800	ArityCheckMode arity;
798	if (execCallee->argumentCountIncludingThis() < static_cast<size_t>(codeBlock->numParameters()) \|\| callLinkInfo->callType() == CallLinkInfo::CallVarargs \|\| callLinkInfo->callType() == CallLinkInfo::ConstructVarargs)	801	if (execCallee->argumentCountIncludingThis() < static_cast<size_t>(codeBlock->numParameters()) \|\| (callLinkInfo && (callLinkInfo->callType() == CallLinkInfo::CallVarargs \|\| callLinkInfo->callType() == CallLinkInfo::ConstructVarargs)))
799	arity = MustCheckArity;	802	arity = MustCheckArity;
800	else	803	else
801	arity = ArityCheckNotRequired;	804	arity = ArityCheckNotRequired;
802	codePtr = functionExecutable->entrypointFor(*vm, kind, arity, registers);	805	codePtr = functionExecutable->entrypointFor(*vm, kind, arity, registers);
803	}	806	}
804	if (!callLinkInfo->seenOnce())	807	// TODO: support repatching
805	callLinkInfo->setSeen();	808	if (callLinkInfo) {
806	else	809	if (!callLinkInfo->seenOnce())
807	linkFor(execCallee, *callLinkInfo, codeBlock, callee, codePtr, kind, registers);	810	callLinkInfo->setSeen();
		811	else
		812	linkFor(execCallee, *callLinkInfo, codeBlock, callee, codePtr, kind, registers);
		813	}
808		814
809	return reinterpret_cast<char*>(codePtr.executableAddress());	815	return reinterpret_cast<char*>(codePtr.executableAddress());
810	}	816	}

Lines 49-54 a/Source/JavaScriptCore/jsc.cpp_sec1
- a/Source/JavaScriptCore/jsc.cpp +14 lines
49	#include "StructureRareDataInlines.h"	49	#include "StructureRareDataInlines.h"
50	#include "TestRunnerUtils.h"	50	#include "TestRunnerUtils.h"
51	#include "TypeProfilerLog.h"	51	#include "TypeProfilerLog.h"
		52	#include "WasmJITCompiler.h"
52	#include <math.h>	53	#include <math.h>
53	#include <stdio.h>	54	#include <stdio.h>
54	#include <stdlib.h>	55	#include <stdlib.h>
Lines 491-496 static EncodedJSValue JSC_HOST_CALL functionReturnTypeFor(ExecState*); a/Source/JavaScriptCore/jsc.cpp_sec2
491	static EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState*);	492	static EncodedJSValue JSC_HOST_CALL functionDumpBasicBlockExecutionRanges(ExecState*);
492	static EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState*);	493	static EncodedJSValue JSC_HOST_CALL functionHasBasicBlockExecuted(ExecState*);
493	static EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*);	494	static EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*);
		495	static EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState*);
494		496
495	#if ENABLE(SAMPLING_FLAGS)	497	#if ENABLE(SAMPLING_FLAGS)
496	static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);	498	static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
Lines 653-658 protected: a/Source/JavaScriptCore/jsc.cpp_sec3
653	addFunction(vm, "hasBasicBlockExecuted", functionHasBasicBlockExecuted, 2);	655	addFunction(vm, "hasBasicBlockExecuted", functionHasBasicBlockExecuted, 2);
654		656
655	addFunction(vm, "enableExceptionFuzz", functionEnableExceptionFuzz, 0);	657	addFunction(vm, "enableExceptionFuzz", functionEnableExceptionFuzz, 0);
		658
		659	addFunction(vm, "loadWebAssembly", functionLoadWebAssembly, 1);
656		660
657	JSArray* array = constructEmptyArray(globalExec(), 0);	661	JSArray* array = constructEmptyArray(globalExec(), 0);
658	for (size_t i = 0; i < arguments.size(); ++i)	662	for (size_t i = 0; i < arguments.size(); ++i)
Lines 1182-1187 EncodedJSValue JSC_HOST_CALL functionEnableExceptionFuzz(ExecState*) a/Source/JavaScriptCore/jsc.cpp_sec4
1182	return JSValue::encode(jsUndefined());	1186	return JSValue::encode(jsUndefined());
1183	}	1187	}
1184		1188
		1189	EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState* exec)
		1190	{
		1191	String fileName = exec->argument(0).toString(exec)->value(exec);
		1192	Vector<char> buffer;
		1193	if (!fillBufferWithContentsOfFile(fileName, buffer))
		1194	return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
		1195	Wasm::Module* module = Wasm::compile(exec, buffer);
		1196	return JSValue::encode(module);
		1197	}
		1198
1185	// Use SEH for Release builds only to get rid of the crash report dialog	1199	// Use SEH for Release builds only to get rid of the crash report dialog
1186	// (luckily the same tests fail in Release and Debug builds so far). Need to	1200	// (luckily the same tests fail in Release and Debug builds so far). Need to
1187	// be in a separate main function because the jscmain function requires object	1201	// be in a separate main function because the jscmain function requires object

Lines 1119-1125 inline SlowPathReturnType setUpCall(ExecState* execCallee, Instruction* pc, Code a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp_sec1
- a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp -1 / +3 lines
1119		1119
1120	MacroAssemblerCodePtr codePtr;	1120	MacroAssemblerCodePtr codePtr;
1121	CodeBlock* codeBlock = 0;	1121	CodeBlock* codeBlock = 0;
1122	if (executable->isHostFunction())	1122	if (executable->isWebAssemblyExecutable())
		1123	codePtr = executable->entrypointFor(vm, kind, ArityCheckNotRequired, RegisterPreservationNotRequired);
		1124	else if (executable->isHostFunction())
1123	codePtr = executable->entrypointFor(vm, kind, MustCheckArity, RegisterPreservationNotRequired);	1125	codePtr = executable->entrypointFor(vm, kind, MustCheckArity, RegisterPreservationNotRequired);
1124	else {	1126	else {
1125	FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);	1127	FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);

Lines 149-154 void ScriptExecutable::installCode(CodeBlock* genericCodeBlock) a/Source/JavaScriptCore/runtime/Executable.cpp_sec1
- a/Source/JavaScriptCore/runtime/Executable.cpp +87 lines
149	break;	149	break;
150	}	150	}
151		151
		152	if (isWebAssemblyExecutable()) {
		153	WebAssemblyExecutable* executable = jsCast<WebAssemblyExecutable*>(this);
		154	WebAssemblyCodeBlock* codeBlock = static_cast<WebAssemblyCodeBlock*>(genericCodeBlock);
		155
		156	ASSERT(kind == CodeForCall);
		157
		158	executable->m_codeBlockForCall = codeBlock;
		159
		160	// FIXME: this is just to make isHostFunction() happy.
		161	// But this will make isHostFunction() return true.
		162	m_numParametersForCall = 0;
		163	m_numParametersForConstruct = 0;
		164	} else {
		165
		166	// FIXME: need to deal with codeType()
152	switch (genericCodeBlock->codeType()) {	167	switch (genericCodeBlock->codeType()) {
153	case GlobalCode: {	168	case GlobalCode: {
154	ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);	169	ProgramExecutable* executable = jsCast<ProgramExecutable*>(this);
Lines 192-197 void ScriptExecutable::installCode(CodeBlock* genericCodeBlock) a/Source/JavaScriptCore/runtime/Executable.cpp_sec2
192	if (oldCodeBlock)	207	if (oldCodeBlock)
193	oldCodeBlock->unlinkIncomingCalls();	208	oldCodeBlock->unlinkIncomingCalls();
194		209
		210	}
		211
195	Debugger* debugger = genericCodeBlock->globalObject()->debugger();	212	Debugger* debugger = genericCodeBlock->globalObject()->debugger();
196	if (debugger)	213	if (debugger)
197	debugger->registerCodeBlock(genericCodeBlock);	214	debugger->registerCodeBlock(genericCodeBlock);
Lines 228-233 RefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor( a/Source/JavaScriptCore/runtime/Executable.cpp_sec3
228	executable->source().provider(), executable->source().startColumn()));	245	executable->source().provider(), executable->source().startColumn()));
229	}	246	}
230		247
		248	ASSERT(!isWebAssemblyExecutable());
		249
231	RELEASE_ASSERT(classInfo() == FunctionExecutable::info());	250	RELEASE_ASSERT(classInfo() == FunctionExecutable::info());
232	RELEASE_ASSERT(function);	251	RELEASE_ASSERT(function);
233	FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);	252	FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
Lines 323-328 static void setupJIT(VM& vm, CodeBlock* codeBlock) a/Source/JavaScriptCore/runtime/Executable.cpp_sec4
323	JSObject* ScriptExecutable::prepareForExecutionImpl(	342	JSObject* ScriptExecutable::prepareForExecutionImpl(
324	ExecState* exec, JSFunction* function, JSScope* scope, CodeSpecializationKind kind)	343	ExecState* exec, JSFunction* function, JSScope* scope, CodeSpecializationKind kind)
325	{	344	{
		345	ASSERT(!isWebAssemblyExecutable());
		346
326	VM& vm = exec->vm();	347	VM& vm = exec->vm();
327	DeferGC deferGC(vm.heap);	348	DeferGC deferGC(vm.heap);
328		349
Lines 425-430 void FunctionExecutable::destroy(JSCell* cell) a/Source/JavaScriptCore/runtime/Executable.cpp_sec5
425	static_cast<FunctionExecutable*>(cell)->FunctionExecutable::~FunctionExecutable();	446	static_cast<FunctionExecutable*>(cell)->FunctionExecutable::~FunctionExecutable();
426	}	447	}
427		448
		449	const ClassInfo WebAssemblyExecutable::s_info = { "WebAssemblyExecutable", &ScriptExecutable::s_info, 0, CREATE_METHOD_TABLE(WebAssemblyExecutable) };
		450
		451	WebAssemblyExecutable::WebAssemblyExecutable(VM& vm, const SourceCode& source)
		452	: ScriptExecutable(vm.webAssemblyExecutableStructure.get(), vm, source, /isInStrictContext/ false )
		453	{
		454	/*
		455	RELEASE_ASSERT(!source.isNull());
		456	ASSERT(source.length());
		457	m_firstLine = firstLine;
		458	m_lastLine = lastLine;
		459	m_startColumn = startColumn;
		460	m_endColumn = endColumn;
		461	m_parametersStartOffset = unlinkedExecutable->parametersStartOffset();
		462	m_typeProfilingStartOffset = unlinkedExecutable->typeProfilingStartOffset();
		463	m_typeProfilingEndOffset = unlinkedExecutable->typeProfilingEndOffset();
		464	*/
		465	}
		466
		467	void WebAssemblyExecutable::finishCreation(VM& vm)
		468	{
		469	Base::finishCreation(vm);
		470	m_singletonFunction.set(vm, this, InferredValue::create(vm));
		471	}
		472
		473	void WebAssemblyExecutable::destroy(JSCell* cell)
		474	{
		475	static_cast<WebAssemblyExecutable*>(cell)->WebAssemblyExecutable::~WebAssemblyExecutable();
		476	}
		477
428	inline const char* samplingDescription(JITCode::JITType jitType)	478	inline const char* samplingDescription(JITCode::JITType jitType)
429	{	479	{
430	switch (jitType) {	480	switch (jitType) {
Lines 619-624 FunctionExecutable* FunctionExecutable::fromGlobalCode( a/Source/JavaScriptCore/runtime/Executable.cpp_sec6
619	return unlinkedExecutable->link(exec.vm(), source, overrideLineNumber);	669	return unlinkedExecutable->link(exec.vm(), source, overrideLineNumber);
620	}	670	}
621		671
		672	WebAssemblyCodeBlock* WebAssemblyExecutable::baselineCodeBlockFor(CodeSpecializationKind kind)
		673	{
		674	ASSERT(kind == CodeForCall);
		675
		676	WebAssemblyCodeBlock* result = m_codeBlockForCall.get();
		677	if (!result)
		678	return 0;
		679	return static_cast<WebAssemblyCodeBlock*>(result->baselineAlternative());
		680	}
		681
		682	void WebAssemblyExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
		683	{
		684	WebAssemblyExecutable* thisObject = jsCast<WebAssemblyExecutable*>(cell);
		685	ASSERT_GC_OBJECT_INHERITS(thisObject, info());
		686	ScriptExecutable::visitChildren(thisObject, visitor);
		687	if (thisObject->m_codeBlockForCall)
		688	thisObject->m_codeBlockForCall->visitAggregate(visitor);
		689	visitor.append(&thisObject->m_singletonFunction);
		690	}
		691
		692	SymbolTable* WebAssemblyExecutable::symbolTable(CodeSpecializationKind kind)
		693	{
		694	return codeBlockFor(kind)->symbolTable();
		695	}
		696
		697	void WebAssemblyExecutable::clearCode()
		698	{
		699	// FIXME: hacky
		700	// m_codeBlockForCall = nullptr;
		701	// Base::clearCode();
		702	}
		703
		704	void WebAssemblyExecutable::unlinkCalls()
		705	{
		706	// FIXME: hacky
		707	}
		708
622	void ExecutableBase::dump(PrintStream& out) const	709	void ExecutableBase::dump(PrintStream& out) const
623	{	710	{
624	ExecutableBase* realThis = const_cast<ExecutableBase*>(this);	711	ExecutableBase* realThis = const_cast<ExecutableBase*>(this);

Lines 50-55 class EvalCodeBlock; a/Source/JavaScriptCore/runtime/Executable.h_sec1
- a/Source/JavaScriptCore/runtime/Executable.h +122 lines
50	class FunctionCodeBlock;	50	class FunctionCodeBlock;
51	class LLIntOffsetsExtractor;	51	class LLIntOffsetsExtractor;
52	class ProgramCodeBlock;	52	class ProgramCodeBlock;
		53	class WebAssemblyCodeBlock;
53	class JSScope;	54	class JSScope;
54		55
55	enum CompilationKind { FirstCompilation, OptimizingCompilation };	56	enum CompilationKind { FirstCompilation, OptimizingCompilation };
Lines 98-103 public: a/Source/JavaScriptCore/runtime/Executable.h_sec2
98	{	99	{
99	return type() == FunctionExecutableType;	100	return type() == FunctionExecutableType;
100	}	101	}
		102	bool isWebAssemblyExecutable()
		103	{
		104	return type() == WebAssemblyExecutableType;
		105	}
101	bool isProgramExecutable()	106	bool isProgramExecutable()
102	{	107	{
103	return type() == ProgramExecutableType;	108	return type() == ProgramExecutableType;
Lines 678-683 private: a/Source/JavaScriptCore/runtime/Executable.h_sec3
678	WriteBarrier<InferredValue> m_singletonFunction;	683	WriteBarrier<InferredValue> m_singletonFunction;
679	};	684	};
680		685
		686	class WebAssemblyExecutable final : public ScriptExecutable {
		687	friend class JIT;
		688	friend class LLIntOffsetsExtractor;
		689	public:
		690	typedef ScriptExecutable Base;
		691	static const unsigned StructureFlags = Base::StructureFlags \| StructureIsImmortal;
		692
		693	static WebAssemblyExecutable* create(VM& vm, const SourceCode& source)
		694	{
		695	WebAssemblyExecutable* executable = new (NotNull, allocateCell<WebAssemblyExecutable>(vm.heap)) WebAssemblyExecutable(vm, source);
		696	executable->finishCreation(vm);
		697	return executable;
		698	}
		699	// static WebAssemblyExecutable* fromGlobalCode(const Identifier& name, ExecState&, const SourceCode&, JSObject*& exception, int overrideLineNumber);
		700
		701	static void destroy(JSCell*);
		702
		703	bool isGeneratedForCall() const
		704	{
		705	return m_codeBlockForCall;
		706	}
		707
		708	WebAssemblyCodeBlock* codeBlockForCall()
		709	{
		710	return m_codeBlockForCall.get();
		711	}
		712
		713	bool isGeneratedForConstruct() const
		714	{
		715	return false;
		716	}
		717
		718	WebAssemblyCodeBlock* codeBlockForConstruct()
		719	{
		720	return nullptr;
		721	}
		722
		723	bool isGeneratedFor(CodeSpecializationKind kind)
		724	{
		725	if (kind == CodeForCall)
		726	return isGeneratedForCall();
		727	ASSERT(kind == CodeForConstruct);
		728	return isGeneratedForConstruct();
		729	}
		730
		731	WebAssemblyCodeBlock* codeBlockFor(CodeSpecializationKind kind)
		732	{
		733	if (kind == CodeForCall)
		734	return codeBlockForCall();
		735	ASSERT(kind == CodeForConstruct);
		736	return codeBlockForConstruct();
		737	}
		738
		739	WebAssemblyCodeBlock* baselineCodeBlockFor(CodeSpecializationKind);
		740
		741	WebAssemblyCodeBlock* profiledCodeBlockFor(CodeSpecializationKind kind)
		742	{
		743	return baselineCodeBlockFor(kind);
		744	}
		745
		746	RefPtr<TypeSet> returnStatementTypeSet()
		747	{
		748	if (!m_returnStatementTypeSet)
		749	m_returnStatementTypeSet = TypeSet::create();
750
751	return m_returnStatementTypeSet;
752	}
753
754	// FunctionMode functionMode() { return m_unlinkedExecutable->functionMode(); }
755	// bool isBuiltinFunction() const { return m_unlinkedExecutable->isBuiltinFunction(); }
756	// bool isClassConstructorFunction() const { return m_unlinkedExecutable->isClassConstructorFunction(); }
757	// const Identifier& name() { return m_unlinkedExecutable->name(); }
758	// const Identifier& inferredName() { return m_unlinkedExecutable->inferredName(); }
759	// JSString* nameValue() const { return m_unlinkedExecutable->nameValue(); }
760	// size_t parameterCount() const { return m_unlinkedExecutable->parameterCount(); } // Excluding 'this'!
761	SymbolTable* symbolTable(CodeSpecializationKind);
762
763	static void visitChildren(JSCell*, SlotVisitor&);
764	static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
765	{
766	return Structure::create(vm, globalObject, proto, TypeInfo(WebAssemblyExecutableType, StructureFlags), info());
767	}
768
769	unsigned parametersStartOffset() const { return m_parametersStartOffset; }
770
771	/*
772	void overrideParameterAndTypeProfilingStartEndOffsets(unsigned parametersStartOffset, unsigned typeProfilingStartOffset, unsigned typeProfilingEndOffset)
773	{
774	m_parametersStartOffset = parametersStartOffset;
775	m_typeProfilingStartOffset = typeProfilingStartOffset;
776	m_typeProfilingEndOffset = typeProfilingEndOffset;
777	}
778	*/
779
780	DECLARE_INFO;
781
782	void unlinkCalls();
783
784	void clearCode();
785
786	InferredValue* singletonFunction() { return m_singletonFunction.get(); }
787
788	private:
789	WebAssemblyExecutable(VM&, const SourceCode&);
790
791	void finishCreation(VM&);
792
793	friend class ScriptExecutable;
794
795	RefPtr<WebAssemblyCodeBlock> m_codeBlockForCall;
796	RefPtr<TypeSet> m_returnStatementTypeSet;
797	unsigned m_parametersStartOffset;
798	WriteBarrier<InferredValue> m_singletonFunction;
799	};
800
681	inline void ExecutableBase::clearCodeVirtual(ExecutableBase* executable)	801	inline void ExecutableBase::clearCodeVirtual(ExecutableBase* executable)
682	{	802	{
683	switch (executable->type()) {	803	switch (executable->type()) {
Lines 687-692 inline void ExecutableBase::clearCodeVirtual(ExecutableBase* executable) a/Source/JavaScriptCore/runtime/Executable.h_sec4
687	return jsCast<ProgramExecutable*>(executable)->clearCode();	807	return jsCast<ProgramExecutable*>(executable)->clearCode();
688	case FunctionExecutableType:	808	case FunctionExecutableType:
689	return jsCast<FunctionExecutable*>(executable)->clearCode();	809	return jsCast<FunctionExecutable*>(executable)->clearCode();
		810	case WebAssemblyExecutableType:
		811	return jsCast<WebAssemblyExecutable*>(executable)->clearCode();
690	default:	812	default:
691	return jsCast<NativeExecutable*>(executable)->clearCode();	813	return jsCast<NativeExecutable*>(executable)->clearCode();
692	}	814	}



    return isHostFunction();
}

JSFunction* JSFunction::create(VM& vm, ExecutableBase* executable, JSScope* scope)
{
    JSFunction* result = createImpl(vm, executable, scope);
    if (executable->isFunctionExecutable())
        static_cast<FunctionExecutable*>(executable)->singletonFunction()->notifyWrite(vm, result, "Allocating a function");
    return result;
}




    static JSFunction* createWithInvalidatedReallocationWatchpoint(VM&, FunctionExecutable*, JSScope*);
    JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeStdFunction&&, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);

    static JSFunction* create(VM&, ExecutableBase*, JSScope*);

    static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*);
    static JSFunction* createBuiltinFunction(VM&, FunctionExecutable*, JSGlobalObject*, const String& name);


protected:
    JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject*, Structure*);
    JSFunction(VM&, ExecutableBase*, JSScope*);

    void finishCreation(VM&, NativeExecutable*, int length, const String& name);
    using Base::finishCreation;

    static void visitChildren(JSCell*, SlotVisitor&);

private:
    static JSFunction* createImpl(VM& vm, ExecutableBase* executable, JSScope* scope)
    {
        JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope);
        ASSERT(function->structure()->globalObject());

Lines 38-44 inline JSFunction* JSFunction::createWithInvalidatedReallocationWatchpoint( a/Source/JavaScriptCore/runtime/JSFunctionInlines.h_sec1
- a/Source/JavaScriptCore/runtime/JSFunctionInlines.h -1 / +3 lines
38	return createImpl(vm, executable, scope);	38	return createImpl(vm, executable, scope);
39	}	39	}
40		40
41	inline JSFunction::JSFunction(VM& vm, FunctionExecutable* executable, JSScope* scope)	41	inline JSFunction::JSFunction(VM& vm, ExecutableBase* executable, JSScope* scope)
42	: Base(vm, scope, scope->globalObject()->functionStructure())	42	: Base(vm, scope, scope->globalObject()->functionStructure())
43	, m_executable(vm, this, executable)	43	, m_executable(vm, this, executable)
44	, m_rareData()	44	, m_rareData()
Lines 54-59 inline FunctionExecutable* JSFunction::jsExecutable() const a/Source/JavaScriptCore/runtime/JSFunctionInlines.h_sec2
54	inline bool JSFunction::isHostFunction() const	54	inline bool JSFunction::isHostFunction() const
55	{	55	{
56	ASSERT(m_executable);	56	ASSERT(m_executable);
		57	if (m_executable->isWebAssemblyExecutable()) // FIXME: hacky
		58	return true;
57	return m_executable->isHostFunction();	59	return m_executable->isHostFunction();
58	}	60	}
59		61

Lines 74-79 enum JSType : uint8_t { a/Source/JavaScriptCore/runtime/JSType.h_sec1
- a/Source/JavaScriptCore/runtime/JSType.h +2 lines
74		74
75	NameScopeObjectType,	75	NameScopeObjectType,
76		76
		77	WebAssemblyExecutableType, // FIXME: Move it above.
		78
77	GlobalObjectType,	79	GlobalObjectType,
78	ActivationObjectType,	80	ActivationObjectType,
79		81

Lines 220-225 VM::VM(VMType vmType, HeapType heapType) a/Source/JavaScriptCore/runtime/VM.cpp_sec1
- a/Source/JavaScriptCore/runtime/VM.cpp +1 lines
220	evalExecutableStructure.set(this, EvalExecutable::createStructure(this, 0, jsNull()));	220	evalExecutableStructure.set(this, EvalExecutable::createStructure(this, 0, jsNull()));
221	programExecutableStructure.set(this, ProgramExecutable::createStructure(this, 0, jsNull()));	221	programExecutableStructure.set(this, ProgramExecutable::createStructure(this, 0, jsNull()));
222	functionExecutableStructure.set(this, FunctionExecutable::createStructure(this, 0, jsNull()));	222	functionExecutableStructure.set(this, FunctionExecutable::createStructure(this, 0, jsNull()));
		223	webAssemblyExecutableStructure.set(this, WebAssemblyExecutable::createStructure(this, 0, jsNull()));
223	regExpStructure.set(this, RegExp::createStructure(this, 0, jsNull()));	224	regExpStructure.set(this, RegExp::createStructure(this, 0, jsNull()));
224	symbolStructure.set(this, Symbol::createStructure(this, 0, jsNull()));	225	symbolStructure.set(this, Symbol::createStructure(this, 0, jsNull()));
225	symbolTableStructure.set(this, SymbolTable::createStructure(this, 0, jsNull()));	226	symbolTableStructure.set(this, SymbolTable::createStructure(this, 0, jsNull()));

Lines 259-264 public: a/Source/JavaScriptCore/runtime/VM.h_sec1
- a/Source/JavaScriptCore/runtime/VM.h +1 lines
259	Strong<Structure> evalExecutableStructure;	259	Strong<Structure> evalExecutableStructure;
260	Strong<Structure> programExecutableStructure;	260	Strong<Structure> programExecutableStructure;
261	Strong<Structure> functionExecutableStructure;	261	Strong<Structure> functionExecutableStructure;
		262	Strong<Structure> webAssemblyExecutableStructure;
262	Strong<Structure> regExpStructure;	263	Strong<Structure> regExpStructure;
263	Strong<Structure> symbolStructure;	264	Strong<Structure> symbolStructure;
264	Strong<Structure> symbolTableStructure;	265	Strong<Structure> symbolTableStructure;



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

#include "config.h"
#include "WasmJITCompiler.h"

#include "JITCode.h"
#include "JSCJSValueInlines.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "Register.h"

namespace JSC {

namespace Wasm {

class JumpScope {
public:
    JumpScope(MacroAssembler* macroAssembler)
        : m_macroAssembler(macroAssembler)
        , m_linked(false)
    {
    }

    JumpScope(MacroAssembler* macroAssembler, const MacroAssembler::Label& label)
        : m_macroAssembler(macroAssembler)
        , m_linked(true)
        , m_label(label)
    {
    }

    void jump()
    {
        if (m_linked)
            m_macroAssembler->jump(m_label);
        else
            m_jumpList.append(m_macroAssembler->jump());
    }

    void link()
    {
        ASSERT(!m_linked);
        m_jumpList.link(m_macroAssembler);
    }

private:
    MacroAssembler* m_macroAssembler;
    bool m_linked;
    MacroAssembler::Label m_label;
    MacroAssembler::JumpList m_jumpList;
};

enum class LinearMemoryType : unsigned {
    I8,
    S8,
    U8,
    I16,
    S16,
    U16,
    I32,
    F32,
    F64
};

RefPtr<JITCode> JITCompiler::compileFunction(VM& vm, size_t functionIndex)
{
    emitFunctionPrologue();
    emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);

    const Signature& signature = m_module->m_signatures[m_module->m_funcSignatures[functionIndex]];
    m_currentReturnType = signature.returnType;
    parseArguments(signature);

    // FIXME: Calculate the actual height. (Be careful about calls.)
    m_stackHeight = WTF::roundUpToMultipleOf(stackAlignmentRegisters(), signature.arguments.size() + 8) * sizeof(Register);
    allocateSpaceOnStack();

    parseVars();
    parseStmtList();

    // FIXME: Skip these if the last statement is a return statement.
    move(TrustedImm64(JSValue::encode(jsUndefined())), GPRInfo::regT0); // FIXME: Should we return undefined?
    deallocateSpaceOnStack();
    emitFunctionEpilogue();
    ret();

    LinkBuffer patchBuffer(vm, *this, 0, JITCompilationMustSucceed);
    MacroAssemblerCodePtr withArityCheck;
    CodeRef result = FINALIZE_CODE(patchBuffer, ("Baseline JIT code for WebAssembly"));
    return adoptRef(new DirectJITCode(result, withArityCheck, JITCode::BaselineJIT));
}

void JITCompiler::allocateSpaceOnStack()
{
    addPtr(TrustedImm32(-m_stackHeight), stackPointerRegister);
}

void JITCompiler::deallocateSpaceOnStack()
{
    addPtr(TrustedImm32(m_stackHeight), stackPointerRegister);
}

void JITCompiler::parseArguments(const Signature& signature)
{
    size_t argumentCount = signature.arguments.size();
    for (uint32_t argIndex = 0; argIndex < argumentCount; ++argIndex) {
        Type type = signature.arguments[argIndex];
        m_currentLocalTypes.append(type);
        switch (type) {
        case Type::I32:
            load32(Address(GPRInfo::callFrameRegister, (argIndex + 1 + CallFrame::thisArgumentOffset()) * sizeof(Register)), GPRInfo::regT0);
            store32(GPRInfo::regT0, stackAddress(argIndex));
            break;
        case Type::F32:
            RELEASE_ASSERT_NOT_REACHED();
        case Type::F64:
            load64(Address(GPRInfo::callFrameRegister, (argIndex + 1 + CallFrame::thisArgumentOffset()) * sizeof(Register)), GPRInfo::regT0);
            unboxDoubleWithoutAssertions(GPRInfo::regT0, FPRInfo::fpRegT0);
            storeDouble(FPRInfo::fpRegT0, stackAddress(argIndex));
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    }
}

void JITCompiler::parseVars()
{
    uint32_t numberOfI32Vars = 0;
    uint32_t numberOfF32Vars = 0;
    uint32_t numberOfF64Vars = 0;

    VarTypes varTypes;
    VarTypesWithImm varTypesWithImm;
    uint8_t imm;
    if (m_module->m_reader.code(&varTypes, &varTypesWithImm, &imm)) {
        if (varTypes & VarTypes::I32)
            numberOfI32Vars = m_module->m_reader.immU32();
        if (varTypes & VarTypes::F32)
            numberOfF32Vars = m_module->m_reader.immU32();
        if (varTypes & VarTypes::F64)
            numberOfF64Vars = m_module->m_reader.immU32();
    } else
        numberOfI32Vars = imm;

    uint32_t numberOfVars = numberOfI32Vars + numberOfF32Vars + numberOfF64Vars;
    if (numberOfVars > 0) {
        uint32_t localIndex = m_currentLocalTypes.size();
        for (uint32_t i = 0; i < numberOfI32Vars; ++i) {
            m_currentLocalTypes.append(Type::I32);
            store32(TrustedImm32(0), stackAddress(localIndex++));
        }
        for (uint32_t i = 0; i < numberOfF32Vars; ++i) {
            m_currentLocalTypes.append(Type::F32);
            store32(TrustedImm32(0), stackAddress(localIndex++));
        }
        for (uint32_t i = 0; i < numberOfF64Vars; ++i) {
            m_currentLocalTypes.append(Type::F64);
            store64(TrustedImm64(0), stackAddress(localIndex++));
        }
    }
}

void JITCompiler::parseStmt()
{
    Stmt stmt;
    StmtWithImm stmtWithImm;
    uint8_t imm;
    if (m_module->m_reader.code(&stmt, &stmtWithImm, &imm)) {
        switch (stmt) {
        case Stmt::SetLoc:
            parseSetLocal(0);
            break;
        case Stmt::SetGlo:
            RELEASE_ASSERT_NOT_REACHED();
        case Stmt::I32Store8:
            parseStore(ReturnType::I32, LinearMemoryType::I8, false, 0);
            break;
        case Stmt::I32StoreOff8:
            parseStore(ReturnType::I32, LinearMemoryType::I8, true, 0);
            break;
        case Stmt::I32Store16:
            parseStore(ReturnType::I32, LinearMemoryType::I16, false, 0);
            break;
        case Stmt::I32StoreOff16:
            parseStore(ReturnType::I32, LinearMemoryType::I16, true, 0);
            break;
        case Stmt::I32Store32:
            parseStore(ReturnType::I32, LinearMemoryType::I32, false, 0);
            break;
        case Stmt::I32StoreOff32:
            parseStore(ReturnType::I32, LinearMemoryType::I32, true, 0);
            break;
        case Stmt::F32Store:
            parseStore(ReturnType::F32, LinearMemoryType::F32, false, 0);
            break;
        case Stmt::F32StoreOff:
            parseStore(ReturnType::F32, LinearMemoryType::F32, true, 0);
            break;
        case Stmt::F64Store:
            parseStore(ReturnType::F64, LinearMemoryType::F64, false, 0);
            break;
        case Stmt::F64StoreOff:
            parseStore(ReturnType::F64, LinearMemoryType::F64, true, 0);
            break;
        case Stmt::CallInt:
            parseCallInternal(ReturnType::Void, 0);
            break;
        case Stmt::CallInd:
            RELEASE_ASSERT_NOT_REACHED();
        case Stmt::CallImp:
            parseCallImport(ReturnType::Void, 0); // FIXME: Is it really Void?
            break;
        case Stmt::Ret:
            parseReturnStmt();
            return;
        case Stmt::Block:
            parseBlockStmt();
            return;
        case Stmt::IfThen:
            parseIfStmt();
            return;
        case Stmt::IfElse:
            parseIfElseStmt();
            return;
        case Stmt::While:
            parseWhileStmt();
            return;
        case Stmt::Do:
            parseDoStmt();
            return;
        case Stmt::Label:
            parseLabelStmt();
            return;
        case Stmt::Break:
            parseBreakStmt();
            return;
        case Stmt::BreakLabel:
            parseBreakLabelStmt();
            return;
        case Stmt::Continue:
            parseContinueStmt();
            break;
        case Stmt::ContinueLabel:
            parseContinueLabelStmt();
            return;
        case Stmt::Switch:
            parseSwitchStmt();
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    } else {
        switch (stmtWithImm) {
        case StmtWithImm::SetLoc:
            parseSetLocal(imm, 0);
            break;
        case StmtWithImm::SetGlo:
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    }
}

void JITCompiler::parseGetLocal(int dst)
{
    uint32_t imm = m_module->m_reader.immU32();
    switch (m_currentLocalTypes[imm]) {
    case Type::I32:
    case Type::F32:
        load32(stackAddress(imm), GPRInfo::regT0);
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case Type::F64:
        load64(stackAddress(imm), GPRInfo::regT0);
        store64(GPRInfo::regT0, temporaryAddress(dst));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseSetLocal(uint32_t imm, int dst)
{
    Type type = m_currentLocalTypes[imm];
    parseExpr(ReturnType(type), dst);
    switch (type) {
    case Type::I32:
    case Type::F32:
        load32(temporaryAddress(dst), GPRInfo::regT0);
        store32(GPRInfo::regT0, stackAddress(imm));
        break;
    case Type::F64:
        load64(temporaryAddress(dst), GPRInfo::regT0);
        store64(GPRInfo::regT0, stackAddress(imm));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseSetLocal(int dst)
{
    parseSetLocal(m_module->m_reader.immU32(), dst);
}

static const void* JSC_HOST_CALL getArrayBufferData(Module* module)
{
    // FIXME: Do we really have to do this?
    return module->arrayBufferData();
}

void JITCompiler::parseArrayBufferOffset(bool hasOffset, int dst)
{
    // TODO: Check for out-of-bounds access.
    uint32_t offset = hasOffset ? m_module->m_reader.immU32() : 0;
    uint32_t u32;
    if (m_module->m_reader.ifI32Lit(m_module->m_constantI32s, &u32))
        store32(TrustedImm32(u32 + offset), temporaryAddress(dst));
    else {
        parseExpr(ReturnType::I32, dst);
        load32(temporaryAddress(dst), GPRInfo::regT0);
        if (offset)
            add32(TrustedImm32(offset), GPRInfo::regT0);
        store32(GPRInfo::regT0, temporaryAddress(dst));
    }

    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(-maxFrameExtentForSlowPathCall), stackPointerRegister);
    setupArguments(TrustedImmPtr(m_module));
    move(TrustedImmPtr(bitwise_cast<void*>(getArrayBufferData)), GPRInfo::nonArgGPR0);
    call(GPRInfo::nonArgGPR0);
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);
}
    
void JITCompiler::parseLoad(ReturnType returnType, LinearMemoryType linearMemoryType, bool hasOffset, int dst)
{
    parseArrayBufferOffset(hasOffset, dst);
    load32(temporaryAddress(dst), GPRInfo::regT1);
    BaseIndex address = BaseIndex(GPRInfo::returnValueGPR, GPRInfo::regT1, TimesOne);

    switch (returnType) {
    case ReturnType::I32:
        switch (linearMemoryType) {
        case LinearMemoryType::S8:
            load8SignedExtendTo32(address, GPRInfo::regT0);
            break;
        case LinearMemoryType::U8:
            load8(address, GPRInfo::regT0);
            break;
        case LinearMemoryType::S16:
            load16SignedExtendTo32(address, GPRInfo::regT0);
            break;
        case LinearMemoryType::U16:
            load16(address, GPRInfo::regT0);
            break;
        case LinearMemoryType::I32:
            load32(address, GPRInfo::regT0);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F32:
        load32(address, GPRInfo::regT0);
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F64:
        load64(address, GPRInfo::regT0);
        store64(GPRInfo::regT0, temporaryAddress(dst));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseStore(ReturnType returnType, LinearMemoryType linearMemoryType, bool hasOffset, int dst)
{
    parseArrayBufferOffset(hasOffset, dst + 1);
    storePtr(GPRInfo::returnValueGPR, temporaryAddress(dst));

    parseExpr(returnType, dst + 2);

    loadPtr(temporaryAddress(dst), GPRInfo::regT1);
    load32(temporaryAddress(dst + 1), GPRInfo::regT2);
    BaseIndex address = BaseIndex(GPRInfo::regT1, GPRInfo::regT2, TimesOne);

    switch (returnType) {
    case ReturnType::I32:
        load32(temporaryAddress(dst + 2), GPRInfo::regT0);
        switch (linearMemoryType) {
        case LinearMemoryType::I8:
            store8(GPRInfo::regT0, address);
            break;
        case LinearMemoryType::I16:
            store16(GPRInfo::regT0, address);
            break;
        case LinearMemoryType::I32:
            store32(GPRInfo::regT0, address);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F32:
        load32(temporaryAddress(dst + 2), GPRInfo::regT0);
        store32(GPRInfo::regT0, address);
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F64:
        load64(temporaryAddress(dst + 2), GPRInfo::regT0);
        store64(GPRInfo::regT0, address);
        store64(GPRInfo::regT0, temporaryAddress(dst));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseReturnStmt()
{
    switch (m_currentReturnType) {
    case ReturnType::I32:
        parseExpr(ReturnType::I32, 0);
        load32(temporaryAddress(0), GPRInfo::returnValueGPR);
        or64(GPRInfo::tagTypeNumberRegister, GPRInfo::returnValueGPR);
        break;
    case ReturnType::F32:
        parseExpr(ReturnType::F32, 0);
        loadDouble(temporaryAddress(0), FPRInfo::fpRegT0); // FIXME: This loads 64 bits!
        convertFloatToDouble(FPRInfo::fpRegT0, FPRInfo::fpRegT0);
        boxDouble(FPRInfo::fpRegT0, GPRInfo::returnValueGPR);
        break;
    case ReturnType::F64:
        parseExpr(ReturnType::F64, 0);
        loadDouble(temporaryAddress(0), FPRInfo::fpRegT0);
        boxDouble(FPRInfo::fpRegT0, GPRInfo::returnValueGPR);
        break;
    case ReturnType::Void:
        break;
    }

    deallocateSpaceOnStack();
    emitFunctionEpilogue();
    ret();
}

void JITCompiler::parseStmtList()
{
    uint32_t numberOfStmts = m_module->m_reader.immU32();
    for (uint32_t i = 0; i < numberOfStmts; ++i)
        parseStmt();
}

void JITCompiler::parseBlockStmt()
{
    parseStmtList();
}

void JITCompiler::parseIfStmt()
{
    parseExpr(ReturnType::I32, 0);
    load32(temporaryAddress(0), GPRInfo::regT0);
    Jump end = branchTest32(Zero, GPRInfo::regT0);
    parseStmt();
    end.link(this);
}

void JITCompiler::parseIfElseStmt()
{
    parseExpr(ReturnType::I32, 0);
    load32(temporaryAddress(0), GPRInfo::regT0);
    Jump els = branchTest32(Zero, GPRInfo::regT0);
    parseStmt();
    Jump end = jump();
    els.link(this);
    parseStmt();
    end.link(this);
}

void JITCompiler::parseWhileStmt()
{
    JumpScope continueJumpScope(this, label());
    pushContinueJumpScope(&continueJumpScope);

    JumpList breakJumpList;
    pushBreakJumpList(&breakJumpList);

    parseExpr(ReturnType::I32, 0);
    load32(temporaryAddress(0), GPRInfo::regT0);
    Jump end = branchTest32(Zero, GPRInfo::regT0);
    parseStmt();
    continueJumpScope.jump();
    end.link(this);
    breakJumpList.link(this);

    popBreakJumpList();

    popContinueJumpScope();
}

void JITCompiler::parseDoStmt()
{
    JumpScope continueJumpScope(this);
    pushContinueJumpScope(&continueJumpScope);

    JumpList breakJumpList;
    pushBreakJumpList(&breakJumpList);

    Label start = label();
    parseStmt();
    continueJumpScope.link();
    parseExpr(ReturnType::I32, 0);
    load32(temporaryAddress(0), GPRInfo::regT0);
    Jump jumpToStart = branchTest32(NonZero, GPRInfo::regT0);
    jumpToStart.linkTo(start, this);
    breakJumpList.link(this);

    popBreakJumpList();

    popContinueJumpScope();
}

void JITCompiler::parseLabelStmt()
{
    Label continueLabel = label();
    JumpList breakJumpList;
    pushContinueLabelLabel(&continueLabel);
    pushBreakLabelJumpList(&breakJumpList);
    parseStmt();
    breakJumpList.link(this);
    popBreakLabelJumpList();
    popContinueLabelLabel();
}

void JITCompiler::parseBreakStmt()
{
    topBreakJumpList()->append(jump());
}

void JITCompiler::parseBreakLabelStmt()
{
    uint32_t index = m_module->m_reader.immU32();
    breakLabelJumpList(index)->append(jump());
}

void JITCompiler::parseContinueStmt()
{
    topContinueJumpScope()->jump();
}

void JITCompiler::parseContinueLabelStmt()
{
    uint32_t index = m_module->m_reader.immU32();
    jump(*continueLabelLabel(index));
}

void JITCompiler::parseSwitchStmt()
{
    JumpList breakJumpList;
    pushBreakJumpList(&breakJumpList);

    uint32_t numberOfCases = m_module->m_reader.immU32();
    parseExpr(ReturnType::I32, 0);
    load32(temporaryAddress(0), GPRInfo::regT0);

    Jump table = jump();

    Vector<Label> labels;
    Vector<int32_t> imms;
    Label defaultLabel;
    bool hasDefault = false;

    for (uint32_t i = 0; i < numberOfCases; ++i) {
        switch (m_module->m_reader.switchCase()) {
        case SwitchCase::Case0:
            labels.append(label());
            imms.append(m_module->m_reader.immS32());
            break;
        case SwitchCase::Case1:
            labels.append(label());
            imms.append(m_module->m_reader.immS32());
            parseStmt();
            break;
        case SwitchCase::CaseN:
            labels.append(label());
            imms.append(m_module->m_reader.immS32());
            parseStmtList();
            break;
        case SwitchCase::Default0:
            defaultLabel = label();
            hasDefault = true;
            break;
        case SwitchCase::Default1:
            defaultLabel = label();
            hasDefault = true;
            parseStmt();
            break;
        case SwitchCase::DefaultN:
            defaultLabel = label();
            hasDefault = true;
            parseStmtList();
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    }

    Jump end = jump();
    table.link(this);

    for (size_t i = 0; i < labels.size(); ++i) {
        Jump jmp = branch32(Equal, GPRInfo::regT0, TrustedImm32(imms[i]));
        jmp.linkTo(labels[i], this);
    }
    if (hasDefault)
        jump(defaultLabel);

    end.link(this);

    breakJumpList.link(this);
    popBreakJumpList();
}

void JITCompiler::parseExpr(ReturnType returnType, int dst)
{
    switch (returnType) {
    case ReturnType::I32:
        parseExprI32(dst);
        break;
    case ReturnType::F64:
        parseExprF64(dst);
        break;
    case ReturnType::Void:
        parseExprVoid(dst);
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseExprI32(int dst)
{
    I32 i32;
    I32WithImm i32WithImm;
    uint8_t imm;

    if (m_module->m_reader.code(&i32, &i32WithImm, &imm)) {
        switch (i32) {
        case I32::LitPool:
            store32(TrustedImm32(m_module->m_constantI32s[m_module->m_reader.immU32()]), temporaryAddress(dst));
            break;
        case I32::LitImm:
            store32(TrustedImm32(m_module->m_reader.immU32()), temporaryAddress(dst));
            break;
        case I32::GetLoc:
            parseGetLocal(dst);
            break;
        case I32::GetGlo:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::SetLoc:
            parseSetLocal(dst);
            break;
        case I32::SetGlo:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::SLoad8:
            parseLoad(ReturnType::I32, LinearMemoryType::S8, false, dst);
            break;
        case I32::SLoadOff8:
            parseLoad(ReturnType::I32, LinearMemoryType::S8, true, dst);
            break;
        case I32::ULoad8:
            parseLoad(ReturnType::I32, LinearMemoryType::U8, false, dst);
            break;
        case I32::ULoadOff8:
            parseLoad(ReturnType::I32, LinearMemoryType::U8, true, dst);
            break;
        case I32::SLoad16:
            parseLoad(ReturnType::I32, LinearMemoryType::S16, false, dst);
            break;
        case I32::SLoadOff16:
            parseLoad(ReturnType::I32, LinearMemoryType::S16, true, dst);
            break;
        case I32::ULoad16:
            parseLoad(ReturnType::I32, LinearMemoryType::U16, false, dst);
            break;
        case I32::ULoadOff16:
            parseLoad(ReturnType::I32, LinearMemoryType::U16, true, dst);
            break;
        case I32::Load32:
            parseLoad(ReturnType::I32, LinearMemoryType::I32, false, dst);
            break;
        case I32::LoadOff32:
            parseLoad(ReturnType::I32, LinearMemoryType::I32, true, dst);
            break;
        case I32::Store8:
            parseStore(ReturnType::I32, LinearMemoryType::I8, false, dst);
            break;
        case I32::StoreOff8:
            parseStore(ReturnType::I32, LinearMemoryType::I8, true, dst);
            break;
        case I32::Store16:
            parseStore(ReturnType::I32, LinearMemoryType::I16, false, dst);
            break;
        case I32::StoreOff16:
            parseStore(ReturnType::I32, LinearMemoryType::I16, true, dst);
            break;
        case I32::Store32:
            parseStore(ReturnType::I32, LinearMemoryType::I32, false, dst);
            break;
        case I32::StoreOff32:
            parseStore(ReturnType::I32, LinearMemoryType::I32, true, dst);
            break;
        case I32::CallInt:
            parseCallInternal(ReturnType::I32, dst);
            break;
        case I32::CallInd:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::CallImp:
            parseCallImport(ReturnType::I32, dst);
            break;
        case I32::Cond:
            parseCond(ReturnType::I32, dst);
            break;
        case I32::Comma:
            parseComma(ReturnType::I32, dst);
            break;
        case I32::FromF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::FromF64:
            parseExprF64(dst);
            loadDouble(temporaryAddress(dst), FPRInfo::fpRegT0);
            truncateDoubleToInt32(FPRInfo::fpRegT0, GPRInfo::regT0);
            store32(GPRInfo::regT0, temporaryAddress(dst));
            break;
        case I32::Neg:
        case I32::BitNot:
        case I32::Clz:
        case I32::Abs:
            parseUnaryOp(static_cast<uint8_t>(i32), ReturnType::I32, dst);
            break;
        case I32::Add:
        case I32::Sub:
        case I32::Mul:
        case I32::SDiv:
        case I32::SMod:
        case I32::BitOr:
        case I32::BitAnd:
        case I32::BitXor:
        case I32::Lsh:
        case I32::ArithRsh:
        case I32::LogicRsh:
            parseBinaryOp(static_cast<uint8_t>(i32), ReturnType::I32, dst);
            break;
        case I32::UDiv:
        case I32::UMod:
        case I32::LogicNot:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::EqI32:
            parseRelationalOpI32(Equal, dst);
            break;
        case I32::EqF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::EqF64:
            parseRelationalOpF64(DoubleEqual, dst);
            break;
        case I32::NEqI32:
            parseRelationalOpI32(NotEqual, dst);
            break;
        case I32::NEqF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::NEqF64:
            parseRelationalOpF64(DoubleNotEqual, dst);
            break;
        case I32::SLeThI32:
            parseRelationalOpI32(LessThan, dst);
            break;
        case I32::ULeThI32:
            parseRelationalOpI32(Below, dst);
            break;
        case I32::LeThF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::LeThF64:
            parseRelationalOpF64(DoubleLessThan, dst);
            break;
        case I32::SLeEqI32:
            parseRelationalOpI32(LessThanOrEqual, dst);
            break;
        case I32::ULeEqI32:
            parseRelationalOpI32(BelowOrEqual, dst);
            break;
        case I32::LeEqF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::LeEqF64:
            parseRelationalOpF64(DoubleLessThanOrEqual, dst);
            break;
        case I32::SGrThI32:
            parseRelationalOpI32(GreaterThan, dst);
            break;
        case I32::UGrThI32:
            parseRelationalOpI32(Above, dst);
            break;
        case I32::GrThF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::GrThF64:
            parseRelationalOpF64(DoubleGreaterThan, dst);
            break;
        case I32::SGrEqI32:
            parseRelationalOpI32(GreaterThanOrEqual, dst);
            break;
        case I32::UGrEqI32:
            parseRelationalOpI32(AboveOrEqual, dst);
            break;
        case I32::GrEqF32:
            RELEASE_ASSERT_NOT_REACHED();
        case I32::GrEqF64:
            parseRelationalOpF64(DoubleGreaterThanOrEqual, dst);
            break;
        case I32::SMin:
            parseMinMaxI32(LessThanOrEqual, dst);
            break;
        case I32::UMin:
            parseMinMaxI32(BelowOrEqual, dst);
            break;
        case I32::SMax:
            parseMinMaxI32(GreaterThanOrEqual, dst);
            break;
        case I32::UMax:
            parseMinMaxI32(AboveOrEqual, dst);
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    } else {
        switch (i32WithImm) {
        case I32WithImm::LitImm:
            store32(TrustedImm32(imm), temporaryAddress(dst));
            break;
        case I32WithImm::LitPool:
            store32(TrustedImm32(m_module->m_constantI32s[imm]), temporaryAddress(dst));
            break;
        case I32WithImm::GetLoc:
            load32(stackAddress(imm), GPRInfo::regT0);
            store32(GPRInfo::regT0, temporaryAddress(dst));
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    }
}

void JITCompiler::parseExprF64(int dst)
{
    F64 f64;
    F64WithImm f64WithImm;
    uint8_t imm;

    if (m_module->m_reader.code(&f64, &f64WithImm, &imm)) {
        switch (f64) {
        case F64::LitPool:
            store64(TrustedImm64(reinterpretDoubleToInt64(m_module->m_constantF64s[m_module->m_reader.immU32()])), temporaryAddress(dst));
            break;
        case F64::LitImm:
            store64(TrustedImm64(reinterpretDoubleToInt64(m_module->m_reader.fixedWidth<double>())), temporaryAddress(dst));
            break;
        case F64::Load:
            parseLoad(ReturnType::F64, LinearMemoryType::F64, false, dst);
            break;
        case F64::LoadOff:
            parseLoad(ReturnType::F64, LinearMemoryType::F64, true, dst);
            break;
        case F64::Store:
            parseStore(ReturnType::F64, LinearMemoryType::F64, false, dst);
            break;
        case F64::StoreOff:
            parseStore(ReturnType::F64, LinearMemoryType::F64, true, dst);
            break;
        case F64::CallInt:
            parseCallInternal(ReturnType::F64, dst);
            break;
        case F64::CallImp:
            parseCallImport(ReturnType::F64, dst);
            break;
        case F64::Cond:
            parseCond(ReturnType::F64, dst);
            break;
        case F64::Comma:
            parseComma(ReturnType::F64, dst);
            break;
        case F64::FromS32:
            parseExprI32(dst);
            convertInt32ToDouble(temporaryAddress(dst), FPRInfo::fpRegT0);
            storeDouble(FPRInfo::fpRegT0, temporaryAddress(dst));
            break;
        case F64::FromU32:
        case F64::FromF32:
            RELEASE_ASSERT_NOT_REACHED();
        case F64::Neg:
        case F64::Abs:
        case F64::Ceil:
        case F64::Floor:
        case F64::Sqrt:
        case F64::Cos:
        case F64::Sin:
        case F64::Tan:
        case F64::ACos:
        case F64::ASin:
        case F64::ATan:
        case F64::Exp:
        case F64::Ln:
            parseUnaryOp(static_cast<uint8_t>(f64), ReturnType::F64, dst);
            break;
        case F64::Add:
        case F64::Sub:
        case F64::Mul:
        case F64::Div:
        case F64::ATan2:
        case F64::Pow:
            parseBinaryOp(static_cast<uint8_t>(f64), ReturnType::F64, dst);
            break;
        case F64::Mod:
        case F64::Min:
        case F64::Max:
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    } else {
        switch (f64WithImm) {
        case F64WithImm::LitPool:
            store64(TrustedImm64(reinterpretDoubleToInt64(m_module->m_constantF64s[imm])), temporaryAddress(dst));
            break;
        case F64WithImm::GetLoc:
            // FIXME: loadDouble/storeDouble?
            load64(stackAddress(imm), GPRInfo::regT0);
            store64(GPRInfo::regT0, temporaryAddress(dst));
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    }
}

void JITCompiler::parseExprVoid(int dst)
{
    switch (m_module->m_reader.voidExpr()) {
    case Void::CallInt:
        parseCallInternal(ReturnType::Void, dst);
        break;
    case Void::CallInd:
        RELEASE_ASSERT_NOT_REACHED();
    case Void::CallImp:
        parseCallImport(ReturnType::Void, dst);
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

static EncodedJSValue JSC_HOST_CALL getInternalFunction(ExecState*, Module* module, uint32_t functionIndex)
{
    // TODO: Use these two lines?
    // VM* vm = exec->vm();
    // NativeCallFrameTracer tracer(vm, exec);

    return JSValue::encode(module->function(functionIndex));
}

void JITCompiler::parseCallInternal(ReturnType returnType, int dst)
{
    uint32_t functionIndex = m_module->m_reader.immU32();
    const Signature& signature = m_module->m_signatures[m_module->m_funcSignatures[functionIndex]];
    const Vector<Type>& arguments = signature.arguments;
    size_t argumentCount = arguments.size();
    // FIXME: returnType is redundant with signature.returnType

    parseCallArguments(arguments, dst);

    store32(TrustedImm32(argumentCount + 1), Address(stackPointerRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset - sizeof(CallerFrameAndPC)));

    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(-maxFrameExtentForSlowPathCall), stackPointerRegister);
    setupArgumentsWithExecState(TrustedImmPtr(m_module), TrustedImm32(functionIndex));
    move(TrustedImmPtr(bitwise_cast<void*>(getInternalFunction)), GPRInfo::nonArgGPR0);
    call(GPRInfo::nonArgGPR0);
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);

    move(GPRInfo::returnValueGPR, GPRInfo::regT0); // regT0 holds callee.
    store64(GPRInfo::regT0, Address(stackPointerRegister, JSStack::Callee * static_cast<int>(sizeof(Register)) - sizeof(CallerFrameAndPC)));

    callFunctionSlowCase(returnType, dst);
}

static EncodedJSValue JSC_HOST_CALL getImportedFunction(ExecState* exec, Module* module, uint32_t funcImportIndex)
{
    // TODO: Use these two lines?
    // VM* vm = exec->vm();
    // NativeCallFrameTracer tracer(vm, exec);

    const String& functionImportName = module->functionImportName(funcImportIndex);

    JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    Identifier identifier = Identifier::fromString(&exec->vm(), functionImportName);
    PropertySlot slot(globalObject);

    if (!globalObject->getPropertySlot(exec, identifier, slot)) {
        // TODO: Do something!
        fprintf(stderr, "Can't find a function named \"%s\".\n", functionImportName.utf8().data());
        abort();
    }

    JSValue value = slot.getValue(exec, identifier);
    if (!value.isFunction()) {
        fprintf(stderr, "\"%s\" is not a function.\n", functionImportName.utf8().data());
        abort();
    }

    return JSValue::encode(value);
}

void JITCompiler::parseCallImport(ReturnType returnType, int dst)
{
    uint32_t funcImportSignatureIndex = m_module->m_reader.immU32();
    const Module::FuncImportSignature& funcImportSignature = m_module->m_funcImportSignatures[funcImportSignatureIndex];
    const Signature& signature = m_module->m_signatures[funcImportSignature.signatureIndex];
    const Vector<Type>& arguments = signature.arguments;
    size_t argumentCount = arguments.size();
    // FIXME: returnType is redundant with signature.returnType

    parseCallArguments(arguments, dst);

    store32(TrustedImm32(argumentCount + 1), Address(stackPointerRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset - sizeof(CallerFrameAndPC)));

    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(-maxFrameExtentForSlowPathCall), stackPointerRegister);
    setupArgumentsWithExecState(TrustedImmPtr(m_module), TrustedImm32(funcImportSignature.funcImportIndex));
    move(TrustedImmPtr(bitwise_cast<void*>(getImportedFunction)), GPRInfo::nonArgGPR0);
    call(GPRInfo::nonArgGPR0);
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);

    move(GPRInfo::returnValueGPR, GPRInfo::regT0); // regT0 holds callee.
    store64(GPRInfo::regT0, Address(stackPointerRegister, JSStack::Callee * static_cast<int>(sizeof(Register)) - sizeof(CallerFrameAndPC)));

    callFunctionSlowCase(returnType, dst);
}

void JITCompiler::callFunctionSlowCase(ReturnType returnType, int dst)
{
    ThunkGenerator generator = linkThunkGeneratorFor(CodeForCall, RegisterPreservationNotRequired);

    move(TrustedImmPtr(nullptr), GPRInfo::regT2); // TODO: Use CallLinkInfo

    CodePtr ptr = m_vm->getCTIStub(generator).code();

    move(TrustedImmPtr(ptr.executableAddress()), GPRInfo::nonArgGPR0);

    call(GPRInfo::nonArgGPR0);

    addPtr(TrustedImm32(-m_stackHeight), GPRInfo::callFrameRegister, stackPointerRegister); // FIXME: hacky

    // FIXME: Can we really use returnValueGPR?
    switch (returnType) {
    case ReturnType::I32:
        store32(GPRInfo::returnValueGPR, temporaryAddress(dst));
        break;
    case ReturnType::F64:
        unboxDoubleWithoutAssertions(GPRInfo::returnValueGPR, FPRInfo::fpRegT0);
        storeDouble(FPRInfo::fpRegT0, temporaryAddress(dst));
        break;
    case ReturnType::Void:
        break; // TODO: Sure?
    default:
        ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseCallArguments(const Vector<Type>& arguments, int dst)
{
    size_t argumentCount = arguments.size();
    size_t offset = WTF::roundUpToMultipleOf(stackAlignmentRegisters(), dst + argumentCount + m_currentLocalTypes.size()) - m_currentLocalTypes.size(); // FIXME: Better name

    for (size_t i = 0; i < argumentCount; ++i) {
        switch (arguments[i]) {
        case Type::I32:
            parseExpr(ReturnType::I32, offset);
            load32(temporaryAddress(offset), GPRInfo::regT0);
            or64(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
            store64(GPRInfo::regT0, temporaryAddress(offset - i - 1));
            break;
        case Type::F64:
            parseExpr(ReturnType::F64, offset);
            loadDouble(temporaryAddress(offset), FPRInfo::fpRegT0);
            boxDouble(FPRInfo::fpRegT0, GPRInfo::regT0);
            store64(GPRInfo::regT0, temporaryAddress(offset - i - 1));
            break;
        default:
            ASSERT_NOT_REACHED();
        }
    }

    store64(TrustedImm64(JSValue::encode(jsUndefined())), temporaryAddress(offset));

    addPtr(TrustedImm32(-(offset + m_currentLocalTypes.size() + 3) * 8 - 8), GPRInfo::callFrameRegister, stackPointerRegister); // FIXME: hacky
}

void JITCompiler::callDoubleFunction(double (*function)(double), FPRegisterID src, FPRegisterID dst)
{
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(-maxFrameExtentForSlowPathCall), stackPointerRegister);
    setupArguments(src);
    move(TrustedImmPtr(bitwise_cast<void*>(function)), GPRInfo::nonArgGPR0);
    call(GPRInfo::nonArgGPR0);
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);

    // FIXME: only works on x86
    moveDouble(FPRInfo::returnValueFPR, dst);
}

void JITCompiler::callDoubleFunction(double (*function)(double, double), FPRegisterID src1, FPRegisterID src2, FPRegisterID dst)
{
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(-maxFrameExtentForSlowPathCall), stackPointerRegister);
    setupArguments(src1, src2);
    move(TrustedImmPtr(bitwise_cast<void*>(function)), GPRInfo::nonArgGPR0);
    call(GPRInfo::nonArgGPR0);
    if (maxFrameExtentForSlowPathCall)
        addPtr(TrustedImm32(maxFrameExtentForSlowPathCall), stackPointerRegister);

    // FIXME: only works on x86
    moveDouble(FPRInfo::returnValueFPR, dst);
}

void JITCompiler::parseUnaryOp(uint8_t op, ReturnType returnType, int dst)
{
    parseExpr(returnType, dst);
    switch (returnType) {
    case ReturnType::I32:
        load32(temporaryAddress(dst), GPRInfo::regT0);
        switch (static_cast<I32>(op)) {
        case I32::Neg:
            neg32(GPRInfo::regT0);
            break;
        case I32::BitNot:
            xor32(TrustedImm32(-1), GPRInfo::regT0);
            break;
        case I32::Clz:
            countLeadingZeros32(GPRInfo::regT0, GPRInfo::regT0);
            break;
        case I32::Abs: {
            Jump end = branchTest32(PositiveOrZero, GPRInfo::regT0);
            neg32(GPRInfo::regT0);
            end.link(this);
            break;
        }
        default:
            ASSERT_NOT_REACHED();
        }
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F64:
        loadDouble(temporaryAddress(dst), FPRInfo::fpRegT0);
        switch (static_cast<F64>(op)) {
        case F64::Neg:
            negateDouble(FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Abs:
            absDouble(FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Ceil:
            callDoubleFunction(ceil, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Floor:
            callDoubleFunction(floor, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Sqrt:
            sqrtDouble(FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Cos:
            callDoubleFunction(cos, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Sin:
            callDoubleFunction(sin, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Tan:
            callDoubleFunction(tan, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::ACos:
            callDoubleFunction(acos, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::ASin:
            callDoubleFunction(asin, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::ATan:
            callDoubleFunction(atan, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Exp:
            callDoubleFunction(exp, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        case F64::Ln:
            callDoubleFunction(log, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
        storeDouble(FPRInfo::fpRegT1, temporaryAddress(dst));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseBinaryOp(uint8_t op, ReturnType returnType, int dst)
{
    parseExpr(returnType, dst);
    parseExpr(returnType, dst + 1);
    switch (returnType) {
    case ReturnType::I32:
        load32(temporaryAddress(dst), GPRInfo::regT0);
        load32(temporaryAddress(dst + 1), GPRInfo::regT1);
        switch (static_cast<I32>(op)) {
        case I32::Add:
            add32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::Sub:
            sub32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::Mul:
            mul32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::SDiv:
            move(GPRInfo::regT1, GPRInfo::regT2);
            m_assembler.cdq();
            m_assembler.idivl_r(GPRInfo::regT2);
            break;
        case I32::SMod:
            move(GPRInfo::regT1, GPRInfo::regT2);
            m_assembler.cdq();
            m_assembler.idivl_r(GPRInfo::regT2);
            move(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::BitOr:
            or32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::BitAnd:
            and32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::BitXor:
            xor32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::Lsh:
            lshift32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::ArithRsh:
            rshift32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        case I32::LogicRsh:
            urshift32(GPRInfo::regT1, GPRInfo::regT0);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
        store32(GPRInfo::regT0, temporaryAddress(dst));
        break;
    case ReturnType::F64:
        loadDouble(temporaryAddress(dst), FPRInfo::fpRegT0);
        loadDouble(temporaryAddress(dst + 1), FPRInfo::fpRegT1);
        switch (static_cast<F64>(op)) {
        case F64::Add:
            addDouble(FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        case F64::Sub:
            subDouble(FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        case F64::Mul:
            mulDouble(FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        case F64::Div:
            divDouble(FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        case F64::ATan2:
            callDoubleFunction(atan2, FPRInfo::fpRegT0, FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        case F64::Pow:
            callDoubleFunction(pow, FPRInfo::fpRegT0, FPRInfo::fpRegT1, FPRInfo::fpRegT0);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
        storeDouble(FPRInfo::fpRegT0, temporaryAddress(dst));
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void JITCompiler::parseRelationalOpI32(RelationalCondition condition, int dst)
{
    parseExpr(ReturnType::I32, dst);
    parseExpr(ReturnType::I32, dst + 1);
    load32(temporaryAddress(dst), GPRInfo::regT0);
    load32(temporaryAddress(dst + 1), GPRInfo::regT1);
    compare32(condition, GPRInfo::regT0, GPRInfo::regT1, GPRInfo::regT0);
    store32(GPRInfo::regT0, temporaryAddress(dst));
}

void JITCompiler::parseRelationalOpF64(DoubleCondition condition, int dst)
{
    parseExpr(ReturnType::F64, dst);
    parseExpr(ReturnType::F64, dst + 1);
    loadDouble(temporaryAddress(dst), FPRInfo::fpRegT0);
    loadDouble(temporaryAddress(dst + 1), FPRInfo::fpRegT1);
    Jump trueCase = branchDouble(condition, FPRInfo::fpRegT0, FPRInfo::fpRegT1);
    store32(TrustedImm32(0), temporaryAddress(dst));
    Jump end = jump();
    trueCase.link(this);
    store32(TrustedImm32(1), temporaryAddress(dst));
    end.link(this);
}

void JITCompiler::parseComma(ReturnType returnType, int dst)
{
    parseExpr(m_module->m_reader.returnType(), dst);
    parseExpr(returnType, dst);
}

void JITCompiler::parseCond(ReturnType returnType, int dst)
{
    parseExpr(ReturnType::I32, dst);
    load32(temporaryAddress(dst), GPRInfo::regT0);
    Jump els = branchTest32(Zero, GPRInfo::regT0);
    parseExpr(returnType, dst);
    Jump end = jump();
    els.link(this);
    parseExpr(returnType, dst);
    end.link(this);
}

void JITCompiler::parseMinMaxI32(RelationalCondition condition, int dst)
{
    uint32_t numberOfArguments = m_module->m_reader.immU32();
    RELEASE_ASSERT(numberOfArguments >= 1);
    parseExpr(ReturnType::I32, dst);
    load32(temporaryAddress(dst), GPRInfo::regT0);
    for (uint32_t i = 1; i < numberOfArguments; ++i) {
        parseExpr(ReturnType::I32, dst);
        load32(temporaryAddress(dst), GPRInfo::regT1);
        Jump end = branch32(condition, GPRInfo::regT0, GPRInfo::regT1);
        move(GPRInfo::regT1, GPRInfo::regT0);
        end.link(this);
    }
    store32(GPRInfo::regT0, temporaryAddress(dst));
}

} } // namespace JSC::Wasm



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

#ifndef WasmJITCompiler_h
#define WasmJITCompiler_h

#include "CCallHelpers.h"
#include "WasmModule.h"

namespace JSC {

class ExecState;
class JITCode;
class VM;

namespace Wasm {

class JumpScope;
enum class LinearMemoryType : unsigned;

class JITCompiler : private CCallHelpers {
public:
    JITCompiler(VM* vm, CodeBlock* codeBlock, Module* module)
        : CCallHelpers(vm, codeBlock)
        , m_module(module)
    {
    }

    RefPtr<JITCode> compileFunction(VM&, size_t functionIndex);

private:
    void allocateSpaceOnStack();
    void deallocateSpaceOnStack();

    void parseArguments(const Signature&);
    void parseVars();

    void parseStmt();
    void parseGetLocal(int dst);
    void parseSetLocal(uint32_t imm, int dst);
    void parseSetLocal(int dst);
    void parseArrayBufferOffset(bool hasOffset, int dst);
    void parseLoad(ReturnType, LinearMemoryType, bool hasOffset, int dst);
    void parseStore(ReturnType, LinearMemoryType, bool hasOffset, int dst);
    void parseReturnStmt();
    void parseBlockStmt();
    void parseStmtList();
    void parseIfStmt();
    void parseIfElseStmt();
    void parseWhileStmt();
    void parseDoStmt();
    void parseLabelStmt();
    void parseBreakStmt();
    void parseBreakLabelStmt();
    void parseContinueStmt();
    void parseContinueLabelStmt();
    void parseSwitchStmt();

    void parseExpr(ReturnType, int dst);
    void parseExprI32(int dst);
    void parseExprF64(int dst);
    void parseExprVoid(int dst);
    void parseCallInternal(ReturnType, int dst);
    void parseCallImport(ReturnType, int dst);
    void callFunctionSlowCase(ReturnType, int dst);
    void parseCallArguments(const Vector<Type>& arguments, int dst);
    void callDoubleFunction(double (*function)(double), FPRegisterID src, FPRegisterID dst);
    void callDoubleFunction(double (*function)(double, double), FPRegisterID src1, FPRegisterID src2, FPRegisterID dst);
    void parseUnaryOp(uint8_t op, ReturnType, int dst);
    void parseBinaryOp(uint8_t op, ReturnType, int dst);
    void parseRelationalOpI32(RelationalCondition, int dst);
    void parseRelationalOpF64(DoubleCondition, int dst);
    void parseComma(ReturnType, int dst);
    void parseCond(ReturnType, int dst);
    void parseMinMaxI32(RelationalCondition, int dst);

    Address stackAddress(int i) const // FIXME: Is this correct?
    {
        return Address(GPRInfo::callFrameRegister, -i * 8 - 8);
    }

    Address temporaryAddress(int i) const // FIXME: Is this correct?
    {
        return Address(GPRInfo::callFrameRegister, -(i + m_currentLocalTypes.size()) * 8 - 8);
    }

    void pushContinueLabelLabel(Label* label) { m_continueLabelLabels.append(label); }
    void popContinueLabelLabel() { m_continueLabelLabels.removeLast(); }
    Label* continueLabelLabel(size_t i) const { return m_continueLabelLabels[i]; }
    void pushBreakLabelJumpList(JumpList* jumpList) { m_breakLabelJumpLists.append(jumpList); }
    void popBreakLabelJumpList() { m_breakLabelJumpLists.removeLast(); }
    JumpList* breakLabelJumpList(size_t i) const { return m_breakLabelJumpLists[i]; }

    void pushContinueJumpScope(JumpScope* jumpScope) { m_continueJumpScopes.append(jumpScope); }
    void popContinueJumpScope() { m_continueJumpScopes.removeLast(); }
    JumpScope* topContinueJumpScope() const { return m_continueJumpScopes.last(); }

    void pushBreakJumpList(JumpList* jumpList) { m_breakJumpLists.append(jumpList); }
    void popBreakJumpList() { m_breakJumpLists.removeLast(); }
    JumpList* topBreakJumpList() const { return m_breakJumpLists.last(); }

    Module* m_module;

    uint32_t m_stackHeight; // FIXME: This caused a 'segmentation fault' heisenbug when I added "size_t m_stackHeight". Something must be wrong.

    ReturnType m_currentReturnType;
    Vector<Type> m_currentLocalTypes;

    Vector<MacroAssembler::Label*> m_continueLabelLabels;
    Vector<MacroAssembler::JumpList*> m_breakLabelJumpLists;

    Vector<JumpScope*> m_continueJumpScopes;
    Vector<MacroAssembler::JumpList*> m_breakJumpLists;
};

} } // namespace JSC::Wasm

#endif // WasmJITCompiler_h



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

#include "config.h"
#include "WasmModule.h"

#include "JITCode.h"
#include "JSArrayBuffer.h"
#include "JSCellInlines.h"
#include "Reject.h"
#include "SlotVisitorInlines.h"
#include "WasmJITCompiler.h"
#include <wtf/text/StringBuilder.h>

namespace JSC {

namespace Wasm {

const ClassInfo Module::s_info = { "Module", &Base::s_info, 0, CREATE_METHOD_TABLE(Module) };

void Module::finishCreation(VM& vm, JSGlobalObject* globalObject, const Vector<char>& buffer)
{
    Base::finishCreation(vm);

    m_reader = Reader(reinterpret_cast<const uint8_t*>(buffer.data()));
    if (m_reader.fixedWidth<uint32_t>() != MagicNumber)
        abort();
    m_reader.fixedWidth<uint32_t>(); // output size in asm.js format

    // TODO: Make this less hacky
    RefPtr<ArrayBuffer> arrayBuffer = ArrayBuffer::create(1024, 1);
    JSArrayBuffer* jsArrayBuffer = JSArrayBuffer::create(vm, globalObject->arrayBufferStructure(), arrayBuffer.release());
    m_arrayBuffer.set(vm, this, jsArrayBuffer);

    parseConstantPoolSection();
    parseSignatureSection();
    parseFunctionImportSection();
    parseGlobalSection();
    parseFunctionDeclarationSection();
    parseFunctionPointerTables();
    parseFunctionDefinitionSection(vm, globalObject);
    parseExportSection(vm);
}

void Module::parseConstantPoolSection()
{
    uint32_t numberOfI32s = m_reader.immU32();
    uint32_t numberOfF32s = m_reader.immU32();
    uint32_t numberOfF64s = m_reader.immU32();

    Vector<uint32_t> constantI32s(numberOfI32s);
    for (uint32_t i = 0; i < numberOfI32s; ++i)
        constantI32s[i] = m_reader.immU32();

    Vector<float> constantF32s(numberOfF32s);
    for (uint32_t i = 0; i < numberOfF32s; ++i)
        constantF32s[i] = m_reader.fixedWidth<float>();

    Vector<double> constantF64s(numberOfF64s);
    for (uint32_t i = 0; i < numberOfF64s; ++i)
        constantF64s[i] = m_reader.fixedWidth<double>();

    m_constantI32s = WTF::move(constantI32s);
    m_constantF32s = WTF::move(constantF32s);
    m_constantF64s = WTF::move(constantF64s);
}

void Module::parseSignatureSection()
{
    uint32_t numberOfSignatures = m_reader.immU32();
    Vector<Signature> signatures(numberOfSignatures);
    for (uint32_t signatureIndex = 0; signatureIndex < numberOfSignatures; ++signatureIndex) {
        ReturnType returnType = m_reader.returnType();
        uint32_t argumentCount = m_reader.immU32();
        Signature signature(returnType, argumentCount);
        for (uint32_t argumentIndex = 0; argumentIndex < argumentCount; ++argumentIndex)
            signature.arguments[argumentIndex] = m_reader.type();
        signatures[signatureIndex] = WTF::move(signature);
    }

    m_signatures = WTF::move(signatures);
}

void Module::parseFunctionImportSection()
{
    uint32_t numberOfFuncImports = m_reader.immU32();
    uint32_t numberOfFuncImportSignatures = m_reader.immU32();

    m_functionImportNames.reserveCapacity(numberOfFuncImports);

    Vector<FuncImportSignature> funcImportSignatures(numberOfFuncImportSignatures);
    FuncImportSignature* funcImportSignature = funcImportSignatures.data();
    for (uint32_t funcImportIndex = 0; funcImportIndex < numberOfFuncImports; ++funcImportIndex) {
        StringBuilder builder;
        while (char c = m_reader.singleChar())
            builder.append(c);
        m_functionImportNames.append(builder.toString());

        uint32_t numberOfSignatures = m_reader.immU32();
        for (uint32_t i = 0; i < numberOfSignatures; ++i) {
            funcImportSignature->signatureIndex = m_reader.immU32();
            funcImportSignature->funcImportIndex = funcImportIndex;
            funcImportSignature++;
        }
    }
    assert(funcImportSignature == funcImportSignatures.data() + numberOfFuncImportSignatures);

    m_funcImportSignatures = WTF::move(funcImportSignatures);
}

void Module::parseGlobalSection()
{
    uint32_t numberOfI32Zero = m_reader.immU32();
    uint32_t numberOfF32Zero = m_reader.immU32();
    uint32_t numberOfF64Zero = m_reader.immU32();
    uint32_t numberOfI32Import = m_reader.immU32();
    uint32_t numberOfF32Import = m_reader.immU32();
    uint32_t numberOfF64Import = m_reader.immU32();
    uint32_t numberOfGlobalVars = numberOfI32Zero + numberOfF32Zero + numberOfF64Zero + numberOfI32Import + numberOfF32Import + numberOfF64Import;

    Vector<Type> globalTypes(numberOfGlobalVars);
    size_t globalTypeIndex = 0;
    for (uint32_t i = 0; i < numberOfI32Zero; ++i)
        globalTypes[globalTypeIndex++] = Type::I32;
    for (uint32_t i = 0; i < numberOfF32Zero; ++i)
        globalTypes[globalTypeIndex++] = Type::F32;
    for (uint32_t i = 0; i < numberOfF64Zero; ++i)
        globalTypes[globalTypeIndex++] = Type::F64;
    for (uint32_t i = 0; i < numberOfI32Import; ++i) {
        while (m_reader.singleChar()) { }
        globalTypes[globalTypeIndex++] = Type::I32;
    }
    for (uint32_t i = 0; i < numberOfF32Import; ++i) {
        while (m_reader.singleChar()) { }
        globalTypes[globalTypeIndex++] = Type::F32;
    }
    for (uint32_t i = 0; i < numberOfF64Import; ++i) {
        while (m_reader.singleChar()) { }
        globalTypes[globalTypeIndex++] = Type::F64;
    }
    m_globalTypes = WTF::move(globalTypes);
}

void Module::parseFunctionDeclarationSection()
{
    uint32_t numberOfFunctions = m_reader.immU32();
    Vector<uint32_t> funcSignatures(numberOfFunctions);
    for (uint32_t i = 0; i < numberOfFunctions; ++i)
        funcSignatures[i] = m_reader.immU32();

    m_funcSignatures = WTF::move(funcSignatures);
}

void Module::parseFunctionPointerTables()
{
    uint32_t numberOfFuncPtrTables = m_reader.immU32();
    Vector<FuncPtrTable> funcPtrTables(numberOfFuncPtrTables);
    for (uint32_t i = 0; i < numberOfFuncPtrTables; ++i) {
        funcPtrTables[i].signatureIndex = m_reader.immU32();
        uint32_t numElements = m_reader.immU32();
        Vector<uint32_t> elements(numElements);
        for (uint32_t j = 0; j < numElements; ++j)
            elements[j] = m_reader.immU32();
        funcPtrTables[i].elements = WTF::move(elements);
    }

    m_funcPtrTables = WTF::move(funcPtrTables);
}

void Module::parseFunctionDefinitionSection(VM& vm, JSGlobalObject* globalObject)
{
    for (size_t i = 0; i < m_funcSignatures.size(); ++i)
        parseFunctionDefinition(vm, globalObject, i);
}

void Module::parseExportSection(VM& vm)
{
    switch (m_reader.exportFormat()) {
    case ExportFormat::Default: {
        uint32_t functionIndex = m_reader.immU32();
        Identifier identifier = Identifier::fromString(&vm, "default"); // TODO: Use other names
        putDirect(vm, identifier, m_functions[functionIndex].get());
        break;
    }
    case ExportFormat::Record: {
        uint32_t numberOfExports = m_reader.immU32();
        for (uint32_t exportIndex = 0; exportIndex < numberOfExports; ++exportIndex) {
            StringBuilder builder;
            while (char c = m_reader.singleChar())
                builder.append(c);
            uint32_t functionIndex = m_reader.immU32();
            Identifier identifier = Identifier::fromString(&vm, builder.toString());
            putDirect(vm, identifier, m_functions[functionIndex].get());
        }
        break;
    }
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

void Module::parseFunctionDefinition(VM& vm, JSGlobalObject* globalObject, size_t functionIndex)
{
    WebAssemblyExecutable* executable = WebAssemblyExecutable::create(vm, SourceCode());
    {
        DeferGC deferGC(vm.heap);
        RefPtr<WebAssemblyCodeBlock> codeBlock = adoptRef(new WebAssemblyCodeBlock(executable, globalObject));
        JITCompiler jitCompiler(&vm, codeBlock.get(), this);
        codeBlock->setJITCode(jitCompiler.compileFunction(vm, functionIndex));
        executable->installCode(codeBlock.get());
    }

    JSFunction* jsFunction = JSFunction::create(vm, executable, globalObject);
    m_functions.append(WriteBarrier<JSFunction>(vm, this, jsFunction));
}

JSFunction* Module::function(size_t functionIndex) const
{
    return m_functions[functionIndex].get();
}

const void* Module::arrayBufferData() const
{
    return m_arrayBuffer->impl()->data();
}

void Module::visitChildren(JSCell* cell, SlotVisitor& visitor)
{
    Module* thisObject = static_cast<Module*>(cell);
    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    Base::visitChildren(thisObject, visitor);
    for (auto function : thisObject->m_functions)
        visitor.append(&function);
    visitor.append(&thisObject->m_arrayBuffer);
}

bool Module::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
    Module* thisObject = jsCast<Module*>(object);
    if (propertyName == exec->propertyNames().buffer) {
        slot.setValue(thisObject, DontDelete | ReadOnly, thisObject->m_arrayBuffer.get());
        return true;
    }

    return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
}

void Module::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
    Module* thisObject = jsCast<Module*>(cell);
    if (propertyName == exec->propertyNames().buffer) {
        reject(exec, slot.isStrictMode(), "Attempting to write to a read-only array buffer property.");
        return;
    }

    Base::put(thisObject, exec, propertyName, value, slot);
}

bool Module::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool shouldThrow)
{
    Module* thisObject = jsCast<Module*>(object);
    if (propertyName == exec->propertyNames().buffer)
        return reject(exec, shouldThrow, "Attempting to define read-only array buffer property.");

    return Base::defineOwnProperty(thisObject, exec, propertyName, descriptor, shouldThrow);
}

bool Module::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
{
    Module* thisObject = jsCast<Module*>(cell);
    if (propertyName == exec->propertyNames().buffer)
        return false;
    
    return Base::deleteProperty(thisObject, exec, propertyName);
}

void Module::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& array, EnumerationMode mode)
{
    Module* thisObject = jsCast<Module*>(object);
    if (mode.includeDontEnumProperties())
        array.add(exec->propertyNames().buffer);
    
    Base::getOwnNonIndexPropertyNames(thisObject, exec, array, mode);
}

Module* compile(ExecState* exec, const Vector<char>& buffer)
{
    return Module::create(exec->vm(), exec->lexicalGlobalObject(), buffer);
}

} } // namespace JSC::Wasm



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

#ifndef WasmModule_h
#define WasmModule_h

#include "JSGlobalObject.h"
#include "WasmOpcodes.h"

namespace JSC {

class JITCompiler;

namespace Wasm {

class Module : public JSGlobalObject {
public:
    typedef JSGlobalObject Base;
    static const unsigned StructureFlags = Base::StructureFlags | OverridesGetPropertyNames | OverridesGetOwnPropertySlot;

    static Module* create(VM& vm, JSGlobalObject* globalObject, const Vector<char>& buffer)
    {
        Structure* structure = createStructure(vm, globalObject); // FIXME: is this right?
        Module* module = new (NotNull, allocateCell<Module>(vm.heap)) Module(vm, structure);
        module->finishCreation(vm, globalObject, buffer);
        return module;
    }

    DECLARE_INFO;

    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject)
    {
        return Structure::create(vm, globalObject, jsNull(), TypeInfo(GlobalObjectType, StructureFlags), info());
    }

    JSFunction* function(size_t functionIndex) const;
    const String& functionImportName(size_t functionImportIndex) const { return m_functionImportNames[functionImportIndex]; }
    const void* arrayBufferData() const;

    static void visitChildren(JSCell*, SlotVisitor&);

private:
    friend class JITCompiler;

    struct FuncImportSignature {
        uint32_t signatureIndex;
        uint32_t funcImportIndex;
    };
    
    struct FuncPtrTable {
        uint32_t signatureIndex;
        Vector<uint32_t> elements;
    };

    Module(VM& vm, Structure* structure)
        : Base(vm, structure)
    {
    }

    void finishCreation(VM&, JSGlobalObject*, const Vector<char>& buffer);

    void parseConstantPoolSection();
    void parseSignatureSection();
    void parseFunctionImportSection();
    void parseGlobalSection();
    void parseFunctionDeclarationSection();
    void parseFunctionPointerTables();
    void parseFunctionDefinitionSection(VM&, JSGlobalObject*);
    void parseExportSection(VM&);

    void parseFunctionDefinition(VM&, JSGlobalObject*, size_t functionIndex);

    static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
    static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
    static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
    static bool deleteProperty(JSCell*, ExecState*, PropertyName);
    static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

    Reader m_reader;

    Vector<Signature> m_signatures;
    Vector<uint32_t> m_constantI32s;
    Vector<float> m_constantF32s;
    Vector<double> m_constantF64s;
    Vector<String> m_functionImportNames;
    Vector<FuncImportSignature> m_funcImportSignatures;
    Vector<Type> m_globalTypes;
    Vector<uint32_t> m_funcSignatures;
    Vector<FuncPtrTable> m_funcPtrTables;

    Vector<WriteBarrier<JSFunction>> m_functions;
    WriteBarrier<JSArrayBuffer> m_arrayBuffer;
};

JS_EXPORT_PRIVATE Module* compile(ExecState*, const Vector<char>& buffer);

} } // namespace JSC::Wasm

#endif // WasmModule_h



/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/

#ifndef WasmOpcodes_h
#define WasmOpcodes_h

#include <wtf/Vector.h>

namespace JSC {

namespace Wasm {

static const uint32_t MagicNumber = 0x6d736177;

enum class Stmt : uint8_t {
    SetLoc,
    SetGlo,
    I32Store8,
    I32StoreOff8,
    I32Store16,
    I32StoreOff16,
    I32Store32,
    I32StoreOff32,
    F32Store,
    F32StoreOff,
    F64Store,
    F64StoreOff,
    CallInt,
    CallInd,
    CallImp,
    Ret,
    Block,
    IfThen,
    IfElse,
    While,
    Do,
    Label,
    Break,
    BreakLabel,
    Continue,
    ContinueLabel,
    Switch,

    Bad
};

enum class StmtWithImm : uint8_t {
    SetLoc,
    SetGlo,
    Reseved1,
    Reseved2,

    Bad
};

enum class SwitchCase : uint8_t {
    Case0,
    Case1,
    CaseN,
    Default0,
    Default1,
    DefaultN
};

enum class I32 : uint8_t {
    LitPool,
    LitImm,
    GetLoc,
    GetGlo,
    SetLoc,
    SetGlo,
    SLoad8,
    SLoadOff8,
    ULoad8,
    ULoadOff8,
    SLoad16,
    SLoadOff16,
    ULoad16,
    ULoadOff16,
    Load32,
    LoadOff32,
    Store8,
    StoreOff8,
    Store16,
    StoreOff16,
    Store32,
    StoreOff32,
    CallInt,
    CallInd,
    CallImp,
    Cond,
    Comma,
    FromF32,
    FromF64,
    Neg,
    Add,
    Sub,
    Mul,
    SDiv,
    UDiv,
    SMod,
    UMod,
    BitNot,
    BitOr,
    BitAnd,
    BitXor,
    Lsh,
    ArithRsh,
    LogicRsh,
    Clz,
    LogicNot,
    EqI32,
    EqF32,
    EqF64,
    NEqI32,
    NEqF32,
    NEqF64,
    SLeThI32,
    ULeThI32,
    LeThF32,
    LeThF64,
    SLeEqI32,
    ULeEqI32,
    LeEqF32,
    LeEqF64,
    SGrThI32,
    UGrThI32,
    GrThF32,
    GrThF64,
    SGrEqI32,
    UGrEqI32,
    GrEqF32,
    GrEqF64,
    SMin,
    UMin,
    SMax,
    UMax,
    Abs,

    Bad
};

enum class I32WithImm : uint8_t {
    LitPool,
    LitImm,
    GetLoc,
    Reserved,

    Bad
};

enum class F32 : uint8_t {
    LitPool,
    LitImm,
    GetLoc,
    GetGlo,
    SetLoc,
    SetGlo,
    Load,
    LoadOff,
    Store,
    StoreOff,
    CallInt,
    CallInd,
    Cond,
    Comma,
    FromS32,
    FromU32,
    FromF64,
    Neg,
    Add,
    Sub,
    Mul,
    Div,
    Abs,
    Ceil,
    Floor,
    Sqrt,

    Bad
};

enum class F32WithImm : uint8_t {
    LitPool,
    GetLoc,
    Reserved0,
    Reserved1,

    Bad
};

enum class F64 : uint8_t {
    LitPool,
    LitImm,
    GetLoc,
    GetGlo,
    SetLoc,
    SetGlo,
    Load,
    LoadOff,
    Store,
    StoreOff,
    CallInt,
    CallInd,
    CallImp,
    Cond,
    Comma,
    FromS32,
    FromU32,
    FromF32,
    Neg,
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    Min,
    Max,
    Abs,
    Ceil,
    Floor,
    Sqrt,
    Cos,
    Sin,
    Tan,
    ACos,
    ASin,
    ATan,
    ATan2,
    Exp,
    Ln,
    Pow,

    Bad
};

enum class F64WithImm : uint8_t {
    LitPool,
    GetLoc,
    Reserved0,
    Reserved1,

    Bad
};

enum class Void : uint8_t {
    CallInt,
    CallInd,
    CallImp,

    Bad
};

enum class Type : uint8_t {
    I32,
    F32,
    F64
};

enum class VarTypes : uint8_t {
    I32 = 0x1,
    F32 = 0x2,
    F64 = 0x4,
};

inline VarTypes operator| (VarTypes lhs, VarTypes rhs) { return VarTypes(uint8_t(lhs) | uint8_t(rhs)); }
inline bool operator&(VarTypes lhs, VarTypes rhs) { return bool(uint8_t(lhs) & uint8_t(rhs)); }

enum class VarTypesWithImm : uint8_t {
    OnlyI32,
    Reserved0,
    Reserved1,
    Reserved2
};

enum class ReturnType : uint8_t {
    I32 = uint8_t(Type::I32),
    F32 = uint8_t(Type::F32),
    F64 = uint8_t(Type::F64),
    Void
};



class Expr {
public:
    Expr()
    : m_type(ReturnType(-1)), u { }
    {
    }
    Expr(I32 i32) : m_type(ReturnType::I32) { u.i32 = i32; }
    Expr(F32 f32) : m_type(ReturnType::F32) { u.f32 = f32; }
    Expr(F64 f64) : m_type(ReturnType::F64) { u.f64 = f64; }
    Expr(Void v) : m_type(ReturnType::Void) { u.v = v; }

    ReturnType type() const { return m_type; }
    I32 i32() const { return u.i32; }
    F32 f32() const { return u.f32; }
    F64 f64() const { return u.f64; }

    bool operator==(Expr rhs) const { return m_type == rhs.m_type && u.raw == rhs.u.raw; }
    bool operator!=(Expr rhs) const { return !(*this == rhs); }

private:
    ReturnType m_type;
    union U {
        I32 i32;
        F32 f32;
        F64 f64;
        Void v;
        uint8_t raw;
    } u;

    static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");
};

static const uint8_t HasImmFlag = 0x80;
static_assert(uint8_t(I32::Bad) <= HasImmFlag, "MSB reserved to distinguish I32 from I32WithImm");
static_assert(uint8_t(F32::Bad) <= HasImmFlag, "MSB reserved to distinguish F32 from F32WithImm");
static_assert(uint8_t(F64::Bad) <= HasImmFlag, "MSB reserved to distinguish F64 from F64WithImm");

static const unsigned OpWithImmBits = 2;
static const uint32_t OpWithImmLimit = 1 << OpWithImmBits;
static_assert(uint8_t(I32WithImm::Bad) <= OpWithImmLimit, "I32WithImm op fits");
static_assert(uint8_t(F32WithImm::Bad) <= OpWithImmLimit, "F32WithImm op fits");
static_assert(uint8_t(F64WithImm::Bad) <= OpWithImmLimit, "F64WithImm op fits");

static const unsigned ImmBits = 5;
static const uint32_t ImmLimit = 1 << ImmBits;
static_assert((1 + OpWithImmBits + ImmBits) == 8, "Bits of immediate op should add up to a byte");

static inline uint8_t PackOpWithImm(uint8_t op, uint8_t imm)
{
    assert(op < OpWithImmLimit);
    assert(imm < ImmLimit);
    return HasImmFlag | (uint8_t(op) << ImmBits) | imm;
}

template <class TWithImm>
static inline void UnpackOpWithImm(uint8_t byte, TWithImm* op, uint8_t *imm)
{
    assert(byte & HasImmFlag);
    *op = TWithImm((byte >> ImmBits) & (OpWithImmLimit - 1));
    *imm = byte & (ImmLimit - 1);
}

class ExprWithImm {
public:
    ExprWithImm()
        : m_type(Type(-1))
    {
    }
    ExprWithImm(I32WithImm i32) : m_type(Type::I32) { u.i32 = i32; }
    ExprWithImm(F32WithImm f32) : m_type(Type::F32) { u.f32 = f32; }
    ExprWithImm(F64WithImm f64) : m_type(Type::F64) { u.f64 = f64; }

    Type type() const { return m_type; }
    I32WithImm i32() const { return u.i32; }
    F32WithImm f32() const { return u.f32; }
    F64WithImm f64() const { return u.f64; }

private:
    Type m_type;
    union U {
        I32WithImm i32;
        F32WithImm f32;
        F64WithImm f64;
        uint8_t raw;
    } u;

    static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");
};

enum class ExportFormat : uint8_t {
    Default,
    Record
};

struct Signature {
    ReturnType returnType;
    Vector<Type> arguments;

    Signature() { }
    Signature(ReturnType returnType)
        : returnType(returnType) { }
    Signature(ReturnType returnType, uint32_t argumentCount)
        : returnType(returnType)
        , arguments(argumentCount) { }
    Signature(ReturnType returnType, Vector<Type>&& arguments)
        : returnType(returnType)
        , arguments(WTF::move(arguments)) { }

    bool operator==(const Signature& rhs) const { return returnType == rhs.returnType && arguments == rhs.arguments; }
    bool operator!=(const Signature& rhs) const { return !(*this == rhs); }

    struct Hash {
        bool operator()(const Signature &signature) const
        {
            static_assert(sizeof(Type) == 1 && sizeof(ReturnType) == 1, "Shift more");
            uint32_t h = uint8_t(signature.returnType);
            for (Type t : signature.arguments)
                h = ((h << 2) | uint8_t(t)) ^ (h >> 30);
            return h;
        }
    };
};

class Reader {
public:
    Reader() { }
    Reader(const uint8_t* begin)
        : m_cursor(begin)
    {
    }

    template <class T> T fixedWidth();
    Stmt stmt() { return u8<Stmt>(); }
    SwitchCase switchCase() { return u8<SwitchCase>(); }
    template<class T, class TWithImm> inline bool code(T*, TWithImm*, uint8_t*);
    Void voidExpr() { return u8<Void>(); }
    ExportFormat exportFormat() { return u8<ExportFormat>(); }
    Type type() { return u8<Type>(); }
    ReturnType returnType() { return u8<ReturnType>(); }
    inline uint32_t immU32();
    inline int32_t immS32();
    char singleChar() { return *m_cursor++; }

    inline bool ifI32Lit(const Vector<uint32_t>& i32s, uint32_t*);

private:
    template <class T> T u8() { return T(*m_cursor++); }

    const uint8_t* m_cursor;
};

template <>
inline uint32_t Reader::fixedWidth<uint32_t>()
{
    uint32_t u32 = m_cursor[0] | m_cursor[1] << 8 | m_cursor[2] << 16 | m_cursor[3] << 24;
    m_cursor += 4;
    return u32;
}

template <>
inline float Reader::fixedWidth<float>()
{
    union {
        uint8_t arr[4];
        float f;
    } u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3] } };
    m_cursor += 4;
    return u.f;
}

template <>
inline double Reader::fixedWidth<double>()
{
    union {
        uint8_t arr[8];
        double d;
    } u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3], m_cursor[4], m_cursor[5], m_cursor[6], m_cursor[7] } };
    m_cursor += 8;
    return u.d;
}

template <class T, class TWithImm>
bool Reader::code(T* t, TWithImm* tWithImm, uint8_t* imm)
{
    uint8_t byte = *m_cursor++;
    if (!(byte & HasImmFlag)) {
        *t = T(byte);
        return true;
    }

    UnpackOpWithImm(byte, tWithImm, imm);
    return false;
}

inline uint32_t Reader::immU32()
{
    uint32_t u32 = *m_cursor++;
    if (u32 < 0x80)
        return u32;

    u32 &= 0x7f;

    for (unsigned shift = 7; true; shift += 7) {
        uint32_t b = *m_cursor++;
        if (b < 0x80)
            return u32 | (b << shift);
        u32 |= (b & 0x7f) << shift;
    }
}

inline int32_t Reader::immS32()
{
    uint32_t u32 = *m_cursor++;
    if (u32 < 0x80)
        return int32_t(u32) << (32-7) >> (32-7);

    u32 &= 0x7f;

    for (unsigned shift = 7; true; shift += 7) {
        uint32_t b = *m_cursor++;
        if (b < 0x80) {
            u32 |= b << shift;
            int signExtend = (32-7) - shift;
            if (signExtend > 0)
                return int32_t(u32) << signExtend >> signExtend;
            return int32_t(u32);
        }
        u32 |= (b & 0x7f) << shift;
    }
}

inline bool Reader::ifI32Lit(const Vector<uint32_t>& i32s, uint32_t* u32)
{
    uint8_t byte = *m_cursor;

    if (byte & HasImmFlag) {
        I32WithImm i32WithImm;
        uint8_t imm;
        UnpackOpWithImm(byte, &i32WithImm, &imm);

        if (i32WithImm == I32WithImm::LitImm) {
            m_cursor++;
            *u32 = imm;
            return true;
        }

        if (i32WithImm == I32WithImm::LitPool) {
            m_cursor++;
            *u32 = i32s[imm];
            return true;
        }

        return false;
    }

    if (I32(byte) == I32::LitImm) {
        m_cursor++;
        *u32 = immU32();
        return true;
    }

    if (I32(byte) == I32::LitPool) {
        m_cursor++;
        *u32 = i32s[immU32()];
        return true;
    }

    return false;
}

} } // namespace JSC::Wasm

#endif // WasmOpcodes_h

Return to Bug 146064

Lines 86-91 CString CodeBlock::inferredName() const a/Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec1
- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp +75 lines
86	case EvalCode:	86	case EvalCode:
87	return "<eval>";	87	return "<eval>";
88	case FunctionCode:	88	case FunctionCode:
		89	// FIXME: hacky
		90	if (ownerExecutable()->isWebAssemblyExecutable())
		91	return "<webassembly>";
89	return jsCast<FunctionExecutable*>(ownerExecutable())->inferredName().utf8();	92	return jsCast<FunctionExecutable*>(ownerExecutable())->inferredName().utf8();
90	default:	93	default:
91	CRASH();	94	CRASH();
Lines 2183-2188 CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlin a/Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec2
2183	m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock) + m_instructions.size() * sizeof(Instruction));	2186	m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock) + m_instructions.size() * sizeof(Instruction));
2184	}	2187	}
2185		2188
		2189	CodeBlock::CodeBlock(ScriptExecutable* ownerExecutable, JSGlobalObject* globalObject)
		2190	: m_globalObject(globalObject->vm(), ownerExecutable, globalObject)
		2191	, m_heap(&m_globalObject->vm().heap)
		2192	, m_numCalleeRegisters(0) // FIXME
		2193	, m_numVars(0) // FIXME
		2194	, m_isConstructor(false) // FIXME
		2195	, m_shouldAlwaysBeInlined(true)
		2196	, m_didFailFTLCompilation(false)
		2197	, m_hasBeenCompiledWithFTL(false)
		2198	// , m_unlinkedCode(m_globalObject->vm(), ownerExecutable, unlinkedCodeBlock)
		2199	, m_hasDebuggerStatement(false)
		2200	, m_steppingMode(SteppingModeDisabled)
		2201	, m_numBreakpoints(0)
		2202	, m_ownerExecutable(m_globalObject->vm(), ownerExecutable, ownerExecutable)
		2203	, m_vm(&m_globalObject->vm()) // FIXME
		2204	, m_thisRegister(VirtualRegister()) // FIXME
		2205	, m_scopeRegister(VirtualRegister()) // FIXME
		2206	, m_lexicalEnvironmentRegister(VirtualRegister()) // FIXME
		2207	, m_isStrictMode(false) // FIXME
		2208	, m_needsActivation(false)
		2209	, m_mayBeExecuting(false)
		2210	, m_source(nullptr)
		2211	, m_sourceOffset(0)
		2212	, m_firstLineColumnOffset(0)
		2213	, m_codeType(FunctionCode) // FIXME
		2214	, m_osrExitCounter(0)
		2215	, m_optimizationDelayCounter(0)
		2216	, m_reoptimizationRetryCounter(0)
		2217	#if ENABLE(JIT)
		2218	, m_capabilityLevelState(DFG::CapabilityLevelNotSet)
		2219	#endif
		2220	{
		2221	m_visitAggregateHasBeenCalled.store(false, std::memory_order_relaxed);
		2222
		2223	ASSERT(m_heap->isDeferred());
		2224
		2225	/*
		2226	ASSERT(m_scopeRegister.isLocal());
		2227
		2228	bool didCloneSymbolTable = false;
		2229
		2230	if (SymbolTable* symbolTable = unlinkedCodeBlock->symbolTable()) {
		2231	if (m_vm->typeProfiler()) {
		2232	ConcurrentJITLocker locker(symbolTable->m_lock);
		2233	symbolTable->prepareForTypeProfiling(locker);
		2234	}
		2235
		2236	if (codeType() == FunctionCode && symbolTable->scopeSize()) {
		2237	m_symbolTable.set(m_vm, m_ownerExecutable.get(), symbolTable->cloneScopePart(m_vm));
		2238	didCloneSymbolTable = true;
		2239	} else
		2240	m_symbolTable.set(*m_vm, m_ownerExecutable.get(), symbolTable);
		2241	}
		2242	*/
		2243
		2244	// FIXME:
		2245	setNumParameters(0);
		2246
		2247	m_heap->m_codeBlocks.add(this);
		2248	m_heap->reportExtraMemoryAllocated(sizeof(CodeBlock));
		2249	}
		2250
2186	CodeBlock::~CodeBlock()	2251	CodeBlock::~CodeBlock()
2187	{	2252	{
2188	if (m_vm->m_perBytecodeProfiler)	2253	if (m_vm->m_perBytecodeProfiler)
Lines 3057-3062 CodeBlock* FunctionCodeBlock::replacement() a/Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec3
3057	return jsCast<FunctionExecutable*>(ownerExecutable())->codeBlockFor(m_isConstructor ? CodeForConstruct : CodeForCall);	3122	return jsCast<FunctionExecutable*>(ownerExecutable())->codeBlockFor(m_isConstructor ? CodeForConstruct : CodeForCall);
3058	}	3123	}
3059		3124
		3125	CodeBlock* WebAssemblyCodeBlock::replacement()
		3126	{
		3127	return jsCast<WebAssemblyExecutable*>(ownerExecutable())->codeBlockFor(m_isConstructor ? CodeForConstruct : CodeForCall);
		3128	}
		3129
3060	DFG::CapabilityLevel ProgramCodeBlock::capabilityLevelInternal()	3130	DFG::CapabilityLevel ProgramCodeBlock::capabilityLevelInternal()
3061	{	3131	{
3062	return DFG::programCapabilityLevel(this);	3132	return DFG::programCapabilityLevel(this);
Lines 3073-3078 DFG::CapabilityLevel FunctionCodeBlock::capabilityLevelInternal() a/Source/JavaScriptCore/bytecode/CodeBlock.cpp_sec4
3073	return DFG::functionForConstructCapabilityLevel(this);	3143	return DFG::functionForConstructCapabilityLevel(this);
3074	return DFG::functionForCallCapabilityLevel(this);	3144	return DFG::functionForCallCapabilityLevel(this);
3075	}	3145	}
		3146
		3147	DFG::CapabilityLevel WebAssemblyCodeBlock::capabilityLevelInternal()
		3148	{
		3149	return DFG::CannotCompile;
		3150	}
3076	#endif	3151	#endif
3077		3152
3078	void CodeBlock::jettison(Profiler::JettisonReason reason, ReoptimizationMode mode, const FireDetail* detail)	3153	void CodeBlock::jettison(Profiler::JettisonReason reason, ReoptimizationMode mode, const FireDetail* detail)

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +174 lines
		1	2015-07-14 Sukolsak Sakshuwong <sukolsak@gmail.com>
		2
		3	JSC should natively support WebAssembly
		4	https://bugs.webkit.org/show_bug.cgi?id=146064
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* JavaScriptCore.xcodeproj/project.pbxproj:
		9	* bytecode/CodeBlock.cpp:
		10	(JSC::CodeBlock::inferredName):
		11	(JSC::CodeBlock::CodeBlock):
		12	(JSC::WebAssemblyCodeBlock::replacement):
		13	(JSC::WebAssemblyCodeBlock::capabilityLevelInternal):
		14	* bytecode/CodeBlock.h:
		15	(JSC::CodeBlock::codeType):
		16	(JSC::WebAssemblyCodeBlock::WebAssemblyCodeBlock):
		17	* jit/JITOperations.cpp:
		18	* jsc.cpp:
		19	(GlobalObject::finishCreation):
		20	(functionLoadWebAssembly):
		21	* llint/LLIntSlowPaths.cpp:
		22	(JSC::LLInt::setUpCall):
		23	* runtime/Executable.cpp:
		24	(JSC::ScriptExecutable::installCode):
		25	(JSC::ScriptExecutable::newCodeBlockFor):
		26	(JSC::ScriptExecutable::prepareForExecutionImpl):
		27	(JSC::WebAssemblyExecutable::WebAssemblyExecutable):
		28	(JSC::WebAssemblyExecutable::finishCreation):
		29	(JSC::WebAssemblyExecutable::destroy):
		30	(JSC::WebAssemblyExecutable::baselineCodeBlockFor):
		31	(JSC::WebAssemblyExecutable::visitChildren):
		32	(JSC::WebAssemblyExecutable::symbolTable):
		33	(JSC::WebAssemblyExecutable::clearCode):
		34	(JSC::WebAssemblyExecutable::unlinkCalls):
		35	* runtime/Executable.h:
		36	(JSC::ExecutableBase::isWebAssemblyExecutable):
		37	(JSC::ExecutableBase::clearCodeVirtual):
		38	* runtime/JSFunction.cpp:
		39	(JSC::JSFunction::create):
		40	* runtime/JSFunction.h:
		41	(JSC::JSFunction::createImpl):
		42	* runtime/JSFunctionInlines.h:
		43	(JSC::JSFunction::JSFunction):
		44	(JSC::JSFunction::isHostFunction):
		45	* runtime/JSType.h:
		46	* runtime/VM.cpp:
		47	(JSC::VM::VM):
		48	* runtime/VM.h:
		49	* wasm/WasmJITCompiler.cpp: Added.
		50	(JSC::Wasm::JumpScope::JumpScope):
		51	(JSC::Wasm::JumpScope::jump):
		52	(JSC::Wasm::JumpScope::link):
		53	(JSC::Wasm::JITCompiler::compileFunction):
		54	(JSC::Wasm::JITCompiler::allocateSpaceOnStack):
		55	(JSC::Wasm::JITCompiler::deallocateSpaceOnStack):
		56	(JSC::Wasm::JITCompiler::parseArguments):
		57	(JSC::Wasm::JITCompiler::parseVars):
		58	(JSC::Wasm::JITCompiler::parseStmt):
		59	(JSC::Wasm::JITCompiler::parseGetLocal):
		60	(JSC::Wasm::JITCompiler::parseSetLocal):
		61	(JSC::Wasm::getArrayBufferData):
		62	(JSC::Wasm::JITCompiler::parseArrayBufferOffset):
		63	(JSC::Wasm::JITCompiler::parseLoad):
		64	(JSC::Wasm::JITCompiler::parseStore):
65	(JSC::Wasm::JITCompiler::parseReturnStmt):
66	(JSC::Wasm::JITCompiler::parseStmtList):
67	(JSC::Wasm::JITCompiler::parseBlockStmt):
68	(JSC::Wasm::JITCompiler::parseIfStmt):
69	(JSC::Wasm::JITCompiler::parseIfElseStmt):
70	(JSC::Wasm::JITCompiler::parseWhileStmt):
71	(JSC::Wasm::JITCompiler::parseDoStmt):
72	(JSC::Wasm::JITCompiler::parseLabelStmt):
73	(JSC::Wasm::JITCompiler::parseBreakStmt):
74	(JSC::Wasm::JITCompiler::parseBreakLabelStmt):
75	(JSC::Wasm::JITCompiler::parseContinueStmt):
76	(JSC::Wasm::JITCompiler::parseContinueLabelStmt):
77	(JSC::Wasm::JITCompiler::parseSwitchStmt):
78	(JSC::Wasm::JITCompiler::parseExpr):
79	(JSC::Wasm::JITCompiler::parseExprI32):
80	(JSC::Wasm::JITCompiler::parseExprF64):
81	(JSC::Wasm::JITCompiler::parseExprVoid):
82	(JSC::Wasm::getInternalFunction):
83	(JSC::Wasm::JITCompiler::parseCallInternal):
84	(JSC::Wasm::getImportedFunction):
85	(JSC::Wasm::JITCompiler::parseCallImport):
86	(JSC::Wasm::JITCompiler::callFunctionSlowCase):
87	(JSC::Wasm::JITCompiler::parseCallArguments):
88	(JSC::Wasm::JITCompiler::callDoubleFunction):
89	(JSC::Wasm::JITCompiler::parseUnaryOp):
90	(JSC::Wasm::JITCompiler::parseBinaryOp):
91	(JSC::Wasm::JITCompiler::parseRelationalOpI32):
92	(JSC::Wasm::JITCompiler::parseRelationalOpF64):
93	(JSC::Wasm::JITCompiler::parseComma):
94	(JSC::Wasm::JITCompiler::parseCond):
95	(JSC::Wasm::JITCompiler::parseMinMaxI32):
96	* wasm/WasmJITCompiler.h: Added.
97	(JSC::Wasm::JITCompiler::JITCompiler):
98	(JSC::Wasm::JITCompiler::stackAddress):
99	(JSC::Wasm::JITCompiler::temporaryAddress):
100	(JSC::Wasm::JITCompiler::pushContinueLabelLabel):
101	(JSC::Wasm::JITCompiler::popContinueLabelLabel):
102	(JSC::Wasm::JITCompiler::continueLabelLabel):
103	(JSC::Wasm::JITCompiler::pushBreakLabelJumpList):
104	(JSC::Wasm::JITCompiler::popBreakLabelJumpList):
105	(JSC::Wasm::JITCompiler::breakLabelJumpList):
106	(JSC::Wasm::JITCompiler::pushContinueJumpScope):
107	(JSC::Wasm::JITCompiler::popContinueJumpScope):
108	(JSC::Wasm::JITCompiler::topContinueJumpScope):
109	(JSC::Wasm::JITCompiler::pushBreakJumpList):
110	(JSC::Wasm::JITCompiler::popBreakJumpList):
111	(JSC::Wasm::JITCompiler::topBreakJumpList):
112	* wasm/WasmModule.cpp: Added.
113	(JSC::Wasm::Module::finishCreation):
114	(JSC::Wasm::Module::parseConstantPoolSection):
115	(JSC::Wasm::Module::parseSignatureSection):
116	(JSC::Wasm::Module::parseFunctionImportSection):
117	(JSC::Wasm::Module::parseGlobalSection):
118	(JSC::Wasm::Module::parseFunctionDeclarationSection):
119	(JSC::Wasm::Module::parseFunctionPointerTables):
120	(JSC::Wasm::Module::parseFunctionDefinitionSection):
121	(JSC::Wasm::Module::parseExportSection):
122	(JSC::Wasm::Module::parseFunctionDefinition):
123	(JSC::Wasm::Module::function):
124	(JSC::Wasm::Module::arrayBufferData):
125	(JSC::Wasm::Module::visitChildren):
126	(JSC::Wasm::Module::getOwnPropertySlot):
127	(JSC::Wasm::Module::put):
128	(JSC::Wasm::Module::defineOwnProperty):
129	(JSC::Wasm::Module::deleteProperty):
130	(JSC::Wasm::Module::getOwnNonIndexPropertyNames):
131	(JSC::Wasm::compile):
132	* wasm/WasmModule.h: Added.
133	(JSC::Wasm::Module::create):
134	(JSC::Wasm::Module::createStructure):
135	(JSC::Wasm::Module::functionImportName):
136	(JSC::Wasm::Module::Module):
137	* wasm/WasmOpcodes.h: Added.
138	(JSC::Wasm::operator\| ):
139	(JSC::Wasm::operator&):
140	(JSC::Wasm::Expr::Expr):
141	(JSC::Wasm::Expr::type):
142	(JSC::Wasm::Expr::i32):
143	(JSC::Wasm::Expr::f32):
144	(JSC::Wasm::Expr::f64):
145	(JSC::Wasm::Expr::operator==):
146	(JSC::Wasm::Expr::operator!=):
147	(JSC::Wasm::PackOpWithImm):
148	(JSC::Wasm::UnpackOpWithImm):
149	(JSC::Wasm::ExprWithImm::ExprWithImm):
150	(JSC::Wasm::ExprWithImm::type):
151	(JSC::Wasm::ExprWithImm::i32):
152	(JSC::Wasm::ExprWithImm::f32):
153	(JSC::Wasm::ExprWithImm::f64):
154	(JSC::Wasm::Signature::Signature):
155	(JSC::Wasm::Signature::operator==):
156	(JSC::Wasm::Signature::operator!=):
157	(JSC::Wasm::Signature::Hash::operator()):
158	(JSC::Wasm::Reader::Reader):
159	(JSC::Wasm::Reader::stmt):
160	(JSC::Wasm::Reader::switchCase):
161	(JSC::Wasm::Reader::voidExpr):
162	(JSC::Wasm::Reader::exportFormat):
163	(JSC::Wasm::Reader::type):
164	(JSC::Wasm::Reader::returnType):
165	(JSC::Wasm::Reader::singleChar):
166	(JSC::Wasm::Reader::u8):
167	(JSC::Wasm::Reader::fixedWidth<uint32_t>):
168	(JSC::Wasm::Reader::fixedWidth<float>):
169	(JSC::Wasm::Reader::fixedWidth<double>):
170	(JSC::Wasm::Reader::code):
171	(JSC::Wasm::Reader::immU32):
172	(JSC::Wasm::Reader::immS32):
173	(JSC::Wasm::Reader::ifI32Lit):
174
1	2015-07-08 Joseph Pecoraro <pecoraro@apple.com>	175	2015-07-08 Joseph Pecoraro <pecoraro@apple.com>
2		176
3	Fix grammar issue in TypeError attempting to change an unconfigurable property	177	Fix grammar issue in TypeError attempting to change an unconfigurable property

Lines 60-69 bool JSFunction::isHostFunctionNonInline() const a/Source/JavaScriptCore/runtime/JSFunction.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSFunction.cpp -2 / +3 lines
60	return isHostFunction();	60	return isHostFunction();
61	}	61	}
62		62
63	JSFunction* JSFunction::create(VM& vm, FunctionExecutable* executable, JSScope* scope)	63	JSFunction* JSFunction::create(VM& vm, ExecutableBase* executable, JSScope* scope)
64	{	64	{
65	JSFunction* result = createImpl(vm, executable, scope);	65	JSFunction* result = createImpl(vm, executable, scope);
66	executable->singletonFunction()->notifyWrite(vm, result, "Allocating a function");	66	if (executable->isFunctionExecutable())
		67	static_cast<FunctionExecutable*>(executable)->singletonFunction()->notifyWrite(vm, result, "Allocating a function");
67	return result;	68	return result;
68	}	69	}
69		70

Lines 72-78 public: a/Source/JavaScriptCore/runtime/JSFunction.h_sec1
- a/Source/JavaScriptCore/runtime/JSFunction.h -3 / +3 lines
72	static JSFunction* createWithInvalidatedReallocationWatchpoint(VM&, FunctionExecutable, JSScope);	72	static JSFunction* createWithInvalidatedReallocationWatchpoint(VM&, FunctionExecutable, JSScope);
73	JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeStdFunction&&, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);	73	JS_EXPORT_PRIVATE static JSFunction* create(VM&, JSGlobalObject*, int length, const String& name, NativeStdFunction&&, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
74		74
75	static JSFunction* create(VM&, FunctionExecutable, JSScope);	75	static JSFunction* create(VM&, ExecutableBase, JSScope);
76		76
77	static JSFunction* createBuiltinFunction(VM&, FunctionExecutable, JSGlobalObject);	77	static JSFunction* createBuiltinFunction(VM&, FunctionExecutable, JSGlobalObject);
78	static JSFunction* createBuiltinFunction(VM&, FunctionExecutable, JSGlobalObject, const String& name);	78	static JSFunction* createBuiltinFunction(VM&, FunctionExecutable, JSGlobalObject, const String& name);
Lines 140-146 public: a/Source/JavaScriptCore/runtime/JSFunction.h_sec2
140		140
141	protected:	141	protected:
142	JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject, Structure);	142	JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject, Structure);
143	JSFunction(VM&, FunctionExecutable, JSScope);	143	JSFunction(VM&, ExecutableBase, JSScope);
144		144
145	void finishCreation(VM&, NativeExecutable*, int length, const String& name);	145	void finishCreation(VM&, NativeExecutable*, int length, const String& name);
146	using Base::finishCreation;	146	using Base::finishCreation;
Lines 159-165 protected: a/Source/JavaScriptCore/runtime/JSFunction.h_sec3
159	static void visitChildren(JSCell*, SlotVisitor&);	159	static void visitChildren(JSCell*, SlotVisitor&);
160		160
161	private:	161	private:
162	static JSFunction* createImpl(VM& vm, FunctionExecutable* executable, JSScope* scope)	162	static JSFunction* createImpl(VM& vm, ExecutableBase* executable, JSScope* scope)
163	{	163	{
164	JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope);	164	JSFunction* function = new (NotNull, allocateCell<JSFunction>(vm.heap)) JSFunction(vm, executable, scope);
165	ASSERT(function->structure()->globalObject());	165	ASSERT(function->structure()->globalObject());

Line 0 a/Source/JavaScriptCore/wasm/WasmJITCompiler.h_sec1
- a/Source/JavaScriptCore/wasm/WasmJITCompiler.h +154 lines
		1	/*
		2	* Copyright (C) 2015 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	/*
		27	Licensed under the Apache License, Version 2.0 (the "License");
		28	you may not use this file except in compliance with the License.
		29	You may obtain a copy of the License at
		30
		31	http://www.apache.org/licenses/LICENSE-2.0
		32
		33	Unless required by applicable law or agreed to in writing, software
		34	distributed under the License is distributed on an "AS IS" BASIS,
		35	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		36	See the License for the specific language governing permissions and
		37	limitations under the License.
		38	*/
		39
		40	#ifndef WasmJITCompiler_h
		41	#define WasmJITCompiler_h
		42
		43	#include "CCallHelpers.h"
		44	#include "WasmModule.h"
		45
		46	namespace JSC {
		47
		48	class ExecState;
		49	class JITCode;
		50	class VM;
		51
		52	namespace Wasm {
		53
		54	class JumpScope;
		55	enum class LinearMemoryType : unsigned;
		56
		57	class JITCompiler : private CCallHelpers {
		58	public:
		59	JITCompiler(VM* vm, CodeBlock* codeBlock, Module* module)
		60	: CCallHelpers(vm, codeBlock)
		61	, m_module(module)
		62	{
		63	}
		64
65	RefPtr<JITCode> compileFunction(VM&, size_t functionIndex);
66
67	private:
68	void allocateSpaceOnStack();
69	void deallocateSpaceOnStack();
70
71	void parseArguments(const Signature&);
72	void parseVars();
73
74	void parseStmt();
75	void parseGetLocal(int dst);
76	void parseSetLocal(uint32_t imm, int dst);
77	void parseSetLocal(int dst);
78	void parseArrayBufferOffset(bool hasOffset, int dst);
79	void parseLoad(ReturnType, LinearMemoryType, bool hasOffset, int dst);
80	void parseStore(ReturnType, LinearMemoryType, bool hasOffset, int dst);
81	void parseReturnStmt();
82	void parseBlockStmt();
83	void parseStmtList();
84	void parseIfStmt();
85	void parseIfElseStmt();
86	void parseWhileStmt();
87	void parseDoStmt();
88	void parseLabelStmt();
89	void parseBreakStmt();
90	void parseBreakLabelStmt();
91	void parseContinueStmt();
92	void parseContinueLabelStmt();
93	void parseSwitchStmt();
94
95	void parseExpr(ReturnType, int dst);
96	void parseExprI32(int dst);
97	void parseExprF64(int dst);
98	void parseExprVoid(int dst);
99	void parseCallInternal(ReturnType, int dst);
100	void parseCallImport(ReturnType, int dst);
101	void callFunctionSlowCase(ReturnType, int dst);
102	void parseCallArguments(const Vector<Type>& arguments, int dst);
103	void callDoubleFunction(double (*function)(double), FPRegisterID src, FPRegisterID dst);
104	void callDoubleFunction(double (*function)(double, double), FPRegisterID src1, FPRegisterID src2, FPRegisterID dst);
105	void parseUnaryOp(uint8_t op, ReturnType, int dst);
106	void parseBinaryOp(uint8_t op, ReturnType, int dst);
107	void parseRelationalOpI32(RelationalCondition, int dst);
108	void parseRelationalOpF64(DoubleCondition, int dst);
109	void parseComma(ReturnType, int dst);
110	void parseCond(ReturnType, int dst);
111	void parseMinMaxI32(RelationalCondition, int dst);
112
113	Address stackAddress(int i) const // FIXME: Is this correct?
114	{
115	return Address(GPRInfo::callFrameRegister, -i * 8 - 8);
116	}
117
118	Address temporaryAddress(int i) const // FIXME: Is this correct?
119	{
120	return Address(GPRInfo::callFrameRegister, -(i + m_currentLocalTypes.size()) * 8 - 8);
121	}
122
123	void pushContinueLabelLabel(Label* label) { m_continueLabelLabels.append(label); }
124	void popContinueLabelLabel() { m_continueLabelLabels.removeLast(); }
125	Label* continueLabelLabel(size_t i) const { return m_continueLabelLabels[i]; }
126	void pushBreakLabelJumpList(JumpList* jumpList) { m_breakLabelJumpLists.append(jumpList); }
127	void popBreakLabelJumpList() { m_breakLabelJumpLists.removeLast(); }
128	JumpList* breakLabelJumpList(size_t i) const { return m_breakLabelJumpLists[i]; }
129
130	void pushContinueJumpScope(JumpScope* jumpScope) { m_continueJumpScopes.append(jumpScope); }
131	void popContinueJumpScope() { m_continueJumpScopes.removeLast(); }
132	JumpScope* topContinueJumpScope() const { return m_continueJumpScopes.last(); }
133
134	void pushBreakJumpList(JumpList* jumpList) { m_breakJumpLists.append(jumpList); }
135	void popBreakJumpList() { m_breakJumpLists.removeLast(); }
136	JumpList* topBreakJumpList() const { return m_breakJumpLists.last(); }
137
138	Module* m_module;
139
140	uint32_t m_stackHeight; // FIXME: This caused a 'segmentation fault' heisenbug when I added "size_t m_stackHeight". Something must be wrong.
141
142	ReturnType m_currentReturnType;
143	Vector<Type> m_currentLocalTypes;
144
145	Vector<MacroAssembler::Label*> m_continueLabelLabels;
146	Vector<MacroAssembler::JumpList*> m_breakLabelJumpLists;
147
148	Vector<JumpScope*> m_continueJumpScopes;
149	Vector<MacroAssembler::JumpList*> m_breakJumpLists;
150	};
151
152	} } // namespace JSC::Wasm
153
154	#endif // WasmJITCompiler_h

Line 0 a/Source/JavaScriptCore/wasm/WasmModule.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmModule.cpp +327 lines
		1	/*
		2	* Copyright (C) 2015 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	/*
		27	Licensed under the Apache License, Version 2.0 (the "License");
		28	you may not use this file except in compliance with the License.
		29	You may obtain a copy of the License at
		30
		31	http://www.apache.org/licenses/LICENSE-2.0
		32
		33	Unless required by applicable law or agreed to in writing, software
		34	distributed under the License is distributed on an "AS IS" BASIS,
		35	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		36	See the License for the specific language governing permissions and
		37	limitations under the License.
		38	*/
		39
		40	#include "config.h"
		41	#include "WasmModule.h"
		42
		43	#include "JITCode.h"
		44	#include "JSArrayBuffer.h"
		45	#include "JSCellInlines.h"
		46	#include "Reject.h"
		47	#include "SlotVisitorInlines.h"
		48	#include "WasmJITCompiler.h"
		49	#include <wtf/text/StringBuilder.h>
		50
		51	namespace JSC {
		52
		53	namespace Wasm {
		54
		55	const ClassInfo Module::s_info = { "Module", &Base::s_info, 0, CREATE_METHOD_TABLE(Module) };
		56
		57	void Module::finishCreation(VM& vm, JSGlobalObject* globalObject, const Vector<char>& buffer)
		58	{
		59	Base::finishCreation(vm);
		60
		61	m_reader = Reader(reinterpret_cast<const uint8_t*>(buffer.data()));
		62	if (m_reader.fixedWidth<uint32_t>() != MagicNumber)
		63	abort();
		64	m_reader.fixedWidth<uint32_t>(); // output size in asm.js format
65
66	// TODO: Make this less hacky
67	RefPtr<ArrayBuffer> arrayBuffer = ArrayBuffer::create(1024, 1);
68	JSArrayBuffer* jsArrayBuffer = JSArrayBuffer::create(vm, globalObject->arrayBufferStructure(), arrayBuffer.release());
69	m_arrayBuffer.set(vm, this, jsArrayBuffer);
70
71	parseConstantPoolSection();
72	parseSignatureSection();
73	parseFunctionImportSection();
74	parseGlobalSection();
75	parseFunctionDeclarationSection();
76	parseFunctionPointerTables();
77	parseFunctionDefinitionSection(vm, globalObject);
78	parseExportSection(vm);
79	}
80
81	void Module::parseConstantPoolSection()
82	{
83	uint32_t numberOfI32s = m_reader.immU32();
84	uint32_t numberOfF32s = m_reader.immU32();
85	uint32_t numberOfF64s = m_reader.immU32();
86
87	Vector<uint32_t> constantI32s(numberOfI32s);
88	for (uint32_t i = 0; i < numberOfI32s; ++i)
89	constantI32s[i] = m_reader.immU32();
90
91	Vector<float> constantF32s(numberOfF32s);
92	for (uint32_t i = 0; i < numberOfF32s; ++i)
93	constantF32s[i] = m_reader.fixedWidth<float>();
94
95	Vector<double> constantF64s(numberOfF64s);
96	for (uint32_t i = 0; i < numberOfF64s; ++i)
97	constantF64s[i] = m_reader.fixedWidth<double>();
98
99	m_constantI32s = WTF::move(constantI32s);
100	m_constantF32s = WTF::move(constantF32s);
101	m_constantF64s = WTF::move(constantF64s);
102	}
103
104	void Module::parseSignatureSection()
105	{
106	uint32_t numberOfSignatures = m_reader.immU32();
107	Vector<Signature> signatures(numberOfSignatures);
108	for (uint32_t signatureIndex = 0; signatureIndex < numberOfSignatures; ++signatureIndex) {
109	ReturnType returnType = m_reader.returnType();
110	uint32_t argumentCount = m_reader.immU32();
111	Signature signature(returnType, argumentCount);
112	for (uint32_t argumentIndex = 0; argumentIndex < argumentCount; ++argumentIndex)
113	signature.arguments[argumentIndex] = m_reader.type();
114	signatures[signatureIndex] = WTF::move(signature);
115	}
116
117	m_signatures = WTF::move(signatures);
118	}
119
120	void Module::parseFunctionImportSection()
121	{
122	uint32_t numberOfFuncImports = m_reader.immU32();
123	uint32_t numberOfFuncImportSignatures = m_reader.immU32();
124
125	m_functionImportNames.reserveCapacity(numberOfFuncImports);
126
127	Vector<FuncImportSignature> funcImportSignatures(numberOfFuncImportSignatures);
128	FuncImportSignature* funcImportSignature = funcImportSignatures.data();
129	for (uint32_t funcImportIndex = 0; funcImportIndex < numberOfFuncImports; ++funcImportIndex) {
130	StringBuilder builder;
131	while (char c = m_reader.singleChar())
132	builder.append(c);
133	m_functionImportNames.append(builder.toString());
134
135	uint32_t numberOfSignatures = m_reader.immU32();
136	for (uint32_t i = 0; i < numberOfSignatures; ++i) {
137	funcImportSignature->signatureIndex = m_reader.immU32();
138	funcImportSignature->funcImportIndex = funcImportIndex;
139	funcImportSignature++;
140	}
141	}
142	assert(funcImportSignature == funcImportSignatures.data() + numberOfFuncImportSignatures);
143
144	m_funcImportSignatures = WTF::move(funcImportSignatures);
145	}
146
147	void Module::parseGlobalSection()
148	{
149	uint32_t numberOfI32Zero = m_reader.immU32();
150	uint32_t numberOfF32Zero = m_reader.immU32();
151	uint32_t numberOfF64Zero = m_reader.immU32();
152	uint32_t numberOfI32Import = m_reader.immU32();
153	uint32_t numberOfF32Import = m_reader.immU32();
154	uint32_t numberOfF64Import = m_reader.immU32();
155	uint32_t numberOfGlobalVars = numberOfI32Zero + numberOfF32Zero + numberOfF64Zero + numberOfI32Import + numberOfF32Import + numberOfF64Import;
156
157	Vector<Type> globalTypes(numberOfGlobalVars);
158	size_t globalTypeIndex = 0;
159	for (uint32_t i = 0; i < numberOfI32Zero; ++i)
160	globalTypes[globalTypeIndex++] = Type::I32;
161	for (uint32_t i = 0; i < numberOfF32Zero; ++i)
162	globalTypes[globalTypeIndex++] = Type::F32;
163	for (uint32_t i = 0; i < numberOfF64Zero; ++i)
164	globalTypes[globalTypeIndex++] = Type::F64;
165	for (uint32_t i = 0; i < numberOfI32Import; ++i) {
166	while (m_reader.singleChar()) { }
167	globalTypes[globalTypeIndex++] = Type::I32;
168	}
169	for (uint32_t i = 0; i < numberOfF32Import; ++i) {
170	while (m_reader.singleChar()) { }
171	globalTypes[globalTypeIndex++] = Type::F32;
172	}
173	for (uint32_t i = 0; i < numberOfF64Import; ++i) {
174	while (m_reader.singleChar()) { }
175	globalTypes[globalTypeIndex++] = Type::F64;
176	}
177	m_globalTypes = WTF::move(globalTypes);
178	}
179
180	void Module::parseFunctionDeclarationSection()
181	{
182	uint32_t numberOfFunctions = m_reader.immU32();
183	Vector<uint32_t> funcSignatures(numberOfFunctions);
184	for (uint32_t i = 0; i < numberOfFunctions; ++i)
185	funcSignatures[i] = m_reader.immU32();
186
187	m_funcSignatures = WTF::move(funcSignatures);
188	}
189
190	void Module::parseFunctionPointerTables()
191	{
192	uint32_t numberOfFuncPtrTables = m_reader.immU32();
193	Vector<FuncPtrTable> funcPtrTables(numberOfFuncPtrTables);
194	for (uint32_t i = 0; i < numberOfFuncPtrTables; ++i) {
195	funcPtrTables[i].signatureIndex = m_reader.immU32();
196	uint32_t numElements = m_reader.immU32();
197	Vector<uint32_t> elements(numElements);
198	for (uint32_t j = 0; j < numElements; ++j)
199	elements[j] = m_reader.immU32();
200	funcPtrTables[i].elements = WTF::move(elements);
201	}
202
203	m_funcPtrTables = WTF::move(funcPtrTables);
204	}
205
206	void Module::parseFunctionDefinitionSection(VM& vm, JSGlobalObject* globalObject)
207	{
208	for (size_t i = 0; i < m_funcSignatures.size(); ++i)
209	parseFunctionDefinition(vm, globalObject, i);
210	}
211
212	void Module::parseExportSection(VM& vm)
213	{
214	switch (m_reader.exportFormat()) {
215	case ExportFormat::Default: {
216	uint32_t functionIndex = m_reader.immU32();
217	Identifier identifier = Identifier::fromString(&vm, "default"); // TODO: Use other names
218	putDirect(vm, identifier, m_functions[functionIndex].get());
219	break;
220	}
221	case ExportFormat::Record: {
222	uint32_t numberOfExports = m_reader.immU32();
223	for (uint32_t exportIndex = 0; exportIndex < numberOfExports; ++exportIndex) {
224	StringBuilder builder;
225	while (char c = m_reader.singleChar())
226	builder.append(c);
227	uint32_t functionIndex = m_reader.immU32();
228	Identifier identifier = Identifier::fromString(&vm, builder.toString());
229	putDirect(vm, identifier, m_functions[functionIndex].get());
230	}
231	break;
232	}
233	default:
234	RELEASE_ASSERT_NOT_REACHED();
235	}
236	}
237
238	void Module::parseFunctionDefinition(VM& vm, JSGlobalObject* globalObject, size_t functionIndex)
239	{
240	WebAssemblyExecutable* executable = WebAssemblyExecutable::create(vm, SourceCode());
241	{
242	DeferGC deferGC(vm.heap);
243	RefPtr<WebAssemblyCodeBlock> codeBlock = adoptRef(new WebAssemblyCodeBlock(executable, globalObject));
244	JITCompiler jitCompiler(&vm, codeBlock.get(), this);
245	codeBlock->setJITCode(jitCompiler.compileFunction(vm, functionIndex));
246	executable->installCode(codeBlock.get());
247	}
248
249	JSFunction* jsFunction = JSFunction::create(vm, executable, globalObject);
250	m_functions.append(WriteBarrier<JSFunction>(vm, this, jsFunction));
251	}
252
253	JSFunction* Module::function(size_t functionIndex) const
254	{
255	return m_functions[functionIndex].get();
256	}
257
258	const void* Module::arrayBufferData() const
259	{
260	return m_arrayBuffer->impl()->data();
261	}
262
263	void Module::visitChildren(JSCell* cell, SlotVisitor& visitor)
264	{
265	Module* thisObject = static_cast<Module*>(cell);
266	ASSERT_GC_OBJECT_INHERITS(thisObject, info());
267	Base::visitChildren(thisObject, visitor);
268	for (auto function : thisObject->m_functions)
269	visitor.append(&function);
270	visitor.append(&thisObject->m_arrayBuffer);
271	}
272
273	bool Module::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
274	{
275	Module* thisObject = jsCast<Module*>(object);
276	if (propertyName == exec->propertyNames().buffer) {
277	slot.setValue(thisObject, DontDelete \| ReadOnly, thisObject->m_arrayBuffer.get());
278	return true;
279	}
280
281	return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
282	}
283
284	void Module::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
285	{
286	Module* thisObject = jsCast<Module*>(cell);
287	if (propertyName == exec->propertyNames().buffer) {
288	reject(exec, slot.isStrictMode(), "Attempting to write to a read-only array buffer property.");
289	return;
290	}
291
292	Base::put(thisObject, exec, propertyName, value, slot);
293	}
294
295	bool Module::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool shouldThrow)
296	{
297	Module* thisObject = jsCast<Module*>(object);
298	if (propertyName == exec->propertyNames().buffer)
299	return reject(exec, shouldThrow, "Attempting to define read-only array buffer property.");
300
301	return Base::defineOwnProperty(thisObject, exec, propertyName, descriptor, shouldThrow);
302	}
303
304	bool Module::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
305	{
306	Module* thisObject = jsCast<Module*>(cell);
307	if (propertyName == exec->propertyNames().buffer)
308	return false;
309
310	return Base::deleteProperty(thisObject, exec, propertyName);
311	}
312
313	void Module::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& array, EnumerationMode mode)
314	{
315	Module* thisObject = jsCast<Module*>(object);
316	if (mode.includeDontEnumProperties())
317	array.add(exec->propertyNames().buffer);
318
319	Base::getOwnNonIndexPropertyNames(thisObject, exec, array, mode);
320	}
321
322	Module* compile(ExecState* exec, const Vector<char>& buffer)
323	{
324	return Module::create(exec->vm(), exec->lexicalGlobalObject(), buffer);
325	}
326
327	} } // namespace JSC::Wasm

Line 0 a/Source/JavaScriptCore/wasm/WasmOpcodes.h_sec1
- a/Source/JavaScriptCore/wasm/WasmOpcodes.h +593 lines
		1	/*
		2	* Copyright (C) 2015 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	/*
		27	Licensed under the Apache License, Version 2.0 (the "License");
		28	you may not use this file except in compliance with the License.
		29	You may obtain a copy of the License at
		30
		31	http://www.apache.org/licenses/LICENSE-2.0
		32
		33	Unless required by applicable law or agreed to in writing, software
		34	distributed under the License is distributed on an "AS IS" BASIS,
		35	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		36	See the License for the specific language governing permissions and
		37	limitations under the License.
		38	*/
		39
		40	#ifndef WasmOpcodes_h
		41	#define WasmOpcodes_h
		42
		43	#include <wtf/Vector.h>
		44
		45	namespace JSC {
		46
		47	namespace Wasm {
		48
		49	static const uint32_t MagicNumber = 0x6d736177;
		50
		51	enum class Stmt : uint8_t {
		52	SetLoc,
		53	SetGlo,
		54	I32Store8,
		55	I32StoreOff8,
		56	I32Store16,
		57	I32StoreOff16,
		58	I32Store32,
		59	I32StoreOff32,
		60	F32Store,
		61	F32StoreOff,
		62	F64Store,
		63	F64StoreOff,
		64	CallInt,
65	CallInd,
66	CallImp,
67	Ret,
68	Block,
69	IfThen,
70	IfElse,
71	While,
72	Do,
73	Label,
74	Break,
75	BreakLabel,
76	Continue,
77	ContinueLabel,
78	Switch,
79
80	Bad
81	};
82
83	enum class StmtWithImm : uint8_t {
84	SetLoc,
85	SetGlo,
86	Reseved1,
87	Reseved2,
88
89	Bad
90	};
91
92	enum class SwitchCase : uint8_t {
93	Case0,
94	Case1,
95	CaseN,
96	Default0,
97	Default1,
98	DefaultN
99	};
100
101	enum class I32 : uint8_t {
102	LitPool,
103	LitImm,
104	GetLoc,
105	GetGlo,
106	SetLoc,
107	SetGlo,
108	SLoad8,
109	SLoadOff8,
110	ULoad8,
111	ULoadOff8,
112	SLoad16,
113	SLoadOff16,
114	ULoad16,
115	ULoadOff16,
116	Load32,
117	LoadOff32,
118	Store8,
119	StoreOff8,
120	Store16,
121	StoreOff16,
122	Store32,
123	StoreOff32,
124	CallInt,
125	CallInd,
126	CallImp,
127	Cond,
128	Comma,
129	FromF32,
130	FromF64,
131	Neg,
132	Add,
133	Sub,
134	Mul,
135	SDiv,
136	UDiv,
137	SMod,
138	UMod,
139	BitNot,
140	BitOr,
141	BitAnd,
142	BitXor,
143	Lsh,
144	ArithRsh,
145	LogicRsh,
146	Clz,
147	LogicNot,
148	EqI32,
149	EqF32,
150	EqF64,
151	NEqI32,
152	NEqF32,
153	NEqF64,
154	SLeThI32,
155	ULeThI32,
156	LeThF32,
157	LeThF64,
158	SLeEqI32,
159	ULeEqI32,
160	LeEqF32,
161	LeEqF64,
162	SGrThI32,
163	UGrThI32,
164	GrThF32,
165	GrThF64,
166	SGrEqI32,
167	UGrEqI32,
168	GrEqF32,
169	GrEqF64,
170	SMin,
171	UMin,
172	SMax,
173	UMax,
174	Abs,
175
176	Bad
177	};
178
179	enum class I32WithImm : uint8_t {
180	LitPool,
181	LitImm,
182	GetLoc,
183	Reserved,
184
185	Bad
186	};
187
188	enum class F32 : uint8_t {
189	LitPool,
190	LitImm,
191	GetLoc,
192	GetGlo,
193	SetLoc,
194	SetGlo,
195	Load,
196	LoadOff,
197	Store,
198	StoreOff,
199	CallInt,
200	CallInd,
201	Cond,
202	Comma,
203	FromS32,
204	FromU32,
205	FromF64,
206	Neg,
207	Add,
208	Sub,
209	Mul,
210	Div,
211	Abs,
212	Ceil,
213	Floor,
214	Sqrt,
215
216	Bad
217	};
218
219	enum class F32WithImm : uint8_t {
220	LitPool,
221	GetLoc,
222	Reserved0,
223	Reserved1,
224
225	Bad
226	};
227
228	enum class F64 : uint8_t {
229	LitPool,
230	LitImm,
231	GetLoc,
232	GetGlo,
233	SetLoc,
234	SetGlo,
235	Load,
236	LoadOff,
237	Store,
238	StoreOff,
239	CallInt,
240	CallInd,
241	CallImp,
242	Cond,
243	Comma,
244	FromS32,
245	FromU32,
246	FromF32,
247	Neg,
248	Add,
249	Sub,
250	Mul,
251	Div,
252	Mod,
253	Min,
254	Max,
255	Abs,
256	Ceil,
257	Floor,
258	Sqrt,
259	Cos,
260	Sin,
261	Tan,
262	ACos,
263	ASin,
264	ATan,
265	ATan2,
266	Exp,
267	Ln,
268	Pow,
269
270	Bad
271	};
272
273	enum class F64WithImm : uint8_t {
274	LitPool,
275	GetLoc,
276	Reserved0,
277	Reserved1,
278
279	Bad
280	};
281
282	enum class Void : uint8_t {
283	CallInt,
284	CallInd,
285	CallImp,
286
287	Bad
288	};
289
290	enum class Type : uint8_t {
291	I32,
292	F32,
293	F64
294	};
295
296	enum class VarTypes : uint8_t {
297	I32 = 0x1,
298	F32 = 0x2,
299	F64 = 0x4,
300	};
301
302	inline VarTypes operator\| (VarTypes lhs, VarTypes rhs) { return VarTypes(uint8_t(lhs) \| uint8_t(rhs)); }
303	inline bool operator&(VarTypes lhs, VarTypes rhs) { return bool(uint8_t(lhs) & uint8_t(rhs)); }
304
305	enum class VarTypesWithImm : uint8_t {
306	OnlyI32,
307	Reserved0,
308	Reserved1,
309	Reserved2
310	};
311
312	enum class ReturnType : uint8_t {
313	I32 = uint8_t(Type::I32),
314	F32 = uint8_t(Type::F32),
315	F64 = uint8_t(Type::F64),
316	Void
317	};
318
319
320
321	class Expr {
322	public:
323	Expr()
324	: m_type(ReturnType(-1)), u { }
325	{
326	}
327	Expr(I32 i32) : m_type(ReturnType::I32) { u.i32 = i32; }
328	Expr(F32 f32) : m_type(ReturnType::F32) { u.f32 = f32; }
329	Expr(F64 f64) : m_type(ReturnType::F64) { u.f64 = f64; }
330	Expr(Void v) : m_type(ReturnType::Void) { u.v = v; }
331
332	ReturnType type() const { return m_type; }
333	I32 i32() const { return u.i32; }
334	F32 f32() const { return u.f32; }
335	F64 f64() const { return u.f64; }
336
337	bool operator==(Expr rhs) const { return m_type == rhs.m_type && u.raw == rhs.u.raw; }
338	bool operator!=(Expr rhs) const { return !(*this == rhs); }
339
340	private:
341	ReturnType m_type;
342	union U {
343	I32 i32;
344	F32 f32;
345	F64 f64;
346	Void v;
347	uint8_t raw;
348	} u;
349
350	static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");
351	};
352
353	static const uint8_t HasImmFlag = 0x80;
354	static_assert(uint8_t(I32::Bad) <= HasImmFlag, "MSB reserved to distinguish I32 from I32WithImm");
355	static_assert(uint8_t(F32::Bad) <= HasImmFlag, "MSB reserved to distinguish F32 from F32WithImm");
356	static_assert(uint8_t(F64::Bad) <= HasImmFlag, "MSB reserved to distinguish F64 from F64WithImm");
357
358	static const unsigned OpWithImmBits = 2;
359	static const uint32_t OpWithImmLimit = 1 << OpWithImmBits;
360	static_assert(uint8_t(I32WithImm::Bad) <= OpWithImmLimit, "I32WithImm op fits");
361	static_assert(uint8_t(F32WithImm::Bad) <= OpWithImmLimit, "F32WithImm op fits");
362	static_assert(uint8_t(F64WithImm::Bad) <= OpWithImmLimit, "F64WithImm op fits");
363
364	static const unsigned ImmBits = 5;
365	static const uint32_t ImmLimit = 1 << ImmBits;
366	static_assert((1 + OpWithImmBits + ImmBits) == 8, "Bits of immediate op should add up to a byte");
367
368	static inline uint8_t PackOpWithImm(uint8_t op, uint8_t imm)
369	{
370	assert(op < OpWithImmLimit);
371	assert(imm < ImmLimit);
372	return HasImmFlag \| (uint8_t(op) << ImmBits) \| imm;
373	}
374
375	template <class TWithImm>
376	static inline void UnpackOpWithImm(uint8_t byte, TWithImm* op, uint8_t *imm)
377	{
378	assert(byte & HasImmFlag);
379	*op = TWithImm((byte >> ImmBits) & (OpWithImmLimit - 1));
380	*imm = byte & (ImmLimit - 1);
381	}
382
383	class ExprWithImm {
384	public:
385	ExprWithImm()
386	: m_type(Type(-1))
387	{
388	}
389	ExprWithImm(I32WithImm i32) : m_type(Type::I32) { u.i32 = i32; }
390	ExprWithImm(F32WithImm f32) : m_type(Type::F32) { u.f32 = f32; }
391	ExprWithImm(F64WithImm f64) : m_type(Type::F64) { u.f64 = f64; }
392
393	Type type() const { return m_type; }
394	I32WithImm i32() const { return u.i32; }
395	F32WithImm f32() const { return u.f32; }
396	F64WithImm f64() const { return u.f64; }
397
398	private:
399	Type m_type;
400	union U {
401	I32WithImm i32;
402	F32WithImm f32;
403	F64WithImm f64;
404	uint8_t raw;
405	} u;
406
407	static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");
408	};
409
410	enum class ExportFormat : uint8_t {
411	Default,
412	Record
413	};
414
415	struct Signature {
416	ReturnType returnType;
417	Vector<Type> arguments;
418
419	Signature() { }
420	Signature(ReturnType returnType)
421	: returnType(returnType) { }
422	Signature(ReturnType returnType, uint32_t argumentCount)
423	: returnType(returnType)
424	, arguments(argumentCount) { }
425	Signature(ReturnType returnType, Vector<Type>&& arguments)
426	: returnType(returnType)
427	, arguments(WTF::move(arguments)) { }
428
429	bool operator==(const Signature& rhs) const { return returnType == rhs.returnType && arguments == rhs.arguments; }
430	bool operator!=(const Signature& rhs) const { return !(*this == rhs); }
431
432	struct Hash {
433	bool operator()(const Signature &signature) const
434	{
435	static_assert(sizeof(Type) == 1 && sizeof(ReturnType) == 1, "Shift more");
436	uint32_t h = uint8_t(signature.returnType);
437	for (Type t : signature.arguments)
438	h = ((h << 2) \| uint8_t(t)) ^ (h >> 30);
439	return h;
440	}
441	};
442	};
443
444	class Reader {
445	public:
446	Reader() { }
447	Reader(const uint8_t* begin)
448	: m_cursor(begin)
449	{
450	}
451
452	template <class T> T fixedWidth();
453	Stmt stmt() { return u8<Stmt>(); }
454	SwitchCase switchCase() { return u8<SwitchCase>(); }
455	template<class T, class TWithImm> inline bool code(T, TWithImm, uint8_t*);
456	Void voidExpr() { return u8<Void>(); }
457	ExportFormat exportFormat() { return u8<ExportFormat>(); }
458	Type type() { return u8<Type>(); }
459	ReturnType returnType() { return u8<ReturnType>(); }
460	inline uint32_t immU32();
461	inline int32_t immS32();
462	char singleChar() { return *m_cursor++; }
463
464	inline bool ifI32Lit(const Vector<uint32_t>& i32s, uint32_t*);
465
466	private:
467	template <class T> T u8() { return T(*m_cursor++); }
468
469	const uint8_t* m_cursor;
470	};
471
472	template <>
473	inline uint32_t Reader::fixedWidth<uint32_t>()
474	{
475	uint32_t u32 = m_cursor[0] \| m_cursor[1] << 8 \| m_cursor[2] << 16 \| m_cursor[3] << 24;
476	m_cursor += 4;
477	return u32;
478	}
479
480	template <>
481	inline float Reader::fixedWidth<float>()
482	{
483	union {
484	uint8_t arr[4];
485	float f;
486	} u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3] } };
487	m_cursor += 4;
488	return u.f;
489	}
490
491	template <>
492	inline double Reader::fixedWidth<double>()
493	{
494	union {
495	uint8_t arr[8];
496	double d;
497	} u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3], m_cursor[4], m_cursor[5], m_cursor[6], m_cursor[7] } };
498	m_cursor += 8;
499	return u.d;
500	}
501
502	template <class T, class TWithImm>
503	bool Reader::code(T* t, TWithImm* tWithImm, uint8_t* imm)
504	{
505	uint8_t byte = *m_cursor++;
506	if (!(byte & HasImmFlag)) {
507	*t = T(byte);
508	return true;
509	}
510
511	UnpackOpWithImm(byte, tWithImm, imm);
512	return false;
513	}
514
515	inline uint32_t Reader::immU32()
516	{
517	uint32_t u32 = *m_cursor++;
518	if (u32 < 0x80)
519	return u32;
520
521	u32 &= 0x7f;
522
523	for (unsigned shift = 7; true; shift += 7) {
524	uint32_t b = *m_cursor++;
525	if (b < 0x80)
526	return u32 \| (b << shift);
527	u32 \|= (b & 0x7f) << shift;
528	}
529	}
530
531	inline int32_t Reader::immS32()
532	{
533	uint32_t u32 = *m_cursor++;
534	if (u32 < 0x80)
535	return int32_t(u32) << (32-7) >> (32-7);
536
537	u32 &= 0x7f;
538
539	for (unsigned shift = 7; true; shift += 7) {
540	uint32_t b = *m_cursor++;
541	if (b < 0x80) {
542	u32 \|= b << shift;
543	int signExtend = (32-7) - shift;
544	if (signExtend > 0)
545	return int32_t(u32) << signExtend >> signExtend;
546	return int32_t(u32);
547	}
548	u32 \|= (b & 0x7f) << shift;
549	}
550	}
551
552	inline bool Reader::ifI32Lit(const Vector<uint32_t>& i32s, uint32_t* u32)
553	{
554	uint8_t byte = *m_cursor;
555
556	if (byte & HasImmFlag) {
557	I32WithImm i32WithImm;
558	uint8_t imm;
559	UnpackOpWithImm(byte, &i32WithImm, &imm);
560
561	if (i32WithImm == I32WithImm::LitImm) {
562	m_cursor++;
563	*u32 = imm;
564	return true;
565	}
566
567	if (i32WithImm == I32WithImm::LitPool) {
568	m_cursor++;
569	*u32 = i32s[imm];
570	return true;
571	}
572
573	return false;
574	}
575
576	if (I32(byte) == I32::LitImm) {
577	m_cursor++;
578	*u32 = immU32();
579	return true;
580	}
581
582	if (I32(byte) == I32::LitPool) {
583	m_cursor++;
584	*u32 = i32s[immU32()];
585	return true;
586	}
587
588	return false;
589	}
590
591	} } // namespace JSC::Wasm
592
593	#endif // WasmOpcodes_h