[compiler] Delay allocation of code-embedded heap numbers.

test/cctest/test-assembler-x64.cc

 // Copyright 2009 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 66 matching lines @@
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Assemble a simple function that copies argument 2 and returns it.
   __ movq(rax, arg2);
   __ nop();
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(2, result);
 }
 
 
 TEST(AssemblerX64StackOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
@@ skipping 11 matching lines @@
   __ pushq(arg2);  // Value at (rbp - 16)
   __ pushq(arg1);  // Value at (rbp - 24)
   __ popq(rax);
   __ popq(rax);
   __ popq(rax);
   __ popq(rbp);
   __ nop();
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(2, result);
 }
 
 
 TEST(AssemblerX64ArithmeticOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Assemble a simple function that adds arguments returning the sum.
   __ movq(rax, arg2);
   __ addq(rax, arg1);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(5, result);
 }
 
 
 TEST(AssemblerX64CmpbOperation) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Assemble a function that compare argument byte returing 1 if equal else 0.
   // On Windows, it compares rcx with rdx which does not require REX prefix;
   // on Linux, it compares rdi with rsi which requires REX prefix.
 
   Label done;
   __ movq(rax, Immediate(1));
   __ cmpb(arg1, arg2);
   __ j(equal, &done);
   __ movq(rax, Immediate(0));
   __ bind(&done);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(0x1002, 0x2002);
   CHECK_EQ(1, result);
   result =  FUNCTION_CAST<F2>(buffer)(0x1002, 0x2003);
   CHECK_EQ(0, result);
 }
 
 TEST(Regression684407) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
@@ skipping 21 matching lines @@
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Assemble a simple function that multiplies arguments returning the high
   // word.
   __ movq(rax, arg2);
   __ imulq(arg1);
   __ movq(rax, rdx);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(0, result);
   result =  FUNCTION_CAST<F2>(buffer)(0x100000000l, 0x100000000l);
   CHECK_EQ(1, result);
   result =  FUNCTION_CAST<F2>(buffer)(-0x100000000l, 0x100000000l);
   CHECK_EQ(-1, result);
 }
 
 TEST(AssemblerX64testbwqOperation) {
@@ skipping 151 matching lines @@
   __ popq(r14);
   __ popq(r13);
   __ popq(r12);
   __ popq(rsi);
   __ popq(rdi);
   __ popq(rbx);
 
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result = FUNCTION_CAST<F2>(buffer)(0, 0);
   CHECK_EQ(1, result);
 }
 
 TEST(AssemblerX64XchglOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg1, 0));
   __ movq(r11, Operand(arg2, 0));
   __ xchgl(rax, r11);
   __ movq(Operand(arg1, 0), rax);
   __ movq(Operand(arg2, 0), r11);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
   uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
   uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 40000000), left);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 20000000), right);
   USE(result);
 }
 
 
 TEST(AssemblerX64OrlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ orl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
   uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
   uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 60000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64RollOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, arg1);
   __ roll(rax, Immediate(1));
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t src = V8_2PART_UINT64_C(0x10000000, C0000000);
   uint64_t result = FUNCTION_CAST<F5>(buffer)(src);
   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 80000001), result);
 }
 
 
 TEST(AssemblerX64SublOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ subl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
   uint64_t right = V8_2PART_UINT64_C(0x30000000, 40000000);
   uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, e0000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64TestlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Set rax with the ZF flag of the testl instruction.
   Label done;
   __ movq(rax, Immediate(1));
   __ movq(r11, Operand(arg2, 0));
   __ testl(Operand(arg1, 0), r11);
   __ j(zero, &done, Label::kNear);
   __ movq(rax, Immediate(0));
   __ bind(&done);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
   uint64_t right = V8_2PART_UINT64_C(0x30000000, 00000000);
   uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(1u, result);
 }
 
 TEST(AssemblerX64TestwOperations) {
   typedef uint16_t (*F)(uint16_t * x);
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Set rax with the ZF flag of the testl instruction.
   Label done;
   __ movq(rax, Immediate(1));
   __ testw(Operand(arg1, 0), Immediate(0xf0f0));
   __ j(not_zero, &done, Label::kNear);
   __ movq(rax, Immediate(0));
   __ bind(&done);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint16_t operand = 0x8000;
   uint16_t result = FUNCTION_CAST<F>(buffer)(&operand);
   CHECK_EQ(1u, result);
 }
 
 TEST(AssemblerX64XorlOperations) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(rax, Operand(arg2, 0));
   __ xorl(Operand(arg1, 0), rax);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   uint64_t left = V8_2PART_UINT64_C(0x10000000, 20000000);
   uint64_t right = V8_2PART_UINT64_C(0x30000000, 60000000);
   uint64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);
   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 40000000), left);
   USE(result);
 }
 
 
 TEST(AssemblerX64MemoryOperands) {
@@ skipping 16 matching lines @@
   const int kStackElementSize = 8;
   __ movq(rax, Operand(rbp, -3 * kStackElementSize));
   __ popq(arg2);
   __ popq(arg2);
   __ popq(arg2);
   __ popq(rbp);
   __ nop();
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(3, result);
 }
 
 
 TEST(AssemblerX64ControlFlow) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   // Assemble a simple function that copies argument 1 and returns it.
   __ pushq(rbp);
 
   __ movq(rbp, rsp);
   __ movq(rax, arg1);
   Label target;
   __ jmp(&target);
   __ movq(rax, arg2);
   __ bind(&target);
   __ popq(rbp);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);
   CHECK_EQ(3, result);
 }
 
 
 TEST(AssemblerX64LoopImmediates) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
