[wasm] Change the return type of traps for tests, and added ftoi64 instructions.

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/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"
@@ skipping 205 matching lines @@
       *effect_ptr = node;
     }
     if (false) {
       // End the control flow with a throw
       Node* thrw =
           graph()->NewNode(common()->Throw(), jsgraph()->ZeroConstant(),
                            *effect_ptr, *control_ptr);
       end = thrw;
     } else {
       // End the control flow with returning 0xdeadbeef
-      Node* ret_dead = graph()->NewNode(common()->Return(),
+
+      Node* ret_dead;
+      if (builder_->GetFunctionSignature()->return_count() > 0) {
+        switch (builder_->GetFunctionSignature()->GetReturn()) {
+          case wasm::kAstI32:
+            ret_dead = graph()->NewNode(jsgraph()->common()->Return(),

[titzer, 2015/12/11 13:49:26]

You can just make the return value node in these cases, the rest is the same.

                                         jsgraph()->Int32Constant(0xdeadbeef),
                                         *effect_ptr, *control_ptr);
+            break;
+          case wasm::kAstI64:
+            ret_dead =
+                graph()->NewNode(jsgraph()->common()->Return(),
+                                 jsgraph()->Int64Constant(0xdeadbeefdeadbeef),
+                                 *effect_ptr, *control_ptr);
+            break;
+          case wasm::kAstF32:
+            ret_dead = graph()->NewNode(
+                jsgraph()->common()->Return(),
+                jsgraph()->Float32Constant(bit_cast<float>(0xdeadbeef)),
+                *effect_ptr, *control_ptr);
+            break;
+          case wasm::kAstF64:
+            ret_dead =
+                graph()->NewNode(jsgraph()->common()->Return(),
+                                 jsgraph()->Float64Constant(
+                                     bit_cast<double>(0xdeadbeefdeadbeef)),
+                                 *effect_ptr, *control_ptr);
+            break;
+          default:
+            UNREACHABLE();
+            ret_dead = nullptr;
+        }
+      } else {
+        ret_dead = graph()->NewNode(common()->Return(),
+                                    jsgraph()->Int32Constant(0xdeadbeef),
+                                    *effect_ptr, *control_ptr);
+      }
       end = ret_dead;
     }
 
     MergeControlToEnd(jsgraph(), end);
   }
 };
 
 
-WasmGraphBuilder::WasmGraphBuilder(Zone* zone, JSGraph* jsgraph)
+WasmGraphBuilder::WasmGraphBuilder(Zone* zone, JSGraph* jsgraph,
+                                   wasm::FunctionSig* function_signature)
     : zone_(zone),
       jsgraph_(jsgraph),
       module_(nullptr),
       mem_buffer_(nullptr),
       mem_size_(nullptr),
       function_table_(nullptr),
       control_(nullptr),
       effect_(nullptr),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
