Convert SIMD wasm ops to runtime function calls

src/wasm/ast-decoder.cc

 // 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.
 
 #include "src/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 1001 matching lines @@
             CallImportOperand operand(this, pc_);
             if (Validate(pc_, operand)) {
               TFNode** buffer = PopArgs(operand.sig);
               TFNode* call =
                   BUILD(CallImport, operand.index, buffer, position());
               Push(GetReturnType(operand.sig), call);
             }
             len = 1 + operand.length;
             break;
           }
+          case kSimdPrefix: {
+            if (FLAG_wasm_simd_prototype) {
+              len++;
+              byte simd_index = *(pc_ + 1);
+              opcode = static_cast<WasmOpcode>(opcode << 8 | simd_index);
+              DecodeSimdOpcode(opcode);
+              break;
+            }
+          }
           case kExprJITSingleFunction: {
             if (FLAG_wasm_jit_prototype) {
               JITSingleFunctionOperand operand(this, pc_);
               if (Validate(pc_, operand)) {
                 Value index = Pop(2, kAstI32);
                 Value length = Pop(1, kAstI32);
                 Value base = Pop(0, kAstI32);
                 TFNode* call =
                     BUILD(JITSingleFunction, base.node, length.node, index.node,
                           operand.sig_index, operand.sig, position());
@@ skipping 100 matching lines @@
   int DecodeStoreMem(LocalType type, MachineType mem_type) {
     MemoryAccessOperand operand(this, pc_);
     Value val = Pop(1, type);
     Value index = Pop(0, kAstI32);
     BUILD(StoreMem, mem_type, index.node, operand.offset, operand.alignment,
           val.node, position());
     Push(type, val.node);
     return 1 + operand.length;
   }
 
+  void DecodeSimdOpcode(WasmOpcode opcode) {
+    FunctionSig* sig = WasmOpcodes::Signature(opcode);
+    compiler::NodeVector inputs(sig->parameter_count(), zone_);
+    for (size_t i = sig->parameter_count(); i > 0; i--) {
+      Value val = Pop(static_cast<int>(i - 1), sig->GetParam(i - 1));
+      inputs[i - 1] = val.node;
+    }
+    TFNode* node = BUILD(SimdOp, opcode, inputs);
+    Push(GetReturnType(sig), node);
+  }
+
   void DoReturn() {
     int count = static_cast<int>(sig_->return_count());
     TFNode** buffer = nullptr;
     if (build()) buffer = builder_->Buffer(count);
 
     // Pop return values off the stack in reverse order.
     for (int i = count - 1; i >= 0; i--) {
       Value val = Pop(i, sig_->GetReturn(i));
       if (buffer) buffer[i] = val.node;
     }
@@ skipping 531 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   WasmFullDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8