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/profiler/cpu-profiler.h"
 
 #include "src/wasm/ast-decoder.h"
@@ skipping 567 matching lines @@
     case wasm::kExprF32Max:
       return BuildF32Max(left, right);
     case wasm::kExprF64Max:
       return BuildF64Max(left, right);
     case wasm::kExprF64Pow:
       return BuildF64Pow(left, right);
     case wasm::kExprF64Atan2:
       return BuildF64Atan2(left, right);
     case wasm::kExprF64Mod:
       return BuildF64Mod(left, right);
+    case wasm::kExprInt32x4ExtractLane:
+      return graph()->NewNode(jsgraph()->machine()->Int32x4ExtractLane(), left,
+                              right);
     case wasm::kExprI32AsmjsDivS:
       return BuildI32AsmjsDivS(left, right);
     case wasm::kExprI32AsmjsDivU:
       return BuildI32AsmjsDivU(left, right);
     case wasm::kExprI32AsmjsRemS:
       return BuildI32AsmjsRemS(left, right);
     case wasm::kExprI32AsmjsRemU:
       return BuildI32AsmjsRemU(left, right);
     case wasm::kExprI32AsmjsStoreMem8:
       return BuildAsmjsStoreMem(MachineType::Int8(), left, right);
@@ skipping 235 matching lines @@
       op = m->RoundUint64ToFloat64();
       break;
     case wasm::kExprI64SConvertF32:
       return BuildI64SConvertF32(input, position);
     case wasm::kExprI64SConvertF64:
       return BuildI64SConvertF64(input, position);
     case wasm::kExprI64UConvertF32:
       return BuildI64UConvertF32(input, position);
     case wasm::kExprI64UConvertF64:
       return BuildI64UConvertF64(input, position);
+    case wasm::kExprInt32x4Splat:
+      return graph()->NewNode(jsgraph()->machine()->CreateInt32x4(), input,
+                              input, input, input);
     case wasm::kExprI32AsmjsLoadMem8S:
       return BuildAsmjsLoadMem(MachineType::Int8(), input);
     case wasm::kExprI32AsmjsLoadMem8U:
       return BuildAsmjsLoadMem(MachineType::Uint8(), input);
     case wasm::kExprI32AsmjsLoadMem16S:
       return BuildAsmjsLoadMem(MachineType::Int16(), input);
     case wasm::kExprI32AsmjsLoadMem16U:
       return BuildAsmjsLoadMem(MachineType::Uint16(), input);
     case wasm::kExprI32AsmjsLoadMem:
       return BuildAsmjsLoadMem(MachineType::Int32(), input);
@@ skipping 1238 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 401 matching lines @@
   DCHECK(module_ && module_->instance);
   uint32_t size = static_cast<uint32_t>(module_->instance->mem_size);
   if (offset == 0) {
     if (!mem_size_) mem_size_ = jsgraph()->Int32Constant(size);
     return mem_size_;
   } else {
     return jsgraph()->Int32Constant(size + 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());
   if (!function_table_) {
     function_table_ = HeapConstant(module_->instance->function_table);
   }
   return function_table_;
 }
 
 Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
@@ skipping 365 matching lines @@
     }
     // Add the function as another context for the exception
     ScopedVector<char> buffer(128);
     wasm::WasmName name = module_env->module->GetName(function->name_offset,
                                                       function->name_length);
     SNPrintF(buffer, "Compiling WASM function #%d:%.*s failed:",
              function->func_index, name.length(), name.start());
     thrower->Failed(buffer.start(), result);
     return std::make_pair(nullptr, nullptr);
   }
+
+  // Run lowering pass if SIMD ops are present in the function
+  if (builder.is_simd_function()) {
+    SimdLowering simd(jsgraph, &builder, module_env->instance->context);
+    GraphReducer graph_reducer(jsgraph->zone(), jsgraph->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);
+    }
+  }
+
   int index = static_cast<int>(function->func_index);
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     PrintAst(isolate->allocator(), body);
   }
   if (FLAG_trace_wasm_decode_time) {
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
   return std::make_pair(jsgraph, source_position_table);
 }
 
@@ skipping 169 matching lines @@
                                  const wasm::WasmFunction* function) {
   WasmCompilationUnit* unit =
       CreateWasmCompilationUnit(thrower, isolate, module_env, function, 0);
   ExecuteCompilation(unit);
   return FinishCompilation(unit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8