[wasm] Initial commit for the Int64Reducer.

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/platform.h"
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.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/simplified-lowering.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/source-position.h"
@@ skipping 446 matching lines @@
       std::swap(left, right);
       break;
     case wasm::kExprI32GtU:
       op = m->Uint32LessThan();
       std::swap(left, right);
       break;
     case wasm::kExprI32GeU:
       op = m->Uint32LessThanOrEqual();
       std::swap(left, right);
       break;
+    case wasm::kExprI64And:
+      op = m->Word64And();
+      break;
 #if WASM_64
     // Opcodes only supported on 64-bit platforms.
     // TODO(titzer): query the machine operator builder here instead of #ifdef.
     case wasm::kExprI64Add:
       op = m->Int64Add();
       break;
     case wasm::kExprI64Sub:
       op = m->Int64Sub();
       break;
     case wasm::kExprI64Mul:
@@ skipping 30 matching lines @@
 
       Node* rem = graph()->NewNode(m->Int64Mod(), left, right, d.if_false);
 
       return d.Phi(MachineRepresentation::kWord64, jsgraph()->Int64Constant(0),
                    rem);
     }
     case wasm::kExprI64RemU:
       op = m->Uint64Mod();
       return graph()->NewNode(op, left, right,
                               trap_->ZeroCheck64(kTrapRemByZero, right));
-    case wasm::kExprI64And:
-      op = m->Word64And();
-      break;
     case wasm::kExprI64Ior:
       op = m->Word64Or();
       break;
     case wasm::kExprI64Xor:
       op = m->Word64Xor();
       break;
     case wasm::kExprI64Shl:
       op = m->Word64Shl();
       break;
     case wasm::kExprI64ShrU:
@@ skipping 229 matching lines @@
       if (!m->Float64RoundTruncate().IsSupported()) return BuildF64Trunc(input);
       op = m->Float64RoundTruncate().op();
       break;
     }
     case wasm::kExprF64NearestInt: {
       if (!m->Float64RoundTiesEven().IsSupported())
         return BuildF64NearestInt(input);
       op = m->Float64RoundTiesEven().op();
       break;
     }
-
+    case wasm::kExprI32ConvertI64:
+      op = m->TruncateInt64ToInt32();
+      break;
 #if WASM_64
     // Opcodes only supported on 64-bit platforms.
     // TODO(titzer): query the machine operator builder here instead of #ifdef.
-    case wasm::kExprI32ConvertI64:
-      op = m->TruncateInt64ToInt32();
-      break;
     case wasm::kExprI64SConvertI32:
       op = m->ChangeInt32ToInt64();
       break;
     case wasm::kExprI64UConvertI32:
       op = m->ChangeUint32ToUint64();
       break;
     case wasm::kExprF32SConvertI64:
       op = m->RoundInt64ToFloat32();
       break;
     case wasm::kExprF32UConvertI64:
@@ skipping 1078 matching lines @@
 
 
 Node* WasmGraphBuilder::String(const char* string) {
   return jsgraph()->Constant(
       jsgraph()->isolate()->factory()->NewStringFromAsciiChecked(string));
 }
 
 
 Graph* WasmGraphBuilder::graph() { return jsgraph()->graph(); }
 
+void WasmGraphBuilder::Int64LoweringForTesting() {
+#if !WASM_64
+  Int64Lowering r(jsgraph()->graph(), jsgraph()->machine(), jsgraph()->common(),
+                  jsgraph()->zone());
+  r.ReduceGraph();
+#endif
+}
 
 static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                       CompilationInfo* info,
                                       const char* message, uint32_t index,
                                       const char* func_name) {
   Isolate* isolate = info->isolate();
   if (isolate->logger()->is_logging_code_events() ||
       isolate->cpu_profiler()->is_profiling()) {
     ScopedVector<char> buffer(128);
     SNPrintF(buffer, "%s#%d:%s", message, index, func_name);
     Handle<String> name_str =
         isolate->factory()->NewStringFromAsciiChecked(buffer.start());
     Handle<String> script_str =
         isolate->factory()->NewStringFromAsciiChecked("(WASM)");
     Handle<Code> code = info->code();
     Handle<SharedFunctionInfo> shared =
         isolate->factory()->NewSharedFunctionInfo(name_str, code, false);
     PROFILE(isolate,
             CodeCreateEvent(tag, *code, *shared, info, *script_str, 0, 0));
   }
 }
 
-
 Handle<JSFunction> CompileJSToWasmWrapper(
     Isolate* isolate, wasm::ModuleEnv* module, Handle<String> name,
     Handle<Code> wasm_code, Handle<JSObject> module_object, uint32_t index) {
   wasm::WasmFunction* func = &module->module->functions->at(index);
 
   //----------------------------------------------------------------------------
   // Create the JSFunction object.
   //----------------------------------------------------------------------------
   Handle<SharedFunctionInfo> shared =
       isolate->factory()->NewSharedFunctionInfo(name, wasm_code, false);
@@ skipping 188 matching lines @@
       FLAG_print_opt_code || FLAG_trace_turbo || FLAG_trace_turbo_graph;
   const char* func_name = "wasm";
   Vector<char> buffer;
   if (debugging) {
     buffer = Vector<char>::New(128);
     SNPrintF(buffer, "WASM_function_#%d:%s", index,
              module_env->module->GetName(function.name_offset));
     func_name = buffer.start();
   }
   CompilationInfo info(func_name, isolate, &zone, flags);
+
   Handle<Code> code =
       Pipeline::GenerateCodeForTesting(&info, descriptor, &graph);
   if (debugging) {
     buffer.Dispose();
   }
   if (!code.is_null()) {
     RecordFunctionCompilation(
         Logger::FUNCTION_TAG, &info, "WASM_function", index,
         module_env->module->GetName(function.name_offset));
   }
 
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8