Changeset 207824 in webkit


Ignore:
Timestamp:
Oct 25, 2016 10:12:20 AM (8 years ago)
Author:
keith_miller@apple.com
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/JavaScriptCore:

  • wasm/WasmB3IRGenerator.cpp:
  • wasm/WasmOps.h:

(JSC::Wasm::isSimple):

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JSTests/ChangeLog

    r207798 r207824  
     12016-10-25  Keith Miller  <keith_miller@apple.com>
     2
     3        Add trivial Wasm conversion opcodes
     4        https://bugs.webkit.org/show_bug.cgi?id=163950
     5
     6        Reviewed by Filip Pizlo.
     7
     8        This patch differentiates between Wasm opcodes that are trivially mapped to a B3 opcode and
     9        those that are not.  Some of the Wasm opcodes that are currently a non-simple opcode will
     10        become simple as we add B3 opcodes for Wasm operations.  The remaining opcodes will need to
     11        be added via patchpoints in a later patch.
     12
     13        * wasm/generate-wasmops-header.js:
     14        (const.template.pragma.once.ENABLE.WEBASSEMBLY.include.cstdint.namespace.JSC.namespace.Wasm.inline.bool.isSimple):
     15        * wasm/wasm.json:
     16
    1172016-10-24  Yusuke Suzuki  <utatane.tea@gmail.com>
    218

  • trunk/JSTests/wasm/generate-wasmops-header.js

    r207781 r207824  
    2828}
    2929
     30const isNormalOp = op => op.category === "arithmetic" || op.category === "conversion" || op.category === "comparison";
     31const isUnaryOp = op => isNormalOp(op) && op.parameter.length === 1;
     32const isBinaryOp = op => isNormalOp(op) && op.parameter.length === 2;
     33
    3034const defines = [
    3135    "#define FOR_EACH_WASM_SPECIAL_OP(macro)",
    … …  
    3337    "\n\n#define FOR_EACH_WASM_CONTROL_FLOW_OP(macro)",
    3438    ...opcodeMacroizer(op => op.category === "control"),
    35     "\n\n#define FOR_EACH_WASM_UNARY_OP(macro)",
    36     ...opcodeMacroizer(op => op.category === "arithmetic" && op.parameter.length === 1),
    37     "\n\n#define FOR_EACH_WASM_BINARY_OP(macro)",
    38     ...opcodeMacroizer(op => (op.category === "arithmetic" || op.category === "comparison") && op.parameter.length === 2),
     39    "\n\n#define FOR_EACH_WASM_SIMPLE_UNARY_OP(macro)",
     40    ...opcodeMacroizer(op => isUnaryOp(op) && op.b3op),
     41    "\n\n#define FOR_EACH_WASM_UNARY_OP(macro) \\\n    FOR_EACH_WASM_SIMPLE_UNARY_OP(macro)",
     42    ...opcodeMacroizer(op => isUnaryOp(op) && !op.b3op),
     43    "\n\n#define FOR_EACH_WASM_SIMPLE_BINARY_OP(macro)",
     44    ...opcodeMacroizer(op => isBinaryOp(op) && op.b3op),
     45    "\n\n#define FOR_EACH_WASM_BINARY_OP(macro) \\\n    FOR_EACH_WASM_SIMPLE_BINARY_OP(macro)",
     46    ...opcodeMacroizer(op => isBinaryOp(op) && !op.b3op),
    3947    "\n\n#define FOR_EACH_WASM_MEMORY_LOAD_OP(macro)",
    4048    ...opcodeMacroizer(op => (op.category === "memory" && op.return.length === 1)),
    … …  
    148156}
    149157
     158inline bool isSimple(UnaryOpType op)
     159{
     160    switch (op) {
     161#define CREATE_CASE(name, id, b3op) case UnaryOpType::name:
     162    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
     163        return true;
     164#undef CREATE_CASE
     165    default:
     166        break;
     167    }
     168    return false;
     169}
     170
     171inline bool isSimple(BinaryOpType op)
     172{
     173    switch (op) {
     174#define CREATE_CASE(name, id, b3op) case BinaryOpType::name:
     175    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
     176        return true;
     177#undef CREATE_CASE
     178    default:
     179        break;
     180    }
     181    return false;
     182}
     183
    150184} } // namespace JSC::Wasm
    151185

  • trunk/JSTests/wasm/wasm.json

    r207781 r207824  
    200200        "i64.trunc_u/f32":     { "category": "conversion", "value": 164, "return": ["i64"],      "parameter": ["f32"],                  "immediate": []                         },
    201201        "i64.trunc_u/f64":     { "category": "conversion", "value": 165, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         },
    202         "i64.extend_s/i32":    { "category": "conversion", "value": 166, "return": ["i64"],      "parameter": ["i32"],                  "immediate": []                         },
    203         "i64.extend_u/i32":    { "category": "conversion", "value": 167, "return": ["i64"],      "parameter": ["i32"],                  "immediate": []                         },
     202        "i64.extend_s/i32":    { "category": "conversion", "value": 166, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "SExt32"       },
     203        "i64.extend_u/i32":    { "category": "conversion", "value": 167, "return": ["i64"],      "parameter": ["i32"],                  "immediate": [], "b3op": "ZExt32"       },
    204204        "f32.convert_s/i32":   { "category": "conversion", "value": 168, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
    205205        "f32.convert_u/i32":   { "category": "conversion", "value": 169, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
    206206        "f32.convert_s/i64":   { "category": "conversion", "value": 170, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
    207207        "f32.convert_u/i64":   { "category": "conversion", "value": 171, "return": ["f32"],      "parameter": ["i64"],                  "immediate": []                         },
    208         "f32.demote/f64":      { "category": "conversion", "value": 172, "return": ["f32"],      "parameter": ["f64"],                  "immediate": []                         },
    209         "f32.reinterpret/i32": { "category": "conversion", "value": 173, "return": ["f32"],      "parameter": ["i32"],                  "immediate": []                         },
     208        "f32.demote/f64":      { "category": "conversion", "value": 172, "return": ["f32"],      "parameter": ["f64"],                  "immediate": [], "b3op": "DoubleToFloat"},
     209        "f32.reinterpret/i32": { "category": "conversion", "value": 173, "return": ["f32"],      "parameter": ["i32"],                  "immediate": [], "b3op": "BitwiseCast"  },
    210210        "f64.convert_s/i32":   { "category": "conversion", "value": 174, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
    211211        "f64.convert_u/i32":   { "category": "conversion", "value": 175, "return": ["f64"],      "parameter": ["i32"],                  "immediate": []                         },
    212212        "f64.convert_s/i64":   { "category": "conversion", "value": 176, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
    213213        "f64.convert_u/i64":   { "category": "conversion", "value": 177, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
    214         "f64.promote/f32":     { "category": "conversion", "value": 178, "return": ["f64"],      "parameter": ["f32"],                  "immediate": []                         },
    215         "f64.reinterpret/i64": { "category": "conversion", "value": 179, "return": ["f64"],      "parameter": ["i64"],                  "immediate": []                         },
    216         "i32.reinterpret/f32": { "category": "conversion", "value": 180, "return": ["i32"],      "parameter": ["f32"],                  "immediate": []                         },
    217         "i64.reinterpret/f64": { "category": "conversion", "value": 181, "return": ["i64"],      "parameter": ["f64"],                  "immediate": []                         }
     214        "f64.promote/f32":     { "category": "conversion", "value": 178, "return": ["f64"],      "parameter": ["f32"],                  "immediate": [], "b3op": "FloatToDouble"},
     215        "f64.reinterpret/i64": { "category": "conversion", "value": 179, "return": ["f64"],      "parameter": ["i64"],                  "immediate": [], "b3op": "BitwiseCast"  },
     216        "i32.reinterpret/f32": { "category": "conversion", "value": 180, "return": ["i32"],      "parameter": ["f32"],                  "immediate": [], "b3op": "BitwiseCast"  },
     217        "i64.reinterpret/f64": { "category": "conversion", "value": 181, "return": ["i64"],      "parameter": ["f64"],                  "immediate": [], "b3op": "BitwiseCast"  }
    218218    }
    219219}

  • trunk/Source/JavaScriptCore/ChangeLog

    r207798 r207824  
     12016-10-25  Keith Miller  <keith_miller@apple.com>
     2
     3        Add trivial Wasm conversion opcodes
     4        https://bugs.webkit.org/show_bug.cgi?id=163950
     5
     6        Reviewed by Filip Pizlo.
     7
     8        This patch differentiates between Wasm opcodes that are trivially mapped to a B3 opcode and
     9        those that are not.  Some of the Wasm opcodes that are currently a non-simple opcode will
     10        become simple as we add B3 opcodes for Wasm operations.  The remaining opcodes will need to
     11        be added via patchpoints in a later patch.
     12
     13        * wasm/WasmB3IRGenerator.cpp:
     14        * wasm/WasmOps.h:
     15        (JSC::Wasm::isSimple):
     16
    1172016-10-24  Yusuke Suzuki  <utatane.tea@gmail.com>
    218

  • trunk/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp

    r207781 r207824  
    449449bool B3IRGenerator::unaryOp(UnaryOpType op, ExpressionType arg, ExpressionType& result)
    450450{
     451    if (!isSimple(op))
     452        return false;
    451453    result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), arg);
    452454    return true;
    … …  
    455457bool B3IRGenerator::binaryOp(BinaryOpType op, ExpressionType left, ExpressionType right, ExpressionType& result)
    456458{
     459    if (!isSimple(op))
     460        return false;
    457461    result = m_currentBlock->appendNew<Value>(m_proc, toB3Op(op), Origin(), left, right);
    458462    return true;

  • trunk/Source/JavaScriptCore/wasm/WasmOps.h

    r207781 r207824  
    6262    macro(End, 0xf, Oops)
    6363
     64#define FOR_EACH_WASM_SIMPLE_UNARY_OP(macro) \
     65    macro(I32Clz, 0x57, Clz) \
     66    macro(I64Clz, 0x72, Clz) \
     67    macro(F32Abs, 0x7b, Abs) \
     68    macro(F32Ceil, 0x7e, Ceil) \
     69    macro(F32Floor, 0x7f, Floor) \
     70    macro(F64Abs, 0x8f, Abs) \
     71    macro(F64Ceil, 0x92, Ceil) \
     72    macro(F64Floor, 0x93, Floor) \
     73    macro(I64ExtendSI32, 0xa6, SExt32) \
     74    macro(I64ExtendUI32, 0xa7, ZExt32) \
     75    macro(F32DemoteF64, 0xac, DoubleToFloat) \
     76    macro(F32ReinterpretI32, 0xad, BitwiseCast) \
     77    macro(F64PromoteF32, 0xb2, FloatToDouble) \
     78    macro(F64ReinterpretI64, 0xb3, BitwiseCast) \
     79    macro(I32ReinterpretF32, 0xb4, BitwiseCast) \
     80    macro(I64ReinterpretF64, 0xb5, BitwiseCast)
     81
    6482#define FOR_EACH_WASM_UNARY_OP(macro) \
    65     macro(I32Clz, 0x57, Clz) \
     83    FOR_EACH_WASM_SIMPLE_UNARY_OP(macro) \
    6684    macro(I32Ctz, 0x58, Oops) \
    6785    macro(I32Popcnt, 0x59, Oops) \
    68     macro(I64Clz, 0x72, Clz) \
     86    macro(I32Eqz, 0x5a, Oops) \
    6987    macro(I64Ctz, 0x73, Oops) \
    7088    macro(I64Popcnt, 0x74, Oops) \
    71     macro(F32Abs, 0x7b, Abs) \
     89    macro(I64Eqz, 0xba, Oops) \
    7290    macro(F32Neg, 0x7c, Oops) \
    7391    macro(F32Copysign, 0x7d, Oops) \
    74     macro(F32Ceil, 0x7e, Ceil) \
    75     macro(F32Floor, 0x7f, Floor) \
    7692    macro(F32Trunc, 0x80, Oops) \
    7793    macro(F32Nearest, 0x81, Oops) \
    7894    macro(F32Sqrt, 0x82, Oops) \
    79     macro(F64Abs, 0x8f, Abs) \
    8095    macro(F64Neg, 0x90, Oops) \
    8196    macro(F64Copysign, 0x91, Oops) \
    82     macro(F64Ceil, 0x92, Ceil) \
    83     macro(F64Floor, 0x93, Floor) \
    8497    macro(F64Trunc, 0x94, Oops) \
    8598    macro(F64Nearest, 0x95, Oops) \
    86     macro(F64Sqrt, 0x96, Oops)
    87 
    88 #define FOR_EACH_WASM_BINARY_OP(macro) \
     99    macro(F64Sqrt, 0x96, Oops) \
     100    macro(I32TruncSF32, 0x9d, Oops) \
     101    macro(I32TruncSF64, 0x9e, Oops) \
     102    macro(I32TruncUF32, 0x9f, Oops) \
     103    macro(I32TruncUF64, 0xa0, Oops) \
     104    macro(I32WrapI64, 0xa1, Oops) \
     105    macro(I64TruncSF32, 0xa2, Oops) \
     106    macro(I64TruncSF64, 0xa3, Oops) \
     107    macro(I64TruncUF32, 0xa4, Oops) \
     108    macro(I64TruncUF64, 0xa5, Oops) \
     109    macro(F32ConvertSI32, 0xa8, Oops) \
     110    macro(F32ConvertUI32, 0xa9, Oops) \
     111    macro(F32ConvertSI64, 0xaa, Oops) \
     112    macro(F32ConvertUI64, 0xab, Oops) \
     113    macro(F64ConvertSI32, 0xae, Oops) \
     114    macro(F64ConvertUI32, 0xaf, Oops) \
     115    macro(F64ConvertSI64, 0xb0, Oops) \
     116    macro(F64ConvertUI64, 0xb1, Oops)
     117
     118#define FOR_EACH_WASM_SIMPLE_BINARY_OP(macro) \
    89119    macro(I32Add, 0x40, Add) \
    90120    macro(I32Sub, 0x41, Sub) \
    91121    macro(I32Mul, 0x42, Mul) \
    92122    macro(I32DivS, 0x43, Div) \
    93     macro(I32DivU, 0x44, Oops) \
    94123    macro(I32RemS, 0x45, Mod) \
    95     macro(I32RemU, 0x46, Oops) \
    96124    macro(I32And, 0x47, BitAnd) \
    97125    macro(I32Or, 0x48, BitOr) \
    … …  
    100128    macro(I32ShrU, 0x4b, SShr) \
    101129    macro(I32ShrS, 0x4c, ZShr) \
    102     macro(I32Rotr, 0xb6, Oops) \
    103     macro(I32Rotl, 0xb7, Oops) \
    104130    macro(I32Eq, 0x4d, Equal) \
    105131    macro(I32Ne, 0x4e, NotEqual) \
    … …  
    116142    macro(I64Mul, 0x5d, Mul) \
    117143    macro(I64DivS, 0x5e, Div) \
    118     macro(I64DivU, 0x5f, Oops) \
    119144    macro(I64RemS, 0x60, Mod) \
    120     macro(I64RemU, 0x61, Oops) \
    121145    macro(I64And, 0x62, BitAnd) \
    122146    macro(I64Or, 0x63, BitOr) \
    … …  
    125149    macro(I64ShrU, 0x66, SShr) \
    126150    macro(I64ShrS, 0x67, ZShr) \
    127     macro(I64Rotr, 0xb8, Oops) \
    128     macro(I64Rotl, 0xb9, Oops) \
    129151    macro(I64Eq, 0x68, Equal) \
    130152    macro(I64Ne, 0x69, NotEqual) \
    … …  
    141163    macro(F32Mul, 0x77, Mul) \
    142164    macro(F32Div, 0x78, Div) \
    143     macro(F32Min, 0x79, Oops) \
    144     macro(F32Max, 0x7a, Oops) \
    145165    macro(F32Eq, 0x83, Equal) \
    146166    macro(F32Ne, 0x84, NotEqual) \
    … …  
    153173    macro(F64Mul, 0x8b, Mul) \
    154174    macro(F64Div, 0x8c, Div) \
    155     macro(F64Min, 0x8d, Oops) \
    156     macro(F64Max, 0x8e, Oops) \
    157175    macro(F64Eq, 0x97, Equal) \
    158176    macro(F64Ne, 0x98, NotEqual) \
    … …  
    161179    macro(F64Gt, 0x9b, GreaterThan) \
    162180    macro(F64Ge, 0x9c, GreaterEqual)
     181
     182#define FOR_EACH_WASM_BINARY_OP(macro) \
     183    FOR_EACH_WASM_SIMPLE_BINARY_OP(macro) \
     184    macro(I32DivU, 0x44, Oops) \
     185    macro(I32RemU, 0x46, Oops) \
     186    macro(I32Rotr, 0xb6, Oops) \
     187    macro(I32Rotl, 0xb7, Oops) \
     188    macro(I64DivU, 0x5f, Oops) \
     189    macro(I64RemU, 0x61, Oops) \
     190    macro(I64Rotr, 0xb8, Oops) \
     191    macro(I64Rotl, 0xb9, Oops) \
     192    macro(F32Min, 0x79, Oops) \
     193    macro(F32Max, 0x7a, Oops) \
     194    macro(F64Min, 0x8d, Oops) \
     195    macro(F64Max, 0x8e, Oops)
    163196
    164197#define FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \
    … …  
    244277}
    245278
     279inline bool isSimple(UnaryOpType op)
     280{
     281    switch (op) {
     282#define CREATE_CASE(name, id, b3op) case UnaryOpType::name:
     283    FOR_EACH_WASM_SIMPLE_UNARY_OP(CREATE_CASE)
     284        return true;
     285#undef CREATE_CASE
     286    default:
     287        break;
     288    }
     289    return false;
     290}
     291
     292inline bool isSimple(BinaryOpType op)
     293{
     294    switch (op) {
     295#define CREATE_CASE(name, id, b3op) case BinaryOpType::name:
     296    FOR_EACH_WASM_SIMPLE_BINARY_OP(CREATE_CASE)
     297        return true;
     298#undef CREATE_CASE
     299    default:
     300        break;
     301    }
     302    return false;
     303}
     304
    246305} } // namespace JSC::Wasm
    247306
Note: See TracChangeset for help on using the changeset viewer.