A64: Do not initialize VM twice in test-assembler-a64.cc.

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 86 matching lines @@
 static void InitializeVM() {
   if (env.IsEmpty()) {
     env = v8::Context::New();
   }
 }
 #endif
 
 #define __ masm.
 
 #define BUF_SIZE 8192
-#define SETUP() SETUP_SIZE(BUF_SIZE)
+#define SETUP()                                                                \
+  CcTest::InitializeVM();                                                      \
+  SETUP_SIZE(BUF_SIZE)
+
+#define SETUP_HELPER()                                                         \
+  SETUP_SIZE(BUF_SIZE)
 
 #define INIT_V8()                                                              \
-  CcTest::InitializeVM();                                                      \
   Isolate* isolate = Isolate::Current();                                       \
   HandleScope scope(isolate);                                                  \
   ASSERT(isolate != NULL);
 
 #ifdef USE_SIMULATOR
 
 // Run tests with the simulator.
 #define SETUP_SIZE(buf_size)                                                   \
   INIT_V8();                                                                   \
   byte* buf = new byte[buf_size];                                              \
@@ skipping 980 matching lines @@
   ASSERT_EQUAL_64(0, x20);
   ASSERT_EQUAL_64(0xffffffff00000001UL, x21);
   ASSERT_EQUAL_64(0xffffffff, x22);
   ASSERT_EQUAL_64(0xffffffffffffffffUL, x23);
 
   TEARDOWN();
 }
 
 
 static void SmullHelper(int64_t expected, int64_t a, int64_t b) {
-  SETUP();
+  SETUP_HELPER();
   START();
   __ Mov(w0, a);
   __ Mov(w1, b);
   __ Smull(x2, w0, w1);
   END();
   RUN();
   ASSERT_EQUAL_64(expected, x2);
   TEARDOWN();
 }
 
 
 TEST(smull) {
+  CcTest::InitializeVM();

[ulan, 2014/02/04 18:35:59]

Is this OK, or should I put hide it behind macro?

[m.m.capewell, 2014/02/04 18:48:34]

Is it possible to hide it in the TEST macro?

[ulan, 2014/02/05 08:24:54]

That would probably break other tests because TEST is part of cctest.

   SmullHelper(0, 0, 0);
   SmullHelper(1, 1, 1);
   SmullHelper(-1, -1, 1);
   SmullHelper(1, -1, -1);
   SmullHelper(0xffffffff80000000, 0x80000000, 1);
   SmullHelper(0x0000000080000000, 0x00010000, 0x00008000);
 }
 
 
 TEST(madd) {
@@ skipping 3438 matching lines @@
   ASSERT_EQUAL_FP64(0.0, d7);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d8);
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d9);
 
   TEARDOWN();
 }
 
 
 static void FmaddFmsubDoubleHelper(double n, double m, double a,
                                    double fmadd, double fmsub) {
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Fmov(d0, n);
   __ Fmov(d1, m);
   __ Fmov(d2, a);
   __ Fmadd(d28, d0, d1, d2);
   __ Fmsub(d29, d0, d1, d2);
   __ Fnmadd(d30, d0, d1, d2);
   __ Fnmsub(d31, d0, d1, d2);
 
   END();
   RUN();
 
   ASSERT_EQUAL_FP64(fmadd, d28);
   ASSERT_EQUAL_FP64(fmsub, d29);
   ASSERT_EQUAL_FP64(-fmadd, d30);
   ASSERT_EQUAL_FP64(-fmsub, d31);
 
   TEARDOWN();
 }
 
 
 TEST(fmadd_fmsub_double) {
+  CcTest::InitializeVM();
   double inputs[] = {
     // Normal numbers, including -0.0.
     DBL_MAX, DBL_MIN, 3.25, 2.0, 0.0,
     -DBL_MAX, -DBL_MIN, -3.25, -2.0, -0.0,
     // Infinities.
     kFP64NegativeInfinity, kFP64PositiveInfinity,
     // Subnormal numbers.
     rawbits_to_double(0x000fffffffffffff),
     rawbits_to_double(0x0000000000000001),
     rawbits_to_double(0x000123456789abcd),
@@ skipping 16 matching lines @@
         double fmsub = fma(-n, m, a);
 
         FmaddFmsubDoubleHelper(n, m, a, fmadd, fmsub);
       }
     }
   }
 }
 
 
 TEST(fmadd_fmsub_double_rounding) {
+  CcTest::InitializeVM();
   // Make sure we run plenty of tests where an intermediate rounding stage would
   // produce an incorrect result.
   const int limit = 1000;
   int count_fmadd = 0;
   int count_fmsub = 0;
 
   uint16_t seed[3] = {42, 43, 44};
   seed48(seed);
 
   while ((count_fmadd < limit) || (count_fmsub < limit)) {
@@ skipping 28 matching lines @@
 
     if (test_fmadd || test_fmsub) {
       FmaddFmsubDoubleHelper(n, m, a, fmadd, fmsub);
     }
   }
 }
 
 
 static void FmaddFmsubFloatHelper(float n, float m, float a,
                                   float fmadd, float fmsub) {
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Fmov(s0, n);
   __ Fmov(s1, m);
   __ Fmov(s2, a);
   __ Fmadd(s30, s0, s1, s2);
   __ Fmsub(s31, s0, s1, s2);
 
   END();
   RUN();
 
   ASSERT_EQUAL_FP32(fmadd, s30);
   ASSERT_EQUAL_FP32(fmsub, s31);
 
   TEARDOWN();
 }
 
 
 TEST(fmadd_fmsub_float) {
+  CcTest::InitializeVM();
   float inputs[] = {
     // Normal numbers, including -0.0f.
     FLT_MAX, FLT_MIN, 3.25f, 2.0f, 0.0f,
     -FLT_MAX, -FLT_MIN, -3.25f, -2.0f, -0.0f,
     // Infinities.
     kFP32NegativeInfinity, kFP32PositiveInfinity,
     // Subnormal numbers.
     rawbits_to_float(0x07ffffff),
     rawbits_to_float(0x00000001),
     rawbits_to_float(0x01234567),
@@ skipping 16 matching lines @@
         float fmsub = fmaf(-n, m, a);
 
         FmaddFmsubFloatHelper(n, m, a, fmadd, fmsub);
       }
     }
   }
 }
 
 
 TEST(fmadd_fmsub_float_rounding) {
+  CcTest::InitializeVM();
   // Make sure we run plenty of tests where an intermediate rounding stage would
   // produce an incorrect result.
   const int limit = 1000;
   int count_fmadd = 0;
   int count_fmsub = 0;
 
   uint16_t seed[3] = {42, 43, 44};
   seed48(seed);
 
   while ((count_fmadd < limit) || (count_fmsub < limit)) {
@@ skipping 157 matching lines @@
       (copysign(1.0, n) != copysign(1.0, m))) {
     return min ? -0.0 : 0.0;
   }
 
   return min ? fmin(n, m) : fmax(n, m);
 }
 
 
 static void FminFmaxDoubleHelper(double n, double m, double min, double max,
                                  double minnm, double maxnm) {
-  SETUP();
+  SETUP_HELPER();
 
   START();
   __ Fmov(d0, n);
   __ Fmov(d1, m);
   __ Fmin(d28, d0, d1);
   __ Fmax(d29, d0, d1);
   __ Fminnm(d30, d0, d1);
   __ Fmaxnm(d31, d0, d1);
   END();
 
   RUN();
 
   ASSERT_EQUAL_FP64(min, d28);
   ASSERT_EQUAL_FP64(max, d29);
   ASSERT_EQUAL_FP64(minnm, d30);
   ASSERT_EQUAL_FP64(maxnm, d31);
 
   TEARDOWN();
 }
 
 
 TEST(fmax_fmin_d) {
+  CcTest::InitializeVM();
   // Bootstrap tests.
   FminFmaxDoubleHelper(0, 0, 0, 0, 0, 0);
   FminFmaxDoubleHelper(0, 1, 0, 1, 0, 1);
   FminFmaxDoubleHelper(kFP64PositiveInfinity, kFP64NegativeInfinity,
                        kFP64NegativeInfinity, kFP64PositiveInfinity,
                        kFP64NegativeInfinity, kFP64PositiveInfinity);
   FminFmaxDoubleHelper(kFP64SignallingNaN, 0,
                        kFP64SignallingNaN, kFP64SignallingNaN,
                        kFP64SignallingNaN, kFP64SignallingNaN);
   FminFmaxDoubleHelper(kFP64QuietNaN, 0,
@@ skipping 20 matching lines @@
                            MinMaxHelper(n, m, false),
                            MinMaxHelper(n, m, true, kFP64PositiveInfinity),
                            MinMaxHelper(n, m, false, kFP64NegativeInfinity));
     }
   }
 }
 
 
 static void FminFmaxFloatHelper(float n, float m, float min, float max,
                                 float minnm, float maxnm) {
-  SETUP();
+  SETUP_HELPER();
 
   START();
   // TODO(all): Signalling NaNs are sometimes converted by the C compiler to
   // quiet NaNs on implicit casts from float to double. Here, we move the raw
   // bits into a W register first, so we get the correct value. Fix Fmov so this
   // additional step is no longer needed.
   __ Mov(w0, float_to_rawbits(n));
   __ Fmov(s0, w0);
   __ Mov(w0, float_to_rawbits(m));
   __ Fmov(s1, w0);
   __ Fmin(s28, s0, s1);
   __ Fmax(s29, s0, s1);
   __ Fminnm(s30, s0, s1);
   __ Fmaxnm(s31, s0, s1);
   END();
 
   RUN();
 
   ASSERT_EQUAL_FP32(min, s28);
   ASSERT_EQUAL_FP32(max, s29);
   ASSERT_EQUAL_FP32(minnm, s30);
   ASSERT_EQUAL_FP32(maxnm, s31);
 
   TEARDOWN();
 }
 
 
 TEST(fmax_fmin_s) {
+  CcTest::InitializeVM();
   // Bootstrap tests.
   FminFmaxFloatHelper(0, 0, 0, 0, 0, 0);
   FminFmaxFloatHelper(0, 1, 0, 1, 0, 1);
   FminFmaxFloatHelper(kFP32PositiveInfinity, kFP32NegativeInfinity,
                       kFP32NegativeInfinity, kFP32PositiveInfinity,
                       kFP32NegativeInfinity, kFP32PositiveInfinity);
   FminFmaxFloatHelper(kFP32SignallingNaN, 0,
                       kFP32SignallingNaN, kFP32SignallingNaN,
                       kFP32SignallingNaN, kFP32SignallingNaN);
   FminFmaxFloatHelper(kFP32QuietNaN, 0,
@@ skipping 634 matching lines @@
   //  - The remaining mantissa bits are copied until they run out.
   //  - The low-order bits that haven't already been assigned are set to 0.
   ASSERT_EQUAL_FP64(rawbits_to_double(0x7ff82468a0000000), d13);
   ASSERT_EQUAL_FP64(rawbits_to_double(0x7ff82468a0000000), d14);
 
   TEARDOWN();
 }
 
 
 TEST(fcvt_sd) {
+  CcTest::InitializeVM();
   // There are a huge number of corner-cases to check, so this test iterates
   // through a list. The list is then negated and checked again (since the sign
   // is irrelevant in ties-to-even rounding), so the list shouldn't include any
   // negative values.
   //
   // 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},
@@ skipping 75 matching lines @@
   int count = sizeof(test) / sizeof(test[0]);
 
   for (int i = 0; i < count; i++) {
     double in = test[i].in;
     float expected = test[i].expected;
 
     // We only expect positive input.
     ASSERT(std::signbit(in) == 0);
     ASSERT(std::signbit(expected) == 0);
 
-    SETUP();
+    SETUP_HELPER();
     START();
 
     __ Fmov(d10, in);
     __ Fcvt(s20, d10);
 
     __ Fmov(d11, -in);
     __ Fcvt(s21, d11);
 
     END();
     RUN();
@@ skipping 841 matching lines @@
   int32_t s32 = s64 & 0x7fffffff;
 
   bool cvtf_s32 = (s64 == s32);
   bool cvtf_u32 = (u64 == u32);
 
   double results_scvtf_x[65];
   double results_ucvtf_x[65];
   double results_scvtf_w[33];
   double results_ucvtf_w[33];
 
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Mov(x0, reinterpret_cast<int64_t>(results_scvtf_x));
   __ Mov(x1, reinterpret_cast<int64_t>(results_ucvtf_x));
   __ Mov(x2, reinterpret_cast<int64_t>(results_scvtf_w));
   __ Mov(x3, reinterpret_cast<int64_t>(results_ucvtf_w));
 
   __ Mov(x10, s64);
 
   // Corrupt the top word, in case it is accidentally used during W-register
@@ skipping 52 matching lines @@
     double expected_ucvtf = expected_ucvtf_base / pow(2, fbits);
     ASSERT_EQUAL_FP64(expected_scvtf, results_scvtf_x[fbits]);
     ASSERT_EQUAL_FP64(expected_ucvtf, results_ucvtf_x[fbits]);
   }
 
   TEARDOWN();
 }
 
 
 TEST(scvtf_ucvtf_double) {
+  CcTest::InitializeVM();
   // Simple conversions of positive numbers which require no rounding; the
   // results should not depened on the rounding mode, and ucvtf and scvtf should
   // produce the same result.
   TestUScvtfHelper(0x0000000000000000, 0x0000000000000000, 0x0000000000000000);
   TestUScvtfHelper(0x0000000000000001, 0x3ff0000000000000, 0x3ff0000000000000);
   TestUScvtfHelper(0x0000000040000000, 0x41d0000000000000, 0x41d0000000000000);
   TestUScvtfHelper(0x0000000100000000, 0x41f0000000000000, 0x41f0000000000000);
   TestUScvtfHelper(0x4000000000000000, 0x43d0000000000000, 0x43d0000000000000);
   // Test mantissa extremities.
   TestUScvtfHelper(0x4000000000000400, 0x43d0000000000001, 0x43d0000000000001);
@@ skipping 61 matching lines @@
   int32_t s32 = s64 & 0x7fffffff;
 
   bool cvtf_s32 = (s64 == s32);
   bool cvtf_u32 = (u64 == u32);
 
   float results_scvtf_x[65];
   float results_ucvtf_x[65];
   float results_scvtf_w[33];
   float results_ucvtf_w[33];
 
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Mov(x0, reinterpret_cast<int64_t>(results_scvtf_x));
   __ Mov(x1, reinterpret_cast<int64_t>(results_ucvtf_x));
   __ Mov(x2, reinterpret_cast<int64_t>(results_scvtf_w));
   __ Mov(x3, reinterpret_cast<int64_t>(results_ucvtf_w));
 
   __ Mov(x10, s64);
 
   // Corrupt the top word, in case it is accidentally used during W-register
@@ skipping 54 matching lines @@
     float expected_ucvtf = expected_ucvtf_base / powf(2, fbits);
     ASSERT_EQUAL_FP32(expected_scvtf, results_scvtf_x[fbits]);
     ASSERT_EQUAL_FP32(expected_ucvtf, results_ucvtf_x[fbits]);
   }
 
   TEARDOWN();
 }
 
 
 TEST(scvtf_ucvtf_float) {
+  CcTest::InitializeVM();
   // Simple conversions of positive numbers which require no rounding; the
   // results should not depened on the rounding mode, and ucvtf and scvtf should
   // produce the same result.
   TestUScvtf32Helper(0x0000000000000000, 0x00000000, 0x00000000);
   TestUScvtf32Helper(0x0000000000000001, 0x3f800000, 0x3f800000);
   TestUScvtf32Helper(0x0000000040000000, 0x4e800000, 0x4e800000);
   TestUScvtf32Helper(0x0000000100000000, 0x4f800000, 0x4f800000);
   TestUScvtf32Helper(0x4000000000000000, 0x5e800000, 0x5e800000);
   // Test mantissa extremities.
   TestUScvtf32Helper(0x0000000000800001, 0x4b000001, 0x4b000001);
@@ skipping 650 matching lines @@
 //  * Pop <reg_count> registers to restore the original contents.
 //  * Drop <claim> bytes to restore the original stack pointer.
 //
 // Different push and pop methods can be specified independently to test for
 // proper word-endian behaviour.
 static void PushPopJsspSimpleHelper(int reg_count,
                                     int claim,
                                     int reg_size,
                                     PushPopMethod push_method,
                                     PushPopMethod pop_method) {
-  SETUP();
+  SETUP_HELPER();
 
   START();
 
   // Registers x8 and x9 are used by the macro assembler for debug code (for
   // example in 'Pop'), so we can't use them here. We can't use jssp because it
   // will be the stack pointer for this test.
   static RegList const allowed = ~(x8.Bit() | x9.Bit() | jssp.Bit());
   if (reg_count == kPushPopJsspMaxRegCount) {
     reg_count = CountSetBits(allowed, kNumberOfRegisters);
   }
@@ skipping 91 matching lines @@
     } else {
       ASSERT_EQUAL_64(literal_base * i, x[i]);
     }
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_simple_32) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
       PushPopJsspSimpleHelper(count, claim, kWRegSize,
                               PushPopByFour, PushPopByFour);
       PushPopJsspSimpleHelper(count, claim, kWRegSize,
                               PushPopByFour, PushPopRegList);
       PushPopJsspSimpleHelper(count, claim, kWRegSize,
                               PushPopRegList, PushPopByFour);
       PushPopJsspSimpleHelper(count, claim, kWRegSize,
                               PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
     PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
                             PushPopByFour, PushPopByFour);
     PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
                             PushPopByFour, PushPopRegList);
     PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
                             PushPopRegList, PushPopByFour);
     PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
                             PushPopRegList, PushPopRegList);
   }
 }
 
 
 TEST(push_pop_jssp_simple_64) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
       PushPopJsspSimpleHelper(count, claim, kXRegSize,
                               PushPopByFour, PushPopByFour);
       PushPopJsspSimpleHelper(count, claim, kXRegSize,
                               PushPopByFour, PushPopRegList);
       PushPopJsspSimpleHelper(count, claim, kXRegSize,
                               PushPopRegList, PushPopByFour);
       PushPopJsspSimpleHelper(count, claim, kXRegSize,
                               PushPopRegList, PushPopRegList);
