Revert of Convert SIMD wasm ops to runtime function calls (patchset #17...

Revert of Convert SIMD wasm ops to runtime function calls (patchset #17 id:320001 of https://codereview.chromium.org/1991143002/ )

Reason for revert:
[Sheriff] Violates msan and tsan:
https://build.chromium.org/p/client.v8/builders/V8%20Linux%20-%20arm64%20-%20sim%20-%20MSAN/builds/9663
https://build.chromium.org/p/client.v8/builders/V8%20Linux64%20TSAN/builds/10670

Original issue's description:
> Convert SIMD machine ops to runtime function calls
>  - Add Simd128 type to Wasm AST types
>  - Add a pass that converts SIMD machine ops to runtime calls
>  - Sample opcodes Int32x4Splat, Int32x4ExtractLane and test
>  - Separate out generic SIMD Machine ops as these cannot be
>  handled by runtime functions just yet.
>
> LOG=N
> BUG=v8:4124
>
> R=bradnelson@chromium.org, bbudge@chromium.org, titzer@chromium.org
>
> Committed: https://crrev.com/73df92fc2fdbbfadc17e8ab4e58ec56ae2b3d91a
> Cr-Commit-Position: refs/heads/master@{#37789}

TBR=bbudge@chromium.org,bradnelson@chromium.org,titzer@chromium.org,gdeepti@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:4124

Review-Url: https://codereview.chromium.org/2154723002
Cr-Commit-Position: refs/heads/master@{#37790}

BUILD.gn

@@ -1029,8 +1029,6 @@ v8_source_set("v8_base") {
     "src/compiler/scheduler.h",
     "src/compiler/select-lowering.cc",
     "src/compiler/select-lowering.h",
-    "src/compiler/simd-lowering.cc",
-    "src/compiler/simd-lowering.h",
     "src/compiler/simplified-lowering.cc",
     "src/compiler/simplified-lowering.h",
     "src/compiler/simplified-operator-reducer.cc",

src/compiler/simd-lowering.cc

-// Copyright 2016 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/compiler/simd-lowering.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-static ConversionSignature* SigCreateInt32x4;
-static ConversionSignature* SigCreateFloat32x4;
-static ConversionSignature* SigCreateInt16x8;
-static ConversionSignature* SigCreateInt8x16;
-static ConversionSignature* SigExtractLaneInt;
-static ConversionSignature* SigExtractLaneFloat;
-static ConversionSignature* SigDefault;
-
-SimdLowering::~SimdLowering() {}
-
-void SimdLowering::InitializeSignatures() {
-  // Initialize signatures for runtime calls
-  const int kReturnCount = 1;
-  const int kBinop = 2;
-  const int kSimd32x4 = 4;
-  const int kSimd16x8 = 8;
-  const int kSimd8x16 = 16;
-
-  ConversionSignature::Builder CreateInt32x4Builder(zone_, kReturnCount,
-                                                    kSimd32x4);
-  ConversionSignature::Builder CreateFloat32x4Builder(zone_, kReturnCount,
-                                                      kSimd32x4);
-  ConversionSignature::Builder CreateInt16x8Builder(zone_, kReturnCount,
-                                                    kSimd16x8);
-  ConversionSignature::Builder CreateInt8x16Builder(zone_, kReturnCount,
-                                                    kSimd8x16);
-  ConversionSignature::Builder ExtractLaneIntBuilder(zone_, kReturnCount,
-                                                     kBinop);
-  ConversionSignature::Builder ExtractLaneFloatBuilder(zone_, kReturnCount,
-                                                       kBinop);
-  ConversionSignature::Builder DefaultBuilder(zone_, kReturnCount, kSimd8x16);
-
-  // Initialize Signatures for create functions
-  for (int i = 0; i < kSimd32x4; i++) {
-    CreateInt32x4Builder.AddParam(Conversion::kInt32);
-    CreateFloat32x4Builder.AddParam(Conversion::kFloat32);
-  }
-  CreateInt32x4Builder.AddReturn(Conversion::kOpaque);
-  SigCreateInt32x4 = CreateInt32x4Builder.Build();
-
-  CreateFloat32x4Builder.AddReturn(Conversion::kOpaque);
-  SigCreateFloat32x4 = CreateFloat32x4Builder.Build();
-
-  for (int i = 0; i < kSimd16x8; i++) {
-    CreateInt16x8Builder.AddParam(Conversion::kInt32);
-  }
-  CreateInt16x8Builder.AddReturn(Conversion::kOpaque);
-  SigCreateInt16x8 = CreateInt16x8Builder.Build();
-
-  for (int i = 0; i < kSimd8x16; i++) {
-    CreateInt8x16Builder.AddParam(Conversion::kInt32);
-  }
-  CreateInt8x16Builder.AddReturn(Conversion::kOpaque);
-  SigCreateInt8x16 = CreateInt8x16Builder.Build();
-
-  // Initialize signatures for ExtractLane functions
-  ExtractLaneIntBuilder.AddParam(Conversion::kOpaque);
-  ExtractLaneIntBuilder.AddParam(Conversion::kInt32);
-  ExtractLaneIntBuilder.AddReturn(Conversion::kInt32);
-  SigExtractLaneInt = ExtractLaneIntBuilder.Build();
-
-  ExtractLaneFloatBuilder.AddParam(Conversion::kOpaque);
-  ExtractLaneFloatBuilder.AddParam(Conversion::kFloat32);
-  ExtractLaneFloatBuilder.AddReturn(Conversion::kFloat32);
-  SigExtractLaneFloat = ExtractLaneFloatBuilder.Build();
-
-  // Initialize default signature.
-  for (int i = 0; i < kSimd8x16; i++) {
-    DefaultBuilder.AddParam(Conversion::kNone);
-  }
-  DefaultBuilder.AddReturn(Conversion::kNone);
-  SigDefault = DefaultBuilder.Build();
-}
-
-Reduction SimdLowering::Reduce(Node* node) {
-  // For now lower everything to runtime calls.
-  switch (node->opcode()) {
-    case IrOpcode::kCreateInt32x4: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kCreateInt32x4, SigCreateInt32x4));
-    }
-    case IrOpcode::kCreateInt16x8: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kCreateInt16x8, SigCreateInt16x8));
-    }
-    case IrOpcode::kCreateInt8x16: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kCreateInt8x16, SigCreateInt8x16));
-    }
-    case IrOpcode::kCreateFloat32x4: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kCreateFloat32x4, SigCreateFloat32x4));
-    }
-    case IrOpcode::kInt8x16ExtractLane:
-    case IrOpcode::kInt16x8ExtractLane:
-    case IrOpcode::kInt32x4ExtractLane: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kInt32x4ExtractLane, SigExtractLaneInt));
-    }
-    case IrOpcode::kFloat32x4ExtractLane: {
-      return Replace(builder_->ChangeToRuntimeCall(
-          node, Runtime::kFloat32x4ExtractLane, SigExtractLaneFloat));
-    }
-    default: { break; }
-  }
-
-  // TODO(gdeepti): Implement and test.
-  // Assume the others are all just simd in and out.
-  switch (node->opcode()) {
-#define F(Opcode)                                                             \
-  case IrOpcode::k##Opcode: {                                                 \
-    return Replace(                                                           \
-        builder_->ChangeToRuntimeCall(node, Runtime::k##Opcode, SigDefault)); \
-  }
-    MACHINE_SIMD_RETURN_SIMD_OP_LIST(F)
-    MACHINE_SIMD_RETURN_BOOL_OP_LIST(F)
-#undef F
-    default: { return NoChange(); }
-  }
-  UNREACHABLE();
-  return NoChange();
-}
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8