@@ skipping 29 matching lines @@
   __ cmpq(rax, Immediate(0x11FE7600));
   __ j(not_equal, &Fail);
 
   __ movq(rax, Immediate(1));
   __ ret(0);
   __ bind(&Fail);
   __ movq(rax, Immediate(0));
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   // Call the function from C++.
   int result =  FUNCTION_CAST<F0>(buffer)();
   CHECK_EQ(1, result);
 }
 
 
 TEST(OperandRegisterDependency) {
   int offsets[4] = {0, 1, 0xfed, 0xbeefcad};
   for (int i = 0; i < 4; i++) {
     int offset = offsets[i];
@@ skipping 96 matching lines @@
   __ bind(&fail);
   __ movq(rax, Immediate(13));
   __ popq(rsi);
   __ popq(rdi);
   __ popq(rdx);
   __ popq(rcx);
   __ popq(rbx);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   int res = f();
   CHECK_EQ(42, res);
 }
 
 
 #ifdef __GNUC__
@@ skipping 35 matching lines @@
   __ movmskps(rax, xmm0);
 
   // Remove unused data from the stack.
   __ addq(rsp, Immediate(ELEMENT_COUNT * sizeof(int32_t)));
   // Restore return address.
   __ pushq(rcx);
 
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   int res = f();
   args.GetReturnValue().Set(v8::Integer::New(CcTest::isolate(), res));
 }
 
 
 TEST(StackAlignmentForSSE2) {
@@ skipping 42 matching lines @@
   v8::HandleScope scope(CcTest::isolate());
   byte buffer[256];
   Isolate* isolate = CcTest::i_isolate();
   Assembler assm(isolate, buffer, sizeof(buffer));
   { CpuFeatureScope fscope2(&assm, SSE4_1);
     __ extractps(rax, xmm0, 0x1);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F3 f = FUNCTION_CAST<F3>(code->entry());
   uint64_t value1 = V8_2PART_UINT64_C(0x12345678, 87654321);
   CHECK_EQ(0x12345678u, f(uint64_to_double(value1)));
@@ skipping 17 matching lines @@
     __ movaps(xmm2, xmm1);
     __ addps(xmm2, xmm0);
     __ mulps(xmm2, xmm1);
     __ subps(xmm2, xmm0);
     __ divps(xmm2, xmm1);
     __ cvttss2si(rax, xmm2);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc,
       Code::ComputeFlags(Code::STUB),
       Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F6 f = FUNCTION_CAST<F6>(code->entry());
@@ skipping 207 matching lines @@
     __ j(not_equal, &exit);
 
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ addq(rsp, Immediate(kDoubleSize));
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F7 f = FUNCTION_CAST<F7>(code->entry());
   CHECK_EQ(0, f(0.000092662107262076, -2.460774966188315, -1.0958787393627414));
 }
@@ skipping 205 matching lines @@
     __ j(not_equal, &exit);
 
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ addq(rsp, Immediate(kDoubleSize));
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F8 f = FUNCTION_CAST<F8>(code->entry());
   CHECK_EQ(0, f(9.26621069e-05f, -2.4607749f, -1.09587872f));
 }
