Remove a bunch of Isolate::Current() callsites from simulators

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 54 matching lines @@
   // Addition.
   __ addu(v0, a0, a1);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0xab0, 0xc, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0xab0, 0xc, 0, 0, 0));
   CHECK_EQ(0xabcL, res);
 }
 
 
 TEST(MIPS1) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0);
@@ skipping 14 matching lines @@
   __ nop();
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 50, 0, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 50, 0, 0, 0, 0));
   CHECK_EQ(1275L, res);
 }
 
 
 TEST(MIPS2) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0);
@@ skipping 124 matching lines @@
 
   __ bind(&exit);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0xab0, 0xc, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0xab0, 0xc, 0, 0, 0));
 
   CHECK_EQ(0x31415926L, res);
 }
 
 
 TEST(MIPS3) {
   // Test floating point instructions.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 97 matching lines @@
   t.f = 0.0;
   t.h = 1.5;
   t.i = 2.75;
   // Single test values.
   t.fa = 1.5e6;
   t.fb = 2.75e4;
   t.fc = 0.0;
   t.fd = 0.0;
   t.fe = 0.0;
   t.ff = 0.0;
-  Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
   // Expected double results.
   CHECK_EQ(1.5e14, t.a);
   CHECK_EQ(1.5e14, t.b);
   CHECK_EQ(1.50275e14, t.c);
   CHECK_EQ(1.50550e14, t.d);
   CHECK_EQ(1.8066e16, t.e);
   CHECK_EQ(120.44, t.f);
   CHECK_EQ(10.97451593465515908537, t.g);
   if (kArchVariant == kMips64r2) {
@@ skipping 61 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   CHECK_EQ(2.75e11, t.a);
   CHECK_EQ(2.75e11, t.b);
   CHECK_EQ(1.5e22, t.c);
   CHECK_EQ(static_cast<int64_t>(0xffffffffc25001d1L), t.high);
   CHECK_EQ(static_cast<int64_t>(0xffffffffbf800000L), t.low);
 }
 
 
@@ skipping 45 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   CHECK_EQ(12345678.0, t.a);
   CHECK_EQ(-100000.0, t.b);
   CHECK_EQ(15000, t.i);
   CHECK_EQ(275000000, t.j);
 }
 
 
 TEST(MIPS6) {
@@ skipping 47 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+  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)  {
     CHECK_EQ(static_cast<int32_t>(0x3344), t.r2);
     CHECK_EQ(static_cast<int32_t>(0xffffbbcc), t.r3);
     CHECK_EQ(static_cast<int32_t>(0x0000bbcc), t.r4);
     CHECK_EQ(static_cast<int32_t>(0xffffffcc), t.r5);
     CHECK_EQ(static_cast<int32_t>(0x3333bbcc), t.r6);
   } else {
@@ skipping 72 matching lines @@
   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;
-  Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
   CHECK_EQ(1.5e14, t.a);
   CHECK_EQ(2.75e11, t.b);
   CHECK_EQ(1, t.result);
 }
 
 
 TEST(MIPS8) {
   if (kArchVariant == kMips64r2) {
     // Test ROTR and ROTRV instructions.
@@ skipping 70 matching lines @@
 
     __ jr(ra);
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&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(f, &t, 0x0, 0, 0, 0);
+    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);
     CHECK_EQ(static_cast<int32_t>(0x45678123), t.result_rotr_20);
     CHECK_EQ(static_cast<int32_t>(0x34567812), t.result_rotr_24);
     CHECK_EQ(static_cast<int32_t>(0x23456781), t.result_rotr_28);
 
     CHECK_EQ(static_cast<int32_t>(0x81234567), t.result_rotrv_4);
@@ skipping 105 matching lines @@
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+    Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
 
     CHECK_EQ(static_cast<int32_t>(0x41DFFFFF), t.dbl_exp);
     CHECK_EQ(static_cast<int32_t>(0xFFC00000), t.dbl_mant);
     CHECK_EQ(0, t.long_hi);
     CHECK_EQ(static_cast<int32_t>(0x7fffffff), t.long_lo);
     CHECK_EQ(2.147483647e9, t.a_converted);
 
     // 0xFF00FF00FF -> 1.095233372415e12.
     CHECK_EQ(1.095233372415e12, t.b);
@@ skipping 114 matching lines @@
     __ nop();
 
     CodeDesc desc;
     assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+    Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
 
     if (kArchEndian == kLittle) {
       CHECK_EQ(static_cast<int32_t>(0x44bbccdd), t.lwl_0);
       CHECK_EQ(static_cast<int32_t>(0x3344ccdd), t.lwl_1);
       CHECK_EQ(static_cast<int32_t>(0x223344dd), t.lwl_2);
       CHECK_EQ(static_cast<int32_t>(0x11223344), t.lwl_3);
 
       CHECK_EQ(static_cast<int32_t>(0x11223344), t.lwr_0);
       CHECK_EQ(static_cast<int32_t>(0xaa112233), t.lwr_1);
@@ skipping 108 matching lines @@
   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;
 
-  Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   CHECK_EQ(3, t.y1);
 }
 
 
 TEST(MIPS13) {
   // Test Cvt_d_uw and Trunc_uw_d macros.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 30 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   CHECK_EQ(t.cvt_big_out, static_cast<double>(t.cvt_big_in));
   CHECK_EQ(t.cvt_small_out, static_cast<double>(t.cvt_small_in));
 
   CHECK_EQ(static_cast<int>(t.trunc_big_out), static_cast<int>(t.cvt_big_in));
   CHECK_EQ(static_cast<int>(t.trunc_small_out),
            static_cast<int>(t.cvt_small_in));
 }
 
@@ skipping 103 matching lines @@
 
   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;
   t.err3_in = static_cast<double>(1) + 0xFFFFFFFF;
   t.err4_in = NAN;
 
-  Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
 #define GET_FPU_ERR(x) (static_cast<int>(x & kFCSRFlagMask))
 #define CHECK_ROUND_RESULT(type) \
   CHECK(GET_FPU_ERR(t.type##_err1_out) & kFCSRInexactFlagMask); \
   CHECK_EQ(0, GET_FPU_ERR(t.type##_err2_out)); \
   CHECK(GET_FPU_ERR(t.type##_err3_out) & kFCSRInvalidOpFlagMask); \
   CHECK(GET_FPU_ERR(t.type##_err4_out) & kFCSRInvalidOpFlagMask); \
   CHECK_EQ(static_cast<int32_t>(kFPUInvalidResult), t.type##_invalid_result);
 
@@ skipping 97 matching lines @@
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
   t.ui = 0x44332211;
   t.si = 0x99aabbcc;
   t.r1 = 0x1111111111111111;
   t.r2 = 0x2222222222222222;
   t.r3 = 0x3333333333333333;
   t.r4 = 0x4444444444444444;
   t.r5 = 0x5555555555555555;
   t.r6 = 0x6666666666666666;
-  Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+  Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
 
   // Unsigned data, 32 & 64.
   CHECK_EQ(static_cast<int64_t>(0x1111111144332211L), t.r1);
   CHECK_EQ(static_cast<int64_t>(0x0000000000002211L), t.r2);
 
   // Signed data, 32 & 64.
   CHECK_EQ(static_cast<int64_t>(0x33333333ffffbbccL), t.r3);
   CHECK_EQ(static_cast<int64_t>(0xffffffff0000bbccL), t.r4);
 
@@ skipping 51 matching lines @@
     __ swc1(f12, MemOperand(a0, offsetof(Test, k)) );  // src
     __ swc1(f14, MemOperand(a0, offsetof(Test, l)) );  // src
     __ jr(ra);
     __ nop();
     CodeDesc desc;
     assm.GetCode(&desc);
     Handle<Code> code = isolate->factory()->NewCode(
         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
     F3 f = FUNCTION_CAST<F3>(code->entry());
 
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
     CHECK_EQ(test.a, 1);
     CHECK_EQ(test.b, 0);
     CHECK_EQ(test.c, 0);
     CHECK_EQ(test.d, 1);
 
     const int test_size = 3;
     const int input_size = 5;
 
     double inputs_D[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     double outputs_D[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     double tests_D[test_size*2] = {2.8, 2.9, -2.8, -2.9,
       18446744073709551616.0, 18446744073709555712.0};
     float inputs_S[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     float outputs_S[input_size] = {0.0, 65.2, -70.32,
       18446744073709551621.0, -18446744073709551621.0};
     float tests_S[test_size*2] = {2.9, 2.8, -2.9, -2.8,
       18446744073709551616.0, 18446746272732807168.0};
     for (int j=0; j < test_size; j+=2) {
       for (int i=0; i < input_size; i++) {
         test.e = inputs_D[i];
         test.f = tests_D[j];
         test.i = inputs_S[i];
         test.j = tests_S[j];
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.g, outputs_D[i]);
         CHECK_EQ(test.h, 0);
         CHECK_EQ(test.k, outputs_S[i]);
         CHECK_EQ(test.l, 0);
 
         test.f = tests_D[j+1];
         test.j = tests_S[j+1];
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.g, 0);
         CHECK_EQ(test.h, outputs_D[i]);
         CHECK_EQ(test.k, 0);
         CHECK_EQ(test.l, outputs_S[i]);
       }
     }
   }
 }
 
 
@@ skipping 49 matching lines @@
     assm.GetCode(&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.e = inputse[i];
       test.f = inputsf[i];
 
-      (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
       if (i < kTableLength - 1) {
         CHECK_EQ(test.c, outputsdmin[i]);
         CHECK_EQ(test.d, outputsdmax[i]);
         CHECK_EQ(test.g, outputsfmin[i]);
         CHECK_EQ(test.h, outputsfmax[i]);
       } else {
         DCHECK(std::isnan(test.c));
         DCHECK(std::isnan(test.d));
         DCHECK(std::isnan(test.g));
@@ skipping 93 matching lines @@
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.b, outputs[j][i]);
       }
     }
   }
 }
 
 
 TEST(sel) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
@@ skipping 45 matching lines @@
     float tests_S[test_size*2] = {2.9, 2.8, -2.9, -2.8,
       18446744073709551616.0, 18446746272732807168.0};
     for (int j=0; j < test_size; j+=2) {
       for (int i=0; i < input_size; i++) {
         test.dt = inputs_dt[i];
         test.dd = tests_D[j];
         test.ds = inputs_ds[i];
         test.ft = inputs_ft[i];
         test.fd = tests_S[j];
         test.fs = inputs_fs[i];
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.dd, inputs_ds[i]);
         CHECK_EQ(test.fd, inputs_fs[i]);
 
         test.dd = tests_D[j+1];
         test.fd = tests_S[j+1];
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.dd, inputs_dt[i]);
         CHECK_EQ(test.fd, inputs_ft[i]);
       }
     }
   }
 }
 
 
 TEST(rint_s)  {
   if (kArchVariant == kMips64r6) {
@@ skipping 86 matching lines @@
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.b, outputs[j][i]);
       }
     }
   }
 }
 
 
 TEST(mina_maxa) {
   if (kArchVariant == kMips64r6) {
     const int kTableLength = 15;
@@ skipping 67 matching lines @@
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
       if (i < kTableLength - 1) {
         CHECK_EQ(test.resd, resd[i]);
         CHECK_EQ(test.resf, resf[i]);
         CHECK_EQ(test.resd1, resd1[i]);
         CHECK_EQ(test.resf1, resf1[i]);
       } else {
         DCHECK(std::isnan(test.resd));
         DCHECK(std::isnan(test.resf));
         DCHECK(std::isnan(test.resd1));
@@ skipping 50 matching lines @@
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.c, outputs[i]);
       CHECK_EQ(test.d, test.c);
     }
   }
 }
 
 
 TEST(movz_movn) {
   if (kArchVariant == kMips64r2) {
     const int kTableLength = 4;
@@ skipping 56 matching lines @@
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.b, test.bold);
       CHECK_EQ(test.d, test.dold);
       CHECK_EQ(test.b1, outputs_D[i]);
       CHECK_EQ(test.d1, outputs_S[i]);
 
       test.rt = 0;
-      (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.b, outputs_D[i]);
       CHECK_EQ(test.d, outputs_S[i]);
       CHECK_EQ(test.b1, test.bold1);
       CHECK_EQ(test.d1, test.dold1);
     }
   }
 }
 
 
 TEST(movt_movd) {
@@ skipping 68 matching lines @@
         __ ctc1(t0, FCSR);
         __ jr(ra);
         __ nop();
 
         CodeDesc desc;
         assm.GetCode(&desc);
         Handle<Code> code = isolate->factory()->NewCode(
             desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
         F3 f = FUNCTION_CAST<F3>(code->entry());
 
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (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;
-        (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+        (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
         CHECK_EQ(test.dstf, test.dstfold);
         CHECK_EQ(test.dstd, test.dstdold);
         CHECK_EQ(test.dstf1, outputs_S[i]);
         CHECK_EQ(test.dstd1, outputs_D[i]);
       }
     }
   }
 }
 
 
@@ skipping 62 matching lines @@
   Test test;
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.b, outputs[j][i]);
     }
   }
 }
 
 
 TEST(trunc_w) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 36 matching lines @@
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.c, outputs[i]);
     CHECK_EQ(test.d, test.c);
   }
 }
 
 
 TEST(round_w) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 36 matching lines @@
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.c, outputs[i]);
     CHECK_EQ(test.d, test.c);
   }
 }
 
 
 TEST(round_l) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
