Downgrade V8 to 3.1.8.25

There are serious performance regressions both in V8 and our own legacy
networking stack. Until we correct our own problems we are going back to the
old V8.

1 files changed, 177 insertions, 247 deletions

diff --git a/deps/v8/test/cctest/test-macro-assembler-x64.cc b/deps/v8/test/cctest/test-macro-assembler-x64.cc
index 59eeed906c..9b1fc46eaf 100755
--- a/deps/v8/test/cctest/test-macro-assembler-x64.cc
+++ b/deps/v8/test/cctest/test-macro-assembler-x64.cc
@@ -35,49 +35,48 @@
 #include "serialize.h"
 #include "cctest.h"
 
+using v8::internal::byte;
+using v8::internal::OS;
 using v8::internal::Assembler;
-using v8::internal::CodeDesc;
 using v8::internal::Condition;
-using v8::internal::FUNCTION_CAST;
+using v8::internal::MacroAssembler;
 using v8::internal::HandleScope;
+using v8::internal::Operand;
 using v8::internal::Immediate;
-using v8::internal::Isolate;
+using v8::internal::SmiIndex;
 using v8::internal::Label;
-using v8::internal::MacroAssembler;
-using v8::internal::OS;
-using v8::internal::Operand;
 using v8::internal::RelocInfo;
-using v8::internal::Smi;
-using v8::internal::SmiIndex;
-using v8::internal::byte;
-using v8::internal::carry;
-using v8::internal::greater;
-using v8::internal::greater_equal;
-using v8::internal::kIntSize;
-using v8::internal::kPointerSize;
-using v8::internal::kSmiTagMask;
-using v8::internal::kSmiValueSize;
-using v8::internal::less_equal;
-using v8::internal::negative;
-using v8::internal::not_carry;
-using v8::internal::not_equal;
-using v8::internal::not_zero;
-using v8::internal::positive;
-using v8::internal::r11;
-using v8::internal::r13;
-using v8::internal::r14;
-using v8::internal::r15;
-using v8::internal::r8;
-using v8::internal::r9;
 using v8::internal::rax;
-using v8::internal::rbp;
 using v8::internal::rbx;
-using v8::internal::rcx;
+using v8::internal::rsi;
 using v8::internal::rdi;
+using v8::internal::rcx;
 using v8::internal::rdx;
-using v8::internal::rsi;
+using v8::internal::rbp;
 using v8::internal::rsp;
+using v8::internal::r8;
+using v8::internal::r9;
+using v8::internal::r11;
+using v8::internal::r12;
+using v8::internal::r13;
+using v8::internal::r14;
 using v8::internal::times_pointer_size;
+using v8::internal::FUNCTION_CAST;
+using v8::internal::CodeDesc;
+using v8::internal::less_equal;
+using v8::internal::not_equal;
+using v8::internal::not_zero;
+using v8::internal::greater;
+using v8::internal::greater_equal;
+using v8::internal::carry;
+using v8::internal::not_carry;
+using v8::internal::negative;
+using v8::internal::positive;
+using v8::internal::Smi;
+using v8::internal::kSmiTagMask;
+using v8::internal::kSmiValueSize;
+using v8::internal::kPointerSize;
+using v8::internal::kIntSize;
 
 // Test the x64 assembler by compiling some simple functions into
 // a buffer and executing them.  These tests do not initialize the
@@ -96,9 +95,7 @@ typedef int (*F0)();
 static void EntryCode(MacroAssembler* masm) {
   // Smi constant register is callee save.
   __ push(v8::internal::kSmiConstantRegister);
-  __ push(v8::internal::kRootRegister);
   __ InitializeSmiConstantRegister();
-  __ InitializeRootRegister();
 }
 
 
@@ -108,7 +105,6 @@ static void ExitCode(MacroAssembler* masm) {
   __ cmpq(rdx, v8::internal::kSmiConstantRegister);
   __ movq(rdx, Immediate(-1));
   __ cmovq(not_equal, rax, rdx);
-  __ pop(v8::internal::kRootRegister);
   __ pop(v8::internal::kSmiConstantRegister);
 }
 