@@ skipping 54 matching lines @@
     __ j(parity_even, &exit);
     __ j(not_equal, &exit);
     __ movl(rax, Immediate(6));
 
     // result in eax
     __ bind(&exit);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F8 f = FUNCTION_CAST<F8>(code->entry());
   int res = f(1.0f, 2.0f, 3.0f);
   PrintF("f(1,2,3) = %d\n", res);
@@ skipping 64 matching lines @@
     __ j(not_equal, &exit);
     __ movl(rax, Immediate(6));
 
     // result in eax
     __ bind(&exit);
     __ addq(rsp, Immediate(kDoubleSize * 2));
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F8 f = FUNCTION_CAST<F8>(code->entry());
   int res = f(1.0f, 2.0f, 3.0f);
   PrintF("f(1,2,3) = %d\n", res);
@@ skipping 218 matching lines @@
     __ j(not_equal, &exit);
     __ movl(rax, Immediate(6));
 
     // result in eax
     __ bind(&exit);
     __ addq(rsp, Immediate(kDoubleSize * 2));
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F7 f = FUNCTION_CAST<F7>(code->entry());
   int res = f(1.0, 2.0, 3.0);
   PrintF("f(1,2,3) = %d\n", res);
@@ skipping 171 matching lines @@
     __ cmpq(r8, r9);
     __ j(not_equal, &exit);
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ popq(rcx);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   CHECK_EQ(0, f());
 }
@@ skipping 39 matching lines @@
     __ cmpq(r8, r9);
     __ j(not_equal, &exit);
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ popq(rcx);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   CHECK_EQ(0, f());
 }
@@ skipping 39 matching lines @@
     __ cmpq(r8, r9);
     __ j(not_equal, &exit);
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ popq(rcx);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   CHECK_EQ(0, f());
 }
@@ skipping 242 matching lines @@
     __ j(not_equal, &exit);
 
     __ xorl(rax, rax);
     __ bind(&exit);
     __ popq(rcx);
     __ popq(rbx);
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F0 f = FUNCTION_CAST<F0>(code->entry());
   CHECK_EQ(0, f());
 }
@@ skipping 24 matching lines @@
   for (int i = 0; i < kNumCases; ++i) {
     __ bind(&labels[i]);
     __ movq(rax, Immediate(values[i]));
     __ jmp(&done);
   }
 
   __ bind(&done);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
 
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
     int res = f(i);
     PrintF("f(%d) = %d\n", i, res);
@@ skipping 28 matching lines @@
 
   __ bind(&done);
   __ ret(0);
 
   __ bind(&table);
   for (int i = 0; i < kNumCases; ++i) {
     __ dq(&labels[i]);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
 
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
     int res = f(i);
     PrintF("f(%d) = %d\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 TEST(AssemblerX64PslldWithXmm15) {
   CcTest::InitializeVM();
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
       Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
 
   __ movq(xmm15, arg1);
   __ pslld(xmm15, 1);
   __ movq(rax, xmm15);
   __ ret(0);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(CcTest::i_isolate(), &desc);
   uint64_t result = FUNCTION_CAST<F5>(buffer)(V8_UINT64_C(0x1122334455667788));
   CHECK_EQ(V8_UINT64_C(0x22446688aaccef10), result);
 }
 
 typedef float (*F9)(float x, float y);
 TEST(AssemblerX64vmovups) {
   CcTest::InitializeVM();
   if (!CpuFeatures::IsSupported(AVX)) return;
 
   Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
   HandleScope scope(isolate);
   v8::internal::byte buffer[256];
   MacroAssembler assm(isolate, buffer, sizeof(buffer),
                       v8::internal::CodeObjectRequired::kYes);
   {
     CpuFeatureScope avx_scope(&assm, AVX);
     __ shufps(xmm0, xmm0, 0x0);  // brocast first argument
     __ shufps(xmm1, xmm1, 0x0);  // brocast second argument
     // copy xmm1 to xmm0 through the stack to test the "vmovups reg, mem".
     __ subq(rsp, Immediate(kSimd128Size));
     __ vmovups(Operand(rsp, 0), xmm1);
     __ vmovups(xmm0, Operand(rsp, 0));
     __ addq(rsp, Immediate(kSimd128Size));
 
     __ ret(0);
   }
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   OFStream os(stdout);
   code->Print(os);
 #endif
 
   F9 f = FUNCTION_CAST<F9>(code->entry());
   CHECK_EQ(-1.5, f(1.5, -1.5));
 }
 
 #undef __