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

test/cctest/test-assembler-mips64.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 45 matching lines @@
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // Addition.
   __ addu(v0, a0, a1);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 0xab0, 0xc, 0, 0, 0));
   CHECK_EQ(0xabcL, res);
 }
 
 
 TEST(MIPS1) {
@@ skipping 15 matching lines @@
 
   __ bind(&C);
   __ xori(v1, a1, 0);
   __ Branch(&L, ne, v1, Operand((int64_t)0));
   __ nop();
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F1 f = FUNCTION_CAST<F1>(code->entry());
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 50, 0, 0, 0, 0));
   CHECK_EQ(1275L, res);
 }
 
 
 TEST(MIPS2) {
@@ skipping 125 matching lines @@
 
   __ bind(&error);
   // Got an error. Return a wrong result.
   __ li(v0, 666);
 
   __ bind(&exit);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 0xab0, 0xc, 0, 0, 0));
 
   CHECK_EQ(0x31415926L, res);
 }
 
 
@@ skipping 82 matching lines @@
   __ div_s(f12, f10, f4);
   __ Swc1(f12, MemOperand(a0, offsetof(T, ff)));  // ff = fe / fa
 
   __ sqrt_s(f14, f12);
   __ Swc1(f14, MemOperand(a0, offsetof(T, fg)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   // Double test values.
   t.a = 1.5e14;
   t.b = 2.75e11;
   t.c = 0.0;
   t.d = 0.0;
   t.e = 0.0;
   t.f = 0.0;
@@ skipping 73 matching lines @@
   __ mfhc1(a4, f4);
   __ mfc1(a5, f4);
 
   __ Sd(a4, MemOperand(a0, offsetof(T, high)));
   __ Sd(a5, MemOperand(a0, offsetof(T, low)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.a = 1.5e22;
   t.b = 2.75e11;
   t.c = 17.17;
   t.d = -2.75e11;
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
@@ skipping 45 matching lines @@
 
   // Convert int in original j (a5) to double in b.
   __ mtc1(a5, f14);
   __ cvt_d_w(f2, f14);
   __ Sdc1(f2, MemOperand(a0, offsetof(T, b)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.a = 1.5e4;
   t.b = 2.75e8;
   t.i = 12345678;
   t.j = -100000;
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
@@ skipping 49 matching lines @@
   __ lui(t1, 0x3333);
   __ ori(t1, t1, 0x3333);
   __ Sw(t1, MemOperand(a0, offsetof(T, r6)));
   __ Lhu(t1, MemOperand(a0, offsetof(T, si)));
   __ Sh(t1, MemOperand(a0, offsetof(T, r6)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.ui = 0x11223344;
   t.si = 0x99aabbcc;
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   CHECK_EQ(static_cast<int32_t>(0x11223344), t.r1);
   if (kArchEndian == kLittle)  {
@@ skipping 66 matching lines @@
   __ Sw(a4, MemOperand(a0, offsetof(T, result)));  // Set true.
 
   // This test-case should have additional tests.
 
   __ bind(&outa_here);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.a = 1.5e14;
   t.b = 2.75e11;
   t.c = 2.0;
   t.d = -4.0;
   t.e = 0.0;
   t.f = 0.0;
   t.result = 0;
@@ skipping 77 matching lines @@
     __ Sw(a7, MemOperand(a0, offsetof(T, result_rotrv_12)));
     __ Sw(t0, MemOperand(a0, offsetof(T, result_rotrv_16)));
     __ Sw(t1, MemOperand(a0, offsetof(T, result_rotrv_20)));
     __ Sw(t2, MemOperand(a0, offsetof(T, result_rotrv_24)));
     __ Sw(t3, MemOperand(a0, offsetof(T, result_rotrv_28)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.input = 0x12345678;
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0x0, 0, 0, 0);
     USE(dummy);
     CHECK_EQ(static_cast<int32_t>(0x81234567), t.result_rotr_4);
     CHECK_EQ(static_cast<int32_t>(0x78123456), t.result_rotr_8);
     CHECK_EQ(static_cast<int32_t>(0x67812345), t.result_rotr_12);
     CHECK_EQ(static_cast<int32_t>(0x56781234), t.result_rotr_16);
@@ skipping 25 matching lines @@
   __ Branch(&exit2, ge, a0, Operand(0x00001FFF));
   __ Branch(&exit3, ge, a0, Operand(0x0001FFFF));
 
   __ bind(&exit);
   __ bind(&exit2);
   __ bind(&exit3);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 }
 
 
 TEST(MIPS10) {
   // Test conversions between doubles and long integers.
   // Test hos the long ints map to FP regs pairs.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 55 matching lines @@
     // Convert double b back to long-int.
     __ Ldc1(f31, MemOperand(a0, offsetof(T, b)));
     __ cvt_l_d(f31, f31);
     __ dmfc1(a7, f31);
     __ Sd(a7, MemOperand(a0, offsetof(T, b_long_as_int64)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.a = 2.147483647e9;       // 0x7fffffff -> 0x41DFFFFFFFC00000 as double.
     t.b_long_hi = 0x000000ff;  // 0xFF00FF00FF -> 0x426FE01FE01FE000 as double.
     t.b_long_lo = 0x00ff00ff;
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
 
     CHECK_EQ(static_cast<int32_t>(0x41DFFFFF), t.dbl_exp);
@@ skipping 115 matching lines @@
 
     __ Lw(a7, MemOperand(a0, offsetof(T, mem_init)));
     __ Sw(a7, MemOperand(a0, offsetof(T, swr_3)));
     __ Lw(a7, MemOperand(a0, offsetof(T, reg_init)));
     __ swr(a7, MemOperand(a0, offsetof(T, swr_3) + 3));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.reg_init = 0xaabbccdd;
     t.mem_init = 0x11223344;
 
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
 
     if (kArchEndian == kLittle) {
@@ skipping 104 matching lines @@
   __ push(a5);
   __ Lw(a6, MemOperand(fp, offsetof(T, y)));
   __ pop(a7);
   __ nop();
 
   __ mov(fp, t2);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.x = 1;
   t.y = 2;
   t.y1 = 3;
   t.y2 = 4;
   t.y3 = 0XBABA;
   t.y4 = 0xDEDA;
 
@@ skipping 33 matching lines @@
   __ Cvt_d_uw(f8, a4);
   __ Sdc1(f8, MemOperand(a0, offsetof(T, cvt_big_out)));
 
   __ Trunc_uw_d(f8, f8, f4);
   __ Swc1(f8, MemOperand(a0, offsetof(T, trunc_big_out)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   t.cvt_big_in = 0xFFFFFFFF;
   t.cvt_small_in  = 333;
 
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
@@ skipping 100 matching lines @@
   RUN_ROUND_TEST(trunc)
   RUN_ROUND_TEST(cvt)
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   t.round_up_in = 123.51;
   t.round_down_in = 123.49;
   t.neg_round_up_in = -123.5;
   t.neg_round_down_in = -123.49;
   t.err1_in = 123.51;
   t.err2_in = 1;
@@ skipping 109 matching lines @@
   // sh writes only 1/2 of word.
   __ Lw(a4, MemOperand(a0, offsetof(T, ui)));
   __ Sh(a4, MemOperand(a0, offsetof(T, r11)));
   __ Lw(a4, MemOperand(a0, offsetof(T, si)));
   __ Sh(a4, MemOperand(a0, offsetof(T, r12)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.ui = 0x44332211;
   t.si = 0x99aabbcc;
   t.r1 = 0x5555555555555555;
   t.r2 = 0x5555555555555555;
   t.r3 = 0x5555555555555555;
   t.r4 = 0x5555555555555555;
   t.r5 = 0x5555555555555555;
@@ skipping 108 matching lines @@
     __ selnez_d(f6, f0, f2);
     __ seleqz_s(f12, f8, f10);
     __ selnez_s(f14, f8, f10);
     __ Sdc1(f4, MemOperand(a0, offsetof(Test, g)));   // src
     __ Sdc1(f6, MemOperand(a0, offsetof(Test, h)));   // src
     __ Swc1(f12, MemOperand(a0, offsetof(Test, k)));  // src
     __ Swc1(f14, MemOperand(a0, offsetof(Test, l)));  // src
     __ jr(ra);
     __ nop();
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
     CHECK_EQ(1, test.a);
     CHECK_EQ(0, test.b);
     CHECK_EQ(0, test.c);
     CHECK_EQ(1, test.d);
@@ skipping 95 matching lines @@
     __ min_s(f14, f2, f6);
     __ max_s(f16, f2, f6);
     __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, c)));
     __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, d)));
     __ Swc1(f14, MemOperand(a0, offsetof(TestFloat, g)));
     __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, h)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 4; i < kTableLength; i++) {
       test.a = inputsa[i];
       test.b = inputsb[i];
       test.e = inputse[i];
       test.f = inputsf[i];
 
       CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0);
@@ skipping 88 matching lines @@
     double* outputs[4] = {outputs_RN, outputs_RZ, outputs_RP, outputs_RM};
     __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
     __ Lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)));
     __ ctc1(t0, FCSR);
     __ rint_d(f8, f4);
     __ Sdc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     for (int j = 0; j < 4; j++) {
       test.fcsr = fcsr_inputs[j];
       for (int i = 0; i < kTableLength; i++) {
         test.a = inputs[i];
         (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.b, outputs[j][i]);
@@ skipping 27 matching lines @@
     __ Lwc1(f6, MemOperand(a0, offsetof(Test, fd)));   // test
     __ Lwc1(f8, MemOperand(a0, offsetof(Test, fs)));   // src1
     __ Lwc1(f10, MemOperand(a0, offsetof(Test, ft)));  // src2
     __ sel_d(f0, f2, f4);
     __ sel_s(f6, f8, f10);
     __ Sdc1(f0, MemOperand(a0, offsetof(Test, dd)));
     __ Swc1(f6, MemOperand(a0, offsetof(Test, fd)));
     __ jr(ra);
     __ nop();
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     const int test_size = 3;
     const int input_size = 5;
 
     double inputs_dt[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     double inputs_ds[input_size] = {0.1, 69.88, -91.325,
@@ skipping 112 matching lines @@
     __ Lw(t0, MemOperand(a0, offsetof(TestFloat, fcsr)));
     __ cfc1(t1, FCSR);
     __ ctc1(t0, FCSR);
     __ rint_s(f8, f4);
     __ Swc1(f8, MemOperand(a0, offsetof(TestFloat, b)));
     __ ctc1(t1, FCSR);
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     for (int j = 0; j < 4; j++) {
       test.fcsr = fcsr_inputs[j];
       for (int i = 0; i < kTableLength; i++) {
         test.a = inputs[i];
         (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.b, outputs[j][i]);
@@ skipping 65 matching lines @@
     __ maxa_d(f14, f2, f4);
     __ maxa_s(f16, f8, f10);
     __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, resf)));
     __ Sdc1(f6, MemOperand(a0, offsetof(TestFloat, resd)));
     __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, resf1)));
     __ Sdc1(f14, MemOperand(a0, offsetof(TestFloat, resd1)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputsa[i];
       test.b = inputsb[i];
       test.c = inputsc[i];
       test.d = inputsd[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
@@ skipping 61 matching lines @@
     __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
     __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ trunc_l_d(f8, f4);
     __ trunc_l_s(f10, f6);
     __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
     __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.b = inputs_S[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
               kArchVariant == kMips64r6) {
         CHECK_EQ(test.c, outputsNaN2008[i]);
@@ skipping 60 matching lines @@
     __ movn_s(f14, f6, t0);
     __ movn_d(f16, f2, t0);
     __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, d)));
     __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, b)));
     __ Swc1(f14, MemOperand(a0, offsetof(TestFloat, d1)));
     __ Sdc1(f16, MemOperand(a0, offsetof(TestFloat, b1)));
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.c = inputs_S[i];
 
       test.rt = 1;
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.b, test.bold);
@@ skipping 80 matching lines @@
         __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold1)));
         __ movf_s(f12, f4, test.cc);
         __ movf_d(f10, f2, test.cc);
         __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, dstf1)));
         __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstd1)));
         __ ctc1(t0, FCSR);
         __ jr(ra);
         __ nop();
 
         CodeDesc desc;
