[webkit-changes] [207824] trunk

Tue, 25 Oct 2016 10:12:13 -0700

Title: [207824] trunk
Revision
207824
Author
[email protected]
Date
2016-10-25 10:12:20 -0700 (Tue, 25 Oct 2016)

Log Message

Add trivial Wasm conversion opcodes
https://bugs.webkit.org/show_bug.cgi?id=163950

Reviewed by Filip Pizlo.

This patch differentiates between Wasm opcodes that are trivially mapped to a B3 opcode and
those that are not.  Some of the Wasm opcodes that are currently a non-simple opcode will
become simple as we add B3 opcodes for Wasm operations.  The remaining opcodes will need to
be added via patchpoints in a later patch.

JSTests:

* wasm/generate-wasmops-header.js:
(const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.Wasm.inline.bool.isSimple):
* wasm/wasm.json:

Source/_javascript_Core:

* wasm/WasmB3IRGenerator.cpp:
* wasm/WasmOps.h:
(JSC::Wasm::isSimple):

Modified Paths

Diff

Modified: trunk/JSTests/ChangeLog (207823 => 207824)


--- trunk/JSTests/ChangeLog	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/JSTests/ChangeLog	2016-10-25 17:12:20 UTC (rev 207824)
@@ -1,3 +1,19 @@
+2016-10-25  Keith Miller  <[email protected]>
+
+        Add trivial Wasm conversion opcodes
+        https://bugs.webkit.org/show_bug.cgi?id=163950
+
+        Reviewed by Filip Pizlo.
+
+        This patch differentiates between Wasm opcodes that are trivially mapped to a B3 opcode and
+        those that are not.  Some of the Wasm opcodes that are currently a non-simple opcode will
+        become simple as we add B3 opcodes for Wasm operations.  The remaining opcodes will need to
+        be added via patchpoints in a later patch.
+
+        * wasm/generate-wasmops-header.js:
+        (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.Wasm.inline.bool.isSimple):
+        * wasm/wasm.json:
+
 2016-10-24  Yusuke Suzuki  <[email protected]>
 
         Arrow functions with concise bodies cannot return regular expressions

Modified: trunk/JSTests/wasm/generate-wasmops-header.js (207823 => 207824)


--- trunk/JSTests/wasm/generate-wasmops-header.js	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/JSTests/wasm/generate-wasmops-header.js	2016-10-25 17:12:20 UTC (rev 207824)
@@ -27,15 +27,23 @@
         yield cppMacro(op.name, op.opcode.value, op.opcode.b3op || "Oops");
 }
 
+const isNormalOp = op => op.category === "arithmetic" || op.category === "conversion" || op.category === "comparison";
+const isUnaryOp = op => isNormalOp(op) && op.parameter.length === 1;
+const isBinaryOp = op => isNormalOp(op) && op.parameter.length === 2;
+
 const defines = [
     "#define FOR_EACH_WASM_SPECIAL_OP(macro)",
     ...opcodeMacroizer(op => op.category === "special" || op.category === "call"),
     "\n\n#define FOR_EACH_WASM_CONTROL_FLOW_OP(macro)",
     ...opcodeMacroizer(op => op.category === "control"),
-    "\n\n#define FOR_EACH_WASM_UNARY_OP(macro)",
-    ...opcodeMacroizer(op => op.category === "arithmetic" && op.parameter.length === 1),
-    "\n\n#define FOR_EACH_WASM_BINARY_OP(macro)",
-    ...opcodeMacroizer(op => (op.category === "arithmetic" || op.category === "comparison") && op.parameter.length === 2),
+    "\n\n#define FOR_EACH_WASM_SIMPLE_UNARY_OP(macro)",
+    ...opcodeMacroizer(op => isUnaryOp(op) && op.b3op),
+    "\n\n#define FOR_EACH_WASM_UNARY_OP(macro) \\\n    FOR_EACH_WASM_SIMPLE_UNARY_OP(macro)",
+    ...opcodeMacroizer(op => isUnaryOp(op) && !op.b3op),
+    "\n\n#define FOR_EACH_WASM_SIMPLE_BINARY_OP(macro)",
+    ...opcodeMacroizer(op => isBinaryOp(op) && op.b3op),
+    "\n\n#define FOR_EACH_WASM_BINARY_OP(macro) \\\n    FOR_EACH_WASM_SIMPLE_BINARY_OP(macro)",
+    ...opcodeMacroizer(op => isBinaryOp(op) && !op.b3op),
     "\n\n#define FOR_EACH_WASM_MEMORY_LOAD_OP(macro)",
     ...opcodeMacroizer(op => (op.category === "memory" && op.return.length === 1)),
     "\n\n#define FOR_EACH_WASM_MEMORY_STORE_OP(macro)",
@@ -147,6 +155,32 @@
     return false;
 }
 
