Attachment #286349 for bug #160928

View Details Raw Unified Return to Bug 160928

| Differences between



2016-08-16  Keith Miller  <keith_miller@apple.com>

        Add WASM support for i64 simple opcodes.
        https://bugs.webkit.org/show_bug.cgi?id=160928

        Reviewed by NOBODY (OOPS!).

        This patch also removes the unsigned int32 mod operator, which is not supported by B3 yet.

        * wasm/WASMB3IRGenerator.cpp:
        (JSC::WASM::toB3Op):
        (JSC::WASM::B3IRGenerator::unaryOp):
        * wasm/WASMFunctionParser.h:
        (JSC::WASM::WASMFunctionParser<Context>::parseExpression):
        * wasm/WASMOps.h:

2016-08-16  Mark Lam  <mark.lam@apple.com>

        Heap::collectAllGarbage() should work with JSC_useImmortalObjects=true.

Lines 41-47 namespace WASM { a/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp_sec1
- a/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp -1 / +17 lines
41		41
42	using namespace B3;	42	using namespace B3;
43		43
44	inline JSC::B3::Opcode toB3Op(WASMBinaryOpType op)	44	inline B3::Opcode toB3Op(WASMBinaryOpType op)
45	{	45	{
46	switch (op) {	46	switch (op) {
47	#define CREATE_CASE(name, op, b3op) case WASMBinaryOpType::name: return b3op;	47	#define CREATE_CASE(name, op, b3op) case WASMBinaryOpType::name: return b3op;
Lines 50-55 inline JSC::B3::Opcode toB3Op(WASMBinaryOpType op) a/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp_sec2
50	}	50	}
51	}	51	}
52		52
		53	inline B3::Opcode toB3Op(WASMUnaryOpType op)
		54	{
		55	switch (op) {
		56	#define CREATE_CASE(name, op, b3op) case WASMUnaryOpType::name: return b3op;
		57	FOR_EACH_WASM_UNARY_OP(CREATE_CASE)
		58	#undef CREATE_CASE
		59	}
		60	}
		61
53	class B3IRGenerator {	62	class B3IRGenerator {
54	public:	63	public:
55	typedef Value* ExpressionType;	64	typedef Value* ExpressionType;
Lines 60-65 public: a/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp_sec3
60	ExpressionType addConstant(WASMValueType, uint64_t);	69	ExpressionType addConstant(WASMValueType, uint64_t);
61		70
62	bool WARN_UNUSED_RETURN binaryOp(WASMBinaryOpType, ExpressionType left, ExpressionType right, ExpressionType& result);	71	bool WARN_UNUSED_RETURN binaryOp(WASMBinaryOpType, ExpressionType left, ExpressionType right, ExpressionType& result);
		72	bool WARN_UNUSED_RETURN unaryOp(WASMUnaryOpType, ExpressionType arg, ExpressionType& result);
63		73
64	bool WARN_UNUSED_RETURN addBlock();	74	bool WARN_UNUSED_RETURN addBlock();
65	bool WARN_UNUSED_RETURN endBlock(Vector<ExpressionType>& expressionStack);	75	bool WARN_UNUSED_RETURN endBlock(Vector<ExpressionType>& expressionStack);
Lines 89-94 void B3IRGenerator::addLocal(WASMValueType, uint32_t) a/Source/JavaScriptCore/wasm/WASMB3IRGenerator.cpp_sec4
89	// TODO: Add locals.	99	// TODO: Add locals.
90	}	100	}
91		101
		102	bool B3IRGenerator::unaryOp(WASMUnaryOpType op, ExpressionType arg, ExpressionType& result)
		103	{
		104	result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), arg);
		105	return true;
		106	}
		107
