x87: fix the use of CheckFloatEq and CheckDoubleEq in test.

test/cctest/compiler/test-run-calls-to-external-references.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 "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 template <typename T>
 void TestExternalReferenceRoundingFunction(
     BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
     T (*comparison)(T)) {
   T parameter;
 
   Node* function = m->ExternalConstant(ref);
   m->CallCFunction1(MachineType::Pointer(), MachineType::Pointer(), function,
                     m->PointerConstant(&parameter));
   m->Return(m->Int32Constant(4356));
   FOR_FLOAT64_INPUTS(i) {
     parameter = *i;
     m->Call();
-    CheckDoubleEq(comparison(*i), parameter);
+    CHECK_DOUBLE_EQ(comparison(*i), parameter);
   }
 }
 
 TEST(RunCallF32Trunc) {
   BufferedRawMachineAssemblerTester<int32_t> m;
   ExternalReference ref = ExternalReference::wasm_f32_trunc(m.isolate());
   TestExternalReferenceRoundingFunction<float>(&m, ref, truncf);
 }
 
 TEST(RunCallF32Floor) {
@@ skipping 46 matching lines @@
   float output;
 
   Node* function = m.ExternalConstant(ref);
   m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
                    MachineType::Pointer(), function, m.PointerConstant(&input),
                    m.PointerConstant(&output));
   m.Return(m.Int32Constant(4356));
   FOR_INT64_INPUTS(i) {
     input = *i;
     m.Call();
-    CheckFloatEq(static_cast<float>(*i), output);
+    CHECK_FLOAT_EQ(static_cast<float>(*i), output);
   }
 }
 
 TEST(RunCallUint64ToFloat32) {
   struct {
     uint64_t input;
     uint32_t expected;
   } values[] = {{0x0, 0x0},
                 {0x1, 0x3f800000},
                 {0xffffffff, 0x4f800000},
@@ skipping 107 matching lines @@
   double output;
 
   Node* function = m.ExternalConstant(ref);
   m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
                    MachineType::Pointer(), function, m.PointerConstant(&input),
                    m.PointerConstant(&output));
   m.Return(m.Int32Constant(4356));
   FOR_INT64_INPUTS(i) {
     input = *i;
     m.Call();
-    CheckDoubleEq(static_cast<double>(*i), output);
+    CHECK_DOUBLE_EQ(static_cast<double>(*i), output);
   }
 }
 
 TEST(RunCallUint64ToFloat64) {
   struct {
     uint64_t input;
     uint64_t expected;
   } values[] = {{0x0, 0x0},
                 {0x1, 0x3ff0000000000000},
                 {0xffffffff, 0x41efffffffe00000},
@@ skipping 95 matching lines @@
   for (size_t i = 0; i < arraysize(values); i++) {
     input = values[i].input;
     m.Call();
     CHECK_EQ(values[i].expected, bit_cast<uint64_t>(output));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8