-        assm.GetCode(&desc);
+        assm.GetCode(isolate, &desc);
         Handle<Code> code = isolate->factory()->NewCode(
             desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
         F3 f = FUNCTION_CAST<F3>(code->entry());
 
         (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.dstf, outputs_S[i]);
         CHECK_EQ(test.dstd, outputs_D[i]);
         CHECK_EQ(test.dstf1, test.dstfold1);
         CHECK_EQ(test.dstd1, test.dstdold1);
         test.fcsr = 0;
@@ skipping 65 matching lines @@
   __ Lw(t0, MemOperand(a0, offsetof(Test, fcsr)));
   __ cfc1(t1, FCSR);
   __ ctc1(t0, FCSR);
   __ cvt_w_d(f8, f4);
   __ Swc1(f8, MemOperand(a0, offsetof(Test, b)));
   __ ctc1(t1, FCSR);
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int j = 0; j < 4; j++) {
     test.fcsr = fcsr_inputs[j];
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.b, outputs[j][i]);
     }
@@ skipping 46 matching lines @@
   __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
   __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ trunc_w_d(f8, f4);
   __ trunc_w_s(f10, f6);
   __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
   __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
     test.b = inputs_S[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
       CHECK_EQ(test.c, outputsNaN2008[i]);
     } else {
@@ skipping 48 matching lines @@
   __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
   __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ round_w_d(f8, f4);
   __ round_w_s(f10, f6);
   __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
   __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
     test.b = inputs_S[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
       CHECK_EQ(test.c, outputsNaN2008[i]);
     } else {
@@ skipping 50 matching lines @@
     __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
     __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ round_l_d(f8, f4);
     __ round_l_s(f10, f6);
     __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
     __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.b = inputs_S[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
               kArchVariant == kMips64r6) {
         CHECK_EQ(test.c, outputsNaN2008[i]);
@@ skipping 51 matching lines @@
   __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
   __ Ldc1(f10, MemOperand(a0, offsetof(TestFloat, d)));
   __ sub_s(f6, f2, f4);
   __ sub_d(f12, f8, f10);
   __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
   __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputfs_S[i];
     test.b = inputft_S[i];
     test.c = inputfs_D[i];
     test.d = inputft_D[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, outputs_S[i]);
@@ skipping 51 matching lines @@
   __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
   __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ Swc1(f16, MemOperand(a0, offsetof(TestFloat, resultS1)));
   __ Sdc1(f14, MemOperand(a0, offsetof(TestFloat, resultD1)));
   __ Swc1(f4, MemOperand(a0, offsetof(TestFloat, resultS2)));
   __ Sdc1(f18, MemOperand(a0, offsetof(TestFloat, resultD2)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   for (int i = 0; i < kTableLength; i++) {
     float f1;
     double d1;
     test.a = inputs_S[i];
     test.c = inputs_D[i];
 
@@ skipping 57 matching lines @@
   __ Lwc1(f2, MemOperand(a0, offsetof(TestFloat, a)));
   __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, c)));
   __ neg_s(f6, f2);
   __ neg_d(f12, f8);
   __ Swc1(f6, MemOperand(a0, offsetof(TestFloat, resultS)));
   __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_S[i];
     test.c = inputs_D[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, outputs_S[i]);
     CHECK_EQ(test.resultD, outputs_D[i]);
   }
@@ skipping 37 matching lines @@
   __ Ldc1(f6, MemOperand(a0, offsetof(TestFloat, c)));
   __ Ldc1(f8, MemOperand(a0, offsetof(TestFloat, d)));
   __ mul_s(f10, f2, f4);
   __ mul_d(f12, f6, f8);
   __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, resultS)));
   __ Sdc1(f12, MemOperand(a0, offsetof(TestFloat, resultD)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputfs_S[i];
     test.b = inputft_S[i];
     test.c = inputfs_D[i];
     test.d = inputft_D[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, inputfs_S[i]*inputft_S[i]);
@@ skipping 34 matching lines @@
   __ Ldc1(f4, MemOperand(a0, offsetof(TestFloat, a)));
   __ Lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)));
   __ mov_s(f8, f6);
   __ mov_d(f10, f4);
   __ Swc1(f8, MemOperand(a0, offsetof(TestFloat, d)));
   __ Sdc1(f10, MemOperand(a0, offsetof(TestFloat, b)));
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
     test.c = inputs_S[i];
 
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.b, outputs_D[i]);
     CHECK_EQ(test.d, outputs_S[i]);