92	bool B3IRGenerator::binaryOp(WASMBinaryOpType op, ExpressionType left, ExpressionType right, ExpressionType& result)	108	bool B3IRGenerator::binaryOp(WASMBinaryOpType op, ExpressionType left, ExpressionType right, ExpressionType& result)
93	{	109	{
94	result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), left, right);	110	result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), left, right);



    switch (op) {
#define CREATE_CASE(name, id, b3op) case name:
    FOR_EACH_WASM_BINARY_OP(CREATE_CASE) {
#undef CREATE_CASE
        ExpressionType left = m_expressionStack.takeLast();
        ExpressionType right = m_expressionStack.takeLast();
        ExpressionType result;

        return true;
    }

    FOR_EACH_WASM_UNARY_OP(CREATE_CASE) {
        ExpressionType arg = m_expressionStack.takeLast();
        ExpressionType result;
        if (!m_context.unaryOp(static_cast<WASMUnaryOpType>(op), arg, result))
            return false;
        m_expressionStack.append(result);
        return true;
    }
#undef CREATE_CASE

    case WASMOpType::I32Const: {
        uint32_t constant;
        if (!parseVarUInt32(constant))

Lines 39-45 namespace WASM { a/Source/JavaScriptCore/wasm/WASMOps.h_sec1
- a/Source/JavaScriptCore/wasm/WASMOps.h -6 / +38 lines
39	macro(Return, 0x09, NA) \	39	macro(Return, 0x09, NA) \
40	macro(End, 0x0f, NA)	40	macro(End, 0x0f, NA)
41		41
42	#define FOR_EACH_WASM_UNARY_OP(macro)	42	#define FOR_EACH_WASM_UNARY_OP(macro) \
		43	macro(I32Clz, 0x57, Clz) \
		44	/* macro(I32Ctz, 0x58) */ \
		45	/* macro(I32PopCnt, 0x59) */ \
		46	/* macro(I32Eqz, 0x5a) */ \
		47	macro(I64Clz, 0x72, Clz) \
		48	/* macro(I64Ctz, 0x73) */ \
		49	/* macro(I64PopCnt, 0x74) */ \
		50	/* macro(I64Eqz, 0xba) */
43		51
44	#define FOR_EACH_WASM_BINARY_OP(macro) \	52	#define FOR_EACH_WASM_BINARY_OP(macro) \
45	macro(I32Add, 0x40, Add) \	53	macro(I32Add, 0x40, Add) \
Lines 48-54 namespace WASM { a/Source/JavaScriptCore/wasm/WASMOps.h_sec2
48	macro(I32DivS, 0x43, Div) \	56	macro(I32DivS, 0x43, Div) \
49	/* macro(I32DivU, 0x44) */ \	57	/* macro(I32DivU, 0x44) */ \
50	macro(I32RemS, 0x45, Mod) \	58	macro(I32RemS, 0x45, Mod) \
51	macro(I32RemU, 0x46, Mod) \	59	/* macro(I32RemU, 0x46, Mod) */ \
52	macro(I32And, 0x47, BitAnd) \	60	macro(I32And, 0x47, BitAnd) \
53	macro(I32Or, 0x48, BitOr) \	61	macro(I32Or, 0x48, BitOr) \
54	macro(I32Xor, 0x49, BitXor) \	62	macro(I32Xor, 0x49, BitXor) \
Lines 67-72 namespace WASM { a/Source/JavaScriptCore/wasm/WASMOps.h_sec3
67	macro(I32GeS, 0x54, GreaterEqual) \	75	macro(I32GeS, 0x54, GreaterEqual) \
68	macro(I32GtU, 0x55, Above) \	76	macro(I32GtU, 0x55, Above) \
69	macro(I32GeU, 0x56, AboveEqual) \	77	macro(I32GeU, 0x56, AboveEqual) \
		78	macro(I64Add, 0x5b, Add) \
		79	macro(I64Sub, 0x5c, Sub) \
		80	macro(I64Mul, 0x5d, Mul) \
		81	macro(I64DivS, 0x5e, Div) \
		82	/* macro(I64DivU, 0x5f) */ \
		83	macro(I64RemS, 0x60, Mod) \
		84	/* macro(I64RemU, 0x61) */ \
		85	macro(I64And, 0x62, BitAnd) \
		86	macro(I64Or, 0x63, BitOr) \
		87	macro(I64Xor, 0x64, BitXor) \
		88	macro(I64Shl, 0x65, Shl) \
		89	macro(I64ShrU, 0x66, SShr) \
		90	macro(I64ShrS, 0x67, ZShr) \
		91	/* macro(I64RotR, 0xb8) */ \
		92	/* macro(I64RotL, 0xb9) */ \
		93	macro(I64Eq, 0x68, Equal) \
		94	macro(I64Ne, 0x69, NotEqual) \
		95	macro(I64LtS, 0x6a, LessThan) \
		96	macro(I64LeS, 0x6b, LessEqual) \
		97	macro(I64LtU, 0x6c, Below) \
		98	macro(I64LeU, 0x6d, BelowEqual) \
		99
70		100
71	#define FOR_EACH_WASM_OP(macro) \	101	#define FOR_EACH_WASM_OP(macro) \
72	FOR_EACH_WASM_SPECIAL_OP(macro) \	102	FOR_EACH_WASM_SPECIAL_OP(macro) \
Lines 80-95 enum WASMOpType : uint8_t { a/Source/JavaScriptCore/wasm/WASMOps.h_sec4
80	FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)	110	FOR_EACH_WASM_OP(CREATE_ENUM_VALUE)
81	};	111	};
82		112
83
84
85	enum class WASMBinaryOpType : uint8_t {	113	enum class WASMBinaryOpType : uint8_t {
86	FOR_EACH_WASM_BINARY_OP(CREATE_ENUM_VALUE)	114	FOR_EACH_WASM_BINARY_OP(CREATE_ENUM_VALUE)
87	};	115	};
88		116
		117	enum class WASMUnaryOpType : uint8_t {
		118	FOR_EACH_WASM_UNARY_OP(CREATE_ENUM_VALUE)
		119	};
		120
		121	#undef CREATE_ENUM_VALUE
		122
89	} // namespace WASM	123	} // namespace WASM
90		124
91	} // namespace JSC	125	} // namespace JSC
92		126
93	#undef CREATE_ENUM_VALUE
94
95	#endif // ENABLE(WEBASSEMBLY)	127	#endif // ENABLE(WEBASSEMBLY)

Return to Bug 160928

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +16 lines
		1	2016-08-16 Keith Miller <keith_miller@apple.com>
		2
		3	Add WASM support for i64 simple opcodes.
		4	https://bugs.webkit.org/show_bug.cgi?id=160928
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This patch also removes the unsigned int32 mod operator, which is not supported by B3 yet.
		9
		10	* wasm/WASMB3IRGenerator.cpp:
		11	(JSC::WASM::toB3Op):
		12	(JSC::WASM::B3IRGenerator::unaryOp):
		13	* wasm/WASMFunctionParser.h:
		14	(JSC::WASM::WASMFunctionParser<Context>::parseExpression):
		15	* wasm/WASMOps.h:
		16
1	2016-08-16 Mark Lam <mark.lam@apple.com>	17	2016-08-16 Mark Lam <mark.lam@apple.com>
2		18
3	Heap::collectAllGarbage() should work with JSC_useImmortalObjects=true.	19	Heap::collectAllGarbage() should work with JSC_useImmortalObjects=true.

Lines 112-118 bool WASMFunctionParser<Context>::parseExpression(WASMOpType op) a/Source/JavaScriptCore/wasm/WASMFunctionParser.h_sec1
- a/Source/JavaScriptCore/wasm/WASMFunctionParser.h -1 / +10 lines
112	switch (op) {	112	switch (op) {
113	#define CREATE_CASE(name, id, b3op) case name:	113	#define CREATE_CASE(name, id, b3op) case name:
114	FOR_EACH_WASM_BINARY_OP(CREATE_CASE) {	114	FOR_EACH_WASM_BINARY_OP(CREATE_CASE) {
115	#undef CREATE_CASE
116	ExpressionType left = m_expressionStack.takeLast();	115	ExpressionType left = m_expressionStack.takeLast();
117	ExpressionType right = m_expressionStack.takeLast();	116	ExpressionType right = m_expressionStack.takeLast();
118	ExpressionType result;	117	ExpressionType result;
Lines 122-127 bool WASMFunctionParser<Context>::parseExpression(WASMOpType op) a/Source/JavaScriptCore/wasm/WASMFunctionParser.h_sec2
122	return true;	121	return true;
123	}	122	}
124		123
		124	FOR_EACH_WASM_UNARY_OP(CREATE_CASE) {
		125	ExpressionType arg = m_expressionStack.takeLast();
		126	ExpressionType result;
		127	if (!m_context.unaryOp(static_cast<WASMUnaryOpType>(op), arg, result))
		128	return false;
		129	m_expressionStack.append(result);
		130	return true;
		131	}
		132	#undef CREATE_CASE
		133
125	case WASMOpType::I32Const: {	134	case WASMOpType::I32Const: {
126	uint32_t constant;	135	uint32_t constant;
127	if (!parseVarUInt32(constant))	136	if (!parseVarUInt32(constant))