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 568 matching lines @@
     case wasm::kExprF64Max:
       return BuildF64Max(left, right);
     case wasm::kExprF64Pow:
       op = m->Float64Pow();
       break;
     case wasm::kExprF64Atan2:
       op = m->Float64Atan2();
       break;
     case wasm::kExprF64Mod:
       return BuildF64Mod(left, right);
+    case wasm::kExprI32x4ExtractLane:
+      SetHasSimdOps(true);
+      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 253 matching lines @@
     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::kExprGrowMemory:
       return BuildGrowMemory(input);
+    case wasm::kExprI32x4Splat:
+      SetHasSimdOps(true);
+      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 1342 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 416 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::LoadGlobal(uint32_t index) {
@@ skipping 618 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.HasSimdOps()) {
+    SimdLowering simd(jsgraph_, &builder, module_env_->instance->context);
+    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