A64: More fixes to enable building for Android Arm64

test/cctest/test-assembler-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 148 matching lines @@
   __ Ret();                                                                    \
   __ GetCode(NULL);
 
 #define TEARDOWN()                                                             \
   delete pdis;                                                                 \
   delete[] buf;
 
 #else  // ifdef USE_SIMULATOR.
 // Run the test on real hardware or models.
 #define SETUP_SIZE(buf_size)                                                   \
+  Isolate* isolate = Isolate::Current();                                       \
+  HandleScope scope(isolate);                                                  \
+  ASSERT(isolate != NULL);                                                     \
   byte* buf = new byte[buf_size];                                              \
   MacroAssembler masm(isolate, buf, buf_size);                                 \
   RegisterDump core;                                                           \
   CPU::SetUp();
 
 #define RESET()                                                                \
   __ Reset();
 
 #define START_AFTER_RESET()                                                    \
   __ SetStackPointer(csp);                                                     \
@@ skipping 5603 matching lines @@
   // Note that this test only checks ties-to-even rounding, because that is all
   // that the simulator supports.
   struct {double in; float expected;} test[] = {
     // Check some simple conversions.
     {0.0, 0.0f},
     {1.0, 1.0f},
     {1.5, 1.5f},
     {2.0, 2.0f},
     {FLT_MAX, FLT_MAX},
     //  - The smallest normalized float.
-    {pow(2, -126), powf(2, -126)},
+    {pow(2.0, -126), powf(2, -126)},
     //  - Normal floats that need (ties-to-even) rounding.
     //    For normalized numbers:
     //         bit 29 (0x0000000020000000) is the lowest-order bit which will
     //                                     fit in the float's mantissa.
     {rawbits_to_double(0x3ff0000000000000), rawbits_to_float(0x3f800000)},
     {rawbits_to_double(0x3ff0000000000001), rawbits_to_float(0x3f800000)},
     {rawbits_to_double(0x3ff0000010000000), rawbits_to_float(0x3f800000)},
     {rawbits_to_double(0x3ff0000010000001), rawbits_to_float(0x3f800001)},
     {rawbits_to_double(0x3ff0000020000000), rawbits_to_float(0x3f800001)},
     {rawbits_to_double(0x3ff0000020000001), rawbits_to_float(0x3f800001)},
     {rawbits_to_double(0x3ff0000030000000), rawbits_to_float(0x3f800002)},
     {rawbits_to_double(0x3ff0000030000001), rawbits_to_float(0x3f800002)},
     {rawbits_to_double(0x3ff0000040000000), rawbits_to_float(0x3f800002)},
     {rawbits_to_double(0x3ff0000040000001), rawbits_to_float(0x3f800002)},
     {rawbits_to_double(0x3ff0000050000000), rawbits_to_float(0x3f800002)},
     {rawbits_to_double(0x3ff0000050000001), rawbits_to_float(0x3f800003)},
     {rawbits_to_double(0x3ff0000060000000), rawbits_to_float(0x3f800003)},
     //  - A mantissa that overflows into the exponent during rounding.
     {rawbits_to_double(0x3feffffff0000000), rawbits_to_float(0x3f800000)},
     //  - The largest double that rounds to a normal float.
     {rawbits_to_double(0x47efffffefffffff), rawbits_to_float(0x7f7fffff)},
 
     // Doubles that are too big for a float.
     {kFP64PositiveInfinity, kFP32PositiveInfinity},
     {DBL_MAX, kFP32PositiveInfinity},
     //  - The smallest exponent that's too big for a float.
-    {pow(2, 128), kFP32PositiveInfinity},
+    {pow(2.0, 128), kFP32PositiveInfinity},
     //  - This exponent is in range, but the value rounds to infinity.
     {rawbits_to_double(0x47effffff0000000), kFP32PositiveInfinity},
 
     // Doubles that are too small for a float.
     //  - The smallest (subnormal) double.
     {DBL_MIN, 0.0},
     //  - The largest double which is too small for a subnormal float.
     {rawbits_to_double(0x3690000000000000), rawbits_to_float(0x00000000)},
 
     // Normal doubles that become subnormal floats.
@@ skipping 956 matching lines @@
   }
 
   END();
   RUN();
 
   // Check the results.
   double expected_scvtf_base = rawbits_to_double(expected_scvtf_bits);
   double expected_ucvtf_base = rawbits_to_double(expected_ucvtf_bits);
 
   for (int fbits = 0; fbits <= 32; fbits++) {
-    double expected_scvtf = expected_scvtf_base / pow(2, fbits);
-    double expected_ucvtf = expected_ucvtf_base / pow(2, fbits);
+    double expected_scvtf = expected_scvtf_base / pow(2.0, fbits);
+    double expected_ucvtf = expected_ucvtf_base / pow(2.0, fbits);
     ASSERT_EQUAL_FP64(expected_scvtf, results_scvtf_x[fbits]);
     ASSERT_EQUAL_FP64(expected_ucvtf, results_ucvtf_x[fbits]);
     if (cvtf_s32) ASSERT_EQUAL_FP64(expected_scvtf, results_scvtf_w[fbits]);
     if (cvtf_u32) ASSERT_EQUAL_FP64(expected_ucvtf, results_ucvtf_w[fbits]);
   }
   for (int fbits = 33; fbits <= 64; fbits++) {
-    double expected_scvtf = expected_scvtf_base / pow(2, fbits);
-    double expected_ucvtf = expected_ucvtf_base / pow(2, fbits);
+    double expected_scvtf = expected_scvtf_base / pow(2.0, fbits);
+    double expected_ucvtf = expected_ucvtf_base / pow(2.0, fbits);
     ASSERT_EQUAL_FP64(expected_scvtf, results_scvtf_x[fbits]);
     ASSERT_EQUAL_FP64(expected_ucvtf, results_ucvtf_x[fbits]);
   }
 
   TEARDOWN();
 }
 
 
 TEST(scvtf_ucvtf_double) {
   INIT_V8();
@@ skipping 2558 matching lines @@
 TEST(ecma_262_to_int32) {
   INIT_V8();
   // ==== exponent < 64 ====
 
   ECMA262ToInt32Helper(0, 0.0);
   ECMA262ToInt32Helper(0, -0.0);
   ECMA262ToInt32Helper(1, 1.0);
   ECMA262ToInt32Helper(-1, -1.0);
 
   // The largest representable value that is less than 1.
-  ECMA262ToInt32Helper(0, 0x001fffffffffffff * pow(2, -53));
-  ECMA262ToInt32Helper(0, 0x001fffffffffffff * -pow(2, -53));
+  ECMA262ToInt32Helper(0, 0x001fffffffffffff * pow(2.0, -53));
+  ECMA262ToInt32Helper(0, 0x001fffffffffffff * -pow(2.0, -53));
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::denorm_min());
   ECMA262ToInt32Helper(0, -std::numeric_limits<double>::denorm_min());
 
   // The largest conversion which doesn't require the integer modulo-2^32 step.
   ECMA262ToInt32Helper(0x7fffffff, 0x7fffffff);
   ECMA262ToInt32Helper(-0x80000000, -0x80000000);
 
   // The largest simple conversion, requiring module-2^32, but where the fcvt
   // does not saturate when converting to int64_t.
   ECMA262ToInt32Helper(0xfffffc00, 0x7ffffffffffffc00);
   ECMA262ToInt32Helper(-0xfffffc00, 0x7ffffffffffffc00 * -1.0);
 
   // ==== 64 <= exponent < 84 ====
 
   // The smallest conversion where the fcvt saturates.
   ECMA262ToInt32Helper(0, 0x8000000000000000);
   ECMA262ToInt32Helper(0, 0x8000000000000000 * -1.0);
 
   // The smallest conversion where the fcvt saturates, and where all the
   // mantissa bits are '1' (to check the shift logic).
   ECMA262ToInt32Helper(0xfffff800, 0xfffffffffffff800);
   ECMA262ToInt32Helper(-0xfffff800, 0xfffffffffffff800 * -1.0);
 
   // The largest conversion which doesn't produce a zero result.
-  ECMA262ToInt32Helper(0x80000000, 0x001fffffffffffff * pow(2, 31));
-  ECMA262ToInt32Helper(-0x80000000, 0x001fffffffffffff * -pow(2, 31));
+  ECMA262ToInt32Helper(0x80000000, 0x001fffffffffffff * pow(2.0, 31));
+  ECMA262ToInt32Helper(-0x80000000, 0x001fffffffffffff * -pow(2.0, 31));
 
   // Some large conversions to check the shifting function.
   ECMA262ToInt32Helper(0x6789abcd, 0x001123456789abcd);
-  ECMA262ToInt32Helper(0x12345678, 0x001123456789abcd * pow(2, -20));
-  ECMA262ToInt32Helper(0x891a2b3c, 0x001123456789abcd * pow(2, -21));
-  ECMA262ToInt32Helper(0x11234567, 0x001123456789abcd * pow(2, -24));
+  ECMA262ToInt32Helper(0x12345678, 0x001123456789abcd * pow(2.0, -20));
+  ECMA262ToInt32Helper(0x891a2b3c, 0x001123456789abcd * pow(2.0, -21));
+  ECMA262ToInt32Helper(0x11234567, 0x001123456789abcd * pow(2.0, -24));
   ECMA262ToInt32Helper(-0x6789abcd, 0x001123456789abcd * -1.0);
-  ECMA262ToInt32Helper(-0x12345678, 0x001123456789abcd * -pow(2, -20));
-  ECMA262ToInt32Helper(-0x891a2b3c, 0x001123456789abcd * -pow(2, -21));
-  ECMA262ToInt32Helper(-0x11234567, 0x001123456789abcd * -pow(2, -24));
+  ECMA262ToInt32Helper(-0x12345678, 0x001123456789abcd * -pow(2.0, -20));
+  ECMA262ToInt32Helper(-0x891a2b3c, 0x001123456789abcd * -pow(2.0, -21));
+  ECMA262ToInt32Helper(-0x11234567, 0x001123456789abcd * -pow(2.0, -24));
 
   // ==== 84 <= exponent ====
 
   // The smallest conversion which produces a zero result by shifting the
   // mantissa out of the int32_t range.
-  ECMA262ToInt32Helper(0, pow(2, 32));
-  ECMA262ToInt32Helper(0, -pow(2, 32));
+  ECMA262ToInt32Helper(0, pow(2.0, 32));
+  ECMA262ToInt32Helper(0, -pow(2.0, 32));
 
   // Some very large conversions.
-  ECMA262ToInt32Helper(0, 0x001fffffffffffff * pow(2, 32));
-  ECMA262ToInt32Helper(0, 0x001fffffffffffff * -pow(2, 32));
+  ECMA262ToInt32Helper(0, 0x001fffffffffffff * pow(2.0, 32));
+  ECMA262ToInt32Helper(0, 0x001fffffffffffff * -pow(2.0, 32));
   ECMA262ToInt32Helper(0, DBL_MAX);
   ECMA262ToInt32Helper(0, -DBL_MAX);
 
   // ==== Special values. ====
 
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::infinity());
   ECMA262ToInt32Helper(0, -std::numeric_limits<double>::infinity());
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::quiet_NaN());
   ECMA262ToInt32Helper(0, -std::numeric_limits<double>::quiet_NaN());
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::signaling_NaN());
@@ skipping 120 matching lines @@
   AbsHelperX(-42);
   AbsHelperX(kXMinInt);
   AbsHelperX(kXMaxInt);
 
   AbsHelperW(0);
   AbsHelperW(42);
   AbsHelperW(-42);
   AbsHelperW(kWMinInt);
   AbsHelperW(kWMaxInt);
 }