src/compiler/simd-lowering.h

-// Copyright 2016 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_COMPILER_SIMD_LOWERING_H_
-#define V8_COMPILER_SIMD_LOWERING_H_
-
-#include "src/compiler/graph-reducer.h"
-#include "src/compiler/wasm-compiler.h"
-#include "src/runtime/runtime.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-typedef Signature<Conversion> ConversionSignature;
-
-class SimdLowering final : public Reducer {
- public:
-  SimdLowering(Zone* zone, WasmGraphBuilder* builder)
-      : builder_(builder), zone_(zone) {
-    InitializeSignatures();
-  }
-  virtual ~SimdLowering();
-  Reduction Reduce(Node* node) override;
-
- private:
-  WasmGraphBuilder* builder_;
-  Zone* zone_;
-
-  void InitializeSignatures();
-};
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_COMPILER_SIMD_LOWERING_H_

src/compiler/wasm-compiler.cc

@@ -23,7 +23,6 @@
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/pipeline.h"
-#include "src/compiler/simd-lowering.h"
 #include "src/compiler/source-position.h"
 #include "src/compiler/zone-pool.h"
 
@@ -2347,12 +2346,6 @@ Node* WasmGraphBuilder::ToJS(Node* node, Node* context, wasm::LocalType type) {
   }
 }
 
