[test] Add FOR_INT64_INPUTS and FOR_UINT64_INPUTS.

test/cctest/compiler/test-run-machops.cc

 // Copyright 2014 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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 5262 matching lines @@
                             kMachInt32, function, param, param, param, param,
                             param, param, param, param));
   FOR_INT32_INPUTS(i) {
     int32_t const x = *i;
     CHECK_EQ(x * 8, m.Call(x));
   }
 }
 #endif  // USE_SIMULATOR
 
 #if V8_TARGET_ARCH_64_BIT
+// TODO(titzer): run int64 tests on all platforms when supported.
 TEST(RunCheckedLoadInt64) {
   int64_t buffer[] = {0x66bbccddeeff0011LL, 0x1122334455667788LL};
   RawMachineAssemblerTester<int64_t> m(kMachInt32);
   Node* base = m.PointerConstant(buffer);
   Node* index = m.Parameter(0);
   Node* length = m.Int32Constant(16);
   Node* load =
       m.AddNode(m.machine()->CheckedLoad(kMachInt64), base, index, length);
   m.Return(load);
 
@@ skipping 25 matching lines @@
   CHECK_EQ(write, buffer[0]);
   CHECK_EQ(before, buffer[1]);
 
   CHECK_EQ(11, m.Call(8));
   CHECK_EQ(write, buffer[0]);
   CHECK_EQ(write, buffer[1]);
 }
 
 
 TEST(RunBitcastInt64ToFloat64) {
-  // TODO(titzer): run int64 tests on all platforms when supported.
   int64_t input = 1;
   double output = 0.0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
       &output, kMachFloat64,
       m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, kMachInt64)));
   m.Return(m.Int32Constant(11));
-  FOR_INT32_INPUTS(i) {
-    input = static_cast<int64_t>(*i) * 14444;
+  FOR_INT64_INPUTS(i) {
+    input = *i;
     CHECK_EQ(11, m.Call());
     double expected = bit_cast<double>(input);
     CHECK_EQ(bit_cast<int64_t>(expected), bit_cast<int64_t>(output));
   }
 }
 
 
 TEST(RunBitcastFloat64ToInt64) {
-  // TODO(titzer): run int64 tests on all platforms when supported.
   double input = 0;
   int64_t output = 0;
   RawMachineAssemblerTester<int32_t> m;
   m.StoreToPointer(
       &output, kMachInt64,
       m.BitcastFloat64ToInt64(m.LoadFromPointer(&input, kMachFloat64)));
   m.Return(m.Int32Constant(11));
   FOR_FLOAT64_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
@@ skipping 24 matching lines @@
       &output, kMachFloat32,
       m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, kMachInt32)));
   m.Return(m.Int32Constant(11));
   FOR_INT32_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
     float expected = bit_cast<float>(input);
     CHECK_EQ(bit_cast<int32_t>(expected), bit_cast<int32_t>(output));
   }
 }