@@ skipping 22 matching lines @@
 //  * Pop <reg_count> FP registers to restore the original contents.
 //  * Drop <claim> bytes to restore the original stack pointer.
 //
 // Different push and pop methods can be specified independently to test for
 // proper word-endian behaviour.
 static void PushPopFPJsspSimpleHelper(int reg_count,
                                       int claim,
                                       int reg_size,
                                       PushPopMethod push_method,
                                       PushPopMethod pop_method) {
-  SETUP();
+  SETUP_HELPER();
 
   START();
 
   // We can use any floating-point register. None of them are reserved for
   // debug code, for example.
   static RegList const allowed = ~0;
   if (reg_count == kPushPopFPJsspMaxRegCount) {
     reg_count = CountSetBits(allowed, kNumberOfFPRegisters);
   }
   // Work out which registers to use, based on reg_size.
@@ skipping 93 matching lines @@
     double expected;
     memcpy(&expected, &literal, sizeof(expected));
     ASSERT_EQUAL_FP64(expected, d[i]);
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_fp_jssp_simple_32) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
       PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
                                 PushPopByFour, PushPopByFour);
       PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
                                 PushPopByFour, PushPopRegList);
       PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
                                 PushPopRegList, PushPopByFour);
       PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
                                 PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
                               PushPopByFour, PushPopByFour);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
                               PushPopByFour, PushPopRegList);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
                               PushPopRegList, PushPopByFour);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
                               PushPopRegList, PushPopRegList);
   }
 }
 
 
 TEST(push_pop_fp_jssp_simple_64) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
       PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
                                 PushPopByFour, PushPopByFour);
       PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
                                 PushPopByFour, PushPopRegList);
       PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
                                 PushPopRegList, PushPopByFour);
       PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
                                 PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
                               PushPopByFour, PushPopByFour);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
                               PushPopByFour, PushPopRegList);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
                               PushPopRegList, PushPopByFour);
     PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
                               PushPopRegList, PushPopRegList);
   }
 }
 
 
 // Push and pop data using an overlapping combination of Push/Pop and
 // RegList-based methods.
 static void PushPopJsspMixedMethodsHelper(int claim, int reg_size) {
-  SETUP();
+  SETUP_HELPER();
 
   // Registers x8 and x9 are used by the macro assembler for debug code (for
   // example in 'Pop'), so we can't use them here. We can't use jssp because it
   // will be the stack pointer for this test.
   static RegList const allowed =
       ~(x8.Bit() | x9.Bit() | jssp.Bit() | xzr.Bit());
   // Work out which registers to use, based on reg_size.
   Register r[10];
   Register x[10];
   PopulateRegisterArray(NULL, x, r, reg_size, 10, allowed);
@@ skipping 66 matching lines @@
   ASSERT_EQUAL_64(literal_base * 0, x[7]);
   ASSERT_EQUAL_64(literal_base * 3, x[6]);
   ASSERT_EQUAL_64(literal_base * 1, x[5]);
   ASSERT_EQUAL_64(literal_base * 2, x[4]);
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_mixed_methods_64) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     PushPopJsspMixedMethodsHelper(claim, kXRegSize);
   }
 }
 
 
 TEST(push_pop_jssp_mixed_methods_32) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     PushPopJsspMixedMethodsHelper(claim, kWRegSize);
   }
 }
 
 
 // Push and pop data using overlapping X- and W-sized quantities.
 static void PushPopJsspWXOverlapHelper(int reg_count, int claim) {
   // This test emits rather a lot of code.
   SETUP_SIZE(BUF_SIZE * 2);
@@ skipping 175 matching lines @@
       ASSERT_EQUAL_64(expected, x[i]);
     }
   }
   ASSERT(slot == requested_w_slots);
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_wx_overlap) {
+  CcTest::InitializeVM();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 1; count <= 8; count++) {
       PushPopJsspWXOverlapHelper(count, claim);
       PushPopJsspWXOverlapHelper(count, claim);
       PushPopJsspWXOverlapHelper(count, claim);
       PushPopJsspWXOverlapHelper(count, claim);
     }
     // Test with the maximum number of registers.
     PushPopJsspWXOverlapHelper(kPushPopJsspMaxRegCount, claim);
     PushPopJsspWXOverlapHelper(kPushPopJsspMaxRegCount, claim);
