A64: Only initialize V8 per test 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 90 matching lines @@
 }
 #endif
 
 #define __ masm.
 
 #define BUF_SIZE 8192
 #define SETUP() 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();                                                                   \
+  Isolate* isolate = Isolate::Current();                                       \
+  HandleScope scope(isolate);                                                  \
+  ASSERT(isolate != NULL);                                                     \
   byte* buf = new byte[buf_size];                                              \
   MacroAssembler masm(isolate, buf, buf_size);                                 \
   Decoder decoder;                                                             \
   Simulator simulator(&decoder);                                               \
   PrintDisassembler* pdis = NULL;                                              \
   RegisterDump core;
 
 /*  if (Cctest::trace_sim()) {                                                 \
     pdis = new PrintDisassembler(stdout);                                      \
     decoder.PrependVisitor(pdis);                                              \
@@ skipping 30 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)                                                   \
-  INIT_V8();                                                                   \
   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 43 matching lines @@
 #ifdef DEBUG
 #define ASSERT_LITERAL_POOL_SIZE(expected)                                     \
   CHECK((expected) == (__ LiteralPoolSize()))
 #else
 #define ASSERT_LITERAL_POOL_SIZE(expected)                                     \
   ((void) 0)
 #endif
 
 
 TEST(stack_ops) {
+  INIT_V8();
   SETUP();
 
   START();
   // save csp.
   __ Mov(x29, csp);
 
   // Set the csp to a known value.
   __ Mov(x16, 0x1000);
   __ Mov(csp, x16);
   __ Mov(x0, csp);
@@ skipping 30 matching lines @@
   ASSERT_EQUAL_64(0x104f, x2);
   ASSERT_EQUAL_64(0x1fff, x3);
   ASSERT_EQUAL_64(0xfffffff8, x4);
   ASSERT_EQUAL_64(0xfffffff8, x5);
 
   TEARDOWN();
 }
 
 
 TEST(mvn) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mvn(w0, 0xfff);
   __ Mvn(x1, 0xfff);
   __ Mvn(w2, Operand(w0, LSL, 1));
   __ Mvn(x3, Operand(x1, LSL, 2));
   __ Mvn(w4, Operand(w0, LSR, 3));
   __ Mvn(x5, Operand(x1, LSR, 4));
   __ Mvn(w6, Operand(w0, ASR, 11));
@@ skipping 25 matching lines @@
   ASSERT_EQUAL_64(0xffff8003, x12);
   ASSERT_EQUAL_64(0xffffffffffff0007UL, x13);
   ASSERT_EQUAL_64(0xfffffffffffe000fUL, x14);
   ASSERT_EQUAL_64(0xfffffffffffe000fUL, x15);
 
   TEARDOWN();
 }
 
 
 TEST(mov) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xffffffffffffffffL);
   __ Mov(x1, 0xffffffffffffffffL);
   __ Mov(x2, 0xffffffffffffffffL);
   __ Mov(x3, 0xffffffffffffffffL);
 
   __ Mov(x0, 0x0123456789abcdefL);
 
@@ skipping 60 matching lines @@
   ASSERT_EQUAL_64(0xfffffffffffffffcUL, x24);
   ASSERT_EQUAL_64(0x00007ff8, x25);
   ASSERT_EQUAL_64(0x000000000000fff0UL, x26);
   ASSERT_EQUAL_64(0x000000000001ffe0UL, x27);
 
   TEARDOWN();
 }
 
 
 TEST(mov_imm_w) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w0, 0xffffffffL);
   __ Mov(w1, 0xffff1234L);
   __ Mov(w2, 0x1234ffffL);
   __ Mov(w3, 0x00000000L);
   __ Mov(w4, 0x00001234L);
   __ Mov(w5, 0x12340000L);
   __ Mov(w6, 0x12345678L);
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0xffffffffL, x0);
   ASSERT_EQUAL_64(0xffff1234L, x1);
   ASSERT_EQUAL_64(0x1234ffffL, x2);
   ASSERT_EQUAL_64(0x00000000L, x3);
   ASSERT_EQUAL_64(0x00001234L, x4);
   ASSERT_EQUAL_64(0x12340000L, x5);
   ASSERT_EQUAL_64(0x12345678L, x6);
 
   TEARDOWN();
 }
 
 
 TEST(mov_imm_x) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xffffffffffffffffL);
   __ Mov(x1, 0xffffffffffff1234L);
   __ Mov(x2, 0xffffffff12345678L);
   __ Mov(x3, 0xffff1234ffff5678L);
   __ Mov(x4, 0x1234ffffffff5678L);
   __ Mov(x5, 0x1234ffff5678ffffL);
   __ Mov(x6, 0x12345678ffffffffL);
@@ skipping 46 matching lines @@
   ASSERT_EQUAL_64(0x0000123456789abcL, x25);
   ASSERT_EQUAL_64(0x123456789abcdef0L, x26);
   ASSERT_EQUAL_64(0xffff000000000001L, x27);
   ASSERT_EQUAL_64(0x8000ffff00000000L, x28);
 
   TEARDOWN();
 }
 
 
 TEST(orr) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xf0f0);
   __ Mov(x1, 0xf00000ff);
 
   __ Orr(x2, x0, Operand(x1));
   __ Orr(w3, w0, Operand(w1, LSL, 28));
   __ Orr(x4, x0, Operand(x1, LSL, 32));
   __ Orr(x5, x0, Operand(x1, LSR, 4));
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_64(0x0ffff0f0, x8);
   ASSERT_EQUAL_64(0x0ff00000000ff0f0L, x9);
   ASSERT_EQUAL_64(0xf0ff, x10);
   ASSERT_EQUAL_64(0xf0000000f000f0f0L, x11);
 
   TEARDOWN();
 }
 
 
 TEST(orr_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 1);
   __ Mov(x1, 0x8000000080008080UL);
   __ Orr(w6, w0, Operand(w1, UXTB));
   __ Orr(x7, x0, Operand(x1, UXTH, 1));
   __ Orr(w8, w0, Operand(w1, UXTW, 2));
   __ Orr(x9, x0, Operand(x1, UXTX, 3));
   __ Orr(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0x00000000ffffff81UL, x10);
   ASSERT_EQUAL_64(0xffffffffffff0101UL, x11);
   ASSERT_EQUAL_64(0xfffffffe00020201UL, x12);
   ASSERT_EQUAL_64(0x0000000400040401UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(bitwise_wide_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0xf0f0f0f0f0f0f0f0UL);
 
   __ Orr(x10, x0, Operand(0x1234567890abcdefUL));
   __ Orr(w11, w1, Operand(0x90abcdef));
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0, x0);
   ASSERT_EQUAL_64(0xf0f0f0f0f0f0f0f0UL, x1);
   ASSERT_EQUAL_64(0x1234567890abcdefUL, x10);
   ASSERT_EQUAL_64(0xf0fbfdffUL, x11);
 
   TEARDOWN();
 }
 
 
 TEST(orn) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xf0f0);
   __ Mov(x1, 0xf00000ff);
 
   __ Orn(x2, x0, Operand(x1));
   __ Orn(w3, w0, Operand(w1, LSL, 4));
   __ Orn(x4, x0, Operand(x1, LSL, 4));
   __ Orn(x5, x0, Operand(x1, LSR, 1));
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_64(0xff00ffff, x8);
   ASSERT_EQUAL_64(0xff00ffffffffffffL, x9);
   ASSERT_EQUAL_64(0xfffff0f0, x10);
   ASSERT_EQUAL_64(0xffff0000fffff0f0L, x11);
 
   TEARDOWN();
 }
 
 
 TEST(orn_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 1);
   __ Mov(x1, 0x8000000080008081UL);
   __ Orn(w6, w0, Operand(w1, UXTB));
   __ Orn(x7, x0, Operand(x1, UXTH, 1));
   __ Orn(w8, w0, Operand(w1, UXTW, 2));
   __ Orn(x9, x0, Operand(x1, UXTX, 3));
   __ Orn(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0x0000007f, x10);
   ASSERT_EQUAL_64(0x0000fefd, x11);
   ASSERT_EQUAL_64(0x00000001fffdfdfbUL, x12);
   ASSERT_EQUAL_64(0xfffffffbfffbfbf7UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(and_) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xfff0);
   __ Mov(x1, 0xf00000ff);
 
   __ And(x2, x0, Operand(x1));
   __ And(w3, w0, Operand(w1, LSL, 4));
   __ And(x4, x0, Operand(x1, LSL, 4));
   __ And(x5, x0, Operand(x1, LSR, 1));
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_64(0x00000ff0, x8);
   ASSERT_EQUAL_64(0x00000000, x9);
   ASSERT_EQUAL_64(0x0000ff00, x10);
   ASSERT_EQUAL_64(0x000000f0, x11);
 
   TEARDOWN();
 }
 
 
 TEST(and_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xffffffffffffffffUL);
   __ Mov(x1, 0x8000000080008081UL);
   __ And(w6, w0, Operand(w1, UXTB));
   __ And(x7, x0, Operand(x1, UXTH, 1));
   __ And(w8, w0, Operand(w1, UXTW, 2));
   __ And(x9, x0, Operand(x1, UXTX, 3));
   __ And(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0xffffff81, x10);
   ASSERT_EQUAL_64(0xffffffffffff0102UL, x11);
   ASSERT_EQUAL_64(0xfffffffe00020204UL, x12);
   ASSERT_EQUAL_64(0x0000000400040408UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(ands) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0xf00000ff);
   __ Ands(w0, w1, Operand(w1));
   END();
 
   RUN();
 
   ASSERT_EQUAL_NZCV(NFlag);
@@ skipping 39 matching lines @@
   RUN();
 
   ASSERT_EQUAL_NZCV(NFlag);
   ASSERT_EQUAL_64(0x80000000, x0);
 
   TEARDOWN();
 }
 
 
 TEST(bic) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xfff0);
   __ Mov(x1, 0xf00000ff);
 
   __ Bic(x2, x0, Operand(x1));
   __ Bic(w3, w0, Operand(w1, LSL, 4));
   __ Bic(x4, x0, Operand(x1, LSL, 4));
   __ Bic(x5, x0, Operand(x1, LSR, 1));
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_64(0x0000ffe0, x10);
   ASSERT_EQUAL_64(0x0000fef0, x11);
 
   ASSERT_EQUAL_64(0x543210, x21);
 
   TEARDOWN();
 }
 
 
 TEST(bic_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xffffffffffffffffUL);
   __ Mov(x1, 0x8000000080008081UL);
   __ Bic(w6, w0, Operand(w1, UXTB));
   __ Bic(x7, x0, Operand(x1, UXTH, 1));
   __ Bic(w8, w0, Operand(w1, UXTW, 2));
   __ Bic(x9, x0, Operand(x1, UXTX, 3));
   __ Bic(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0x0000007e, x10);
   ASSERT_EQUAL_64(0x0000fefd, x11);
   ASSERT_EQUAL_64(0x00000001fffdfdfbUL, x12);
   ASSERT_EQUAL_64(0xfffffffbfffbfbf7UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(bics) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0xffff);
   __ Bics(w0, w1, Operand(w1));
   END();
 
   RUN();
 
   ASSERT_EQUAL_NZCV(ZFlag);
@@ skipping 38 matching lines @@
   RUN();
 
   ASSERT_EQUAL_NZCV(ZFlag);
   ASSERT_EQUAL_64(0x00000000, x0);
 
   TEARDOWN();
 }
 
 
 TEST(eor) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xfff0);
   __ Mov(x1, 0xf00000ff);
 
   __ Eor(x2, x0, Operand(x1));
   __ Eor(w3, w0, Operand(w1, LSL, 4));
   __ Eor(x4, x0, Operand(x1, LSL, 4));
   __ Eor(x5, x0, Operand(x1, LSR, 1));
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_64(0x0000f00f, x8);
   ASSERT_EQUAL_64(0x00000ff00000ffffL, x9);
   ASSERT_EQUAL_64(0xff0000f0, x10);
   ASSERT_EQUAL_64(0xff00ff00ff0000f0L, x11);
 
   TEARDOWN();
 }
 
 
 TEST(eor_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0x1111111111111111UL);
   __ Mov(x1, 0x8000000080008081UL);
   __ Eor(w6, w0, Operand(w1, UXTB));
   __ Eor(x7, x0, Operand(x1, UXTH, 1));
   __ Eor(w8, w0, Operand(w1, UXTW, 2));
   __ Eor(x9, x0, Operand(x1, UXTX, 3));
   __ Eor(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0xeeeeee90, x10);
   ASSERT_EQUAL_64(0xeeeeeeeeeeee1013UL, x11);
   ASSERT_EQUAL_64(0xeeeeeeef11131315UL, x12);
   ASSERT_EQUAL_64(0x1111111511151519UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(eon) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xfff0);
   __ Mov(x1, 0xf00000ff);
 
   __ Eon(x2, x0, Operand(x1));
   __ Eon(w3, w0, Operand(w1, LSL, 4));
   __ Eon(x4, x0, Operand(x1, LSL, 4));
   __ Eon(x5, x0, Operand(x1, LSR, 1));
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_64(0xffff0ff0, x8);
   ASSERT_EQUAL_64(0xfffff00fffff0000L, x9);
   ASSERT_EQUAL_64(0xfc3f03cf, x10);
   ASSERT_EQUAL_64(0xffffefffffff100fL, x11);
 
   TEARDOWN();
 }
 
 
 TEST(eon_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0x1111111111111111UL);
   __ Mov(x1, 0x8000000080008081UL);
   __ Eon(w6, w0, Operand(w1, UXTB));
   __ Eon(x7, x0, Operand(x1, UXTH, 1));
   __ Eon(w8, w0, Operand(w1, UXTW, 2));
   __ Eon(x9, x0, Operand(x1, UXTX, 3));
   __ Eon(w10, w0, Operand(w1, SXTB));
@@ skipping 11 matching lines @@
   ASSERT_EQUAL_64(0x1111116f, x10);
   ASSERT_EQUAL_64(0x111111111111efecUL, x11);
   ASSERT_EQUAL_64(0x11111110eeececeaUL, x12);
   ASSERT_EQUAL_64(0xeeeeeeeaeeeaeae6UL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(mul) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
   __ Mov(x18, 0xffffffff);
   __ Mov(x19, 0xffffffffffffffffUL);
 
   __ Mul(w0, w16, w16);
   __ Mul(w1, w16, w17);
@@ skipping 49 matching lines @@
   __ Mov(w1, b);
   __ Smull(x2, w0, w1);
   END();
   RUN();
   ASSERT_EQUAL_64(expected, x2);
   TEARDOWN();
 }
 
 
 TEST(smull) {
+  INIT_V8();
   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) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
   __ Mov(x18, 0xffffffff);
   __ Mov(x19, 0xffffffffffffffffUL);
 
   __ Madd(w0, w16, w16, w16);
   __ Madd(w1, w16, w16, w17);
@@ skipping 49 matching lines @@
   ASSERT_EQUAL_64(0x1fffffffe, x24);
   ASSERT_EQUAL_64(0xfffffffe00000002UL, x25);
   ASSERT_EQUAL_64(0, x26);
   ASSERT_EQUAL_64(0, x27);
 
   TEARDOWN();
 }
 
 
 TEST(msub) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 0);
   __ Mov(x17, 1);
   __ Mov(x18, 0xffffffff);
   __ Mov(x19, 0xffffffffffffffffUL);
 
   __ Msub(w0, w16, w16, w16);
   __ Msub(w1, w16, w16, w17);
@@ skipping 49 matching lines @@
   ASSERT_EQUAL_64(0, x24);
   ASSERT_EQUAL_64(0x200000000UL, x25);
   ASSERT_EQUAL_64(0x1fffffffeUL, x26);
   ASSERT_EQUAL_64(0xfffffffffffffffeUL, x27);
 
   TEARDOWN();
 }
 
 
 TEST(smulh) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x20, 0);
   __ Mov(x21, 1);
   __ Mov(x22, 0x0000000100000000L);
   __ Mov(x23, 0x12345678);
   __ Mov(x24, 0x0123456789abcdefL);
   __ Mov(x25, 0x0000000200000000L);
   __ Mov(x26, 0x8000000000000000UL);
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_64(0, x8);
   ASSERT_EQUAL_64(0x1c71c71c71c71c71UL, x9);
   ASSERT_EQUAL_64(0xe38e38e38e38e38eUL, x10);
   ASSERT_EQUAL_64(0x1c71c71c71c71c72UL, x11);
 
   TEARDOWN();
 }
 
 
 TEST(smaddl_umaddl) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x17, 1);
   __ Mov(x18, 0xffffffff);
   __ Mov(x19, 0xffffffffffffffffUL);
   __ Mov(x20, 4);
   __ Mov(x21, 0x200000000UL);
 
   __ Smaddl(x9, w17, w18, x20);
@@ skipping 15 matching lines @@
   ASSERT_EQUAL_64(0x100000003UL, x13);
   ASSERT_EQUAL_64(0xfffffffe00000005UL, x14);
   ASSERT_EQUAL_64(0xfffffffe00000005UL, x15);
   ASSERT_EQUAL_64(0x1, x22);
 
   TEARDOWN();
 }
 
 
 TEST(smsubl_umsubl) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x17, 1);
   __ Mov(x18, 0xffffffff);
   __ Mov(x19, 0xffffffffffffffffUL);
   __ Mov(x20, 4);
   __ Mov(x21, 0x200000000UL);
 
   __ Smsubl(x9, w17, w18, x20);
@@ skipping 15 matching lines @@
   ASSERT_EQUAL_64(0xffffffff00000005UL, x13);
   ASSERT_EQUAL_64(0x200000003UL, x14);
   ASSERT_EQUAL_64(0x200000003UL, x15);
   ASSERT_EQUAL_64(0x3ffffffffUL, x22);
 
   TEARDOWN();
 }
 
 
 TEST(div) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 1);
   __ Mov(x17, 0xffffffff);
   __ Mov(x18, 0xffffffffffffffffUL);
   __ Mov(x19, 0x80000000);
   __ Mov(x20, 0x8000000000000000UL);
   __ Mov(x21, 2);
 
@@ skipping 62 matching lines @@
   ASSERT_EQUAL_64(0, x18);
   ASSERT_EQUAL_64(0, x19);
   ASSERT_EQUAL_64(0, x20);
   ASSERT_EQUAL_64(0, x21);
 
   TEARDOWN();
 }
 
 
 TEST(rbit_rev) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x24, 0xfedcba9876543210UL);
   __ Rbit(w0, w24);
   __ Rbit(x1, x24);
   __ Rev16(w2, w24);
   __ Rev16(x3, x24);
   __ Rev(w4, w24);
   __ Rev32(x5, x24);
   __ Rev(x6, x24);
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0x084c2a6e, x0);
   ASSERT_EQUAL_64(0x084c2a6e195d3b7fUL, x1);
   ASSERT_EQUAL_64(0x54761032, x2);
   ASSERT_EQUAL_64(0xdcfe98ba54761032UL, x3);
   ASSERT_EQUAL_64(0x10325476, x4);
   ASSERT_EQUAL_64(0x98badcfe10325476UL, x5);
   ASSERT_EQUAL_64(0x1032547698badcfeUL, x6);
 
   TEARDOWN();
 }
 
 
 TEST(clz_cls) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x24, 0x0008000000800000UL);
   __ Mov(x25, 0xff800000fff80000UL);
   __ Mov(x26, 0);
   __ Clz(w0, w24);
   __ Clz(x1, x24);
   __ Clz(w2, w25);
   __ Clz(x3, x25);
@@ skipping 20 matching lines @@
   ASSERT_EQUAL_64(12, x8);
   ASSERT_EQUAL_64(8, x9);
   ASSERT_EQUAL_64(31, x10);
   ASSERT_EQUAL_64(63, x11);
 
   TEARDOWN();
 }
 
 
 TEST(label) {
+  INIT_V8();
   SETUP();
 
   Label label_1, label_2, label_3, label_4;
 
   START();
   __ Mov(x0, 0x1);
   __ Mov(x1, 0x0);
   __ Mov(x22, lr);    // Save lr.
 
   __ B(&label_1);
@@ skipping 18 matching lines @@
   RUN();
 
   ASSERT_EQUAL_64(0x1, x0);
   ASSERT_EQUAL_64(0x1, x1);
 
   TEARDOWN();
 }
 
 
 TEST(branch_at_start) {
+  INIT_V8();
   SETUP();
 
   Label good, exit;
 
   // Test that branches can exist at the start of the buffer. (This is a
   // boundary condition in the label-handling code.) To achieve this, we have
   // to work around the code generated by START.
   RESET();
   __ B(&good);
 
@@ skipping 11 matching lines @@
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0x1, x0);
   TEARDOWN();
 }
 
 
 TEST(adr) {
+  INIT_V8();
   SETUP();
 
   Label label_1, label_2, label_3, label_4;
 
   START();
   __ Mov(x0, 0x0);        // Set to non-zero to indicate failure.
   __ Adr(x1, &label_3);   // Set to zero to indicate success.
 
   __ Adr(x2, &label_1);   // Multiple forward references to the same label.
   __ Adr(x3, &label_1);
@@ skipping 25 matching lines @@
   RUN();
 
   ASSERT_EQUAL_64(0x0, x0);
   ASSERT_EQUAL_64(0x0, x1);
 
   TEARDOWN();
 }
 
 
 TEST(branch_cond) {
+  INIT_V8();
   SETUP();
 
   Label wrong;
 
   START();
   __ Mov(x0, 0x1);
   __ Mov(x1, 0x1);
   __ Mov(x2, 0x8000000000000000L);
 
   // For each 'cmp' instruction below, condition codes other than the ones
@@ skipping 69 matching lines @@
 
   RUN();
 
   ASSERT_EQUAL_64(0x1, x0);
 
   TEARDOWN();
 }
 
 
 TEST(branch_to_reg) {
+  INIT_V8();
   SETUP();
 
   // Test br.
   Label fn1, after_fn1;
 
   START();
   __ Mov(x29, lr);
 
   __ Mov(x1, 0);
   __ B(&after_fn1);
@@ skipping 28 matching lines @@
 
   ASSERT_EQUAL_64(core.xreg(3) + kInstructionSize, x0);
   ASSERT_EQUAL_64(42, x1);
   ASSERT_EQUAL_64(84, x2);
 
   TEARDOWN();
 }
 
 
 TEST(compare_branch) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0);
   __ Mov(x2, 0);
   __ Mov(x3, 0);
   __ Mov(x4, 0);
   __ Mov(x5, 0);
   __ Mov(x16, 0);
@@ skipping 52 matching lines @@
   ASSERT_EQUAL_64(1, x2);
   ASSERT_EQUAL_64(0, x3);
   ASSERT_EQUAL_64(1, x4);
   ASSERT_EQUAL_64(0, x5);
 
   TEARDOWN();
 }
 
 
 TEST(test_branch) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0);
   __ Mov(x2, 0);
   __ Mov(x3, 0);
   __ Mov(x16, 0xaaaaaaaaaaaaaaaaUL);
 
   Label bz, bz_end;
@@ skipping 30 matching lines @@
   ASSERT_EQUAL_64(1, x0);
   ASSERT_EQUAL_64(0, x1);
   ASSERT_EQUAL_64(1, x2);
   ASSERT_EQUAL_64(0, x3);
 
   TEARDOWN();
 }
 
 
 TEST(ldr_str_offset) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[2] = {0xfedcba9876543210UL, 0x0123456789abcdefUL};
   uint64_t dst[5] = {0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base);
   __ Mov(x18, dst_base);
@@ skipping 22 matching lines @@
   ASSERT_EQUAL_64(0x7654, x4);
   ASSERT_EQUAL_64(0x765400, dst[4]);
   ASSERT_EQUAL_64(src_base, x17);
   ASSERT_EQUAL_64(dst_base, x18);
 
   TEARDOWN();
 }
 
 
 TEST(ldr_str_wide) {
+  INIT_V8();
   SETUP();
 
   uint32_t src[8192];
   uint32_t dst[8192];
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
   memset(src, 0xaa, 8192 * sizeof(src[0]));
   memset(dst, 0xaa, 8192 * sizeof(dst[0]));
   src[0] = 0;
   src[6144] = 6144;
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_32(6144, w2);
   ASSERT_EQUAL_32(6144, dst[6144]);
   ASSERT_EQUAL_64(src_base + 6144 * sizeof(src[0]), x26);
   ASSERT_EQUAL_64(dst_base + 6144 * sizeof(dst[0]), x27);
 
   TEARDOWN();
 }
 
 
 TEST(ldr_str_preindex) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[2] = {0xfedcba9876543210UL, 0x0123456789abcdefUL};
   uint64_t dst[6] = {0, 0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base);
   __ Mov(x18, dst_base);
@@ skipping 38 matching lines @@
   ASSERT_EQUAL_64(src_base + 1, x23);
   ASSERT_EQUAL_64(dst_base + 25, x24);
   ASSERT_EQUAL_64(src_base + 3, x25);
   ASSERT_EQUAL_64(dst_base + 41, x26);
 
   TEARDOWN();
 }
 
 
 TEST(ldr_str_postindex) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[2] = {0xfedcba9876543210UL, 0x0123456789abcdefUL};
   uint64_t dst[6] = {0, 0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base + 4);
   __ Mov(x18, dst_base + 12);
@@ skipping 38 matching lines @@
   ASSERT_EQUAL_64(src_base + 2, x23);
   ASSERT_EQUAL_64(dst_base + 30, x24);
   ASSERT_EQUAL_64(src_base, x25);
   ASSERT_EQUAL_64(dst_base, x26);
 
   TEARDOWN();
 }
 
 
 TEST(load_signed) {
+  INIT_V8();
   SETUP();
 
   uint32_t src[2] = {0x80008080, 0x7fff7f7f};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
 
   START();
   __ Mov(x24, src_base);
   __ Ldrsb(w0, MemOperand(x24));
   __ Ldrsb(w1, MemOperand(x24, 4));
   __ Ldrsh(w2, MemOperand(x24));
@@ skipping 17 matching lines @@
   ASSERT_EQUAL_64(0xffffffffffff8080UL, x6);
   ASSERT_EQUAL_64(0x0000000000007f7fUL, x7);
   ASSERT_EQUAL_64(0xffffffff80008080UL, x8);
   ASSERT_EQUAL_64(0x000000007fff7f7fUL, x9);
 
   TEARDOWN();
 }
 
 
 TEST(load_store_regoffset) {
+  INIT_V8();
   SETUP();
 
   uint32_t src[3] = {1, 2, 3};
   uint32_t dst[4] = {0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
@@ skipping 27 matching lines @@
   ASSERT_EQUAL_32(1, dst[0]);
   ASSERT_EQUAL_32(2, dst[1]);
   ASSERT_EQUAL_32(3, dst[2]);
   ASSERT_EQUAL_32(3, dst[3]);
 
   TEARDOWN();
 }
 
 
 TEST(load_store_float) {
+  INIT_V8();
   SETUP();
 
   float src[3] = {1.0, 2.0, 3.0};
   float dst[3] = {0.0, 0.0, 0.0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base);
   __ Mov(x18, dst_base);
@@ skipping 22 matching lines @@
   ASSERT_EQUAL_64(src_base + sizeof(src[0]), x19);
   ASSERT_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   ASSERT_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
   ASSERT_EQUAL_64(dst_base, x22);
 
   TEARDOWN();
 }
 
 
 TEST(load_store_double) {
+  INIT_V8();
   SETUP();
 
   double src[3] = {1.0, 2.0, 3.0};
   double dst[3] = {0.0, 0.0, 0.0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base);
   __ Mov(x18, dst_base);
@@ skipping 22 matching lines @@
   ASSERT_EQUAL_64(src_base + sizeof(src[0]), x19);
   ASSERT_EQUAL_64(dst_base + 2 * sizeof(dst[0]), x20);
   ASSERT_EQUAL_64(src_base + 2 * sizeof(src[0]), x21);
   ASSERT_EQUAL_64(dst_base, x22);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_stp_float) {
+  INIT_V8();
   SETUP();
 
   float src[2] = {1.0, 2.0};
   float dst[3] = {0.0, 0.0, 0.0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
   __ Ldp(s31, s0, MemOperand(x16, 2 * sizeof(src[0]), PostIndex));
   __ Stp(s0, s31, MemOperand(x17, sizeof(dst[1]), PreIndex));
   END();
 
   RUN();
 
   ASSERT_EQUAL_FP32(1.0, s31);
   ASSERT_EQUAL_FP32(2.0, s0);
   ASSERT_EQUAL_FP32(0.0, dst[0]);
   ASSERT_EQUAL_FP32(2.0, dst[1]);
   ASSERT_EQUAL_FP32(1.0, dst[2]);
   ASSERT_EQUAL_64(src_base + 2 * sizeof(src[0]), x16);
   ASSERT_EQUAL_64(dst_base + sizeof(dst[1]), x17);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_stp_double) {
+  INIT_V8();
   SETUP();
 
   double src[2] = {1.0, 2.0};
   double dst[3] = {0.0, 0.0, 0.0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
   __ Mov(x17, dst_base);
   __ Ldp(d31, d0, MemOperand(x16, 2 * sizeof(src[0]), PostIndex));
   __ Stp(d0, d31, MemOperand(x17, sizeof(dst[1]), PreIndex));
   END();
 
   RUN();
 
   ASSERT_EQUAL_FP64(1.0, d31);
   ASSERT_EQUAL_FP64(2.0, d0);
   ASSERT_EQUAL_FP64(0.0, dst[0]);
   ASSERT_EQUAL_FP64(2.0, dst[1]);
   ASSERT_EQUAL_FP64(1.0, dst[2]);
   ASSERT_EQUAL_64(src_base + 2 * sizeof(src[0]), x16);
   ASSERT_EQUAL_64(dst_base + sizeof(dst[1]), x17);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_stp_offset) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[3] = {0x0011223344556677UL, 0x8899aabbccddeeffUL,
                      0xffeeddccbbaa9988UL};
   uint64_t dst[7] = {0, 0, 0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_64(src_base, x16);
   ASSERT_EQUAL_64(dst_base, x17);
   ASSERT_EQUAL_64(src_base + 24, x18);
   ASSERT_EQUAL_64(dst_base + 56, x19);
 
   TEARDOWN();
 }
 
 
 TEST(ldnp_stnp_offset) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[3] = {0x0011223344556677UL, 0x8899aabbccddeeffUL,
                      0xffeeddccbbaa9988UL};
   uint64_t dst[7] = {0, 0, 0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_64(src_base, x16);
   ASSERT_EQUAL_64(dst_base, x17);
   ASSERT_EQUAL_64(src_base + 24, x18);
   ASSERT_EQUAL_64(dst_base + 56, x19);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_stp_preindex) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[3] = {0x0011223344556677UL, 0x8899aabbccddeeffUL,
                      0xffeeddccbbaa9988UL};
   uint64_t dst[5] = {0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_64(src_base + 4, x19);
   ASSERT_EQUAL_64(dst_base + 4, x20);
   ASSERT_EQUAL_64(src_base + 8, x21);
   ASSERT_EQUAL_64(dst_base + 24, x22);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_stp_postindex) {
+  INIT_V8();
   SETUP();
 
   uint64_t src[4] = {0x0011223344556677UL, 0x8899aabbccddeeffUL,
                      0xffeeddccbbaa9988UL, 0x7766554433221100UL};
   uint64_t dst[5] = {0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x16, src_base);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_64(src_base + 4, x19);
   ASSERT_EQUAL_64(dst_base + 4, x20);
   ASSERT_EQUAL_64(src_base + 8, x21);
   ASSERT_EQUAL_64(dst_base + 24, x22);
 
   TEARDOWN();
 }
 
 
 TEST(ldp_sign_extend) {
+  INIT_V8();
   SETUP();
 
   uint32_t src[2] = {0x80000000, 0x7fffffff};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
 
   START();
   __ Mov(x24, src_base);
   __ Ldpsw(x0, x1, MemOperand(x24));
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0xffffffff80000000UL, x0);
   ASSERT_EQUAL_64(0x000000007fffffffUL, x1);
 
   TEARDOWN();
 }
 
 
 TEST(ldur_stur) {
+  INIT_V8();
   SETUP();
 
   int64_t src[2] = {0x0123456789abcdefUL, 0x0123456789abcdefUL};
   int64_t dst[5] = {0, 0, 0, 0, 0};
   uintptr_t src_base = reinterpret_cast<uintptr_t>(src);
   uintptr_t dst_base = reinterpret_cast<uintptr_t>(dst);
 
   START();
   __ Mov(x17, src_base);
   __ Mov(x18, dst_base);
@@ skipping 26 matching lines @@
   ASSERT_EQUAL_64(src_base + 16, x19);
   ASSERT_EQUAL_64(dst_base + 32, x20);
 
   TEARDOWN();
 }
 
 
 #if 0  // TODO(all) enable.
 // TODO(rodolph): Adapt w16 Literal tests for RelocInfo.
 TEST(ldr_literal) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Ldr(x2, 0x1234567890abcdefUL);
   __ Ldr(w3, 0xfedcba09);
   __ Ldr(d13, 1.234);
   __ Ldr(s25, 2.5);
   END();
 
   RUN();
@@ skipping 89 matching lines @@
   ASSERT_EQUAL_64(0x34567890abcdef12UL, x4);
   ASSERT_EQUAL_64(0xdcba09fe, x5);
   ASSERT_EQUAL_FP64(123.4, d4);
   ASSERT_EQUAL_FP32(250.0, s5);
 
   TEARDOWN();
 }
 
 
 TEST(ldr_literal_range_1) {
+  INIT_V8();
   LdrLiteralRangeHelper(kRecommendedLiteralPoolRange,
                         NoJumpRequired,
                         true);
 }
 
 
 TEST(ldr_literal_range_2) {
+  INIT_V8();
   LdrLiteralRangeHelper(kRecommendedLiteralPoolRange-sizeof(Instr),
                         NoJumpRequired,
                         false);
 }
 
 
 TEST(ldr_literal_range_3) {
+  INIT_V8();
   LdrLiteralRangeHelper(2 * kRecommendedLiteralPoolRange,
                         JumpRequired,
                         true);
 }
 
 
 TEST(ldr_literal_range_4) {
+  INIT_V8();
   LdrLiteralRangeHelper(2 * kRecommendedLiteralPoolRange-sizeof(Instr),
                         JumpRequired,
                         false);
 }
 
 
 TEST(ldr_literal_range_5) {
+  INIT_V8();
   LdrLiteralRangeHelper(kLiteralPoolCheckInterval,
                         JumpRequired,
                         false);
 }
 
 
 TEST(ldr_literal_range_6) {
+  INIT_V8();
   LdrLiteralRangeHelper(kLiteralPoolCheckInterval-sizeof(Instr),
                         JumpRequired,
                         false);
 }
 #endif
 
 TEST(add_sub_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0x0);
   __ Mov(x1, 0x1111);
   __ Mov(x2, 0xffffffffffffffffL);
   __ Mov(x3, 0x8000000000000000L);
 
   __ Add(x10, x0, Operand(0x123));
   __ Add(x11, x1, Operand(0x122000));
@@ skipping 36 matching lines @@
   ASSERT_EQUAL_32(0xffffffff, w24);
   ASSERT_EQUAL_32(0x1000, w25);
   ASSERT_EQUAL_32(0x111, w26);
   ASSERT_EQUAL_32(0xffffffff, w27);
 
   TEARDOWN();
 }
 
 
 TEST(add_sub_wide_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0x0);
   __ Mov(x1, 0x1);
 
   __ Add(x10, x0, Operand(0x1234567890abcdefUL));
   __ Add(x11, x1, Operand(0xffffffff));
 
   __ Add(w12, w0, Operand(0x12345678));
@@ skipping 14 matching lines @@
 
   ASSERT_EQUAL_64(-0x1234567890abcdefUL, x20);
 
   ASSERT_EQUAL_32(-0x12345678, w21);
 
   TEARDOWN();
 }
 
 
 TEST(add_sub_shifted) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0x0123456789abcdefL);
   __ Mov(x2, 0xfedcba9876543210L);
   __ Mov(x3, 0xffffffffffffffffL);
 
   __ Add(x10, x1, Operand(x2));
   __ Add(x11, x0, Operand(x1, LSL, 8));
@@ skipping 32 matching lines @@
   ASSERT_EQUAL_64(0x000123456789abcdL, x24);
   ASSERT_EQUAL_64(0x00765432, x25);
   ASSERT_EQUAL_64(0x10765432, x26);
   ASSERT_EQUAL_64(0x10fedcba98765432L, x27);
 
   TEARDOWN();
 }
 
 
 TEST(add_sub_extended) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0x0123456789abcdefL);
   __ Mov(x2, 0xfedcba9876543210L);
   __ Mov(w3, 0x80);
 
   __ Add(x10, x0, Operand(x1, UXTB, 0));
   __ Add(x11, x0, Operand(x1, UXTB, 1));
@@ skipping 50 matching lines @@
   ASSERT_EQUAL_32(0x4d5e6f78, w28);
   ASSERT_EQUAL_64(0xfffffffc4d5e6f78L, x29);
 
   ASSERT_EQUAL_64(256, x30);
 
   TEARDOWN();
 }
 
 
 TEST(add_sub_negative) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 4687);
   __ Mov(x2, 0x1122334455667788);
   __ Mov(w3, 0x11223344);
   __ Mov(w4, 400000);
 
   __ Add(x10, x0, -42);
@@ skipping 25 matching lines @@
   ASSERT_EQUAL_32(398000, w20);
 
   ASSERT_EQUAL_32(0x11223400, w21);
   ASSERT_EQUAL_32(402000, w22);
 
   TEARDOWN();
 }
 
 
 TEST(add_sub_zero) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0);
   __ Mov(x2, 0);
 
   Label blob1;
   __ Bind(&blob1);
   __ Add(x0, x0, 0);
@@ skipping 17 matching lines @@
 
   ASSERT_EQUAL_64(0, x0);
   ASSERT_EQUAL_64(0, x1);
   ASSERT_EQUAL_64(0, x2);
 
   TEARDOWN();
 }
 
 
 TEST(claim_drop_zero) {
+  INIT_V8();
   SETUP();
 
   START();
 
   Label start;
   __ Bind(&start);
   __ Claim(0);
   __ Drop(0);
   __ Claim(xzr, 8);
   __ Drop(xzr, 8);
   __ Claim(xzr, 0);
   __ Drop(xzr, 0);
   __ Claim(x7, 0);
   __ Drop(x7, 0);
   __ ClaimBySMI(xzr, 8);
   __ DropBySMI(xzr, 8);
   __ ClaimBySMI(xzr, 0);
   __ DropBySMI(xzr, 0);
   CHECK_EQ(0, __ SizeOfCodeGeneratedSince(&start));
 
   END();
 
   RUN();
 
   TEARDOWN();
 }
 
 
 TEST(neg) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0xf123456789abcdefL);
 
   // Immediate.
   __ Neg(x1, 0x123);
   __ Neg(w2, 0x123);
 
   // Shifted.
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_64(0xfffcc844, x11);
   ASSERT_EQUAL_64(0x0000000000019088UL, x12);
   ASSERT_EQUAL_64(0x65432110, x13);
   ASSERT_EQUAL_64(0x0000000765432110UL, x14);
 
   TEARDOWN();
 }
 
 
 TEST(adc_sbc_shift) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 1);
   __ Mov(x2, 0x0123456789abcdefL);
   __ Mov(x3, 0xfedcba9876543210L);
   __ Mov(x4, 0xffffffffffffffffL);
 
   // Clear the C flag.
@@ skipping 177 matching lines @@
   RUN();
 
   ASSERT_EQUAL_NZCV(NFlag);
   ASSERT_EQUAL_64(0x8000000000000001L, x10);
 
   TEARDOWN();
 }
 
 
 TEST(adc_sbc_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   // Clear the C flag.
   __ Adds(x0, x0, Operand(0));
 
   __ Mov(x0, 0);
   __ Mov(x1, 1);
   __ Mov(x2, 0x0123456789abcdefL);
 
@@ skipping 73 matching lines @@
 
   RUN();
 
   ASSERT_EQUAL_NZCV(NVFlag);
 
   TEARDOWN();
 }
 
 
 TEST(adc_sbc_wide_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
 
   // Clear the C flag.
   __ Adds(x0, x0, Operand(0));
 
   __ Adc(x7, x0, Operand(0x1234567890abcdefUL));
   __ Adc(w8, w0, Operand(0xffffffff));
@@ skipping 27 matching lines @@
   ASSERT_EQUAL_64(0xedcba9876f543211UL, x20);
   ASSERT_EQUAL_64(1, x21);
   ASSERT_EQUAL_64(0x100000000UL, x22);
   ASSERT_EQUAL_64(0x10000, x23);
 
   TEARDOWN();
 }
 
 
 TEST(flags) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x0, 0);
   __ Mov(x1, 0x1111111111111111L);
   __ Neg(x10, Operand(x0));
   __ Neg(x11, Operand(x1));
   __ Neg(w12, Operand(w1));
   // Clear the C flag.
   __ Adds(x0, x0, Operand(0));
@@ skipping 129 matching lines @@
 
   RUN();
 
   ASSERT_EQUAL_NZCV(ZCFlag);
 
   TEARDOWN();
 }
 
 
 TEST(cmp_shift) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x18, 0xf0000000);
   __ Mov(x19, 0xf000000010000000UL);
   __ Mov(x20, 0xf0000000f0000000UL);
   __ Mov(x21, 0x7800000078000000UL);
   __ Mov(x22, 0x3c0000003c000000UL);
   __ Mov(x23, 0x8000000780000000UL);
   __ Mov(x24, 0x0000000f00000000UL);
@@ skipping 35 matching lines @@
   ASSERT_EQUAL_32(ZCFlag, w4);
   ASSERT_EQUAL_32(ZCFlag, w5);
   ASSERT_EQUAL_32(ZCFlag, w6);
   ASSERT_EQUAL_32(ZCFlag, w7);
 
   TEARDOWN();
 }
 
 
 TEST(cmp_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w20, 0x2);
   __ Mov(w21, 0x1);
   __ Mov(x22, 0xffffffffffffffffUL);
   __ Mov(x23, 0xff);
   __ Mov(x24, 0xfffffffffffffffeUL);
   __ Mov(x25, 0xffff);
   __ Mov(x26, 0xffffffff);
@@ skipping 32 matching lines @@
   ASSERT_EQUAL_32(NCFlag, w4);
   ASSERT_EQUAL_32(ZCFlag, w5);
   ASSERT_EQUAL_32(NCFlag, w6);
   ASSERT_EQUAL_32(ZCFlag, w7);
 
   TEARDOWN();
 }
 
 
 TEST(ccmp) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w16, 0);
   __ Mov(w17, 1);
   __ Cmp(w16, w16);
   __ Ccmp(w16, w17, NCFlag, eq);
   __ Mrs(x0, NZCV);
 
   __ Cmp(w16, w16);
@@ skipping 23 matching lines @@
   ASSERT_EQUAL_32(NoFlag, w2);
   ASSERT_EQUAL_32(NZCVFlag, w3);
   ASSERT_EQUAL_32(ZCFlag, w4);
   ASSERT_EQUAL_32(ZCFlag, w5);
 
   TEARDOWN();
 }
 
 
 TEST(ccmp_wide_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w20, 0);
 
   __ Cmp(w20, Operand(w20));
   __ Ccmp(w20, Operand(0x12345678), NZCVFlag, eq);
   __ Mrs(x0, NZCV);
 
   __ Cmp(w20, Operand(w20));
   __ Ccmp(x20, Operand(0xffffffffffffffffUL), NZCVFlag, eq);
   __ Mrs(x1, NZCV);
   END();
 
   RUN();
 
   ASSERT_EQUAL_32(NFlag, w0);
   ASSERT_EQUAL_32(NoFlag, w1);
 
   TEARDOWN();
 }
 
 
 TEST(ccmp_shift_extend) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w20, 0x2);
   __ Mov(w21, 0x1);
   __ Mov(x22, 0xffffffffffffffffUL);
   __ Mov(x23, 0xff);
   __ Mov(x24, 0xfffffffffffffffeUL);
 
   __ Cmp(w20, Operand(w20));
@@ skipping 23 matching lines @@
   ASSERT_EQUAL_32(ZCFlag, w1);
   ASSERT_EQUAL_32(ZCFlag, w2);
   ASSERT_EQUAL_32(NCFlag, w3);
   ASSERT_EQUAL_32(NZCVFlag, w4);
 
   TEARDOWN();
 }
 
 
 TEST(csel) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 0);
   __ Mov(x24, 0x0000000f0000000fUL);
   __ Mov(x25, 0x0000001f0000001fUL);
   __ Mov(x26, 0);
   __ Mov(x27, 0);
 
   __ Cmp(w16, 0);
@@ skipping 49 matching lines @@
   ASSERT_EQUAL_64(0, x24);
   ASSERT_EQUAL_64(0x0000001f0000001fUL, x25);
   ASSERT_EQUAL_64(0x0000001f0000001fUL, x26);
   ASSERT_EQUAL_64(0, x27);
 
   TEARDOWN();
 }
 
 
 TEST(csel_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x18, 0);
   __ Mov(x19, 0x80000000);
   __ Mov(x20, 0x8000000000000000UL);
 
   __ Cmp(x18, Operand(0));
   __ Csel(w0, w19, -2, ne);
   __ Csel(w1, w19, -1, ne);
@@ skipping 33 matching lines @@
   ASSERT_EQUAL_64(2, x12);
   ASSERT_EQUAL_64(-1, x13);
   ASSERT_EQUAL_64(0x4000000000000000UL, x14);
   ASSERT_EQUAL_64(0x8000000000000000UL, x15);
 
   TEARDOWN();
 }
 
 
 TEST(lslv) {
+  INIT_V8();
   SETUP();
 
   uint64_t value = 0x0123456789abcdefUL;
   int shift[] = {1, 3, 5, 9, 17, 33};
 
   START();
   __ Mov(x0, value);
   __ Mov(w1, shift[0]);
   __ Mov(w2, shift[1]);
   __ Mov(w3, shift[2]);
@@ skipping 32 matching lines @@
   ASSERT_EQUAL_32(value << (shift[2] & 31), w24);
   ASSERT_EQUAL_32(value << (shift[3] & 31), w25);
   ASSERT_EQUAL_32(value << (shift[4] & 31), w26);
   ASSERT_EQUAL_32(value << (shift[5] & 31), w27);
 
   TEARDOWN();
 }
 
 
 TEST(lsrv) {
+  INIT_V8();
   SETUP();
 
   uint64_t value = 0x0123456789abcdefUL;
   int shift[] = {1, 3, 5, 9, 17, 33};
 
   START();
   __ Mov(x0, value);
   __ Mov(w1, shift[0]);
   __ Mov(w2, shift[1]);
   __ Mov(w3, shift[2]);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_32(value >> (shift[2] & 31), w24);
   ASSERT_EQUAL_32(value >> (shift[3] & 31), w25);
   ASSERT_EQUAL_32(value >> (shift[4] & 31), w26);
   ASSERT_EQUAL_32(value >> (shift[5] & 31), w27);
 
   TEARDOWN();
 }
 
 
 TEST(asrv) {
+  INIT_V8();
   SETUP();
 
   int64_t value = 0xfedcba98fedcba98UL;
   int shift[] = {1, 3, 5, 9, 17, 33};
 
   START();
   __ Mov(x0, value);
   __ Mov(w1, shift[0]);
   __ Mov(w2, shift[1]);
   __ Mov(w3, shift[2]);
@@ skipping 34 matching lines @@
   ASSERT_EQUAL_32(value32 >> (shift[2] & 31), w24);
   ASSERT_EQUAL_32(value32 >> (shift[3] & 31), w25);
   ASSERT_EQUAL_32(value32 >> (shift[4] & 31), w26);
   ASSERT_EQUAL_32(value32 >> (shift[5] & 31), w27);
 
   TEARDOWN();
 }
 
 
 TEST(rorv) {
+  INIT_V8();
   SETUP();
 
   uint64_t value = 0x0123456789abcdefUL;
   int shift[] = {4, 8, 12, 16, 24, 36};
 
   START();
   __ Mov(x0, value);
   __ Mov(w1, shift[0]);
   __ Mov(w2, shift[1]);
   __ Mov(w3, shift[2]);
@@ skipping 32 matching lines @@
   ASSERT_EQUAL_32(0xdef89abc, w24);
   ASSERT_EQUAL_32(0xcdef89ab, w25);
   ASSERT_EQUAL_32(0xabcdef89, w26);
   ASSERT_EQUAL_32(0xf89abcde, w27);
 
   TEARDOWN();
 }
 
 
 TEST(bfm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0x0123456789abcdefL);
 
   __ Mov(x10, 0x8888888888888888L);
   __ Mov(x11, 0x8888888888888888L);
   __ Mov(x12, 0x8888888888888888L);
   __ Mov(x13, 0x8888888888888888L);
   __ Mov(w20, 0x88888888);
@@ skipping 20 matching lines @@
   ASSERT_EQUAL_32(0x88cdef88, w21);
 
   ASSERT_EQUAL_64(0x8888888888ef8888L, x12);
   ASSERT_EQUAL_64(0x88888888888888abL, x13);
 
   TEARDOWN();
 }
 
 
 TEST(sbfm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0x0123456789abcdefL);
   __ Mov(x2, 0xfedcba9876543210L);
 
   __ sbfm(x10, x1, 16, 31);
   __ sbfm(x11, x1, 32, 15);
   __ sbfm(x12, x1, 32, 47);
   __ sbfm(x13, x1, 48, 35);
@@ skipping 42 matching lines @@
   ASSERT_EQUAL_64(0xffffffffffffcdefL, x26);
   ASSERT_EQUAL_64(0x3210, x27);
   ASSERT_EQUAL_64(0xffffffff89abcdefL, x28);
   ASSERT_EQUAL_64(0x76543210, x29);
 
   TEARDOWN();
 }
 
 
 TEST(ubfm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0x0123456789abcdefL);
   __ Mov(x2, 0xfedcba9876543210L);
 
   __ Mov(x10, 0x8888888888888888L);
   __ Mov(x11, 0x8888888888888888L);
 
   __ ubfm(x10, x1, 16, 31);
@@ skipping 36 matching lines @@
   ASSERT_EQUAL_64(0xabcdL, x19);
   ASSERT_EQUAL_64(0xefL, x20);
   ASSERT_EQUAL_64(0xcdefL, x21);
   ASSERT_EQUAL_64(0x89abcdefL, x22);
 
   TEARDOWN();
 }
 
 
 TEST(extr) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x1, 0x0123456789abcdefL);
   __ Mov(x2, 0xfedcba9876543210L);
 
   __ Extr(w10, w1, w2, 0);
   __ Extr(w11, w1, w2, 1);
   __ Extr(x12, x2, x1, 2);
 
@@ skipping 13 matching lines @@
   ASSERT_EQUAL_64(0x19083b2a, x14);
   ASSERT_EQUAL_64(0x13579bdf, x15);
   ASSERT_EQUAL_64(0x7f6e5d4c3b2a1908UL, x18);
   ASSERT_EQUAL_64(0x02468acf13579bdeUL, x19);
 
   TEARDOWN();
 }
 
 
 TEST(fmov_imm) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s11, 1.0);
   __ Fmov(d22, -13.0);
   __ Fmov(s1, 255.0);
   __ Fmov(d2, 12.34567);
   __ Fmov(s3, 0.0);
   __ Fmov(d4, 0.0);
   __ Fmov(s5, kFP32PositiveInfinity);
   __ Fmov(d6, kFP64NegativeInfinity);
   END();
 
   RUN();
 
   ASSERT_EQUAL_FP32(1.0, s11);
   ASSERT_EQUAL_FP64(-13.0, d22);
   ASSERT_EQUAL_FP32(255.0, s1);
   ASSERT_EQUAL_FP64(12.34567, d2);
   ASSERT_EQUAL_FP32(0.0, s3);
   ASSERT_EQUAL_FP64(0.0, d4);
   ASSERT_EQUAL_FP32(kFP32PositiveInfinity, s5);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d6);
 
   TEARDOWN();
 }
 
 
 TEST(fmov_reg) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s20, 1.0);
   __ Fmov(w10, s20);
   __ Fmov(s30, w10);
   __ Fmov(s5, s20);
   __ Fmov(d1, -13.0);
   __ Fmov(x1, d1);
   __ Fmov(d2, x1);
@@ skipping 10 matching lines @@
   ASSERT_EQUAL_64(double_to_rawbits(-13.0), x1);
   ASSERT_EQUAL_FP64(-13.0, d2);
   ASSERT_EQUAL_FP64(-13.0, d4);
   ASSERT_EQUAL_FP32(rawbits_to_float(0x89abcdef), s6);
 
   TEARDOWN();
 }
 
 
 TEST(fadd) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s13, -0.0);
   __ Fmov(s14, kFP32PositiveInfinity);
   __ Fmov(s15, kFP32NegativeInfinity);
   __ Fmov(s16, 3.25);
   __ Fmov(s17, 1.0);
   __ Fmov(s18, 0);
 
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_FP64(2.25, d6);
   ASSERT_EQUAL_FP64(2.25, d7);
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d8);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d9);
 
   TEARDOWN();
 }
 
 
 TEST(fsub) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s13, -0.0);
   __ Fmov(s14, kFP32PositiveInfinity);
   __ Fmov(s15, kFP32NegativeInfinity);
   __ Fmov(s16, 3.25);
   __ Fmov(s17, 1.0);
   __ Fmov(s18, 0);
 
@@ skipping 28 matching lines @@
   ASSERT_EQUAL_FP64(-2.25, d6);
   ASSERT_EQUAL_FP64(-2.25, d7);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d8);
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d9);
 
   TEARDOWN();
 }
 
 
 TEST(fmul) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s13, -0.0);
   __ Fmov(s14, kFP32PositiveInfinity);
   __ Fmov(s15, kFP32NegativeInfinity);
   __ Fmov(s16, 3.25);
   __ Fmov(s17, 2.0);
   __ Fmov(s18, 0);
   __ Fmov(s19, -2.0);
@@ skipping 54 matching lines @@
   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) {
+  INIT_V8();
   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) {
+  INIT_V8();
   // 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 48 matching lines @@
   RUN();
 
   ASSERT_EQUAL_FP32(fmadd, s30);
   ASSERT_EQUAL_FP32(fmsub, s31);
 
   TEARDOWN();
 }
 
 
 TEST(fmadd_fmsub_float) {
+  INIT_V8();
   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) {
+  INIT_V8();
   // 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 24 matching lines @@
     count_fmsub += test_fmsub;
 
     if (test_fmadd || test_fmsub) {
       FmaddFmsubFloatHelper(n, m, a, fmadd, fmsub);
     }
   }
 }
 
 
 TEST(fdiv) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s13, -0.0);
   __ Fmov(s14, kFP32PositiveInfinity);
   __ Fmov(s15, kFP32NegativeInfinity);
   __ Fmov(s16, 3.25);
   __ Fmov(s17, 2.0);
   __ Fmov(s18, 2.0);
   __ Fmov(s19, -2.0);
@@ skipping 136 matching lines @@
   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) {
+  INIT_V8();
   // 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 49 matching lines @@
   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) {
+  INIT_V8();
   // 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 19 matching lines @@
                           MinMaxHelper(n, m, true),
                           MinMaxHelper(n, m, false),
                           MinMaxHelper(n, m, true, kFP32PositiveInfinity),
                           MinMaxHelper(n, m, false, kFP32NegativeInfinity));
     }
   }
 }
 
 
 TEST(fccmp) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 0.0);
   __ Fmov(s17, 0.5);
   __ Fmov(d18, -0.5);
   __ Fmov(d19, -1.0);
   __ Mov(x20, 0);
 
   __ Cmp(x20, 0);
@@ skipping 47 matching lines @@
   ASSERT_EQUAL_32(CFlag, w6);
   ASSERT_EQUAL_32(NFlag, w7);
   ASSERT_EQUAL_32(ZCFlag, w8);
   ASSERT_EQUAL_32(ZCFlag, w9);
 
   TEARDOWN();
 }
 
 
 TEST(fcmp) {
+  INIT_V8();
   SETUP();
 
   START();
 
   // Some of these tests require a floating-point scratch register assigned to
   // the macro assembler, but most do not.
   __ SetFPScratchRegister(NoFPReg);
 
   __ Fmov(s8, 0.0);
   __ Fmov(s9, 0.5);
@@ skipping 55 matching lines @@
   ASSERT_EQUAL_32(CVFlag, w13);
   ASSERT_EQUAL_32(CVFlag, w14);
   ASSERT_EQUAL_32(ZCFlag, w15);
   ASSERT_EQUAL_32(NFlag, w16);
 
   TEARDOWN();
 }
 
 
 TEST(fcsel) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(x16, 0);
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 2.0);
   __ Fmov(d18, 3.0);
   __ Fmov(d19, 4.0);
 
   __ Cmp(x16, 0);
@@ skipping 12 matching lines @@
   ASSERT_EQUAL_FP64(3.0, d2);
   ASSERT_EQUAL_FP64(4.0, d3);
   ASSERT_EQUAL_FP32(1.0, s4);
   ASSERT_EQUAL_FP64(3.0, d5);
 
   TEARDOWN();
 }
 
 
 TEST(fneg) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 0.0);
   __ Fmov(s18, kFP32PositiveInfinity);
   __ Fmov(d19, 1.0);
   __ Fmov(d20, 0.0);
   __ Fmov(d21, kFP64PositiveInfinity);
 
@@ skipping 24 matching lines @@
   ASSERT_EQUAL_FP64(-0.0, d8);
   ASSERT_EQUAL_FP64(0.0, d9);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d10);
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d11);
 
   TEARDOWN();
 }
 
 
 TEST(fabs) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, -1.0);
   __ Fmov(s17, -0.0);
   __ Fmov(s18, kFP32NegativeInfinity);
   __ Fmov(d19, -1.0);
   __ Fmov(d20, -0.0);
   __ Fmov(d21, kFP64NegativeInfinity);
 
@@ skipping 16 matching lines @@
   ASSERT_EQUAL_FP64(1.0, d4);
   ASSERT_EQUAL_FP64(1.0, d5);
   ASSERT_EQUAL_FP64(0.0, d6);
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d7);
 
   TEARDOWN();
 }
 
 
 TEST(fsqrt) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 0.0);
   __ Fmov(s17, 1.0);
   __ Fmov(s18, 0.25);
   __ Fmov(s19, 65536.0);
   __ Fmov(s20, -0.0);
   __ Fmov(s21, kFP32PositiveInfinity);
   __ Fmov(d22, 0.0);
@@ skipping 30 matching lines @@
   ASSERT_EQUAL_FP64(0.5, d8);
   ASSERT_EQUAL_FP64(65536.0, d9);
   ASSERT_EQUAL_FP64(-0.0, d10);
   ASSERT_EQUAL_FP64(kFP32PositiveInfinity, d11);
 
   TEARDOWN();
 }
 
 
 TEST(frinta) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 1.1);
   __ Fmov(s18, 1.5);
   __ Fmov(s19, 1.9);
   __ Fmov(s20, 2.5);
   __ Fmov(s21, -1.5);
   __ Fmov(s22, -2.5);
@@ skipping 62 matching lines @@
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d18);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d19);
   ASSERT_EQUAL_FP64(0.0, d20);
   ASSERT_EQUAL_FP64(-0.0, d21);
 
   TEARDOWN();
 }
 
 
 TEST(frintn) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 1.1);
   __ Fmov(s18, 1.5);
   __ Fmov(s19, 1.9);
   __ Fmov(s20, 2.5);
   __ Fmov(s21, -1.5);
   __ Fmov(s22, -2.5);
@@ skipping 62 matching lines @@
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d18);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d19);
   ASSERT_EQUAL_FP64(0.0, d20);
   ASSERT_EQUAL_FP64(-0.0, d21);
 
   TEARDOWN();
 }
 
 
 TEST(frintz) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 1.1);
   __ Fmov(s18, 1.5);
   __ Fmov(s19, 1.9);
   __ Fmov(s20, 2.5);
   __ Fmov(s21, -1.5);
   __ Fmov(s22, -2.5);
@@ skipping 62 matching lines @@
   ASSERT_EQUAL_FP64(kFP64PositiveInfinity, d18);
   ASSERT_EQUAL_FP64(kFP64NegativeInfinity, d19);
   ASSERT_EQUAL_FP64(0.0, d20);
   ASSERT_EQUAL_FP64(-0.0, d21);
 
   TEARDOWN();
 }
 
 
 TEST(fcvt_ds) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s16, 1.0);
   __ Fmov(s17, 1.1);
   __ Fmov(s18, 1.5);
   __ Fmov(s19, 1.9);
   __ Fmov(s20, 2.5);
   __ Fmov(s21, -1.5);
   __ Fmov(s22, -2.5);
@@ skipping 45 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) {
+  INIT_V8();
   // 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 94 matching lines @@
     END();
     RUN();
     ASSERT_EQUAL_FP32(expected, s20);
     ASSERT_EQUAL_FP32(-expected, s21);
     TEARDOWN();
   }
 }
 
 
 TEST(fcvtas) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 2.5);
   __ Fmov(s3, -2.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 84 matching lines @@
   ASSERT_EQUAL_64(0x7fffffffffffffffUL, x27);
   ASSERT_EQUAL_64(0x8000000000000000UL, x28);
   ASSERT_EQUAL_64(0x7ffffffffffffc00UL, x29);
   ASSERT_EQUAL_64(0x8000000000000400UL, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtau) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 2.5);
   __ Fmov(s3, -2.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0xffffff00);  // Largest float < UINT32_MAX.
@@ skipping 79 matching lines @@
   ASSERT_EQUAL_64(0xffffffffffffffffUL, x27);
   ASSERT_EQUAL_64(0, x28);
   ASSERT_EQUAL_64(0xfffffffffffff800UL, x29);
   ASSERT_EQUAL_64(0xffffffff, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtms) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 84 matching lines @@
   ASSERT_EQUAL_64(0x7fffffffffffffffUL, x27);
   ASSERT_EQUAL_64(0x8000000000000000UL, x28);
   ASSERT_EQUAL_64(0x7ffffffffffffc00UL, x29);
   ASSERT_EQUAL_64(0x8000000000000400UL, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtmu) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 82 matching lines @@
   ASSERT_EQUAL_64(0xffffffffffffffffUL, x27);
   ASSERT_EQUAL_64(0x0UL, x28);
   ASSERT_EQUAL_64(0x7ffffffffffffc00UL, x29);
   ASSERT_EQUAL_64(0x0UL, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtns) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 84 matching lines @@
   ASSERT_EQUAL_64(0x7fffffffffffffffUL, x27);
 //  ASSERT_EQUAL_64(0x8000000000000000UL, x28);
   ASSERT_EQUAL_64(0x7ffffffffffffc00UL, x29);
   ASSERT_EQUAL_64(0x8000000000000400UL, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtnu) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0xffffff00);  // Largest float < UINT32_MAX.
@@ skipping 79 matching lines @@
   ASSERT_EQUAL_64(0xffffffffffffffffUL, x27);
 //  ASSERT_EQUAL_64(0, x28);
   ASSERT_EQUAL_64(0xfffffffffffff800UL, x29);
   ASSERT_EQUAL_64(0xffffffff, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtzs) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 84 matching lines @@
   ASSERT_EQUAL_64(0x7fffffffffffffffUL, x27);
   ASSERT_EQUAL_64(0x8000000000000000UL, x28);
   ASSERT_EQUAL_64(0x7ffffffffffffc00UL, x29);
   ASSERT_EQUAL_64(0x8000000000000400UL, x30);
 
   TEARDOWN();
 }
 
 
 TEST(fcvtzu) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Fmov(s0, 1.0);
   __ Fmov(s1, 1.1);
   __ Fmov(s2, 1.5);
   __ Fmov(s3, -1.5);
   __ Fmov(s4, kFP32PositiveInfinity);
   __ Fmov(s5, kFP32NegativeInfinity);
   __ Fmov(s6, 0x7fffff80);  // Largest float < INT32_MAX.
@@ skipping 180 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) {
+  INIT_V8();
   // 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 136 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) {
+  INIT_V8();
   // 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 48 matching lines @@
   TestUScvtf32Helper(0x00000000ffffff80, 0x4f800000, 0x4f800000);
   TestUScvtf32Helper(0x00000000ffffffff, 0x4f800000, 0x4f800000);
   TestUScvtf32Helper(0x7fffffc000000000, 0x5f000000, 0x5f000000);
   TestUScvtf32Helper(0x7fffffffffffffff, 0x5f000000, 0x5f000000);
   TestUScvtf32Helper(0xffffff8000000000, 0xd3000000, 0x5f800000);
   TestUScvtf32Helper(0xffffffffffffffff, 0xbf800000, 0x5f800000);
 }
 
 
 TEST(system_mrs) {
+  INIT_V8();
   SETUP();
 
   START();
   __ Mov(w0, 0);
   __ Mov(w1, 1);
   __ Mov(w2, 0x80000000);
 
   // Set the Z and C flags.
   __ Cmp(w0, w0);
   __ Mrs(x3, NZCV);
@@ skipping 19 matching lines @@
 
   // FPCR
   // The default FPCR on Linux-based platforms is 0.
   ASSERT_EQUAL_32(0, w6);
 
   TEARDOWN();
 }
 
 
 TEST(system_msr) {
+  INIT_V8();
   // All FPCR fields that must be implemented: AHP, DN, FZ, RMode
   const uint64_t fpcr_core = 0x07c00000;
 
   // All FPCR fields (including fields which may be read-as-zero):
   //  Stride, Len
   //  IDE, IXE, UFE, OFE, DZE, IOE
   const uint64_t fpcr_all = fpcr_core | 0x00379f00;
 
   SETUP();
 
@@ skipping 51 matching lines @@
 
   ASSERT_EQUAL_64(fpcr_core, x8);
   ASSERT_EQUAL_64(fpcr_core, x9);
   ASSERT_EQUAL_64(0, x10);
 
   TEARDOWN();
 }
 
 
 TEST(system_nop) {
+  INIT_V8();
   SETUP();
   RegisterDump before;
 
   START();
   before.Dump(&masm);
   __ Nop();
   END();
 
   RUN();
 
   ASSERT_EQUAL_REGISTERS(before);
   ASSERT_EQUAL_NZCV(before.flags_nzcv());
 
   TEARDOWN();
 }
 
 
 TEST(zero_dest) {
+  INIT_V8();
   SETUP();
   RegisterDump before;
 
   START();
   // Preserve the system stack pointer, in case we clobber it.
   __ Mov(x30, csp);
   // Initialize the other registers used in this test.
   uint64_t literal_base = 0x0100001000100101UL;
   __ Mov(x0, 0);
   __ Mov(x1, literal_base);
@@ skipping 46 matching lines @@
   RUN();
 
   ASSERT_EQUAL_REGISTERS(before);
   ASSERT_EQUAL_NZCV(before.flags_nzcv());
 
   TEARDOWN();
 }
 
 
 TEST(zero_dest_setflags) {
+  INIT_V8();
   SETUP();
   RegisterDump before;
 
   START();
   // Preserve the system stack pointer, in case we clobber it.
   __ Mov(x30, csp);
   // Initialize the other registers used in this test.
   uint64_t literal_base = 0x0100001000100101UL;
   __ Mov(x0, 0);
   __ Mov(x1, literal_base);
@@ skipping 76 matching lines @@
   CHECK(x10.Bit() == w10.Bit());
   CHECK(jssp.Bit() == wjssp.Bit());
   CHECK(xzr.Bit() == wzr.Bit());
   CHECK(csp.Bit() == wcsp.Bit());
 }
 
 
 TEST(stack_pointer_override) {
   // This test generates some stack maintenance code, but the test only checks
   // the reported state.
+  INIT_V8();
   SETUP();
   START();
 
   // The default stack pointer in V8 is jssp, but for compatibility with W16,
   // the test framework sets it to csp before calling the test.
   CHECK(csp.Is(__ StackPointer()));
   __ SetStackPointer(x0);
   CHECK(x0.Is(__ StackPointer()));
   __ SetStackPointer(jssp);
   CHECK(jssp.Is(__ StackPointer()));
   __ SetStackPointer(csp);
   CHECK(csp.Is(__ StackPointer()));
 
   END();
   RUN();
   TEARDOWN();
 }
 
 
 TEST(peek_poke_simple) {
+  INIT_V8();
   SETUP();
   START();
 
   static const RegList x0_to_x3 = x0.Bit() | x1.Bit() | x2.Bit() | x3.Bit();
   static const RegList x10_to_x13 = x10.Bit() | x11.Bit() |
                                     x12.Bit() | x13.Bit();
 
   // The literal base is chosen to have two useful properties:
   //  * When multiplied by small values (such as a register index), this value
   //    is clearly readable in the result.
@@ skipping 46 matching lines @@
   ASSERT_EQUAL_64((literal_base * 1) & 0xffffffff, x10);
   ASSERT_EQUAL_64((literal_base * 2) & 0xffffffff, x11);
   ASSERT_EQUAL_64((literal_base * 3) & 0xffffffff, x12);
   ASSERT_EQUAL_64((literal_base * 4) & 0xffffffff, x13);
 
   TEARDOWN();
 }
 
 
 TEST(peek_poke_unaligned) {
+  INIT_V8();
   SETUP();
   START();
 
   // The literal base is chosen to have two useful properties:
   //  * When multiplied by small values (such as a register index), this value
   //    is clearly readable in the result.
   //  * The value is not formed from repeating fixed-size smaller values, so it
   //    can be used to detect endianness-related errors.
   uint64_t literal_base = 0x0100001000100101UL;
 
@@ skipping 59 matching lines @@
 
   ASSERT_EQUAL_64((literal_base * 1) & 0xffffffff, x10);
   ASSERT_EQUAL_64((literal_base * 2) & 0xffffffff, x11);
   ASSERT_EQUAL_64((literal_base * 3) & 0xffffffff, x12);
 
   TEARDOWN();
 }
 
 
 TEST(peek_poke_endianness) {
+  INIT_V8();
   SETUP();
   START();
 
   // The literal base is chosen to have two useful properties:
   //  * When multiplied by small values (such as a register index), this value
   //    is clearly readable in the result.
   //  * The value is not formed from repeating fixed-size smaller values, so it
   //    can be used to detect endianness-related errors.
   uint64_t literal_base = 0x0100001000100101UL;
 
@@ skipping 29 matching lines @@
   ASSERT_EQUAL_64(x0_expected, x0);
   ASSERT_EQUAL_64(x1_expected, x1);
   ASSERT_EQUAL_64(x4_expected, x4);
   ASSERT_EQUAL_64(x5_expected, x5);
 
   TEARDOWN();
 }
 
 
 TEST(peek_poke_mixed) {
+  INIT_V8();
   SETUP();
   START();
 
   // The literal base is chosen to have two useful properties:
   //  * When multiplied by small values (such as a register index), this value
   //    is clearly readable in the result.
   //  * The value is not formed from repeating fixed-size smaller values, so it
   //    can be used to detect endianness-related errors.
   uint64_t literal_base = 0x0100001000100101UL;
 
@@ skipping 190 matching lines @@
     } else {
       ASSERT_EQUAL_64(literal_base * i, x[i]);
     }
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_simple_32) {
+  INIT_V8();
   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) {
+  INIT_V8();
   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 136 matching lines @@
     double expected;
     memcpy(&expected, &literal, sizeof(expected));
     ASSERT_EQUAL_FP64(expected, d[i]);
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_fp_jssp_simple_32) {
+  INIT_V8();
   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) {
+  INIT_V8();
   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);
@@ skipping 94 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) {
+  INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
     PushPopJsspMixedMethodsHelper(claim, kXRegSize);
   }
 }
 
 
 TEST(push_pop_jssp_mixed_methods_32) {
+  INIT_V8();
   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) {
+  INIT_V8();
   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);
     PushPopJsspWXOverlapHelper(kPushPopJsspMaxRegCount, claim);
     PushPopJsspWXOverlapHelper(kPushPopJsspMaxRegCount, claim);
   }
 }
 
 
 TEST(push_pop_csp) {
+  INIT_V8();
   SETUP();
 
   START();
 
   ASSERT(csp.Is(__ StackPointer()));
 
   __ Mov(x3, 0x3333333333333333UL);
   __ Mov(x2, 0x2222222222222222UL);
   __ Mov(x1, 0x1111111111111111UL);
   __ Mov(x0, 0x0000000000000000UL);
@@ skipping 68 matching lines @@
 
   ASSERT_EQUAL_32(0x33333333U, w25);
   ASSERT_EQUAL_32(0x00000000U, w27);
   ASSERT_EQUAL_32(0x22222222U, w28);
   ASSERT_EQUAL_32(0x33333333U, w29);
   TEARDOWN();
 }
 
 
 TEST(jump_both_smi) {
+  INIT_V8();
   SETUP();
 
   Label cond_pass_00, cond_pass_01, cond_pass_10, cond_pass_11;
   Label cond_fail_00, cond_fail_01, cond_fail_10, cond_fail_11;
   Label return1, return2, return3, done;
 
   START();
 
   __ Mov(x0, 0x5555555500000001UL);  // A pointer.
   __ Mov(x1, 0xaaaaaaaa00000001UL);  // A pointer.
@@ skipping 52 matching lines @@
   ASSERT_EQUAL_64(0, x4);
   ASSERT_EQUAL_64(0, x5);
   ASSERT_EQUAL_64(0, x6);
   ASSERT_EQUAL_64(1, x7);
 
   TEARDOWN();
 }
 
 
 TEST(jump_either_smi) {
+  INIT_V8();
   SETUP();
 
   Label cond_pass_00, cond_pass_01, cond_pass_10, cond_pass_11;
   Label cond_fail_00, cond_fail_01, cond_fail_10, cond_fail_11;
   Label return1, return2, return3, done;
 
   START();
 
   __ Mov(x0, 0x5555555500000001UL);  // A pointer.
   __ Mov(x1, 0xaaaaaaaa00000001UL);  // A pointer.
@@ skipping 395 matching lines @@
   CHECK(fpreg64.PopHighestIndex().IsNone());
 
   CHECK(reg32.IsEmpty());
   CHECK(reg64.IsEmpty());
   CHECK(fpreg32.IsEmpty());
   CHECK(fpreg64.IsEmpty());
 }
 
 
 TEST(printf) {
+  INIT_V8();
   SETUP();
   START();
 
   char const * test_plain_string = "Printf with no arguments.\n";
   char const * test_substring = "'This is a substring.'";
   RegisterDump before;
 
   // Initialize x29 to the value of the stack pointer. We will use x29 as a
   // temporary stack pointer later, and initializing it in this way allows the
   // RegisterDump check to pass.
@@ skipping 70 matching lines @@
   // Printf preserves all registers by default, we can't look at the number of
   // bytes that were printed. However, the printf_no_preserve test should check
   // that, and here we just test that we didn't clobber any registers.
   ASSERT_EQUAL_REGISTERS(before);
 
   TEARDOWN();
 }
 
 
 TEST(printf_no_preserve) {
+  INIT_V8();
   SETUP();
   START();
 
   char const * test_plain_string = "Printf with no arguments.\n";
   char const * test_substring = "'This is a substring.'";
 
   __ PrintfNoPreserve(test_plain_string);   // NOLINT(runtime/printf)
   __ Mov(x19, x0);
 
   // Test simple integer arguments.
@@ skipping 150 matching lines @@
     for (unsigned j = 0; j < i; j++) {
       CHECK(src[j] == dst[i][j]);
     }
     delete [] dst[i];
   }
 }
 
 
 // This is a V8-specific test.
 TEST(copyfields) {
+  INIT_V8();
   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();
 
@@ skipping 24 matching lines @@
 
     // Check that we didn't jump on slow.
     ASSERT_EQUAL_64(0xc001c0de, x2);
   }
 
   TEARDOWN();
 }
 
 
 TEST(smi_abs) {
+  INIT_V8();
   // 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.
   DoSmiAbsTest(0x80000000, true);
 }
 
 
 TEST(blr_lr) {
   // A simple test to check that the simulator correcty handle "blr lr".
+  INIT_V8();
   SETUP();
 
   START();
   Label target;
   Label end;
 
   __ Mov(x0, 0x0);
   __ Adr(lr, &target);
 
   __ Blr(lr);
   __ Mov(x0, 0xdeadbeef);
   __ B(&end);
 
   __ Bind(&target);
   __ Mov(x0, 0xc001c0de);
 
   __ Bind(&end);
   END();
 
   RUN();
 
   ASSERT_EQUAL_64(0xc001c0de, x0);
 
   TEARDOWN();
 }
 
 
 TEST(barriers) {
   // Generate all supported barriers, this is just a smoke test
+  INIT_V8();
   SETUP();
 
   START();
 
   // DMB
   __ Dmb(FullSystem, BarrierAll);
   __ Dmb(FullSystem, BarrierReads);
   __ Dmb(FullSystem, BarrierWrites);
   __ Dmb(FullSystem, BarrierOther);
 
@@ skipping 41 matching lines @@
   RUN();
 
   TEARDOWN();
 }
 
 
 TEST(call_no_relocation) {
   Address call_start;
   Address return_address;
 
+  INIT_V8();
   SETUP();
 
   START();
 
   Label function;
   Label test;
 
   __ B(&test);
 
   __ Bind(&function);
@@ skipping 49 matching lines @@
 
   ASSERT_EQUAL_32(expected, w0);
   ASSERT_EQUAL_64(expected64, x1);
   ASSERT_EQUAL_64(expected64 << kSmiShift | kSmiTag, x2);
 
   TEARDOWN();
 }
 
 
 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));
@@ skipping 164 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) {
+  INIT_V8();
   AbsHelperX(0);
   AbsHelperX(42);
   AbsHelperX(-42);
   AbsHelperX(kXMinInt);
   AbsHelperX(kXMaxInt);
 
   AbsHelperW(0);
   AbsHelperW(42);
   AbsHelperW(-42);
   AbsHelperW(kWMinInt);
   AbsHelperW(kWMaxInt);
 }