@@ skipping 46 matching lines @@
   __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
   __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ floor_w_d(f8, f4);
   __ floor_w_s(f10, f6);
   __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
   __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
     test.b = inputs_S[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
       CHECK_EQ(test.c, outputsNaN2008[i]);
     } else {
@@ skipping 50 matching lines @@
     __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
     __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ floor_l_d(f8, f4);
     __ floor_l_s(f10, f6);
     __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
     __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.b = inputs_S[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
               kArchVariant == kMips64r6) {
         CHECK_EQ(test.c, outputsNaN2008[i]);
@@ skipping 50 matching lines @@
   __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
   __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
   __ ceil_w_d(f8, f4);
   __ ceil_w_s(f10, f6);
   __ Swc1(f8, MemOperand(a0, offsetof(Test, c)));
   __ Swc1(f10, MemOperand(a0, offsetof(Test, d)));
   __ jr(ra);
   __ nop();
   Test test;
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   for (int i = 0; i < kTableLength; i++) {
     test.a = inputs_D[i];
     test.b = inputs_S[i];
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     if ((test.isNaN2008 & kFCSRNaN2008FlagMask) && kArchVariant == kMips64r6) {
       CHECK_EQ(test.c, outputsNaN2008[i]);
     } else {
@@ skipping 50 matching lines @@
     __ Ldc1(f4, MemOperand(a0, offsetof(Test, a)));
     __ Lwc1(f6, MemOperand(a0, offsetof(Test, b)));
     __ ceil_l_d(f8, f4);
     __ ceil_l_s(f10, f6);
     __ Sdc1(f8, MemOperand(a0, offsetof(Test, c)));
     __ Sdc1(f10, MemOperand(a0, offsetof(Test, d)));
     __ jr(ra);
     __ nop();
     Test test;
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     for (int i = 0; i < kTableLength; i++) {
       test.a = inputs_D[i];
       test.b = inputs_S[i];
       (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       if ((test.isNaN2008 & kFCSRNaN2008FlagMask) &&
               kArchVariant == kMips64r6) {
         CHECK_EQ(test.c, outputsNaN2008[i]);
@@ skipping 50 matching lines @@
 
   __ bind(&done);
   __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   CHECK_EQ(0, assm.UnboundLabelsCount());
 
   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) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
@@ skipping 49 matching lines @@
     }
   }
 
   __ bind(&done);
   __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   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) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
@@ skipping 59 matching lines @@
     }
   }
 
   __ bind(&done);
   __ Ld(ra, MemOperand(sp));
   __ daddiu(sp, sp, 8);
   __ jr(ra);
   __ nop();
 
   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) {
     Handle<Object> result(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0), isolate);
 #ifdef OBJECT_PRINT
