Convert SIMD wasm ops to runtime function calls

src/wasm/wasm-opcodes.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_WASM_OPCODES_H_
 #define V8_WASM_OPCODES_H_
 
 #include "src/machine-type.h"
 #include "src/signature.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 // Binary encoding of local types.
 enum LocalTypeCode {
   kLocalVoid = 0,
   kLocalI32 = 1,
   kLocalI64 = 2,
   kLocalF32 = 3,
-  kLocalF64 = 4
+  kLocalF64 = 4,
+  kLocalS128 = 5
 };
 
 // Binary encoding of memory types.
 enum MemTypeCode {
   kMemI8 = 0,
   kMemU8 = 1,
   kMemI16 = 2,
   kMemU16 = 3,
   kMemI32 = 4,
   kMemU32 = 5,
   kMemI64 = 6,
   kMemU64 = 7,
   kMemF32 = 8,
-  kMemF64 = 9
+  kMemF64 = 9,
+  kMemS128 = 10
 };
 
 // We reuse the internal machine type to represent WebAssembly AST types.
 // A typedef improves readability without adding a whole new type system.
 typedef MachineRepresentation LocalType;
 const LocalType kAstStmt = MachineRepresentation::kNone;
 const LocalType kAstI32 = MachineRepresentation::kWord32;
 const LocalType kAstI64 = MachineRepresentation::kWord64;
 const LocalType kAstF32 = MachineRepresentation::kFloat32;
 const LocalType kAstF64 = MachineRepresentation::kFloat64;
+const LocalType kAstS128 = MachineRepresentation::kSimd128;
 // We use kTagged here because kNone is already used by kAstStmt.
 const LocalType kAstEnd = MachineRepresentation::kTagged;
 
 typedef Signature<LocalType> FunctionSig;
 std::ostream& operator<<(std::ostream& os, const FunctionSig& function);
 
 typedef Vector<const char> WasmName;
 
 typedef int WasmCodePosition;
 const WasmCodePosition kNoCodePosition = -1;
@@ skipping 57 matching lines @@
   V(F32StoreMem, 0x35, f_if)        \
   V(F64StoreMem, 0x36, d_id)
 
 // Load memory expressions.
 #define FOREACH_MISC_MEM_OPCODE(V) \
   V(MemorySize, 0x3b, i_v)         \
   V(GrowMemory, 0x39, i_i)
 
 // Expressions with signatures.
 #define FOREACH_SIMPLE_OPCODE(V)  \
+  FOREACH_SIMD_OPCODE(V)          \
   V(I32Add, 0x40, i_ii)           \
   V(I32Sub, 0x41, i_ii)           \
   V(I32Mul, 0x42, i_ii)           \
   V(I32DivS, 0x43, i_ii)          \
   V(I32DivU, 0x44, i_ii)          \
   V(I32RemS, 0x45, i_ii)          \
   V(I32RemU, 0x46, i_ii)          \
   V(I32And, 0x47, i_ii)           \
   V(I32Ior, 0x48, i_ii)           \
   V(I32Xor, 0x49, i_ii)           \
@@ skipping 138 matching lines @@
   V(I32AsmjsStoreMem8, 0xdb, i_ii)     \
   V(I32AsmjsStoreMem16, 0xdc, i_ii)    \
   V(I32AsmjsStoreMem, 0xdd, i_ii)      \
   V(F32AsmjsStoreMem, 0xde, f_if)      \
   V(F64AsmjsStoreMem, 0xdf, d_id)      \
   V(I32AsmjsSConvertF32, 0xe0, i_f)    \
   V(I32AsmjsUConvertF32, 0xe1, i_f)    \
   V(I32AsmjsSConvertF64, 0xe2, i_d)    \
   V(I32AsmjsUConvertF64, 0xe3, i_d)
 
+// Simd opcodes
+#define FOREACH_SIMD_OPCODE(V) \
+  V(Int32x4Splat, 0xe4, s_i)   \
+  V(Int32x4ExtractLane, 0xe5, i_si)
+
 // All opcodes.
 #define FOREACH_OPCODE(V)     \
   FOREACH_CONTROL_OPCODE(V)   \
   FOREACH_MISC_OPCODE(V)      \
   FOREACH_SIMPLE_OPCODE(V)    \
   FOREACH_STORE_MEM_OPCODE(V) \
   FOREACH_LOAD_MEM_OPCODE(V)  \
   FOREACH_MISC_MEM_OPCODE(V)  \
   FOREACH_ASMJS_COMPAT_OPCODE(V)
 
@@ skipping 18 matching lines @@
   V(f_d, kAstF32, kAstF64)           \
   V(f_i, kAstF32, kAstI32)           \
   V(f_l, kAstF32, kAstI64)           \
   V(d_dd, kAstF64, kAstF64, kAstF64) \
   V(d_d, kAstF64, kAstF64)           \
   V(d_f, kAstF64, kAstF32)           \
   V(d_i, kAstF64, kAstI32)           \
   V(d_l, kAstF64, kAstI64)           \
   V(d_id, kAstF64, kAstI32, kAstF64) \
   V(f_if, kAstF32, kAstI32, kAstF32) \
