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

test/cctest/test-assembler-arm.cc

 // Copyright 2012 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 43 matching lines @@
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   Assembler assm(isolate, NULL, 0);
 
   __ add(r0, r0, Operand(r1));
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F2 f = FUNCTION_CAST<F2>(code->entry());
   int res =
       reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, 3, 4, 0, 0, 0));
   ::printf("f() = %d\n", res);
@@ skipping 16 matching lines @@
   __ bind(&L);
   __ add(r0, r0, Operand(r1));
   __ sub(r1, r1, Operand(1));
 
   __ bind(&C);
   __ teq(r1, Operand::Zero());
   __ b(ne, &L);
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res =
       reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, 100, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
@@ skipping 25 matching lines @@
   // some relocated stuff here, not executed
   __ RecordComment("dead code, just testing relocations");
   __ mov(r0, Operand(isolate->factory()->true_value()));
   __ RecordComment("dead code, just testing immediate operands");
   __ mov(r0, Operand(-1));
   __ mov(r0, Operand(0xFF000000));
   __ mov(r0, Operand(0xF0F0F0F0));
   __ mov(r0, Operand(0xFFF0FFFF));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res =
       reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, 10, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
@@ skipping 27 matching lines @@
   __ add(r0, r2, Operand(r0));
   __ mov(r2, Operand(r2, LSL, 2));
   __ strb(r2, MemOperand(r4, offsetof(T, c)));
   __ ldrsh(r2, MemOperand(r4, offsetof(T, s)));
   __ add(r0, r2, Operand(r0));
   __ mov(r2, Operand(r2, ASR, 3));
   __ strh(r2, MemOperand(r4, offsetof(T, s)));
   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.i = 100000;
   t.c = 10;
   t.s = 1000;
@@ skipping 111 matching lines @@
 
     // Test vmov for single-precision immediates.
     __ vmov(s0, 0.25f);
     __ vstr(s0, r4, offsetof(T, o));
     __ vmov(s0, -16.0f);
     __ vstr(s0, r4, offsetof(T, p));
 
     __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.a = 1.5;
     t.b = 2.75;
     t.c = 17.17;
@@ skipping 42 matching lines @@
     CpuFeatureScope scope(&assm, ARMv7);
     // On entry, r0 = 0xAAAAAAAA = 0b10..10101010.
     __ ubfx(r0, r0, 1, 12);  // 0b00..010101010101 = 0x555
     __ sbfx(r0, r0, 0, 5);   // 0b11..111111110101 = -11
     __ bfc(r0, 1, 3);        // 0b11..111111110001 = -15
     __ mov(r1, Operand(7));
     __ bfi(r0, r1, 3, 3);    // 0b11..111111111001 = -7
     __ mov(pc, Operand(lr));
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F1 f = FUNCTION_CAST<F1>(code->entry());
     int res = reinterpret_cast<int>(
         CALL_GENERATED_CODE(isolate, f, 0xAAAAAAAA, 0, 0, 0, 0));
     ::printf("f() = %d\n", res);