@@ -150,7 +146,6 @@ static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) {
 
 // Test that we can move a Smi value literally into a register.
 TEST(SmiMove) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -158,9 +153,7 @@ TEST(SmiMove) {
                                                    true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
   MacroAssembler* masm = &assembler;  // Create a pointer for the __ macro.
   masm->set_allow_stub_calls(false);
   EntryCode(masm);
@@ -227,7 +220,7 @@ void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) {
       __ j(less_equal, exit);
     }
   } else {
-    __ cmpq(rcx, rcx);
+    __ SmiCompare(rcx, rcx);
     __ movl(rax, Immediate(id + 11));
     __ j(not_equal, exit);
     __ incq(rax);
@@ -239,18 +232,15 @@ void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) {
 
 // Test that we can compare smis for equality (and more).
 TEST(SmiCompare) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
-      static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
+      static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
                                       &actual_size,
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -292,7 +282,6 @@ TEST(SmiCompare) {
 
 
 TEST(Integer32ToSmi) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -300,9 +289,7 @@ TEST(Integer32ToSmi) {
                                                  true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -313,35 +300,35 @@ TEST(Integer32ToSmi) {
   __ movl(rcx, Immediate(0));
   __ Integer32ToSmi(rcx, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
-  __ cmpq(rcx, rdx);
+  __ SmiCompare(rcx, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(2));  // Test number.
   __ movl(rcx, Immediate(1024));
   __ Integer32ToSmi(rcx, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
-  __ cmpq(rcx, rdx);
+  __ SmiCompare(rcx, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(3));  // Test number.
   __ movl(rcx, Immediate(-1));
   __ Integer32ToSmi(rcx, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
-  __ cmpq(rcx, rdx);
+  __ SmiCompare(rcx, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(4));  // Test number.
   __ movl(rcx, Immediate(Smi::kMaxValue));
   __ Integer32ToSmi(rcx, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
-  __ cmpq(rcx, rdx);
+  __ SmiCompare(rcx, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(5));  // Test number.
   __ movl(rcx, Immediate(Smi::kMinValue));
   __ Integer32ToSmi(rcx, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
-  __ cmpq(rcx, rdx);
+  __ SmiCompare(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Different target register.
@@ -350,35 +337,35 @@ TEST(Integer32ToSmi) {
   __ movl(rcx, Immediate(0));
   __ Integer32ToSmi(r8, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
-  __ cmpq(r8, rdx);
+  __ SmiCompare(r8, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(7));  // Test number.
   __ movl(rcx, Immediate(1024));
   __ Integer32ToSmi(r8, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
-  __ cmpq(r8, rdx);
+  __ SmiCompare(r8, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(8));  // Test number.
   __ movl(rcx, Immediate(-1));
   __ Integer32ToSmi(r8, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
-  __ cmpq(r8, rdx);
+  __ SmiCompare(r8, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(9));  // Test number.
   __ movl(rcx, Immediate(Smi::kMaxValue));
   __ Integer32ToSmi(r8, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
-  __ cmpq(r8, rdx);
+  __ SmiCompare(r8, rdx);
   __ j(not_equal, &exit);
 
   __ movq(rax, Immediate(10));  // Test number.
   __ movl(rcx, Immediate(Smi::kMinValue));
   __ Integer32ToSmi(r8, rcx);
   __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
-  __ cmpq(r8, rdx);
+  __ SmiCompare(r8, rdx);
   __ j(not_equal, &exit);
 
 
@@ -407,22 +394,21 @@ void TestI64PlusConstantToSmi(MacroAssembler* masm,
   __ movq(rcx, x, RelocInfo::NONE);
   __ movq(r11, rcx);
   __ Integer64PlusConstantToSmi(rdx, rcx, y);
-  __ cmpq(rdx, r8);
+  __ SmiCompare(rdx, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ Integer64PlusConstantToSmi(rcx, rcx, y);
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 }
 
 
 TEST(Integer64PlusConstantToSmi) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -430,9 +416,7 @@ TEST(Integer64PlusConstantToSmi) {
                                                  true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -468,7 +452,6 @@ TEST(Integer64PlusConstantToSmi) {
 
 
 TEST(SmiCheck) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -476,9 +459,7 @@ TEST(SmiCheck) {
                                                    true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -679,14 +660,14 @@ void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiNeg(r9, rcx, exit);
 
     __ incq(rax);
-    __ cmpq(r11, rcx);
+    __ SmiCompare(r11, rcx);
     __ j(not_equal, exit);
 
     __ incq(rax);
     __ SmiNeg(rcx, rcx, exit);
 
     __ incq(rax);
-    __ cmpq(r11, rcx);
+    __ SmiCompare(r11, rcx);
     __ j(not_equal, exit);
   } else {
     Label smi_ok, smi_ok2;
@@ -698,11 +679,11 @@ void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
     __ jmp(exit);
     __ bind(&smi_ok);
     __ incq(rax);
-    __ cmpq(r9, r8);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
-    __ cmpq(r11, rcx);
+    __ SmiCompare(r11, rcx);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -710,14 +691,13 @@ void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
     __ jmp(exit);
     __ bind(&smi_ok2);
     __ incq(rax);
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiNeg) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -726,9 +706,7 @@ TEST(SmiNeg) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -773,12 +751,12 @@ static void SmiAddTest(MacroAssembler* masm,
 
   __ movl(rax, Immediate(id));  // Test number.
   __ SmiAdd(r9, rcx, rdx, exit);
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiAdd(rcx, rcx, rdx, exit);                              \
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 
   __ movl(rcx, Immediate(first));
@@ -786,11 +764,11 @@ static void SmiAddTest(MacroAssembler* masm,
 
   __ incq(rax);
   __ SmiAddConstant(r9, rcx, Smi::FromInt(second));
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ SmiAddConstant(rcx, rcx, Smi::FromInt(second));
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 
   __ movl(rcx, Immediate(first));
@@ -798,17 +776,16 @@ static void SmiAddTest(MacroAssembler* masm,
 
   __ incq(rax);
   __ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit);
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit);
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 }
 
 TEST(SmiAdd) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -816,9 +793,7 @@ TEST(SmiAdd) {
                                                  true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -859,36 +834,36 @@ static void SmiSubTest(MacroAssembler* masm,
 
   __ movl(rax, Immediate(id));  // Test 0.
   __ SmiSub(r9, rcx, rdx, exit);
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 1.
   __ SmiSub(rcx, rcx, rdx, exit);
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 
   __ Move(rcx, Smi::FromInt(first));
 
   __ incq(rax);  // Test 2.
   __ SmiSubConstant(r9, rcx, Smi::FromInt(second));
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 3.
   __ SmiSubConstant(rcx, rcx, Smi::FromInt(second));
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 
   __ Move(rcx, Smi::FromInt(first));
 
   __ incq(rax);  // Test 4.
   __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 5.
   __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 }
 
@@ -911,7 +886,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -922,7 +897,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -934,7 +909,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -945,7 +920,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -958,7 +933,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -969,7 +944,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -981,7 +956,7 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 
@@ -992,14 +967,13 @@ static void SmiSubOverflowTest(MacroAssembler* masm,
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiSub) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1008,9 +982,7 @@ TEST(SmiSub) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1060,15 +1032,15 @@ void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
     __ Move(r8, Smi::FromIntptr(result));
     __ SmiMul(r9, rcx, rdx, exit);
     __ incq(rax);
-    __ cmpq(r11, rcx);
+    __ SmiCompare(r11, rcx);
     __ j(not_equal, exit);
     __ incq(rax);
-    __ cmpq(r9, r8);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
     __ SmiMul(rcx, rcx, rdx, exit);
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
   } else {
     __ movl(rax, Immediate(id + 8));
@@ -1077,7 +1049,7 @@ void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
-    __ cmpq(r11, rcx);
+    __ SmiCompare(r11, rcx);
     __ j(not_equal, exit);
     __ incq(rax);
     __ SmiMul(rcx, rcx, rdx, &overflow_ok2);
@@ -1085,14 +1057,13 @@ void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
     __ bind(&overflow_ok2);
     // 31-bit version doesn't preserve rcx on failure.
     // __ incq(rax);
-    // __ cmpq(r11, rcx);
+    // __ SmiCompare(r11, rcx);
     // __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiMul) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ -1100,9 +1071,7 @@ TEST(SmiMul) {
                                                  true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1151,30 +1120,30 @@ void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   if (!fraction && !overflow && !negative_zero && !division_by_zero) {
     // Division succeeds
     __ movq(rcx, r11);
-    __ movq(r15, Immediate(id));
+    __ movq(r12, Immediate(id));
     int result = x / y;
     __ Move(r8, Smi::FromInt(result));
     __ SmiDiv(r9, rcx, r14, exit);
     // Might have destroyed rcx and r14.
-    __ incq(r15);
-    __ cmpq(r9, r8);
+    __ incq(r12);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
-    __ incq(r15);
+    __ incq(r12);
     __ movq(rcx, r11);
     __ Move(r14, Smi::FromInt(y));
-    __ cmpq(rcx, r11);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
 
-    __ incq(r15);
+    __ incq(r12);
     __ SmiDiv(rcx, rcx, r14, exit);
 
-    __ incq(r15);
-    __ cmpq(rcx, r8);
+    __ incq(r12);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
   } else {
     // Division fails.
-    __ movq(r15, Immediate(id + 8));
+    __ movq(r12, Immediate(id + 8));
 
     Label fail_ok, fail_ok2;
     __ movq(rcx, r11);
@@ -1182,24 +1151,23 @@ void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) {
     __ jmp(exit);
     __ bind(&fail_ok);
 
-    __ incq(r15);
-    __ cmpq(rcx, r11);
+    __ incq(r12);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
 
-    __ incq(r15);
+    __ incq(r12);
     __ SmiDiv(rcx, rcx, r14, &fail_ok2);
     __ jmp(exit);
     __ bind(&fail_ok2);
 
-    __ incq(r15);
-    __ cmpq(rcx, r11);
+    __ incq(r12);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiDiv) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1208,9 +1176,7 @@ TEST(SmiDiv) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1218,7 +1184,7 @@ TEST(SmiDiv) {
   Label exit;
 
   __ push(r14);
-  __ push(r15);
+  __ push(r12);
   TestSmiDiv(masm, &exit, 0x10, 1, 1);
   TestSmiDiv(masm, &exit, 0x20, 1, 0);
   TestSmiDiv(masm, &exit, 0x30, -1, 0);
@@ -1240,10 +1206,10 @@ TEST(SmiDiv) {
   TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
   TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1);
 
-  __ xor_(r15, r15);  // Success.
+  __ xor_(r12, r12);  // Success.
   __ bind(&exit);
-  __ movq(rax, r15);
-  __ pop(r15);
+  __ movq(rax, r12);
+  __ pop(r12);
   __ pop(r14);
   ExitCode(masm);
   __ ret(0);
@@ -1266,52 +1232,51 @@ void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ Move(r14, Smi::FromInt(y));
   if (!division_overflow && !negative_zero && !division_by_zero) {
     // Modulo succeeds
-    __ movq(r15, Immediate(id));
+    __ movq(r12, Immediate(id));
     int result = x % y;
     __ Move(r8, Smi::FromInt(result));
     __ SmiMod(r9, rcx, r14, exit);
 
-    __ incq(r15);
-    __ cmpq(r9, r8);
+    __ incq(r12);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
-    __ incq(r15);
-    __ cmpq(rcx, r11);
+    __ incq(r12);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
 
-    __ incq(r15);
+    __ incq(r12);
     __ SmiMod(rcx, rcx, r14, exit);
 
-    __ incq(r15);
-    __ cmpq(rcx, r8);
+    __ incq(r12);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
   } else {
     // Modulo fails.
-    __ movq(r15, Immediate(id + 8));
+    __ movq(r12, Immediate(id + 8));
 
     Label fail_ok, fail_ok2;
     __ SmiMod(r9, rcx, r14, &fail_ok);
     __ jmp(exit);
     __ bind(&fail_ok);
 
-    __ incq(r15);
-    __ cmpq(rcx, r11);
+    __ incq(r12);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
 
-    __ incq(r15);
+    __ incq(r12);
     __ SmiMod(rcx, rcx, r14, &fail_ok2);
     __ jmp(exit);
     __ bind(&fail_ok2);
 
-    __ incq(r15);
-    __ cmpq(rcx, r11);
+    __ incq(r12);
+    __ SmiCompare(rcx, r11);
     __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiMod) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1320,9 +1285,7 @@ TEST(SmiMod) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1330,7 +1293,7 @@ TEST(SmiMod) {
   Label exit;
 
   __ push(r14);
-  __ push(r15);
+  __ push(r12);
   TestSmiMod(masm, &exit, 0x10, 1, 1);
   TestSmiMod(masm, &exit, 0x20, 1, 0);
   TestSmiMod(masm, &exit, 0x30, -1, 0);
@@ -1352,10 +1315,10 @@ TEST(SmiMod) {
   TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
   TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1);
 
-  __ xor_(r15, r15);  // Success.
+  __ xor_(r12, r12);  // Success.
   __ bind(&exit);
-  __ movq(rax, r15);
-  __ pop(r15);
+  __ movq(rax, r12);
+  __ pop(r12);
   __ pop(r14);
   ExitCode(masm);
   __ ret(0);
@@ -1377,7 +1340,7 @@ void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
     ASSERT(index.reg.is(rcx) || index.reg.is(rdx));
     __ shl(index.reg, Immediate(index.scale));
     __ Set(r8, static_cast<intptr_t>(x) << i);
-    __ cmpq(index.reg, r8);
+    __ SmiCompare(index.reg, r8);
     __ j(not_equal, exit);
     __ incq(rax);
     __ Move(rcx, Smi::FromInt(x));
@@ -1385,7 +1348,7 @@ void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
     ASSERT(index.reg.is(rcx));
     __ shl(rcx, Immediate(index.scale));
     __ Set(r8, static_cast<intptr_t>(x) << i);
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
     __ incq(rax);
 
@@ -1394,7 +1357,7 @@ void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
     ASSERT(index.reg.is(rcx) || index.reg.is(rdx));
     __ shl(index.reg, Immediate(index.scale));
     __ Set(r8, static_cast<intptr_t>(-x) << i);
-    __ cmpq(index.reg, r8);
+    __ SmiCompare(index.reg, r8);
     __ j(not_equal, exit);
     __ incq(rax);
     __ Move(rcx, Smi::FromInt(x));
@@ -1402,14 +1365,13 @@ void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
     ASSERT(index.reg.is(rcx));
     __ shl(rcx, Immediate(index.scale));
     __ Set(r8, static_cast<intptr_t>(-x) << i);
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
     __ incq(rax);
   }
 }
 
 TEST(SmiIndex) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1418,9 +1380,7 @@ TEST(SmiIndex) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1454,7 +1414,7 @@ void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ SelectNonSmi(r9, rcx, rdx, exit);
 
   __ incq(rax);
-  __ cmpq(r9, rdx);
+  __ SmiCompare(r9, rdx);
   __ j(not_equal, exit);
 
   __ incq(rax);
@@ -1464,7 +1424,7 @@ void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ SelectNonSmi(r9, rcx, rdx, exit);
 
   __ incq(rax);
-  __ cmpq(r9, rcx);
+  __ SmiCompare(r9, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
@@ -1480,7 +1440,6 @@ void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
 
 
 TEST(SmiSelectNonSmi) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1489,9 +1448,7 @@ TEST(SmiSelectNonSmi) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);  // Avoid inline checks.
@@ -1531,37 +1488,36 @@ void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ Move(rdx, Smi::FromInt(y));
   __ Move(r8, Smi::FromInt(result));
   __ SmiAnd(r9, rcx, rdx);
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiAnd(rcx, rcx, rdx);
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 
   __ movq(rcx, r11);
   __ incq(rax);
   __ SmiAndConstant(r9, rcx, Smi::FromInt(y));
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiAndConstant(rcx, rcx, Smi::FromInt(y));
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 }
 
 
 TEST(SmiAnd) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1570,9 +1526,7 @@ TEST(SmiAnd) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1614,37 +1568,36 @@ void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ Move(rdx, Smi::FromInt(y));
   __ Move(r8, Smi::FromInt(result));
   __ SmiOr(r9, rcx, rdx);
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiOr(rcx, rcx, rdx);
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 
   __ movq(rcx, r11);
   __ incq(rax);
   __ SmiOrConstant(r9, rcx, Smi::FromInt(y));
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiOrConstant(rcx, rcx, Smi::FromInt(y));
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 }
 
 
 TEST(SmiOr) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1653,9 +1606,7 @@ TEST(SmiOr) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1699,37 +1650,36 @@ void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   __ Move(rdx, Smi::FromInt(y));
   __ Move(r8, Smi::FromInt(result));
   __ SmiXor(r9, rcx, rdx);
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiXor(rcx, rcx, rdx);
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 
   __ movq(rcx, r11);
   __ incq(rax);
   __ SmiXorConstant(r9, rcx, Smi::FromInt(y));
-  __ cmpq(r8, r9);
+  __ SmiCompare(r8, r9);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiXorConstant(rcx, rcx, Smi::FromInt(y));
-  __ cmpq(r8, rcx);
+  __ SmiCompare(r8, rcx);
   __ j(not_equal, exit);
 }
 
 
 TEST(SmiXor) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1738,9 +1688,7 @@ TEST(SmiXor) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1783,22 +1731,21 @@ void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) {
   __ movq(r11, rcx);
 
   __ SmiNot(r9, rcx);
-  __ cmpq(r9, r8);
+  __ SmiCompare(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ cmpq(r11, rcx);
+  __ SmiCompare(r11, rcx);
   __ j(not_equal, exit);
 
   __ incq(rax);
   __ SmiNot(rcx, rcx);
-  __ cmpq(rcx, r8);
+  __ SmiCompare(rcx, r8);
   __ j(not_equal, exit);
 }
 
 
 TEST(SmiNot) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1807,9 +1754,7 @@ TEST(SmiNot) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1852,7 +1797,7 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiShiftLeftConstant(r9, rcx, shift);
 
     __ incq(rax);
-    __ cmpq(r9, r8);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -1860,7 +1805,7 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiShiftLeftConstant(rcx, rcx, shift);
 
     __ incq(rax);
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -1869,7 +1814,7 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiShiftLeft(r9, rdx, rcx);
 
     __ incq(rax);
-    __ cmpq(r9, r8);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -1878,7 +1823,7 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiShiftLeft(r9, rdx, r11);
 
     __ incq(rax);
-    __ cmpq(r9, r8);
+    __ SmiCompare(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -1887,7 +1832,7 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
     __ SmiShiftLeft(rdx, rdx, r11);
 
     __ incq(rax);
-    __ cmpq(rdx, r8);
+    __ SmiCompare(rdx, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -1896,7 +1841,6 @@ void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
 
 
 TEST(SmiShiftLeft) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -1905,9 +1849,7 @@ TEST(SmiShiftLeft) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -1951,7 +1893,7 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
       __ SmiShiftLogicalRightConstant(r9, rcx, shift, exit);
 
       __ incq(rax);
-      __ cmpq(r9, r8);
+      __ SmiCompare(r9, r8);
       __ j(not_equal, exit);
 
       __ incq(rax);
@@ -1960,7 +1902,7 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
       __ SmiShiftLogicalRight(r9, rdx, rcx, exit);
 
       __ incq(rax);
-      __ cmpq(r9, r8);
+      __ SmiCompare(r9, r8);
       __ j(not_equal, exit);
 
       __ incq(rax);
@@ -1969,7 +1911,7 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
       __ SmiShiftLogicalRight(r9, rdx, r11, exit);
 
       __ incq(rax);
-      __ cmpq(r9, r8);
+      __ SmiCompare(r9, r8);
       __ j(not_equal, exit);
 
       __ incq(rax);
@@ -1983,7 +1925,7 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
       __ bind(&fail_ok);
 
       __ incq(rax);
-      __ cmpq(rcx, r11);
+      __ SmiCompare(rcx, r11);
       __ j(not_equal, exit);
 
       __ incq(rax);
@@ -1994,7 +1936,7 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
       __ bind(&fail_ok3);
 
       __ incq(rax);
-      __ cmpq(rcx, r11);
+      __ SmiCompare(rcx, r11);
       __ j(not_equal, exit);
 
       __ addq(rax, Immediate(3));
@@ -2004,7 +1946,6 @@ void TestSmiShiftLogicalRight(MacroAssembler* masm,
 
 
 TEST(SmiShiftLogicalRight) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -2013,9 +1954,7 @@ TEST(SmiShiftLogicalRight) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -2058,7 +1997,7 @@ void TestSmiShiftArithmeticRight(MacroAssembler* masm,
     __ Move(rcx, Smi::FromInt(x));
     __ SmiShiftArithmeticRightConstant(rcx, rcx, shift);
 
-    __ cmpq(rcx, r8);
+    __ SmiCompare(rcx, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -2066,7 +2005,7 @@ void TestSmiShiftArithmeticRight(MacroAssembler* masm,
     __ Move(r11, Smi::FromInt(shift));
     __ SmiShiftArithmeticRight(rdx, rdx, r11);
 
-    __ cmpq(rdx, r8);
+    __ SmiCompare(rdx, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ -2075,7 +2014,6 @@ void TestSmiShiftArithmeticRight(MacroAssembler* masm,
 
 
 TEST(SmiShiftArithmeticRight) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
@@ -2084,9 +2022,7 @@ TEST(SmiShiftArithmeticRight) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -2126,14 +2062,14 @@ void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) {
     __ Move(rcx, Smi::FromInt(x));
     __ movq(r11, rcx);
     __ PositiveSmiTimesPowerOfTwoToInteger64(rdx, rcx, power);
-    __ cmpq(rdx, r8);
+    __ SmiCompare(rdx, r8);
     __ j(not_equal, exit);
     __ incq(rax);
-    __ cmpq(r11, rcx);  // rcx unchanged.
+    __ SmiCompare(r11, rcx);  // rcx unchanged.
     __ j(not_equal, exit);
     __ incq(rax);
     __ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power);
-    __ cmpq(rdx, r8);
+    __ SmiCompare(rdx, r8);
     __ j(not_equal, exit);
     __ incq(rax);
   }
@@ -2141,18 +2077,15 @@ void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) {
 
 
 TEST(PositiveSmiTimesPowerOfTwoToInteger64) {
-  v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
-      static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 4,
+      static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
                                       &actual_size,
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -2183,7 +2116,6 @@ TEST(PositiveSmiTimesPowerOfTwoToInteger64) {
 
 
 TEST(OperandOffset) {
-  v8::internal::V8::Initialize(NULL);
   int data[256];
   for (int i = 0; i < 256; i++) { data[i] = i * 0x01010101; }
 
@@ -2195,9 +2127,7 @@ TEST(OperandOffset) {
                                       true));
   CHECK(buffer);
   HandleScope handles;
-  MacroAssembler assembler(Isolate::Current(),
-                           buffer,
-                           static_cast<int>(actual_size));
+  MacroAssembler assembler(buffer, static_cast<int>(actual_size));
 
   MacroAssembler* masm = &assembler;
   masm->set_allow_stub_calls(false);
@@ -2220,7 +2150,7 @@ TEST(OperandOffset) {
   __ push(Immediate(0x108));
   __ push(Immediate(0x109));  // <-- rsp
   // rbp = rsp[9]
-  // r15 = rsp[3]
+  // r12 = rsp[3]
   // rbx = rsp[5]
   // r13 = rsp[7]
   __ lea(r14, Operand(rsp, 3 * kPointerSize));