-  V(l_il, kAstI64, kAstI32, kAstI64)
+  V(l_il, kAstI64, kAstI32, kAstI64) \
+  V(s_i, kAstS128, kAstI32)          \
+  V(i_si, kAstI32, kAstS128, kAstI32)
 
 enum WasmOpcode {
 // Declare expression opcodes.
 #define DECLARE_NAMED_ENUM(name, opcode, sig) kExpr##name = opcode,
   FOREACH_OPCODE(DECLARE_NAMED_ENUM)
 #undef DECLARE_NAMED_ENUM
 };
 
 // The reason for a trap.
 #define FOREACH_WASM_TRAPREASON(V) \
@@ skipping 12 matching lines @@
   kTrapCount
 #undef DECLARE_ENUM
 };
 
 // A collection of opcode-related static methods.
 class WasmOpcodes {
  public:
   static const char* OpcodeName(WasmOpcode opcode);
   static const char* ShortOpcodeName(WasmOpcode opcode);
   static FunctionSig* Signature(WasmOpcode opcode);
+  static bool IsSimd(WasmOpcode opcode);
 
   static int TrapReasonToMessageId(TrapReason reason);
   static const char* TrapReasonMessage(TrapReason reason);
 
   static byte MemSize(MachineType type) {
     return 1 << ElementSizeLog2Of(type.representation());
   }
 
   static LocalTypeCode LocalTypeCodeFor(LocalType type) {
     switch (type) {
       case kAstI32:
         return kLocalI32;
       case kAstI64:
         return kLocalI64;
       case kAstF32:
         return kLocalF32;
       case kAstF64:
         return kLocalF64;
       case kAstStmt:
         return kLocalVoid;
+      case kAstS128:
+        return kLocalS128;
       default:
         UNREACHABLE();
         return kLocalVoid;
     }
   }
 
   static MemTypeCode MemTypeCodeFor(MachineType type) {
     if (type == MachineType::Int8()) {
       return kMemI8;
     } else if (type == MachineType::Uint8()) {
       return kMemU8;
     } else if (type == MachineType::Int16()) {
       return kMemI16;
     } else if (type == MachineType::Uint16()) {
       return kMemU16;
     } else if (type == MachineType::Int32()) {
       return kMemI32;
     } else if (type == MachineType::Uint32()) {
       return kMemU32;
     } else if (type == MachineType::Int64()) {
       return kMemI64;
     } else if (type == MachineType::Uint64()) {
       return kMemU64;
     } else if (type == MachineType::Float32()) {
       return kMemF32;
     } else if (type == MachineType::Float64()) {
       return kMemF64;
+    } else if (type == MachineType::Simd128()) {
+      return kMemS128;
     } else {
       UNREACHABLE();
       return kMemI32;
     }
   }
 
   static MachineType MachineTypeFor(LocalType type) {
     switch (type) {
       case kAstI32:
         return MachineType::Int32();
       case kAstI64:
         return MachineType::Int64();
       case kAstF32:
         return MachineType::Float32();
       case kAstF64:
         return MachineType::Float64();
+      case kAstS128:
+        return MachineType::Simd128();
       case kAstStmt:
         return MachineType::None();
       default:
         UNREACHABLE();
         return MachineType::None();
     }
   }
 
   static LocalType LocalTypeFor(MachineType type) {
     if (type == MachineType::Int8()) {
       return kAstI32;
     } else if (type == MachineType::Uint8()) {
       return kAstI32;
     } else if (type == MachineType::Int16()) {
       return kAstI32;
     } else if (type == MachineType::Uint16()) {
       return kAstI32;
     } else if (type == MachineType::Int32()) {
       return kAstI32;
     } else if (type == MachineType::Uint32()) {
       return kAstI32;
     } else if (type == MachineType::Int64()) {
       return kAstI64;
     } else if (type == MachineType::Uint64()) {
       return kAstI64;
     } else if (type == MachineType::Float32()) {
       return kAstF32;
     } else if (type == MachineType::Float64()) {
       return kAstF64;
+    } else if (type == MachineType::Simd128()) {
+      return kAstS128;
     } else {
       UNREACHABLE();
       return kAstI32;
     }
   }
 
   static WasmOpcode LoadStoreOpcodeOf(MachineType type, bool store) {
     if (type == MachineType::Int8()) {
       return store ? kExprI32StoreMem8 : kExprI32LoadMem8S;
     } else if (type == MachineType::Uint8()) {
@@ skipping 23 matching lines @@
   static char ShortNameOf(LocalType type) {
     switch (type) {
       case kAstI32:
         return 'i';
       case kAstI64:
         return 'l';
       case kAstF32:
         return 'f';
       case kAstF64:
         return 'd';
+      case kAstS128:
+        return 's';
       case kAstStmt:
         return 'v';
       case kAstEnd:
         return 'x';
       default:
         UNREACHABLE();
         return '?';
     }
   }
 
   static const char* TypeName(LocalType type) {
     switch (type) {
       case kAstI32:
         return "i32";
       case kAstI64:
         return "i64";
       case kAstF32:
         return "f32";
       case kAstF64:
         return "f64";
+      case kAstS128:
+        return "s128";
       case kAstStmt:
         return "<stmt>";
       case kAstEnd:
         return "<end>";
       default:
         return "<unknown>";
     }
   }
 };
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_OPCODES_H_