-      trap_(new (zone) WasmTrapHelper(this)) {
+      trap_(new (zone) WasmTrapHelper(this)),
+      function_signature_(function_signature) {
   DCHECK_NOT_NULL(jsgraph_);
 }
 
 
 Node* WasmGraphBuilder::Error() { return jsgraph()->Dead(); }
 
 
 Node* WasmGraphBuilder::Start(unsigned params) {
   Node* start = graph()->NewNode(jsgraph()->common()->Start(params));
   graph()->SetStart(start);
@@ skipping 577 matching lines @@
       break;
     case wasm::kExprF32UConvertI64:
       op = m->RoundUint64ToFloat32();
       break;
     case wasm::kExprF64SConvertI64:
       op = m->RoundInt64ToFloat64();
       break;
     case wasm::kExprF64UConvertI64:
       op = m->RoundUint64ToFloat64();
       break;
+    case wasm::kExprI64SConvertF32: {
+      Node* trunc = graph()->NewNode(m->TryTruncateFloat32ToInt64(), input);
+      Node* result =
+          graph()->NewNode(jsgraph()->common()->Projection(0), trunc);
+      Node* overflow =
+          graph()->NewNode(jsgraph()->common()->Projection(1), trunc);
+      trap_->ZeroCheck64(kTrapFloatUnrepresentable, overflow);
+      return result;
+    }
+    case wasm::kExprI64SConvertF64: {
+      Node* trunc = graph()->NewNode(m->TryTruncateFloat64ToInt64(), input);
+      Node* result =
+          graph()->NewNode(jsgraph()->common()->Projection(0), trunc);
+      Node* overflow =
+          graph()->NewNode(jsgraph()->common()->Projection(1), trunc);
+      trap_->ZeroCheck64(kTrapFloatUnrepresentable, overflow);
+      return result;
+    }
+    case wasm::kExprI64UConvertF32: {
+      Node* trunc = graph()->NewNode(m->TryTruncateFloat32ToUint64(), input);
+      Node* result =
+          graph()->NewNode(jsgraph()->common()->Projection(0), trunc);
+      Node* overflow =
+          graph()->NewNode(jsgraph()->common()->Projection(1), trunc);
+      trap_->ZeroCheck64(kTrapFloatUnrepresentable, overflow);
+      return result;
+    }
+    case wasm::kExprI64UConvertF64: {
+      Node* trunc = graph()->NewNode(m->TryTruncateFloat64ToUint64(), input);
+      Node* result =
+          graph()->NewNode(jsgraph()->common()->Projection(0), trunc);
+      Node* overflow =
+          graph()->NewNode(jsgraph()->common()->Projection(1), trunc);
+      trap_->ZeroCheck64(kTrapFloatUnrepresentable, overflow);
+      return result;
+    }
     case wasm::kExprF64ReinterpretI64:
       op = m->BitcastInt64ToFloat64();
       break;
     case wasm::kExprI64ReinterpretF64:
       op = m->BitcastFloat64ToInt64();
       break;
     case wasm::kExprI64Clz:
       op = m->Word64Clz();
       break;
     case wasm::kExprI64Ctz: {
@@ skipping 753 matching lines @@
   Zone zone;
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   JSOperatorBuilder javascript(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, &javascript, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
-  WasmGraphBuilder builder(&zone, &jsgraph);
+  WasmGraphBuilder builder(&zone, &jsgraph, func->sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.set_module(module);
   builder.BuildJSToWasmWrapper(wasm_code, func->sig);
 
   //----------------------------------------------------------------------------
   // Run the compilation pipeline.
   //----------------------------------------------------------------------------
   {
     // Changes lowering requires types.
@@ skipping 61 matching lines @@
   Zone zone;
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   JSOperatorBuilder javascript(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, &javascript, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
-  WasmGraphBuilder builder(&zone, &jsgraph);
+  WasmGraphBuilder builder(&zone, &jsgraph, func->sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.set_module(module);
   builder.BuildWasmToJSWrapper(function, func->sig);
 
   Handle<Code> code = Handle<Code>::null();
   {
     // Changes lowering requires types.
     Typer typer(isolate, &graph);
     NodeVector roots(&zone);
@@ skipping 67 matching lines @@
   env.SumLocals();
 
   // Create a TF graph during decoding.
   Zone zone;
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(
       &zone, MachineType::PointerRepresentation(),
       InstructionSelector::SupportedMachineOperatorFlags());
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
-  WasmGraphBuilder builder(&zone, &jsgraph);
+  WasmGraphBuilder builder(&zone, &jsgraph, function.sig);
   wasm::TreeResult result = wasm::BuildTFGraph(
       &builder, &env,                                                 // --
       module_env->module->module_start,                               // --
       module_env->module->module_start + function.code_start_offset,  // --
       module_env->module->module_start + function.code_end_offset);   // --
 
   if (result.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << result << std::endl;
@@ skipping 30 matching lines @@
     code->Disassemble(buffer, os);
   }
 #endif
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8