@@ skipping 37 matching lines @@
     Test test;
     CodeDesc desc;
     assm.GetCode(&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];
       std::cout<< i<< "\n";
-      (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.c, outputs[i]);
       CHECK_EQ(test.d, test.c);
     }
 }
 
 
 TEST(sub) {
   const int kTableLength = 12;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 48 matching lines @@
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, outputs_S[i]);
     CHECK_EQ(test.resultD, outputs_D[i]);
   }
 }
 
 
 TEST(sqrt_rsqrt_recip) {
   const int kTableLength = 4;
   const double deltaDouble = 2E-15;
   const float deltaFloat = 2E-7;
@@ skipping 54 matching lines @@
   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];
 
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
     CHECK_EQ(test.resultS, outputs_S[i]);
     CHECK_EQ(test.resultD, outputs_D[i]);
 
     if (i != 0) {
       f1 = test.resultS1 - 1.0F/outputs_S[i];
       f1 = (f1 < 0) ? f1 : -f1;
       CHECK(f1 <= deltaFloat);
       d1 = test.resultD1 - 1.0L/outputs_D[i];
       d1 = (d1 < 0) ? d1 : -d1;
@@ skipping 53 matching lines @@
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, outputs_S[i]);
     CHECK_EQ(test.resultD, outputs_D[i]);
   }
 }
 
 
 
 TEST(mul) {
   const int kTableLength = 4;
   CcTest::InitializeVM();
@@ skipping 39 matching lines @@
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.resultS, inputfs_S[i]*inputft_S[i]);
     CHECK_EQ(test.resultD, inputfs_D[i]*inputft_D[i]);
   }
 }
 
 
 TEST(mov) {
   const int kTableLength = 4;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 33 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.b, outputs_D[i]);
     CHECK_EQ(test.d, outputs_S[i]);
   }
 }
 
 
 TEST(floor_w) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 36 matching lines @@
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.c, outputs[i]);
     CHECK_EQ(test.d, test.c);
   }
 }
 
 
 TEST(floor_l) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