@@ skipping 11 matching lines @@
   Assembler assm(isolate, NULL, 0);
 
   __ usat(r1, 8, Operand(r0));           // Sat 0xFFFF to 0-255 = 0xFF.
   __ usat(r2, 12, Operand(r0, ASR, 9));  // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
   __ usat(r3, 1, Operand(r0, LSL, 16));  // Sat (0xFFFF<<16) to 0-1 = 0x0.
   __ add(r0, r1, Operand(r2));
   __ add(r0, r0, Operand(r3));
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res = reinterpret_cast<int>(
       CALL_GENERATED_CODE(isolate, f, 0xFFFF, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
@@ skipping 48 matching lines @@
   __ vmov(r0, s0);
   __ mov(pc, Operand(lr));
 
   // The exception behaviour is not what we expected.
   // Load a special value and return.
   __ bind(&wrong_exception);
   __ mov(r0, Operand(11223344));
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res =
       reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
   ::printf("res = %d\n", res);
@@ skipping 162 matching lines @@
   __ vldm(ia_w, r4, s0, s3);
   __ vldm(ia_w, r4, s4, s7);
 
   __ add(r4, r1, Operand(static_cast<int32_t>(offsetof(F, a))));
   __ vstm(ia_w, r4, s6, s7);
   __ vstm(ia_w, r4, s0, s5);
 
   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F4 fn = FUNCTION_CAST<F4>(code->entry());
   d.a = 1.1;
   d.b = 2.2;
   d.c = 3.3;
@@ skipping 89 matching lines @@
   __ vldm(ia, r4, s4, s7);
 
   __ add(r4, r1, Operand(static_cast<int32_t>(offsetof(F, a))));
   __ vstm(ia, r4, s6, s7);
   __ add(r4, r4, Operand(2 * 4));
   __ vstm(ia, r4, s0, s5);
 
   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F4 fn = FUNCTION_CAST<F4>(code->entry());
   d.a = 1.1;
   d.b = 2.2;
   d.c = 3.3;
@@ skipping 85 matching lines @@
   __ vldm(db_w, r4, s4, s7);
   __ vldm(db_w, r4, s0, s3);
 
   __ add(r4, r1, Operand(static_cast<int32_t>(offsetof(F, h)) + 4));
   __ vstm(db_w, r4, s0, s5);
   __ vstm(db_w, r4, s6, s7);
 
   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F4 fn = FUNCTION_CAST<F4>(code->entry());
   d.a = 1.1;
   d.b = 2.2;
   d.c = 3.3;
@@ skipping 74 matching lines @@
 
   __ mov(r1, Operand(0xffffffff));
   __ mov(r2, Operand::Zero());
   __ mov(r3, Operand(r2, ASR, 1), SetCC);  // Unset the carry.
   __ adc(r3, r1, Operand(r2));
   __ str(r3, MemOperand(r0, offsetof(I, d)));
 
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &i, 0, 0, 0, 0);
   USE(dummy);
 
@@ skipping 106 matching lines @@
     __ vstm(ia_w, r4, d20, d22);
     // Move d22 into low and high.
     __ vmov(r4, VmovIndexLo, d22);
     __ str(r4, MemOperand(r0, offsetof(T, low)));
     __ vmov(r4, VmovIndexHi, d22);
     __ str(r4, MemOperand(r0, offsetof(T, high)));
 
     __ ldm(ia_w, sp, r4.bit() | pc.bit());
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.a = 1.5;
     t.b = 2.75;
     t.c = 17.17;
@@ skipping 52 matching lines @@
   __ vsub(d2, d0, d1);
   __ vstr(d2, r0, offsetof(T, sub_result));
   __ vmul(d2, d0, d1);
   __ vstr(d2, r0, offsetof(T, mul_result));
   __ vdiv(d2, d0, d1);
   __ vstr(d2, r0, offsetof(T, div_result));
 
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.left = bit_cast<double>(kHoleNanInt64);
   t.right = 1;
   t.add_result = 0;
@@ skipping 860 matching lines @@
     __ vmov(d2, r4, r5);  // d2 = ff05030106040200
     __ vtbl(d0, NeonListOperand(d2, 1), d2);
     __ vstr(d0, r0, offsetof(T, vtbl));
     __ vtbx(d2, NeonListOperand(d2, 1), d2);
     __ vstr(d2, r0, offsetof(T, vtbx));
 
     // Restore and return.
     __ ldm(ia_w, sp, r4.bit() | r5.bit() | pc.bit());
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.src0 = 0x01020304;
     t.src1 = 0x11121314;
     t.src2 = 0x21222324;
@@ skipping 256 matching lines @@
   __ uxtb(r2, r0, 8);
   __ str(r2, MemOperand(r4, offsetof(T, dst3)));
 
   __ ldr(r0, MemOperand(r4, offsetof(T, src2)));
   __ uxtab(r2, r0, r1, 8);
   __ str(r2, MemOperand(r4, offsetof(T, dst4)));
 
   __ ldm(ia_w, sp, r4.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.src0 = 0x01020304;
   t.src1 = 0x11121314;
   t.src2 = 0x11121300;
@@ skipping 60 matching lines @@
 
     __ ldr(r0, MemOperand(r3, offsetof(T, dividend)));
     __ ldr(r1, MemOperand(r3, offsetof(T, divisor)));
 
     __ sdiv(r2, r0, r1);
     __ str(r2, MemOperand(r3, offsetof(T, result)));
 
   __ bx(lr);
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
     Object* dummy;
     TEST_SDIV(0, kMinInt, 0);
     TEST_SDIV(0, 1024, 0);
@@ skipping 43 matching lines @@
 
     __ ldr(r0, MemOperand(r3, offsetof(T, dividend)));
     __ ldr(r1, MemOperand(r3, offsetof(T, divisor)));
 
     __ sdiv(r2, r0, r1);
     __ str(r2, MemOperand(r3, offsetof(T, result)));
 
     __ bx(lr);
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
     Object* dummy;
     TEST_UDIV(0u, 0, 0);
     TEST_UDIV(0u, 1024, 0);
@@ skipping 10 matching lines @@
 TEST(smmla) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ smmla(r1, r1, r2, r3);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt(), z = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, z, 0);
     CHECK_EQ(bits::SignedMulHighAndAdd32(x, y, z), r);
     USE(dummy);
   }
 }
 
 
 TEST(smmul) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ smmul(r1, r1, r2);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, 0, 0);
     CHECK_EQ(bits::SignedMulHigh32(x, y), r);
     USE(dummy);
   }
 }
 
 
 TEST(sxtb) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ sxtb(r1, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, 0, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<int8_t>(x)), r);
     USE(dummy);
   }
 }
 
 
 TEST(sxtab) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ sxtab(r1, r2, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<int8_t>(x)) + y, r);
     USE(dummy);
   }
 }
 
 
 TEST(sxth) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ sxth(r1, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, 0, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<int16_t>(x)), r);
     USE(dummy);
   }
 }
 
 
 TEST(sxtah) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ sxtah(r1, r2, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<int16_t>(x)) + y, r);
     USE(dummy);
   }
 }
 
 
 TEST(uxtb) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ uxtb(r1, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, 0, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<uint8_t>(x)), r);
     USE(dummy);
   }
 }
 
 
 TEST(uxtab) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ uxtab(r1, r2, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<uint8_t>(x)) + y, r);
     USE(dummy);
   }
 }
 
 
 TEST(uxth) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ uxth(r1, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, 0, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<uint16_t>(x)), r);
     USE(dummy);
   }
 }
 
 
 TEST(uxtah) {
   CcTest::InitializeVM();
   Isolate* const isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   RandomNumberGenerator* const rng = isolate->random_number_generator();
   Assembler assm(isolate, nullptr, 0);
   __ uxtah(r1, r2, r1);
   __ str(r1, MemOperand(r0));
   __ bx(lr);
   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
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (size_t i = 0; i < 128; ++i) {
     int32_t r, x = rng->NextInt(), y = rng->NextInt();
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &r, x, y, 0, 0);
     CHECK_EQ(static_cast<int32_t>(static_cast<uint16_t>(x)) + y, r);
@@ skipping 21 matching lines @@
       uint32_t result;
     } T;
     T t;
 
     __ ldr(r1, MemOperand(r0, offsetof(T, input)));
     __ rbit(r1, r1);
     __ str(r1, MemOperand(r0, offsetof(T, result)));
     __ bx(lr);
 
     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
 
     F3 f = FUNCTION_CAST<F3>(code->entry());
     Object* dummy = NULL;
     TEST_RBIT(0xffffffff, 0xffffffff);
