Revert runtime lowering of wasm SIMD ops

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/int64-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/linkage.h"
 #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"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/factory.h"
 #include "src/log-inl.h"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/wasm-module.h"
@@ skipping 2166 matching lines @@
     case wasm::kAstF64:
       return BuildChangeFloat64ToTagged(node);
     case wasm::kAstStmt:
       return jsgraph()->UndefinedConstant();
     default:
       UNREACHABLE();
       return nullptr;
   }
 }
 
-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());
   CallDescriptor* desc = Linkage::GetStubCallDescriptor(
       jsgraph()->isolate(), jsgraph()->zone(), callable.descriptor(), 0,
       CallDescriptor::kNoFlags, Operator::kNoProperties);
   Node* stub_code = jsgraph()->HeapConstant(callable.code());
 
   Node* result = graph()->NewNode(jsgraph()->common()->Call(desc), stub_code,
                                   node, context, effect, control);
@@ skipping 419 matching lines @@
     if (!mem_size_)
       mem_size_ = jsgraph()->RelocatableInt32Constant(
           size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
     return mem_size_;
   } else {
     return jsgraph()->RelocatableInt32Constant(
         size + offset, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   }
 }
 
-Node* WasmGraphBuilder::DefaultS128Value() {
-  Node* zero = jsgraph()->Int32Constant(0);
-  return graph()->NewNode(jsgraph()->machine()->CreateInt32x4(), zero, zero,
-                          zero, zero);
-}
-
 Node* WasmGraphBuilder::FunctionTable(uint32_t index) {
   DCHECK(module_ && module_->instance &&
          index < module_->instance->function_tables.size());
   if (!function_tables_.size()) {
     for (size_t i = 0; i < module_->instance->function_tables.size(); ++i) {
       DCHECK(!module_->instance->function_tables[i].is_null());
       function_tables_.push_back(
           HeapConstant(module_->instance->function_tables[i]));
     }
   }
   return function_tables_[index];
 }
 
-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::GetGlobal(uint32_t index) {
   MachineType mem_type =
       wasm::WasmOpcodes::MachineTypeFor(module_->GetGlobalType(index));
   Node* addr = jsgraph()->RelocatableIntPtrConstant(
       reinterpret_cast<uintptr_t>(module_->instance->globals_start +
                                   module_->module->globals[index].offset),
       RelocInfo::WASM_GLOBAL_REFERENCE);
   const Operator* op = jsgraph()->machine()->Load(mem_type);
   Node* node = graph()->NewNode(op, addr, jsgraph()->Int32Constant(0), *effect_,
                                 *control_);
@@ skipping 169 matching lines @@
 }
 
 void WasmGraphBuilder::SetSourcePosition(Node* node,
                                          wasm::WasmCodePosition position) {
   DCHECK_NE(position, wasm::kNoCodePosition);
   compiler::SourcePosition pos(position);
   if (source_position_table_)
     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]);
+      return graph()->NewNode(jsgraph()->machine()->Int32x4ExtractLane(),
+                              inputs[0], inputs[1]);
     case wasm::kExprI32x4Splat:
-      return graph()->NewNode(simd()->CreateInt32x4(), inputs[0], inputs[0],
-                              inputs[0], inputs[0]);
+      return graph()->NewNode(jsgraph()->machine()->Int32x4ExtractLane(),
+                              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,
                                       const wasm::WasmName& module_name,
                                       const wasm::WasmName& func_name) {
@@ skipping 198 matching lines @@
     return nullptr;
   }
 
   if (machine->Is32()) {
     Int64Lowering r(graph, machine, common, jsgraph_->zone(), function_->sig);
     r.LowerGraph();
   }
 
   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);
   }
   if (FLAG_trace_wasm_decode_time) {
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
   return source_position_table;
 }
 
@@ skipping 127 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8