@@ skipping 36 matching lines @@
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.c, outputs[i]);
       CHECK_EQ(test.d, test.c);
     }
 }
 
 
 TEST(ceil_w) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
@@ skipping 36 matching lines @@
   __ nop();
   Test test;
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.c, outputs[i]);
     CHECK_EQ(test.d, test.c);
   }
 }
 
 
 TEST(ceil_l) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
@@ skipping 36 matching lines @@
     __ nop();
     Test test;
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+      (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
       CHECK_EQ(test.c, outputs[i]);
       CHECK_EQ(test.d, test.c);
     }
 }
 
 
 TEST(jump_tables1) {
   // Test jump tables with forward jumps.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 48 matching lines @@
   CodeDesc desc;
   assm.GetCode(&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(f, i, 0, 0, 0, 0));
+        CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], static_cast<int>(res));
   }
 }
 
 
 TEST(jump_tables2) {
   // Test jump tables with backward jumps.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 52 matching lines @@
   CodeDesc desc;
   assm.GetCode(&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(f, i, 0, 0, 0, 0));
+        CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 
 TEST(jump_tables3) {
   // Test jump tables with backward jumps and embedded heap objects.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 61 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, i, 0, 0, 0, 0), isolate);
+    Handle<Object> result(
+        CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0), isolate);
 #ifdef OBJECT_PRINT
     ::printf("f(%d) = ", i);
     result->Print(std::cout);
     ::printf("\n");
 #endif
     CHECK(values[i].is_identical_to(result));
   }
 }
 
 