@@ skipping 61 matching lines @@
   for (int i = 0; i < (1 << 21); i++) {
     __ ldr(r3, MemOperand(r3));
   }
   __ bind(&target_faraway);
   // r0 = r0 + 5 + 5 + 11
   __ add(r0, r0, Operand(11));
 
   __ ldm(ia_w, sp, r4.bit() | r5.bit() | pc.bit());
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), code_object);
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int res =
       reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, 21, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
   CHECK_EQ(42, res);
 }
 
 TEST(msr_mrs) {
@@ skipping 19 matching lines @@
   __ str(r3, MemOperand(r1));
 
   // Also check mrs, ignoring everything other than the flags.
   __ mrs(r3, CPSR);
   __ and_(r3, r3, Operand(kSpecialCondition));
   __ str(r3, MemOperand(r2));
 
   __ bx(lr);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F5 f = FUNCTION_CAST<F5>(code->entry());
   Object* dummy = nullptr;
   USE(dummy);
 
@@ skipping 80 matching lines @@
     __ vstr(s5, r4, offsetof(T, mr));
 
     // Test vrintz
     __ vldr(s6, r4, offsetof(T, input));
     __ vrintz(s5, s6);
     __ vstr(s5, r4, offsetof(T, zr));
 
     __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     Object* dummy = nullptr;
     USE(dummy);
@@ skipping 84 matching lines @@
     __ vstr(d5, r4, offsetof(T, mr));
 
     // Test vrintz
     __ vldr(d6, r4, offsetof(T, input));
     __ vrintz(d5, d6);
     __ vstr(d5, r4, offsetof(T, zr));
 
     __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     Object* dummy = nullptr;
     USE(dummy);
@@ skipping 119 matching lines @@
     __ vsel(lt, d0, d1, d2);
     __ vstr(d0, r2, offsetof(ResultsF64, vsellt_));
     __ vsel(le, d0, d1, d2);
     __ vstr(d0, r2, offsetof(ResultsF64, vselle_));
     __ vsel(vc, d0, d1, d2);
     __ vstr(d0, r2, offsetof(ResultsF64, vselvc_));
 
     __ bx(lr);
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F5 f = FUNCTION_CAST<F5>(code->entry());
     Object* dummy = nullptr;
     USE(dummy);
 
@@ skipping 73 matching lines @@
     __ vldr(d2, r0, offsetof(Inputs, right_));
 
     __ vminnm(d0, d1, d2);
     __ vstr(d0, r1, offsetof(Results, vminnm_));
     __ vmaxnm(d0, d1, d2);
     __ vstr(d0, r1, offsetof(Results, vmaxnm_));
 
     __ bx(lr);
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F4 f = FUNCTION_CAST<F4>(code->entry());
     Object* dummy = nullptr;
     USE(dummy);
 
@@ skipping 61 matching lines @@
     __ vldr(s2, r0, offsetof(Inputs, right_));
 
     __ vminnm(s0, s1, s2);
     __ vstr(s0, r1, offsetof(Results, vminnm_));
     __ vmaxnm(s0, s1, s2);
     __ vstr(s0, r1, offsetof(Results, vmaxnm_));
 
     __ bx(lr);
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
     OFStream os(stdout);
     code->Print(os);
 #endif
     F4 f = FUNCTION_CAST<F4>(code->entry());
     Object* dummy = nullptr;
     USE(dummy);
 
@@ skipping 111 matching lines @@
 
   __ bind(&ool_max_aab);
   __ FloatMaxOutOfLine(a, a, b);
   __ b(&done_max_aab);
 
   __ bind(&ool_max_aba);
   __ FloatMaxOutOfLine(a, b, a);
   __ b(&done_max_aba);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(assm.isolate(), &desc);
   Handle<Code> code = assm.isolate()->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   return FUNCTION_CAST<F4>(code->entry());
 }
 
 TEST(macro_float_minmax_f64) {
@@ skipping 147 matching lines @@
   Assembler assm(isolate, NULL, 0);
   __ ldrh(ip, MemOperand(r1, r2));
   __ str(ip, MemOperand(r0, offsetof(T, ldrh)));
   __ ldrsh(ip, MemOperand(r1, r2));
   __ str(ip, MemOperand(r0, offsetof(T, ldrsh)));
   __ ldr(ip, MemOperand(r1, r2));
   __ str(ip, MemOperand(r0, offsetof(T, ldr)));
   __ bx(lr);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F4 f = FUNCTION_CAST<F4>(code->entry());
 
   Object* dummy = nullptr;
   USE(dummy);
@@ skipping 25 matching lines @@
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   Assembler assm(isolate, NULL, 0);
   __ strh(r3, MemOperand(r0, r2));
   __ str(r3, MemOperand(r1, r2));
   __ bx(lr);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F4 f = FUNCTION_CAST<F4>(code->entry());
 
   Object* dummy = nullptr;
   USE(dummy);
@@ skipping 82 matching lines @@
   __ vswp(q4, q5);
   __ add(r6, r0, Operand(static_cast<int32_t>(offsetof(T, vswp_q4))));
   __ vst1(Neon8, NeonListOperand(q4), NeonMemOperand(r6));
   __ add(r6, r0, Operand(static_cast<int32_t>(offsetof(T, vswp_q5))));
   __ vst1(Neon8, NeonListOperand(q5), NeonMemOperand(r6));
 
   __ ldm(ia_w, sp, r4.bit() | r5.bit() | r6.bit() | r7.bit() | pc.bit());
   __ bx(lr);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   F3 f = FUNCTION_CAST<F3>(code->entry());
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
   CHECK_EQ(minus_one, t.vswp_d0);
@@ skipping 63 matching lines @@
   HandleScope scope(isolate);
 
   Assembler assm(isolate, NULL, 0);
   __ mov(r0, Operand(isolate->factory()->infinity_value()));
   __ BlockConstPoolFor(1019);
   for (int i = 0; i < 1019; ++i) __ nop();
   __ vldr(d0, MemOperand(r0, 0));
 }
 
 #undef __