+inline bool isSimple(UnaryOpType op)
+{
+    switch (op) {
+#define CREATE_CASE(name, id, b3op) case UnaryOpType::name:
+    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
+        return true;
+#undef CREATE_CASE
+    default:
+        break;
+    }
+    return false;
+}
+
+inline bool isSimple(BinaryOpType op)
+{
+    switch (op) {
+#define CREATE_CASE(name, id, b3op) case BinaryOpType::name:
+    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
+        return true;
+#undef CREATE_CASE
+    default:
+        break;
+    }
+    return false;
+}
+
 } } // namespace JSC::Wasm
 
 #endif // ENABLE(WEBASSEMBLY)

Modified: trunk/JSTests/wasm/wasm.json (207823 => 207824)


--- trunk/JSTests/wasm/wasm.json	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/JSTests/wasm/wasm.json	2016-10-25 17:12:20 UTC (rev 207824)
@@ -199,21 +199,21 @@
         "i64.trunc_s/f64":     { "category": "conversion", "value": 163, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
         "i64.trunc_u/f32":     { "category": "conversion", "value": 164, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
         "i64.trunc_u/f64":     { "category": "conversion", "value": 165, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
-        "i64.extend_s/i32":    { "category": "conversion", "value": 166, "return": ["i64"],      "parameter": ["i32"],                  "immediate": []                         },
-        "i64.extend_u/i32":    { "category": "conversion", "value": 167, "return": ["i64"],      "parameter": ["i32"],                  "immediate": []                         },
+        "i64.extend_s/i32":    { "category": "conversion", "value": 166, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "SExt32"       },
+        "i64.extend_u/i32":    { "category": "conversion", "value": 167, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "ZExt32"       },
         "f32.convert_s/i32":   { "category": "conversion", "value": 168, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
         "f32.convert_u/i32":   { "category": "conversion", "value": 169, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
         "f32.convert_s/i64":   { "category": "conversion", "value": 170, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
         "f32.convert_u/i64":   { "category": "conversion", "value": 171, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
-        "f32.demote/f64":      { "category": "conversion", "value": 172, "return": ["f32"],      "parameter": ["f64"],                  "immediate": []                         },
-        "f32.reinterpret/i32": { "category": "conversion", "value": 173, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
+        "f32.demote/f64":      { "category": "conversion", "value": 172, "return": ["f32"],      "parameter": ["f64"],                  "immediate": [], "b3op": "DoubleToFloat"},
+        "f32.reinterpret/i32": { "category": "conversion", "value": 173, "return": ["f32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "BitwiseCast"  },
         "f64.convert_s/i32":   { "category": "conversion", "value": 174, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
         "f64.convert_u/i32":   { "category": "conversion", "value": 175, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
         "f64.convert_s/i64":   { "category": "conversion", "value": 176, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
         "f64.convert_u/i64":   { "category": "conversion", "value": 177, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
-        "f64.promote/f32":     { "category": "conversion", "value": 178, "return": ["f64"],      "parameter": ["f32"],                  "immediate": []                         },
-        "f64.reinterpret/i64": { "category": "conversion", "value": 179, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
-        "i32.reinterpret/f32": { "category": "conversion", "value": 180, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
-        "i64.reinterpret/f64": { "category": "conversion", "value": 181, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         }
+        "f64.promote/f32":     { "category": "conversion", "value": 178, "return": ["f64"],      "parameter": ["f32"],                  "immediate": [], "b3op": "FloatToDouble"},
+        "f64.reinterpret/i64": { "category": "conversion", "value": 179, "return": ["f64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "BitwiseCast"  },
+        "i32.reinterpret/f32": { "category": "conversion", "value": 180, "return": ["i32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "BitwiseCast"  },
+        "i64.reinterpret/f64": { "category": "conversion", "value": 181, "return": ["i64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "BitwiseCast"  }
     }
 }

Modified: trunk/Source/_javascript_Core/ChangeLog (207823 => 207824)


--- trunk/Source/_javascript_Core/ChangeLog	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/Source/_javascript_Core/ChangeLog	2016-10-25 17:12:20 UTC (rev 207824)
@@ -1,3 +1,19 @@
+2016-10-25  Keith Miller  <[email protected]>
+
+        Add trivial Wasm conversion opcodes
+        https://bugs.webkit.org/show_bug.cgi?id=163950
+
+        Reviewed by Filip Pizlo.
+
+        This patch differentiates between Wasm opcodes that are trivially mapped to a B3 opcode and
+        those that are not.  Some of the Wasm opcodes that are currently a non-simple opcode will
+        become simple as we add B3 opcodes for Wasm operations.  The remaining opcodes will need to
+        be added via patchpoints in a later patch.
+
+        * wasm/WasmB3IRGenerator.cpp:
+        * wasm/WasmOps.h:
+        (JSC::Wasm::isSimple):
+
 2016-10-24  Yusuke Suzuki  <[email protected]>
 
         Arrow functions with concise bodies cannot return regular expressions

Modified: trunk/Source/_javascript_Core/wasm/WasmB3IRGenerator.cpp (207823 => 207824)


--- trunk/Source/_javascript_Core/wasm/WasmB3IRGenerator.cpp	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/Source/_javascript_Core/wasm/WasmB3IRGenerator.cpp	2016-10-25 17:12:20 UTC (rev 207824)
@@ -448,6 +448,8 @@
 
 bool B3IRGenerator::unaryOp(UnaryOpType op, ExpressionType arg, ExpressionType& result)
 {
+    if (!isSimple(op))
+        return false;
     result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), arg);
     return true;
 }
@@ -454,6 +456,8 @@
 
 bool B3IRGenerator::binaryOp(BinaryOpType op, ExpressionType left, ExpressionType right, ExpressionType& result)
 {
+    if (!isSimple(op))
+        return false;
     result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), left, right);
     return true;
 }

Modified: trunk/Source/_javascript_Core/wasm/WasmOps.h (207823 => 207824)


--- trunk/Source/_javascript_Core/wasm/WasmOps.h	2016-10-25 16:34:32 UTC (rev 207823)
+++ trunk/Source/_javascript_Core/wasm/WasmOps.h	2016-10-25 17:12:20 UTC (rev 207824)
@@ -61,38 +61,66 @@
     macro(Nop, 0xa, Oops) \
     macro(End, 0xf, Oops)
 
+#define FOR_EACH_WASM_SIMPLE_UNARY_OP(macro) \
+    macro(I32Clz, 0x57, Clz) \
+    macro(I64Clz, 0x72, Clz) \
+    macro(F32Abs, 0x7b, Abs) \
+    macro(F32Ceil, 0x7e, Ceil) \
+    macro(F32Floor, 0x7f, Floor) \
+    macro(F64Abs, 0x8f, Abs) \
+    macro(F64Ceil, 0x92, Ceil) \
+    macro(F64Floor, 0x93, Floor) \
+    macro(I64ExtendSI32, 0xa6, SExt32) \
+    macro(I64ExtendUI32, 0xa7, ZExt32) \
+    macro(F32DemoteF64, 0xac, DoubleToFloat) \
+    macro(F32ReinterpretI32, 0xad, BitwiseCast) \
+    macro(F64PromoteF32, 0xb2, FloatToDouble) \
+    macro(F64ReinterpretI64, 0xb3, BitwiseCast) \
+    macro(I32ReinterpretF32, 0xb4, BitwiseCast) \
+    macro(I64ReinterpretF64, 0xb5, BitwiseCast)
+
 #define FOR_EACH_WASM_UNARY_OP(macro) \
-    macro(I32Clz, 0x57, Clz) \
+    FOR_EACH_WASM_SIMPLE_UNARY_OP(macro) \
     macro(I32Ctz, 0x58, Oops) \
     macro(I32Popcnt, 0x59, Oops) \
-    macro(I64Clz, 0x72, Clz) \
+    macro(I32Eqz, 0x5a, Oops) \
     macro(I64Ctz, 0x73, Oops) \
     macro(I64Popcnt, 0x74, Oops) \
-    macro(F32Abs, 0x7b, Abs) \
+    macro(I64Eqz, 0xba, Oops) \
     macro(F32Neg, 0x7c, Oops) \
     macro(F32Copysign, 0x7d, Oops) \
-    macro(F32Ceil, 0x7e, Ceil) \
-    macro(F32Floor, 0x7f, Floor) \
     macro(F32Trunc, 0x80, Oops) \
     macro(F32Nearest, 0x81, Oops) \
     macro(F32Sqrt, 0x82, Oops) \
-    macro(F64Abs, 0x8f, Abs) \
     macro(F64Neg, 0x90, Oops) \
     macro(F64Copysign, 0x91, Oops) \
-    macro(F64Ceil, 0x92, Ceil) \
-    macro(F64Floor, 0x93, Floor) \
     macro(F64Trunc, 0x94, Oops) \
     macro(F64Nearest, 0x95, Oops) \
-    macro(F64Sqrt, 0x96, Oops)
+    macro(F64Sqrt, 0x96, Oops) \
+    macro(I32TruncSF32, 0x9d, Oops) \
+    macro(I32TruncSF64, 0x9e, Oops) \
+    macro(I32TruncUF32, 0x9f, Oops) \
+    macro(I32TruncUF64, 0xa0, Oops) \
+    macro(I32WrapI64, 0xa1, Oops) \
+    macro(I64TruncSF32, 0xa2, Oops) \
+    macro(I64TruncSF64, 0xa3, Oops) \
+    macro(I64TruncUF32, 0xa4, Oops) \
+    macro(I64TruncUF64, 0xa5, Oops) \
+    macro(F32ConvertSI32, 0xa8, Oops) \
+    macro(F32ConvertUI32, 0xa9, Oops) \
+    macro(F32ConvertSI64, 0xaa, Oops) \
+    macro(F32ConvertUI64, 0xab, Oops) \
+    macro(F64ConvertSI32, 0xae, Oops) \
+    macro(F64ConvertUI32, 0xaf, Oops) \
+    macro(F64ConvertSI64, 0xb0, Oops) \
+    macro(F64ConvertUI64, 0xb1, Oops)
 
-#define FOR_EACH_WASM_BINARY_OP(macro) \
+#define FOR_EACH_WASM_SIMPLE_BINARY_OP(macro) \
     macro(I32Add, 0x40, Add) \
     macro(I32Sub, 0x41, Sub) \
     macro(I32Mul, 0x42, Mul) \
     macro(I32DivS, 0x43, Div) \
-    macro(I32DivU, 0x44, Oops) \
     macro(I32RemS, 0x45, Mod) \
-    macro(I32RemU, 0x46, Oops) \
     macro(I32And, 0x47, BitAnd) \
     macro(I32Or, 0x48, BitOr) \
     macro(I32Xor, 0x49, BitXor) \
@@ -99,8 +127,6 @@
     macro(I32Shl, 0x4a, Shl) \
     macro(I32ShrU, 0x4b, SShr) \
     macro(I32ShrS, 0x4c, ZShr) \
-    macro(I32Rotr, 0xb6, Oops) \
-    macro(I32Rotl, 0xb7, Oops) \
     macro(I32Eq, 0x4d, Equal) \
     macro(I32Ne, 0x4e, NotEqual) \
     macro(I32LtS, 0x4f, LessThan) \
@@ -115,9 +141,7 @@
     macro(I64Sub, 0x5c, Sub) \
     macro(I64Mul, 0x5d, Mul) \
     macro(I64DivS, 0x5e, Div) \
-    macro(I64DivU, 0x5f, Oops) \
     macro(I64RemS, 0x60, Mod) \
-    macro(I64RemU, 0x61, Oops) \
     macro(I64And, 0x62, BitAnd) \
     macro(I64Or, 0x63, BitOr) \
     macro(I64Xor, 0x64, BitXor) \
@@ -124,8 +148,6 @@
     macro(I64Shl, 0x65, Shl) \
     macro(I64ShrU, 0x66, SShr) \
     macro(I64ShrS, 0x67, ZShr) \
-    macro(I64Rotr, 0xb8, Oops) \
-    macro(I64Rotl, 0xb9, Oops) \
     macro(I64Eq, 0x68, Equal) \
     macro(I64Ne, 0x69, NotEqual) \
     macro(I64LtS, 0x6a, LessThan) \
@@ -140,8 +162,6 @@
     macro(F32Sub, 0x76, Sub) \
     macro(F32Mul, 0x77, Mul) \
     macro(F32Div, 0x78, Div) \
-    macro(F32Min, 0x79, Oops) \
-    macro(F32Max, 0x7a, Oops) \
     macro(F32Eq, 0x83, Equal) \
     macro(F32Ne, 0x84, NotEqual) \
     macro(F32Lt, 0x85, LessThan) \
@@ -152,8 +172,6 @@
     macro(F64Sub, 0x8a, Sub) \
     macro(F64Mul, 0x8b, Mul) \
     macro(F64Div, 0x8c, Div) \
-    macro(F64Min, 0x8d, Oops) \
-    macro(F64Max, 0x8e, Oops) \
     macro(F64Eq, 0x97, Equal) \
     macro(F64Ne, 0x98, NotEqual) \
     macro(F64Lt, 0x99, LessThan) \
@@ -161,6 +179,21 @@
     macro(F64Gt, 0x9b, GreaterThan) \
     macro(F64Ge, 0x9c, GreaterEqual)
 
+#define FOR_EACH_WASM_BINARY_OP(macro) \
+    FOR_EACH_WASM_SIMPLE_BINARY_OP(macro) \
+    macro(I32DivU, 0x44, Oops) \
+    macro(I32RemU, 0x46, Oops) \
+    macro(I32Rotr, 0xb6, Oops) \
+    macro(I32Rotl, 0xb7, Oops) \
+    macro(I64DivU, 0x5f, Oops) \
+    macro(I64RemU, 0x61, Oops) \
+    macro(I64Rotr, 0xb8, Oops) \
+    macro(I64Rotl, 0xb9, Oops) \
+    macro(F32Min, 0x79, Oops) \
+    macro(F32Max, 0x7a, Oops) \
+    macro(F64Min, 0x8d, Oops) \
+    macro(F64Max, 0x8e, Oops)
+
 #define FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \
     macro(I32Load8S, 0x20, Oops) \
     macro(I32Load8U, 0x21, Oops) \
@@ -243,6 +276,32 @@
     return false;
 }
 
+inline bool isSimple(UnaryOpType op)
+{
+    switch (op) {
+#define CREATE_CASE(name, id, b3op) case UnaryOpType::name:
+    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
+        return true;
+#undef CREATE_CASE
+    default:
+        break;
+    }
+    return false;
+}
+
+inline bool isSimple(BinaryOpType op)
+{
+    switch (op) {
+#define CREATE_CASE(name, id, b3op) case BinaryOpType::name:
+    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
+        return true;
+#undef CREATE_CASE
+    default:
+        break;
+    }
+    return false;
+}
+
 } } // namespace JSC::Wasm
 
 #endif // ENABLE(WEBASSEMBLY)

_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to