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

test/cctest/wasm/test-run-wasm.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 <stdlib.h>
 #include <string.h>
 
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/wasm-compiler.h"
@@ skipping 14 matching lines @@
 #if !V8_TARGET_ARCH_32_BIT || V8_TARGET_ARCH_X64
 #define WASM_64 1
 #else
 #define WASM_64 0
 #endif
 
 // TODO(titzer): check traps more robustly in tests.
 // Currently, in tests, we just return 0xdeadbeef from the function in which
 // the trap occurs if the runtime context is not available to throw a JavaScript
 // exception.
-#define CHECK_TRAP(x) CHECK_EQ(0xdeadbeef, (x)&0xFFFFFFFF)
+#define CHECK_TRAP32(x) \
+  CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
+#define CHECK_TRAP64(x) \
+  CHECK_EQ(0xdeadbeefdeadbeef, (bit_cast<uint64_t>(x)) & 0xFFFFFFFFFFFFFFFF)
+#define CHECK_TRAP(x) CHECK_TRAP32(x)
+
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
 
 static void init_env(FunctionEnv* env, FunctionSig* sig) {
   env->module = nullptr;
   env->sig = sig;
   env->local_int32_count = 0;
@@ skipping 161 matching lines @@
   CallDescriptor* descriptor_;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   CallDescriptor* descriptor() { return descriptor_; }
 
   void Build(const byte* start, const byte* end) {
-    compiler::WasmGraphBuilder builder(main_zone(), &jsgraph);
+    compiler::WasmGraphBuilder builder(main_zone(), &jsgraph, env.sig);
     TreeResult result = BuildTFGraph(&builder, &env, start, end);
     if (result.failed()) {
       ptrdiff_t pc = result.error_pc - result.start;
       ptrdiff_t pt = result.error_pt - result.start;
       std::ostringstream str;
       str << "Verification failed: " << result.error_code << " pc = +" << pc;
       if (result.error_pt) str << ", pt = +" << pt;
       str << ", msg = " << result.error_msg.get();
       FATAL(str.str().c_str());
     }
@@ skipping 738 matching lines @@
   CHECK_TRAP(r.Call(0, 0));
 }
 
 
 #if WASM_64
 #define as64(x) static_cast<int64_t>(x)
 TEST(Run_WASM_Int64DivS_trap) {
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(0, r.Call(as64(0), as64(100)));
-  CHECK_TRAP(r.Call(as64(100), as64(0)));
-  CHECK_TRAP(r.Call(as64(-1001), as64(0)));
-  CHECK_TRAP(r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
-  CHECK_TRAP(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
+  CHECK_TRAP64(r.Call(as64(100), as64(0)));
+  CHECK_TRAP64(r.Call(as64(-1001), as64(0)));
+  CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
+  CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
 }
 
 
 TEST(Run_WASM_Int64RemS_trap) {
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(33, r.Call(as64(133), as64(100)));
   CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
-  CHECK_TRAP(r.Call(as64(100), as64(0)));
-  CHECK_TRAP(r.Call(as64(-1001), as64(0)));
-  CHECK_TRAP(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
+  CHECK_TRAP64(r.Call(as64(100), as64(0)));
+  CHECK_TRAP64(r.Call(as64(-1001), as64(0)));
+  CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
 }
 
 
 TEST(Run_WASM_Int64DivU_trap) {
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(0, r.Call(as64(0), as64(100)));
   CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
-  CHECK_TRAP(r.Call(as64(100), as64(0)));
-  CHECK_TRAP(r.Call(as64(-1001), as64(0)));
-  CHECK_TRAP(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
+  CHECK_TRAP64(r.Call(as64(100), as64(0)));
+  CHECK_TRAP64(r.Call(as64(-1001), as64(0)));
+  CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
 }
 
 
 TEST(Run_WASM_Int64RemU_trap) {
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   CHECK_EQ(17, r.Call(as64(217), as64(100)));
-  CHECK_TRAP(r.Call(as64(100), as64(0)));
-  CHECK_TRAP(r.Call(as64(-1001), as64(0)));
-  CHECK_TRAP(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
+  CHECK_TRAP64(r.Call(as64(100), as64(0)));
+  CHECK_TRAP64(r.Call(as64(-1001), as64(0)));
+  CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
   CHECK_EQ(std::numeric_limits<int64_t>::min(),
            r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
 }
 
 
 TEST(Run_WASM_Int64DivS_byzero_const) {
   for (int8_t denom = -2; denom < 8; denom++) {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64(denom)));
     for (int64_t val = -7; val < 8; val++) {
       if (denom == 0) {
-        CHECK_TRAP(r.Call(val));
+        CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 
 TEST(Run_WASM_Int64DivU_byzero_const) {
   for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
     WasmRunner<uint64_t> r(MachineType::Uint64());
     BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64(denom)));
 
     for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) {
       if (denom == 0) {
-        CHECK_TRAP(r.Call(val));
+        CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 #endif
 
 
 void TestFloat32Binop(WasmOpcode opcode, int32_t expected, float a, float b) {
@@ skipping 2186 matching lines @@
 }
 
 
 TEST(Run_Wasm_F64UConvertI64) {
   WasmRunner<double> r(MachineType::Uint64());
   BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0)));
   FOR_UINT64_INPUTS(i) { CHECK_EQ(static_cast<double>(*i), r.Call(*i)); }
 }
 
 
+TEST(Run_Wasm_I64SConvertF32) {
+  WasmRunner<int64_t> r(MachineType::Float32());
+  BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
+
+  FOR_FLOAT32_INPUTS(i) {
+    if (*i < 9223372036854775808.0 && *i > -9223372036854775809.0) {
+      CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
+    } else {
+      CHECK_TRAP64(r.Call(*i));
+    }
+  }
+}
+
+
+TEST(Run_Wasm_I64SConvertF64) {
+  WasmRunner<int64_t> r(MachineType::Float64());
+  BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
+
+  FOR_FLOAT64_INPUTS(i) {
+    if (*i < 9223372036854775808.0 && *i > -9223372036854775809.0) {
+      CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
+    } else {
+      CHECK_TRAP64(r.Call(*i));
+    }
+  }
+}
+
+
+TEST(Run_Wasm_I64UConvertF32) {
+  WasmRunner<uint64_t> r(MachineType::Float32());
+  BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
+
+  FOR_FLOAT32_INPUTS(i) {
+    if (*i < 18446744073709551616.0 && *i >= 0) {
+      CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
+    } else {
+      CHECK_TRAP64(r.Call(*i));
+    }
+  }
+}
+
+
+TEST(Run_Wasm_I64UConvertF64) {
+  WasmRunner<uint64_t> r(MachineType::Float64());
+  BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
+
+  FOR_FLOAT64_INPUTS(i) {
+    if (*i < 18446744073709551616.0 && *i >= 0) {
+      CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i));
+    } else {
+      CHECK_TRAP64(r.Call(*i));
+    }
+  }
+}
 #endif
 
 
 TEST(Run_Wasm_F64CopySign) {
   WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
   BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(copysign(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 
 TEST(Run_Wasm_F32CopySign) {
   WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
   BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
     FOR_FLOAT32_INPUTS(j) { CheckFloatEq(copysign(*i, *j), r.Call(*i, *j)); }
   }
 }