@@ skipping 53 matching lines @@
     assm.GetCode(&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(f, &t, 0, 0, 0, 0);
+    Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
 
     CHECK_EQ(static_cast<int64_t>(0x000000001E58A8C3L), t.r1);
     CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFD18E3F7BL), t.r2);
     CHECK_EQ(static_cast<int64_t>(0x000000001E58A8C3L), t.r3);
     CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFD18E3F7BL), t.r4);
     CHECK_EQ(static_cast<int64_t>(0x08038490D18E3F7BL), t.r5);
     CHECK_EQ(static_cast<int64_t>(0xDF01E8FF1E58A8C3L), t.r6);
   }
 }
@@ skipping 140 matching lines @@
     t.fQuietNan     = std::numeric_limits<float>::quiet_NaN();
     t.fNegInf       = -0.5/0.0;
     t.fNegNorm      = -FLT_MIN;
     t.fNegSubnorm   = -FLT_MIN / 1.5;
     t.fNegZero      = -0.0;
     t.fPosInf       = 100000.0 / 0.0;
     t.fPosNorm      = FLT_MAX;
     t.fPosSubnorm   = FLT_MIN / 20.0;
     t.fPosZero      = +0.0;
 
-    Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
+    Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
     USE(dummy);
     // Expected double results.
     CHECK_EQ(bit_cast<int64_t>(t.dSignalingNan), 0x001);
     CHECK_EQ(bit_cast<int64_t>(t.dQuietNan),     0x002);
     CHECK_EQ(bit_cast<int64_t>(t.dNegInf),       0x004);
     CHECK_EQ(bit_cast<int64_t>(t.dNegNorm),      0x008);
     CHECK_EQ(bit_cast<int64_t>(t.dNegSubnorm),   0x010);
     CHECK_EQ(bit_cast<int64_t>(t.dNegZero),      0x020);
     CHECK_EQ(bit_cast<int64_t>(t.dPosInf),       0x040);
     CHECK_EQ(bit_cast<int64_t>(t.dPosNorm),      0x080);