@@ skipping 53 matching lines @@
 
     __ Ld(a4, MemOperand(a0, offsetof(T, r6)));
     __ nop();
     __ dbitswap(a6, a4);
     __ Sd(a6, MemOperand(a0, offsetof(T, r6)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     t.r1 = 0x00102100781A15C3;
     t.r2 = 0x001021008B71FCDE;
     t.r3 = 0xFF8017FF781A15C3;
     t.r4 = 0xFF8017FF8B71FCDE;
     t.r5 = 0x10C021098B71FCDE;
     t.r6 = 0xFB8017FF781A15C3;
     Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
@@ skipping 122 matching lines @@
     __ Swc1(f6, MemOperand(a0, offsetof(T, fPosSubnorm)));
 
     __ Lwc1(f4, MemOperand(a0, offsetof(T, fPosZero)));
     __ class_s(f6, f4);
     __ Swc1(f6, MemOperand(a0, offsetof(T, fPosZero)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
     // Double test values.
     t.dSignalingNan =  std::numeric_limits<double>::signaling_NaN();
     t.dQuietNan = std::numeric_limits<double>::quiet_NaN();
     t.dNegInf       = -1.0 / 0.0;
     t.dNegNorm      = -5.0;
     t.dNegSubnorm   = -DBL_MIN / 2.0;
@@ skipping 73 matching lines @@
   __ abs_s(f10, f4);
   __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, b)));
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   test.a = -2.0;
   test.b = -2.0;
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, 2.0);
   CHECK_EQ(test.b, 2.0);
 
   test.a = 2.0;