-Node* WasmGraphBuilder::BuildChangeTaggedToInt32(Node* value) {
-  value = BuildChangeTaggedToFloat64(value);
-  value = graph()->NewNode(jsgraph()->machine()->ChangeFloat64ToInt32(), value);
-  return value;
-}
-
 Node* WasmGraphBuilder::BuildJavaScriptToNumber(Node* node, Node* context,
                                                 Node* effect, Node* control) {
   Callable callable = CodeFactory::ToNumber(jsgraph()->isolate());
@@ -2792,12 +2785,6 @@ Node* WasmGraphBuilder::MemSize(uint32_t offset) {
   }
 }
 
-Node* WasmGraphBuilder::DefaultS128Value() {
-  Node* zero = jsgraph()->Int32Constant(0);
-  return graph()->NewNode(jsgraph()->machine()->CreateInt32x4(), zero, zero,
-                          zero, zero);
-}
-
 Node* WasmGraphBuilder::FunctionTable() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
@@ -2807,79 +2794,6 @@ Node* WasmGraphBuilder::FunctionTable() {
   return function_table_;
 }
 
-Node* WasmGraphBuilder::ChangeToRuntimeCall(Node* node,
-                                            Runtime::FunctionId function_id,
-                                            Signature<Conversion>* signature) {
-  SimplifiedOperatorBuilder simplified(jsgraph()->zone());
-  const Runtime::Function* function = Runtime::FunctionForId(function_id);
-  CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
-      jsgraph()->zone(), function_id, function->nargs, Operator::kNoProperties,
-      CallDescriptor::kNoFlags);
-  const int kInputSize = 16;
-  const int kDefaultFunctionParams = 6;
-  Node* inputs[kInputSize + kDefaultFunctionParams];
-  DCHECK_LE(function->nargs + kDefaultFunctionParams,
-            static_cast<int>(arraysize(inputs)));
-  // Either there are control + effect or not.
-  DCHECK(node->InputCount() == function->nargs ||
-         node->InputCount() == function->nargs + 2);
-  int index = 0;
-  inputs[index++] = jsgraph()->CEntryStubConstant(function->result_size);
-  for (int i = 0; i < function->nargs; ++i) {
-    Node* arg = node->InputAt(i);
-    switch (signature->GetParam(i)) {
-      case Conversion::kInt32:
-        arg = BuildChangeInt32ToTagged(arg);
-        break;
-      case Conversion::kFloat32:
-        arg = jsgraph()->graph()->NewNode(
-            jsgraph()->machine()->ChangeFloat32ToFloat64(), arg);
-        arg = BuildChangeFloat64ToTagged(arg);
-        break;
-      case Conversion::kFloat64:
-        arg = BuildChangeFloat64ToTagged(arg);
-        break;
-      default:
-        break;
-    }
-    inputs[index++] = arg;
-  }
-  inputs[index++] = jsgraph()->ExternalConstant(
-      ExternalReference(function_id, jsgraph()->isolate()));
-  inputs[index++] = jsgraph()->Int32Constant(function->nargs);
-  inputs[index++] = jsgraph()->Constant(module_->instance->context);
-  // Loads and stores have control and effect, others do not and use
-  // the start node instead.
-  if (node->InputCount() == function->nargs + 2) {
-    inputs[index++] = node->InputAt(function->nargs + 1);  // effect
-    inputs[index++] = node->InputAt(function->nargs + 2);  // control
-  } else {
-    inputs[index++] = jsgraph()->graph()->start();  // effect
-    inputs[index++] = jsgraph()->graph()->start();  // control
-  }
-  Node* ret = jsgraph()->graph()->NewNode(jsgraph()->common()->Call(desc),
-                                          index, inputs);
-
-  Conversion return_type = signature->GetReturn();
-  switch (return_type) {
-    case Conversion::kInt32:
-      ret = BuildChangeTaggedToInt32(ret);
-      break;
-    case Conversion::kFloat32:
-      NodeProperties::SetType(ret, Type::Number());
-      ret = BuildChangeTaggedToFloat64(ret);
-      ret = jsgraph()->graph()->NewNode(
-          jsgraph()->machine()->TruncateInt64ToInt32(), ret);
-      break;
-    case Conversion::kFloat64:
-      ret = BuildChangeTaggedToFloat64(ret);
-      break;
-    default:
-      break;
-  }
-  return ret;
-}
-
 Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
   MachineType mem_type = module_->GetGlobalType(index);
   Node* addr = jsgraph()->RelocatableIntPtrConstant(
@@ -3276,25 +3190,6 @@ void WasmGraphBuilder::SetSourcePosition(Node* node,
     source_position_table_->SetSourcePosition(node, pos);
 }
 
-MachineOperatorBuilder* WasmGraphBuilder::simd() {
-  has_simd_ops_ = true;
-  return jsgraph()->machine();
-}
-
-Node* WasmGraphBuilder::SimdOp(wasm::WasmOpcode opcode,
-                               const NodeVector& inputs) {
-  switch (opcode) {
-    case wasm::kExprI32x4ExtractLane:
-      return graph()->NewNode(simd()->Int32x4ExtractLane(), inputs[0],
-                              inputs[1]);
-    case wasm::kExprI32x4Splat:
-      return graph()->NewNode(simd()->CreateInt32x4(), inputs[0], inputs[0],
-                              inputs[0], inputs[0]);
-    default:
-      return graph()->NewNode(UnsupportedOpcode(opcode), nullptr);
-  }
-}
-
 static void RecordFunctionCompilation(CodeEventListener::LogEventsAndTags tag,
                                       Isolate* isolate, Handle<Code> code,
                                       const char* message, uint32_t index,
@@ -3507,21 +3402,6 @@ SourcePositionTable* WasmCompilationUnit::BuildGraphForWasmFunction(
   }
 
   int index = static_cast<int>(function_->func_index);
-
-  // Run lowering pass if SIMD ops are present in the function
-  if (builder.has_simd_ops()) {
-    SimdLowering simd(jsgraph_->zone(), &builder);
-    GraphReducer graph_reducer(jsgraph_->zone(), graph);
-    graph_reducer.AddReducer(&simd);
-    graph_reducer.ReduceGraph();
-
-    if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
-      OFStream os(stdout);
-      os << "-- Graph after simd lowering -- " << std::endl;
-      os << AsRPO(*graph);
-    }
-  }
-
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     OFStream os(stdout);
     PrintAst(isolate_->allocator(), body, os, nullptr);

src/compiler/wasm-compiler.h

@@ -22,7 +22,6 @@ class JSGraph;
 class Graph;
 class Operator;
 class SourcePositionTable;
-class MachineOperatorBuilder;
 }  // namespace compiler
 
 namespace wasm {
@@ -91,8 +90,6 @@ Handle<Code> CompileJSToWasmWrapper(Isolate* isolate, wasm::ModuleEnv* module,
 // Abstracts details of building TurboFan graph nodes for WASM to separate
 // the WASM decoder from the internal details of TurboFan.
 class WasmTrapHelper;
-enum class Conversion { kNone, kOpaque, kInt32, kFloat32, kFloat64 };
-typedef ZoneVector<Node*> NodeVector;
 class WasmGraphBuilder {
  public:
   WasmGraphBuilder(
@@ -127,7 +124,6 @@ class WasmGraphBuilder {
   Node* Float32Constant(float value);
   Node* Float64Constant(double value);
   Node* HeapConstant(Handle<HeapObject> value);
-  Node* DefaultS128Value();
   Node* Binop(wasm::WasmOpcode opcode, Node* left, Node* right,
               wasm::WasmCodePosition position = wasm::kNoCodePosition);
   Node* Unop(wasm::WasmOpcode opcode, Node* input,
@@ -165,8 +161,6 @@ class WasmGraphBuilder {
   Node* FromJS(Node* node, Node* context, wasm::LocalType type);
   Node* Invert(Node* node);
   Node* FunctionTable();
-  Node* ChangeToRuntimeCall(Node* node, Runtime::FunctionId function_id,
-                            Signature<Conversion>* signature);
 
   //-----------------------------------------------------------------------
   // Operations that concern the linear memory.
@@ -198,10 +192,6 @@ class WasmGraphBuilder {
 
   void SetSourcePosition(Node* node, wasm::WasmCodePosition position);
 
-  Node* SimdOp(wasm::WasmOpcode opcode, const NodeVector& inputs);
-
-  bool has_simd_ops() { return has_simd_ops_; }
-
  private:
   static const int kDefaultBufferSize = 16;
   friend class WasmTrapHelper;
@@ -223,7 +213,6 @@ class WasmGraphBuilder {
   SetOncePointer<const Operator> allocate_heap_number_operator_;
 
   compiler::SourcePositionTable* source_position_table_ = nullptr;
-  bool has_simd_ops_;
 
   // Internal helper methods.
   JSGraph* jsgraph() { return jsgraph_; }
@@ -327,7 +316,6 @@ class WasmGraphBuilder {
   Node* BuildJavaScriptToNumber(Node* node, Node* context, Node* effect,
                                 Node* control);
   Node* BuildChangeInt32ToTagged(Node* value);
-  Node* BuildChangeTaggedToInt32(Node* value);
   Node* BuildChangeFloat64ToTagged(Node* value);
   Node* BuildChangeTaggedToFloat64(Node* value);
 
@@ -360,9 +348,6 @@ class WasmGraphBuilder {
     if (buf != buffer) memcpy(buf, buffer, old_count * sizeof(Node*));
     return buf;
   }
-
-  // Simd helper functions
-  MachineOperatorBuilder* simd();
 };
 }  // namespace compiler
 }  // namespace internal

src/flag-definitions.h

@@ -513,8 +513,6 @@ DEFINE_INT(typed_array_max_size_in_heap, 64,
 
 DEFINE_BOOL(wasm_jit_prototype, false,
             "enable experimental wasm runtime dynamic code generation")
-DEFINE_BOOL(wasm_simd_prototype, false,
-            "enable prototype simd opcodes for wasm")
 
 // Profiler flags.
 DEFINE_INT(frame_count, 1, "number of stack frames inspected by the profiler")

src/v8.gyp

@@ -660,8 +660,6 @@
         'compiler/scheduler.h',
         'compiler/select-lowering.cc',
         'compiler/select-lowering.h',
-        'compiler/simd-lowering.cc',
-        'compiler/simd-lowering.h',
         'compiler/simplified-lowering.cc',
         'compiler/simplified-lowering.h',
         'compiler/simplified-operator-reducer.cc',

src/wasm/ast-decoder.cc

@@ -1019,15 +1019,6 @@ class WasmFullDecoder : public WasmDecoder {
             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_);
@@ -1148,17 +1139,6 @@ class WasmFullDecoder : public WasmDecoder {
     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;

src/wasm/wasm-macro-gen.h

@@ -579,13 +579,6 @@ class LocalDeclEncoder {
 #define WASM_I32_REINTERPRET_F32(x) x, kExprI32ReinterpretF32
 #define WASM_I64_REINTERPRET_F64(x) x, kExprI64ReinterpretF64
 
-//------------------------------------------------------------------------------
-// Simd Operations.
-//------------------------------------------------------------------------------
-#define WASM_SIMD_I32x4_SPLAT(x) x, kSimdPrefix, kExprI32x4Splat & 0xff
-#define WASM_SIMD_I32x4_EXTRACT_LANE(x, y) \
-  x, y, kSimdPrefix, kExprI32x4ExtractLane & 0xff
-
 #define SIG_ENTRY_v_v kWasmFunctionTypeForm, 0, 0
 #define SIZEOF_SIG_ENTRY_v_v 3
 

src/wasm/wasm-opcodes.cc

@@ -68,27 +68,15 @@ FOREACH_SIGNATURE(DECLARE_SIG)
 static const FunctionSig* kSimpleExprSigs[] = {
     nullptr, FOREACH_SIGNATURE(DECLARE_SIG_ENTRY)};
 
-#define DECLARE_SIMD_SIG_ENTRY(name, ...) &kSig_##name,
-
-static const FunctionSig* kSimdExprSigs[] = {
-    nullptr, FOREACH_SIMD_SIGNATURE(DECLARE_SIMD_SIG_ENTRY)};
-
 static byte kSimpleExprSigTable[256];
-static byte kSimdExprSigTable[256];
 
 // Initialize the signature table.
-static void InitSigTables() {
+static void InitSigTable() {
 #define SET_SIG_TABLE(name, opcode, sig) \
   kSimpleExprSigTable[opcode] = static_cast<int>(kSigEnum_##sig) + 1;
   FOREACH_SIMPLE_OPCODE(SET_SIG_TABLE);
   FOREACH_SIMPLE_MEM_OPCODE(SET_SIG_TABLE);
   FOREACH_ASMJS_COMPAT_OPCODE(SET_SIG_TABLE);
-#undef SET_SIG_TABLE
-  byte simd_index;
-#define SET_SIG_TABLE(name, opcode, sig) \
-  simd_index = opcode & 0xff;            \
-  kSimdExprSigTable[simd_index] = static_cast<int>(kSigEnum_##sig) + 1;
-  FOREACH_SIMD_OPCODE(SET_SIG_TABLE)
 #undef SET_SIG_TABLE
 }
 
@@ -96,26 +84,18 @@ class SigTable {
  public:
   SigTable() {
     // TODO(ahaas): Move {InitSigTable} into the class.
-    InitSigTables();
+    InitSigTable();
   }
   FunctionSig* Signature(WasmOpcode opcode) const {
     return const_cast<FunctionSig*>(
         kSimpleExprSigs[kSimpleExprSigTable[static_cast<byte>(opcode)]]);
   }
-  FunctionSig* SimdSignature(WasmOpcode opcode) const {
-    return const_cast<FunctionSig*>(
-        kSimdExprSigs[kSimdExprSigTable[static_cast<byte>(opcode & 0xff)]]);
-  }
 };
 
 static base::LazyInstance<SigTable>::type sig_table = LAZY_INSTANCE_INITIALIZER;
 
 FunctionSig* WasmOpcodes::Signature(WasmOpcode opcode) {
-  if (opcode >> 8 == kSimdPrefix) {
-    return sig_table.Get().SimdSignature(opcode);
-  } else {
-    return sig_table.Get().Signature(opcode);
-  }
+  return sig_table.Get().Signature(opcode);
 }
 
 // TODO(titzer): pull WASM_64 up to a common header.

src/wasm/wasm-opcodes.h

@@ -465,16 +465,11 @@ const WasmCodePosition kNoCodePosition = -1;
   V(s_sii, kAstS128, kAstS128, kAstI32, kAstI32)   \
   V(s_si, kAstS128, kAstS128, kAstI32)
 
-#define FOREACH_PREFIX(V) V(Simd, 0xe5)
-
 enum WasmOpcode {
 // Declare expression opcodes.
 #define DECLARE_NAMED_ENUM(name, opcode, sig) kExpr##name = opcode,
   FOREACH_OPCODE(DECLARE_NAMED_ENUM)
 #undef DECLARE_NAMED_ENUM
-#define DECLARE_PREFIX(name, opcode) k##name##Prefix = opcode,
-      FOREACH_PREFIX(DECLARE_PREFIX)
-#undef DECLARE_PREFIX
 };
 
 // The reason for a trap.

test/cctest/cctest.gyp

@@ -188,10 +188,9 @@
       'wasm/test-run-wasm-interpreter.cc',
       'wasm/test-run-wasm-js.cc',
       'wasm/test-run-wasm-module.cc',
-      'wasm/test-run-wasm-relocation.cc',
-      'wasm/test-run-wasm-simd.cc',
       'wasm/test-signatures.h',
       'wasm/test-wasm-function-name-table.cc',
+      'wasm/test-run-wasm-relocation.cc',
       'wasm/test-wasm-stack.cc',
       'wasm/test-wasm-trap-position.cc',
       'wasm/wasm-run-utils.h',

test/cctest/wasm/test-run-wasm-simd.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 <stdlib.h>
-#include <string.h>
-
-#include "src/wasm/encoder.h"
-#include "src/wasm/wasm-js.h"
-#include "src/wasm/wasm-macro-gen.h"
-#include "src/wasm/wasm-module.h"
-#include "src/wasm/wasm-opcodes.h"
-
-#include "test/cctest/cctest.h"
-#include "test/cctest/wasm/test-signatures.h"
-
-using namespace v8::base;
-using namespace v8::internal;
-using namespace v8::internal::compiler;
-using namespace v8::internal::wasm;
-
-namespace {
-void TestModule(Zone* zone, WasmModuleBuilder* builder,
-                int32_t expected_result) {
-  FLAG_wasm_simd_prototype = true;
-  FLAG_wasm_num_compilation_tasks = 0;
-  ZoneBuffer buffer(zone);
-  builder->WriteTo(buffer);
-
-  Isolate* isolate = CcTest::InitIsolateOnce();
-  HandleScope scope(isolate);
-  WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
-  int32_t result =
-      testing::CompileAndRunWasmModule(isolate, buffer.begin(), buffer.end());
-  CHECK_EQ(expected_result, result);
-}
-
-void ExportAsMain(WasmFunctionBuilder* f) {
-  static const char kMainName[] = "main";
-  f->SetExported();
-  f->SetName(kMainName, arraysize(kMainName) - 1);
-}
-}  // namespace
-
-TEST(Run_WasmMoule_simd) {
-  v8::base::AccountingAllocator allocator;
-  Zone zone(&allocator);
-  TestSignatures sigs;
-
-  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
-  uint16_t f_index = builder->AddFunction();
-  WasmFunctionBuilder* f = builder->FunctionAt(f_index);
-  f->SetSignature(sigs.i_i());
-  ExportAsMain(f);
-
-  byte code[] = {WASM_SIMD_I32x4_EXTRACT_LANE(
-      WASM_SIMD_I32x4_SPLAT(WASM_I8(123)), WASM_I8(2))};
-  f->EmitCode(code, sizeof(code));
-  TestModule(&zone, builder, 123);
-}

test/cctest/wasm/test-signatures.h

@@ -35,8 +35,7 @@ class TestSignatures {
         sig_v_v(0, 0, kIntTypes4),
         sig_v_i(0, 1, kIntTypes4),
         sig_v_ii(0, 2, kIntTypes4),
-        sig_v_iii(0, 3, kIntTypes4),
-        sig_s_i(1, 1, kSimd128IntTypes4) {
+        sig_v_iii(0, 3, kIntTypes4) {
     // I used C++ and you won't believe what happened next....
     for (int i = 0; i < 4; i++) kIntTypes4[i] = kAstI32;
     for (int i = 0; i < 4; i++) kLongTypes4[i] = kAstI64;
@@ -45,11 +44,9 @@ class TestSignatures {
     for (int i = 0; i < 4; i++) kIntLongTypes4[i] = kAstI64;
     for (int i = 0; i < 4; i++) kIntFloatTypes4[i] = kAstF32;
     for (int i = 0; i < 4; i++) kIntDoubleTypes4[i] = kAstF64;
-    for (int i = 0; i < 4; i++) kSimd128IntTypes4[i] = kAstS128;
     kIntLongTypes4[0] = kAstI32;
     kIntFloatTypes4[0] = kAstI32;
     kIntDoubleTypes4[0] = kAstI32;
-    kSimd128IntTypes4[1] = kAstI32;
   }
 
   FunctionSig* i_v() { return &sig_i_v; }
@@ -74,7 +71,6 @@ class TestSignatures {
   FunctionSig* v_i() { return &sig_v_i; }
   FunctionSig* v_ii() { return &sig_v_ii; }
   FunctionSig* v_iii() { return &sig_v_iii; }
-  FunctionSig* s_i() { return &sig_s_i; }
 
   FunctionSig* many(Zone* zone, LocalType ret, LocalType param, int count) {
     FunctionSig::Builder builder(zone, ret == kAstStmt ? 0 : 1, count);
@@ -93,7 +89,6 @@ class TestSignatures {
   LocalType kIntLongTypes4[4];
   LocalType kIntFloatTypes4[4];
   LocalType kIntDoubleTypes4[4];
-  LocalType kSimd128IntTypes4[4];
 
   FunctionSig sig_i_v;
   FunctionSig sig_i_i;
@@ -117,7 +112,6 @@ class TestSignatures {
   FunctionSig sig_v_i;
   FunctionSig sig_v_ii;
   FunctionSig sig_v_iii;
-  FunctionSig sig_s_i;
 };
 }  // namespace wasm
 }  // namespace internal

test/mjsunit/wasm/test-wasm-simd-ops.js

-// Copyright 2016 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.
-
-// Flags: --expose-wasm --wasm-simd-prototype --wasm-num-compilation-tasks=0
-
-load('test/mjsunit/wasm/wasm-constants.js');
-load('test/mjsunit/wasm/wasm-module-builder.js');
-
-// TODO(gdeepti): Currently wasm simd ops are tested using runtime calls to
-// JS runtime functions, as this needs heap allocation sequential compile is
-// triggered here. This is only used for bootstrapping and needs to be removed
-// when we have architectuaral/scalar implementations for wasm simd ops.
-
-(function SimdSplatExtractTest() {
-  var module = new WasmModuleBuilder();
-  module.addFunction("splatextract", kSig_i_ii)
-      .addBody([kExprGetLocal, 0, kExprSimdPrefix, kExprI32x4Splat,
-          kExprI32Const, 1, kExprSimdPrefix, kExprI32x4ExtractLane])
-      .exportAs("main");
-  var instance = module.instantiate();
-  assertEquals(123, instance.exports.main(123, 2));
-})();

test/mjsunit/wasm/wasm-constants.js

@@ -303,9 +303,6 @@ var kExprI32Ror = 0xb6;
 var kExprI32Rol = 0xb7;
 var kExprI64Ror = 0xb8;
 var kExprI64Rol = 0xb9;
-var kExprSimdPrefix = 0xe5;
-var kExprI32x4Splat = 0x1b;
-var kExprI32x4ExtractLane = 0x1c;
 
 var kExprJITSingleFunction = 0xf0;