@@ skipping 50 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 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;
   test.b = 2.0;
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, 2.0);
   CHECK_EQ(test.b, 2.0);
 
   // Testing biggest positive number
   test.a = std::numeric_limits<double>::max();
   test.b = std::numeric_limits<float>::max();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, std::numeric_limits<double>::max());
   CHECK_EQ(test.b, std::numeric_limits<float>::max());
 
   // Testing smallest negative number
   test.a = -std::numeric_limits<double>::max();  // lowest()
   test.b = -std::numeric_limits<float>::max();   // lowest()
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, std::numeric_limits<double>::max());
   CHECK_EQ(test.b, std::numeric_limits<float>::max());
 
   // Testing smallest positive number
   test.a = -std::numeric_limits<double>::min();
   test.b = -std::numeric_limits<float>::min();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, std::numeric_limits<double>::min());
   CHECK_EQ(test.b, std::numeric_limits<float>::min());
 
   // Testing infinity
   test.a = -std::numeric_limits<double>::max()
           / std::numeric_limits<double>::min();
   test.b = -std::numeric_limits<float>::max()
           / std::numeric_limits<float>::min();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.a, std::numeric_limits<double>::max()
                  / std::numeric_limits<double>::min());
   CHECK_EQ(test.b, std::numeric_limits<float>::max()
                  / std::numeric_limits<float>::min());
 
   test.a = std::numeric_limits<double>::quiet_NaN();
   test.b = std::numeric_limits<float>::quiet_NaN();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(std::isnan(test.a), true);
   CHECK_EQ(std::isnan(test.b), true);
 
   test.a = std::numeric_limits<double>::signaling_NaN();
   test.b = std::numeric_limits<float>::signaling_NaN();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(std::isnan(test.a), true);
   CHECK_EQ(std::isnan(test.b), true);
 }
 
 
 TEST(ADD_FMT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   MacroAssembler assm(isolate, NULL, 0);
@@ skipping 24 matching lines @@
 
   CodeDesc desc;
   assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.c, 5.0);
   CHECK_EQ(test.fc, 5.0);
 
   test.a = std::numeric_limits<double>::max();
   test.b = -std::numeric_limits<double>::max();  // lowest()
   test.fa = std::numeric_limits<float>::max();
   test.fb = -std::numeric_limits<float>::max();  // lowest()
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.c, 0.0);
   CHECK_EQ(test.fc, 0.0);
 
   test.a = std::numeric_limits<double>::max();
   test.b = std::numeric_limits<double>::max();
   test.fa = std::numeric_limits<float>::max();
   test.fb = std::numeric_limits<float>::max();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(std::isfinite(test.c), false);
   CHECK_EQ(std::isfinite(test.fc), false);
 
   test.a = 5.0;
   test.b = std::numeric_limits<double>::signaling_NaN();
   test.fa = 5.0;
   test.fb = std::numeric_limits<float>::signaling_NaN();
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(std::isnan(test.c), true);
   CHECK_EQ(std::isnan(test.fc), true);
 }
 
 
 TEST(C_COND_FMT) {
   if (kArchVariant == kMips64r2) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
@@ skipping 109 matching lines @@
 
     CodeDesc desc;
     assm.GetCode(&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(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dF, 0U);
     CHECK_EQ(test.dUn, 0U);
     CHECK_EQ(test.dEq, 0U);
     CHECK_EQ(test.dUeq, 0U);
     CHECK_EQ(test.dOlt, 1U);
     CHECK_EQ(test.dUlt, 1U);
     CHECK_EQ(test.dOle, 1U);
     CHECK_EQ(test.dUle, 1U);
     CHECK_EQ(test.fF, 0U);
     CHECK_EQ(test.fUn, 0U);
     CHECK_EQ(test.fEq, 0U);
     CHECK_EQ(test.fUeq, 0U);
     CHECK_EQ(test.fOlt, 1U);
     CHECK_EQ(test.fUlt, 1U);
     CHECK_EQ(test.fOle, 1U);
     CHECK_EQ(test.fUle, 1U);
 
     test.dOp1 = std::numeric_limits<double>::max();
     test.dOp2 = std::numeric_limits<double>::min();
     test.fOp1 = std::numeric_limits<float>::min();
     test.fOp2 = -std::numeric_limits<float>::max();  // lowest()
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dF, 0U);
     CHECK_EQ(test.dUn, 0U);
     CHECK_EQ(test.dEq, 0U);
     CHECK_EQ(test.dUeq, 0U);
     CHECK_EQ(test.dOlt, 0U);
     CHECK_EQ(test.dUlt, 0U);
     CHECK_EQ(test.dOle, 0U);
     CHECK_EQ(test.dUle, 0U);
     CHECK_EQ(test.fF, 0U);
     CHECK_EQ(test.fUn, 0U);
     CHECK_EQ(test.fEq, 0U);
     CHECK_EQ(test.fUeq, 0U);
     CHECK_EQ(test.fOlt, 0U);
     CHECK_EQ(test.fUlt, 0U);
     CHECK_EQ(test.fOle, 0U);
     CHECK_EQ(test.fUle, 0U);
 
     test.dOp1 = -std::numeric_limits<double>::max();  // lowest()
     test.dOp2 = -std::numeric_limits<double>::max();  // lowest()
     test.fOp1 = std::numeric_limits<float>::max();
     test.fOp2 = std::numeric_limits<float>::max();
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dF, 0U);
     CHECK_EQ(test.dUn, 0U);
     CHECK_EQ(test.dEq, 1U);
     CHECK_EQ(test.dUeq, 1U);
     CHECK_EQ(test.dOlt, 0U);
     CHECK_EQ(test.dUlt, 0U);
     CHECK_EQ(test.dOle, 1U);
     CHECK_EQ(test.dUle, 1U);
     CHECK_EQ(test.fF, 0U);
     CHECK_EQ(test.fUn, 0U);
     CHECK_EQ(test.fEq, 1U);
     CHECK_EQ(test.fUeq, 1U);
     CHECK_EQ(test.fOlt, 0U);
     CHECK_EQ(test.fUlt, 0U);
     CHECK_EQ(test.fOle, 1U);
     CHECK_EQ(test.fUle, 1U);
 
     test.dOp1 = std::numeric_limits<double>::quiet_NaN();
     test.dOp2 = 0.0;
     test.fOp1 = std::numeric_limits<float>::quiet_NaN();
     test.fOp2 = 0.0;
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dF, 0U);
     CHECK_EQ(test.dUn, 1U);
     CHECK_EQ(test.dEq, 0U);
     CHECK_EQ(test.dUeq, 1U);
     CHECK_EQ(test.dOlt, 0U);
     CHECK_EQ(test.dUlt, 1U);
     CHECK_EQ(test.dOle, 0U);
     CHECK_EQ(test.dUle, 1U);
     CHECK_EQ(test.fF, 0U);
     CHECK_EQ(test.fUn, 1U);