@@ skipping 72 matching lines @@
 
   __ Lwc1(f4, MemOperand(a0, offsetof(TestFloat, fa)));
   __ Lwc1(f8, MemOperand(a0, offsetof(TestFloat, fb)));
   __ add_s(f10, f8, f4);
   __ Swc1(f10, MemOperand(a0, offsetof(TestFloat, fc)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   test.a = 2.0;
   test.b = 3.0;
   test.fa = 2.0;
   test.fb = 3.0;
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.c, 5.0);
   CHECK_EQ(test.fc, 5.0);
@@ skipping 134 matching lines @@
     __ c_s(ULE, f14, f16, 0);
     __ movt(t2, t1, 6);
     __ movt(t3, t1, 0);
     __ Sw(t2, MemOperand(a0, offsetof(TestFloat, dUle)));
     __ Sw(t3, MemOperand(a0, offsetof(TestFloat, fUle)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     test.dOp1 = 2.0;
     test.dOp2 = 3.0;
     test.fOp1 = 2.0;
     test.fOp2 = 3.0;
     (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dF, 0U);
     CHECK_EQ(test.dUn, 0U);
@@ skipping 180 matching lines @@
 
     __ cmp_d(NE, f2, f4, f6);
     __ cmp_s(NE, f12, f14, f16);
     __ Sdc1(f2, MemOperand(a0, offsetof(TestFloat, dNe)));
     __ Swc1(f12, MemOperand(a0, offsetof(TestFloat, fNe)));
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
-    assm.GetCode(&desc);
+    assm.GetCode(isolate, &desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
     uint64_t dTrue  = 0xFFFFFFFFFFFFFFFF;
     uint64_t dFalse = 0x0000000000000000;
     uint32_t fTrue  = 0xFFFFFFFF;
     uint32_t fFalse = 0x00000000;
 
     test.dOp1 = 2.0;
     test.dOp2 = 3.0;
@@ skipping 157 matching lines @@
   GENERATE_CVT_TEST(cvt_w_s, lw, sw)
   GENERATE_CVT_TEST(cvt_w_d, ld, sw)
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   test.cvt_d_s_in = -0.51;
   test.cvt_d_w_in = -1;
   test.cvt_d_l_in = -1;
   test.cvt_l_s_in = -0.51;
   test.cvt_l_d_in = -0.51;
   test.cvt_s_d_in = -0.51;
@@ skipping 150 matching lines @@
   __ nop();
   __ div_s(f6, f4, f2);
   __ Swc1(f6, MemOperand(a0, offsetof(Test, fRes)));
 
   // Restore FCSR.
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
   const int test_size = 3;
 
   double dOp1[test_size] = {
     5.0,
@@ skipping 70 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ align(v0, a0, a1, bp);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F4 f = FUNCTION_CAST<F4>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, rs_value, rt_value, 0, 0, 0));
 
   return res;
 }
@@ skipping 32 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ dalign(v0, a0, a1, bp);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F4 f = FUNCTION_CAST<F4>(code->entry());
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, rs_value, rt_value, 0, 0, 0));
 
   return res;
 }
 
