Convert SIMD wasm ops to runtime function calls

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 "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-generic-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 2303 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() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
   if (!function_table_) {
     function_table_ = HeapConstant(module_->instance->function_table);
   }
   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(
       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_);
   *effect_ = node;
@@ skipping 376 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]);
+    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,
                                       const wasm::WasmName& module_name,
                                       const wasm::WasmName& func_name) {
   DCHECK(isolate->logger()->is_logging_code_events() ||
          isolate->is_profiling());
 
   ScopedVector<char> buffer(128);
   SNPrintF(buffer, "%s#%d:%.*s:%.*s", message, index, module_name.length(),
@@ skipping 192 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 126 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8