@@ skipping 118 matching lines @@
     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;
     test.fOp1 = 2.0;
     test.fOp2 = 3.0;
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOle), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dNe), dTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fEq), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fOle), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
 
     test.dOp1 = std::numeric_limits<double>::max();
     test.dOp2 = std::numeric_limits<double>::min();
     test.fOp1 = std::numeric_limits<float>::min();
     test.fOp2 = -std::numeric_limits<float>::max();  // lowest()
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dOle), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUle), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dNe), dTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fEq), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fOle), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUle), fFalse);
 
     test.dOp1 = -std::numeric_limits<double>::max();  // lowest()
     test.dOp2 = -std::numeric_limits<double>::max();  // lowest()
     test.fOp1 = std::numeric_limits<float>::max();
     test.fOp2 = std::numeric_limits<float>::max();
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUn), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dEq), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dOle), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOr), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dUne), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dNe), dFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fF), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUn), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fEq), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fUeq), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fOlt), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUlt), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fOle), fTrue);
     CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
 
     test.dOp1 = std::numeric_limits<double>::quiet_NaN();
     test.dOp2 = 0.0;
     test.fOp1 = std::numeric_limits<float>::quiet_NaN();
     test.fOp2 = 0.0;
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(bit_cast<uint64_t>(test.dF), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUn), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dEq), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUeq), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOlt), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUlt), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOle), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUle), dTrue);
     CHECK_EQ(bit_cast<uint64_t>(test.dOr), dFalse);
     CHECK_EQ(bit_cast<uint64_t>(test.dUne), dTrue);