@@ skipping 37 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ aluipc(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
   PC = (uint64_t) f;  // Set the program counter.
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
@@ skipping 33 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ auipc(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
   PC = (uint64_t) f;  // Set the program counter.
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
@@ skipping 34 matching lines @@
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ li(t0, rs);
   __ aui(v0, t0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res =
     reinterpret_cast<uint64_t>
     (CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 uint64_t run_daui(uint64_t rs, uint16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ li(t0, rs);
   __ daui(v0, t0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res =
     reinterpret_cast<uint64_t>
     (CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 uint64_t run_dahi(uint64_t rs, uint16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ li(v0, rs);
   __ dahi(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res =
     reinterpret_cast<uint64_t>
     (CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 uint64_t run_dati(uint64_t rs, uint16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ li(v0, rs);
   __ dati(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res =
     reinterpret_cast<uint64_t>
     (CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
@@ skipping 84 matching lines @@
   Label code_start;
   __ bind(&code_start);
   __ li(v0, imm, mode);
   if (num_instr > 0) {
     CHECK_EQ(assm.InstructionsGeneratedSince(&code_start), num_instr);
   }
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
@@ skipping 172 matching lines @@
   uint32_t addiu_start_2 = 0x25000000;
   for (int32_t i = 0x80000; i <= 0xbffff; ++i) {
     uint32_t addiu_new = addiu_start_2 + i;
     __ dd(addiu_new);
   }
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 55 matching lines @@
   uint32_t addiu_start_2 = 0x25000000;
   for (int32_t i = 0x80000; i <= 0xbffff; ++i) {
     uint32_t addiu_new = addiu_start_2 + i;
     __ dd(addiu_new);
   }
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 63 matching lines @@
   __ mov(t0, ra);
   __ jr(ra);
   __ nop();
 
   __ bind(&stop_execution);
   __ pop(ra);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 51 matching lines @@
   __ addiu(v0, v0, 0x1000);
   __ addiu(v0, v0, 0x2000);   // <--- offset = 4
   __ jr(ra);
   __ nop();
 
   __ bind(&stop_execution);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, value, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 73 matching lines @@
   __ jr(ra);
   __ nop();
 
   __ bind(&get_program_counter);
   __ mov(t0, ra);
   __ jr(ra);
   __ nop();
 
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 31 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ addiupc(v0, imm19);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
   PC = (uint64_t) f;  // Set the program counter.
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
@@ skipping 55 matching lines @@
   uint32_t addiu_start_2 = 0x25000000;
   for (int32_t i = 0x80000; i <= 0xbffff; ++i) {
     uint32_t addiu_new = addiu_start_2 + i;
     __ dd(addiu_new);
   }
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 68 matching lines @@
 
   for (int32_t i = 0; i <= 99; ++i) {
     __ addiu(v0, v0, 1);
   }
 
   __ pop(ra);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 61 matching lines @@
   __ jr(ra);                          // 2
   __ nop();                           // 3
 
   for (int32_t i = 4; i <= 44; ++i) {
     __ dd(instruction_addiu);
   }
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 29 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ dsll(v0, a0, sa_value);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F4 f = FUNCTION_CAST<F4>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, rt_value, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 35 matching lines @@
 
   __ mov(ra, t0);
   __ jr(ra);
   __ nop();
 
   __ li(v0, 1);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
@@ skipping 33 matching lines @@
   size_t nr_calls = kMaxBranchOffset / (2 * Instruction::kInstrSize) + 2;
 
   for (size_t i = 0; i < nr_calls; ++i) {
     __ BranchShort(&done, eq, a0, Operand(a1));
   }
   __ bind(&done);
   __ Ret(USE_DELAY_SLOT);
   __ mov(v0, zero_reg);
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   int64_t res = reinterpret_cast<int64_t>(
       CALL_GENERATED_CODE(isolate, f, 42, 42, 0, 0, 0));
   CHECK_EQ(0, res);
 }
 
 template <class T>
@@ skipping 46 matching lines @@
   } else {
     UNREACHABLE();
   }
 
   func(assm);
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
   const size_t kTableLength = sizeof(test_cases) / sizeof(TestCaseMaddMsub<T>);
   TestCaseMaddMsub<T> tc;
   for (size_t i = 0; i < kTableLength; i++) {
     tc.fr = test_cases[i].fr;
     tc.fs = test_cases[i].fs;
     tc.ft = test_cases[i].ft;
@@ skipping 62 matching lines @@
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label code_start;
   __ bind(&code_start);
   __ Subu(v0, zero_reg, Operand(imm));
   CHECK_EQ(assm.InstructionsGeneratedSince(&code_start), num_instr);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
@@ skipping 58 matching lines @@
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label code_start;
   __ bind(&code_start);
   __ Dsubu(v0, zero_reg, Operand(imm));
   CHECK_EQ(assm.InstructionsGeneratedSince(&code_start), num_instr);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
@@ skipping 66 matching lines @@
 
   MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ li(v0, imm);
   __ li(t0, source);
   __ Dins(v0, t0, pos, size);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assm.GetCode(&desc);
+  assm.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F2 f = FUNCTION_CAST<F2>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
@@ skipping 75 matching lines @@
     __ copy_s_w(t1, w4, 1);
     __ sd(t1, MemOperand(a0, offsetof(T, s32)));
     __ copy_s_d(t1, w6, 0);
     __ sd(t1, MemOperand(a0, offsetof(T, s64)));
 
     __ jr(ra);
     __ nop();
   }
 
   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 = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
@@ skipping 43 matching lines @@
 
     STORE_MSA_REG(w0, a0, t2)
     STORE_MSA_REG(w2, a1, t2)
 #undef STORE_MSA_REG
 
     __ jr(ra);
     __ nop();
   }
 
   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
   F5 f = FUNCTION_CAST<F5>(code->entry());
 
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t[0], &t[1], 0, 0, 0);
   USE(dummy);
 
@@ skipping 33 matching lines @@
     __ fill_d(w2, t1);
 
     __ Sdc1(f0, MemOperand(a0, offsetof(T, d0)));
     __ Sdc1(f2, MemOperand(a1, offsetof(T, d0)));
 
     __ jr(ra);
     __ nop();
   }
 
   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
   F5 f = FUNCTION_CAST<F5>(code->entry());
 
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t[0], &t[1], 0, 0, 0);
   USE(dummy);
 
@@ skipping 42 matching lines @@
   __ sw(t2, MemOperand(a0, 4));
   __ copy_u_w(t2, w0, 2);
   __ sw(t2, MemOperand(a0, 8));
   __ copy_u_w(t2, w0, 3);
   __ sw(t2, MemOperand(a0, 12));
 
   __ jr(ra);
   __ nop();
 
   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());
 
   (CALL_GENERATED_CODE(isolate, f, w, 0, 0, 0, 0));
 }
 
@@ skipping 136 matching lines @@
   __ sw(t2, MemOperand(a0, 8));
   __ copy_u_w(t2, w2, 3);
   __ sw(t2, MemOperand(a0, 12));
 
   __ jr(ra);
   __ nop();
 
 #undef LOAD_W_REG
 
   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());
 
   (CALL_GENERATED_CODE(isolate, f, &res, 0, 0, 0, 0));
 
   uint64_t mask = i8 * 0x0101010101010101ull;
@@ skipping 145 matching lines @@
   };
 
   for (size_t i = 0; i < sizeof(tc) / sizeof(TestCaseMsaI8); ++i) {
     run_msa_i8(SHF_B, tc[i].input_lo, tc[i].input_hi, tc[i].i8);
     run_msa_i8(SHF_H, tc[i].input_lo, tc[i].input_hi, tc[i].i8);
     run_msa_i8(SHF_W, tc[i].input_lo, tc[i].input_hi, tc[i].i8);
   }
 }
 
 #undef __