@@ skipping 805 matching lines @@
   dst_tagged[0] = kHeapObjectTag;
 
   // Allocate memory for each other test. Each test <n> will have <n> fields.
   // This is intended to exercise as many paths in CopyFields as possible.
   for (unsigned i = 1; i < kTestCount; i++) {
     dst[i] = new uint64_t[i];
     memset(dst[i], 0, i * sizeof(kLiteralBase));
     dst_tagged[i] = reinterpret_cast<uint64_t>(dst[i]) + kHeapObjectTag;
   }
 
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Mov(x0, dst_tagged[0]);
   __ Mov(x1, 0);
   __ CopyFields(x0, x1, temps, 0);
   for (unsigned i = 1; i < kTestCount; i++) {
     __ Mov(x0, dst_tagged[i]);
     __ Mov(x1, src_tagged);
     __ CopyFields(x0, x1, temps, i);
   }
 
   END();
   RUN();
   TEARDOWN();
 
   for (unsigned i = 1; i < kTestCount; i++) {
     for (unsigned j = 0; j < i; j++) {
       CHECK(src[j] == dst[i][j]);
     }
     delete [] dst[i];
   }
 }
 
 
 // This is a V8-specific test.
 TEST(copyfields) {
+  CcTest::InitializeVM();
   CopyFieldsHelper(CPURegList(x10));
   CopyFieldsHelper(CPURegList(x10, x11));
   CopyFieldsHelper(CPURegList(x10, x11, x12));
   CopyFieldsHelper(CPURegList(x10, x11, x12, x13));
 }
 
 
 static void DoSmiAbsTest(int32_t value, bool must_fail = false) {
-  SETUP();
+  SETUP_HELPER();
 
   START();
   Label end, slow;
   __ Mov(x2, 0xc001c0de);
   __ Mov(x1, value);
   __ SmiTag(x1);
   __ SmiAbs(x1, x0, &slow);
   __ SmiUntag(x1);
   __ B(&end);
 
@@ skipping 15 matching lines @@
 
     // Check that we didn't jump on slow.
     ASSERT_EQUAL_64(0xc001c0de, x2);
   }
 
   TEARDOWN();
 }
 
 
 TEST(smi_abs) {
+  CcTest::InitializeVM();
   // Simple and edge cases.
   DoSmiAbsTest(0);
   DoSmiAbsTest(0x12345);
   DoSmiAbsTest(0x40000000);
   DoSmiAbsTest(0x7fffffff);
   DoSmiAbsTest(-1);
   DoSmiAbsTest(-12345);
   DoSmiAbsTest(0x80000001);
 
   // Check that the most negative SMI is detected.
@@ skipping 127 matching lines @@
   // TODO(jbramley): Once Crankshaft is complete, decide if we need to support
   // non-relocatable calls at all.
   CHECK(return_address ==
         Assembler::return_address_from_call_start(call_start));
 
   TEARDOWN();
 }
 
 
 static void ECMA262ToInt32Helper(int32_t expected, double input) {
-  SETUP();
+  SETUP_HELPER();
   START();
 
   __ Fmov(d0, input);
 
   __ ECMA262ToInt32(x0, d0, x10, x11, MacroAssembler::INT32_IN_W);
   __ ECMA262ToInt32(x1, d0, x10, x11, MacroAssembler::INT32_IN_X);
   __ ECMA262ToInt32(x2, d0, x10, x11, MacroAssembler::SMI);
 
   // The upper bits of INT32_IN_W are undefined, so make sure we don't try to
   // test them.
   __ Mov(w0, w0);
 
   END();
 
   RUN();
 
   int64_t expected64 = expected;
 
   ASSERT_EQUAL_32(expected, w0);
   ASSERT_EQUAL_64(expected64, x1);
   ASSERT_EQUAL_64(expected64 << kSmiShift | kSmiTag, x2);
 
   TEARDOWN();
 }
 
 
 TEST(ecma_262_to_int32) {
+  CcTest::InitializeVM();
   // ==== 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));
@@ skipping 54 matching lines @@
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::quiet_NaN());
   ECMA262ToInt32Helper(0, -std::numeric_limits<double>::quiet_NaN());
   ECMA262ToInt32Helper(0, std::numeric_limits<double>::signaling_NaN());
   ECMA262ToInt32Helper(0, -std::numeric_limits<double>::signaling_NaN());
 }
 
 
 static void AbsHelperX(int64_t value) {
   int64_t expected;
 
-  SETUP();
+  SETUP_HELPER();
   START();
 
   Label fail;
   Label done;
 
   __ Mov(x0, 0);
   __ Mov(x1, value);
 
   if (value != kXMinInt) {
     expected = labs(value);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_64(expected, x12);
   ASSERT_EQUAL_64(expected, x13);
 
   TEARDOWN();
 }
 
 
 static void AbsHelperW(int32_t value) {
   int32_t expected;
 
-  SETUP();
+  SETUP_HELPER();
   START();
 
   Label fail;
   Label done;
 
   __ Mov(w0, 0);
   // TODO(jbramley): The cast is needed to avoid a sign-extension bug in VIXL.
   // Once it is fixed, we should remove the cast.
   __ Mov(w1, static_cast<uint32_t>(value));
 
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_32(expected, w10);
   ASSERT_EQUAL_32(expected, w11);
   ASSERT_EQUAL_32(expected, w12);
   ASSERT_EQUAL_32(expected, w13);
 
   TEARDOWN();
 }
 
 
 TEST(abs) {
+  CcTest::InitializeVM();
   AbsHelperX(0);
   AbsHelperX(42);
   AbsHelperX(-42);
   AbsHelperX(kXMinInt);
   AbsHelperX(kXMaxInt);
 
   AbsHelperW(0);
   AbsHelperW(42);
   AbsHelperW(-42);
   AbsHelperW(kWMinInt);
   AbsHelperW(kWMaxInt);
 }