@@ skipping 85 matching lines @@
   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;
   test.cvt_s_w_in = -1;
   test.cvt_s_l_in = -1;
   test.cvt_w_s_in = -0.51;
   test.cvt_w_d_in = -0.51;
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   CHECK_EQ(test.cvt_l_s_out, -1);
   CHECK_EQ(test.cvt_l_d_out, -1);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   CHECK_EQ(test.cvt_w_s_out, -1);
   CHECK_EQ(test.cvt_w_d_out, -1);
 
 
   test.cvt_d_s_in = 0.49;
   test.cvt_d_w_in = 1;
   test.cvt_d_l_in = 1;
   test.cvt_l_s_in = 0.49;
   test.cvt_l_d_in = 0.49;
   test.cvt_s_d_in = 0.49;
   test.cvt_s_w_in = 1;
   test.cvt_s_l_in = 1;
   test.cvt_w_s_in = 0.49;
   test.cvt_w_d_in = 0.49;
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   CHECK_EQ(test.cvt_l_s_out, 0);
   CHECK_EQ(test.cvt_l_d_out, 0);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   CHECK_EQ(test.cvt_w_s_out, 0);
   CHECK_EQ(test.cvt_w_d_out, 0);
 
   test.cvt_d_s_in = std::numeric_limits<float>::max();
   test.cvt_d_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_d_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_l_s_in = std::numeric_limits<float>::max();
   test.cvt_l_d_in = std::numeric_limits<double>::max();
   test.cvt_s_d_in = std::numeric_limits<double>::max();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::max();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::max();
   test.cvt_w_s_in = std::numeric_limits<float>::max();
   test.cvt_w_d_in = std::numeric_limits<double>::max();
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   CHECK_EQ(test.cvt_l_s_out, std::numeric_limits<int64_t>::max());
   CHECK_EQ(test.cvt_l_d_out, std::numeric_limits<int64_t>::max());
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   CHECK_EQ(test.cvt_w_s_out, std::numeric_limits<int32_t>::max());
   CHECK_EQ(test.cvt_w_d_out, std::numeric_limits<int32_t>::max());
 
 
   test.cvt_d_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_d_w_in = std::numeric_limits<int32_t>::min();  // lowest()
   test.cvt_d_l_in = std::numeric_limits<int64_t>::min();  // lowest()
   test.cvt_l_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_l_d_in = -std::numeric_limits<double>::max();  // lowest()
   test.cvt_s_d_in = -std::numeric_limits<double>::max();  // lowest()
   test.cvt_s_w_in = std::numeric_limits<int32_t>::min();  // lowest()
   test.cvt_s_l_in = std::numeric_limits<int64_t>::min();  // lowest()
   test.cvt_w_s_in = -std::numeric_limits<float>::max();   // lowest()
   test.cvt_w_d_in = -std::numeric_limits<double>::max();  // lowest()
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   // The returned value when converting from fixed-point to float-point
   // is not consistent between board, simulator and specification
   // in this test case, therefore modifying the test
   CHECK(test.cvt_l_s_out == std::numeric_limits<int64_t>::min() ||
        test.cvt_l_s_out == std::numeric_limits<int64_t>::max());
   CHECK(test.cvt_l_d_out == std::numeric_limits<int64_t>::min() ||
         test.cvt_l_d_out == std::numeric_limits<int64_t>::max());
@@ skipping 10 matching lines @@
   test.cvt_d_w_in = std::numeric_limits<int32_t>::min();
   test.cvt_d_l_in = std::numeric_limits<int64_t>::min();
   test.cvt_l_s_in = std::numeric_limits<float>::min();
   test.cvt_l_d_in = std::numeric_limits<double>::min();
   test.cvt_s_d_in = std::numeric_limits<double>::min();
   test.cvt_s_w_in = std::numeric_limits<int32_t>::min();
   test.cvt_s_l_in = std::numeric_limits<int64_t>::min();
   test.cvt_w_s_in = std::numeric_limits<float>::min();
   test.cvt_w_d_in = std::numeric_limits<double>::min();
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(test.cvt_d_s_out, static_cast<double>(test.cvt_d_s_in));
   CHECK_EQ(test.cvt_d_w_out, static_cast<double>(test.cvt_d_w_in));
   CHECK_EQ(test.cvt_d_l_out, static_cast<double>(test.cvt_d_l_in));
   CHECK_EQ(test.cvt_l_s_out, 0);
   CHECK_EQ(test.cvt_l_d_out, 0);
   CHECK_EQ(test.cvt_s_d_out, static_cast<float>(test.cvt_s_d_in));
   CHECK_EQ(test.cvt_s_w_out, static_cast<float>(test.cvt_s_w_in));
   CHECK_EQ(test.cvt_s_l_out, static_cast<float>(test.cvt_s_l_in));
   CHECK_EQ(test.cvt_w_s_out, 0);
   CHECK_EQ(test.cvt_w_d_out, 0);
@@ skipping 38 matching lines @@
   __ ctc1(a1, FCSR);
 
   __ jr(ra);
   __ nop();
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
   F3 f = FUNCTION_CAST<F3>(code->entry());
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
 
   const int test_size = 3;
 
   double dOp1[test_size] = {
     5.0,
     DBL_MAX,
     DBL_MAX,
   };
   double dOp2[test_size] = {
     2.0,
@@ skipping 20 matching lines @@
     FLT_MAX / 2.0,
     -1.0,
   };
 
   for (int i = 0; i < test_size; i++) {
     test.dOp1 = dOp1[i];
     test.dOp2 = dOp2[i];
     test.fOp1 = fOp1[i];
     test.fOp2 = fOp2[i];
 
-    (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+    (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
     CHECK_EQ(test.dRes, dRes[i]);
     CHECK_EQ(test.fRes, fRes[i]);
   }
 
   test.dOp1 = DBL_MAX;
   test.dOp2 = -0.0;
   test.fOp1 = FLT_MAX;
   test.fOp2 = -0.0;
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(false, std::isfinite(test.dRes));
   CHECK_EQ(false, std::isfinite(test.fRes));
 
   test.dOp1 = 0.0;
   test.dOp2 = -0.0;
   test.fOp1 = 0.0;
   test.fOp2 = -0.0;
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(true, std::isnan(test.dRes));
   CHECK_EQ(true, std::isnan(test.fRes));
 
   test.dOp1 = std::numeric_limits<double>::quiet_NaN();
   test.dOp2 = -5.0;
   test.fOp1 = std::numeric_limits<float>::quiet_NaN();
   test.fOp2 = -5.0;
 
-  (CALL_GENERATED_CODE(f, &test, 0, 0, 0, 0));
+  (CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0));
   CHECK_EQ(true, std::isnan(test.dRes));
   CHECK_EQ(true, std::isnan(test.fRes));
 }
 
 
 uint64_t run_align(uint64_t rs_value, uint64_t rt_value, uint8_t bp) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   MacroAssembler assm(isolate, NULL, 0);
 
   __ align(v0, a0, a1, bp);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, rs_value,
-                                                        rt_value,
-                                                        0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, rs_value, rt_value, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_align) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseAlign {
@@ skipping 30 matching lines @@
   __ dalign(v0, a0, a1, bp);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, rs_value,
-                                                        rt_value,
-                                                        0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, rs_value, rt_value, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_dalign) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseDalign {
@@ skipping 38 matching lines @@
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_aluipc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseAluipc {
@@ skipping 32 matching lines @@
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_auipc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseAuipc {
@@ skipping 53 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_lwpc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseLwpc {
@@ skipping 54 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_lwupc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseLwupc {
@@ skipping 62 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_jic) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseJic {
@@ skipping 50 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, value, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, value, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_beqzc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseBeqzc {
@@ skipping 72 matching lines @@
   __ nop();
 
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_jialc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseJialc {
@@ skipping 31 matching lines @@
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_addiupc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseAddiupc {
@@ skipping 53 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_ldpc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseLdpc {
@@ skipping 61 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_bc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseBc {
@@ skipping 60 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(r6_balc) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
 
     struct TestCaseBalc {
@@ skipping 28 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, rt_value, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, rt_value, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(dsll) {
   CcTest::InitializeVM();
 
   struct TestCaseDsll {
     uint64_t  rt_value;
@@ skipping 34 matching lines @@
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&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(f, 0, 0, 0, 0, 0));
+  uint64_t res = reinterpret_cast<uint64_t>(
+      CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   return res;
 }
 
 
 TEST(bal) {
   CcTest::InitializeVM();
 
   struct TestCaseBal {
     int16_t  offset;
@@ skipping 30 matching lines @@
   __ bind(&done);
   __ Ret(USE_DELAY_SLOT);
   __ mov(v0, zero_reg);
 
   CodeDesc desc;
   assm.GetCode(&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(f, 42, 42, 0, 0, 0));
+  int64_t res = reinterpret_cast<int64_t>(
+      CALL_GENERATED_CODE(isolate, f, 42, 42, 0, 0, 0));
   CHECK_EQ(res, 0);
 }
 
 
 #undef __