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

test/cctest/test-macro-assembler-mips.cc

 // Copyright 2013 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 74 matching lines @@
 
   __ lw(a2, MemOperand(a0, offsetof(T, r5)));
   __ nop();
   __ ByteSwapUnsigned(a2, a2, 2);
   __ sw(a2, MemOperand(a0, offsetof(T, r5)));
 
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->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 = 0x781A15C3;
   t.r2 = 0x2CDE;
   t.r3 = 0x9F;
   t.r4 = 0x9F;
   t.r5 = 0x2CDE;
   Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
   USE(dummy);
@@ skipping 88 matching lines @@
 
   __ bind(&done);
   __ Pop(ra);
   __ jr(ra);
   __ nop();
 
   __ bind(&end);
   __ Branch(&near_start);
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef OBJECT_PRINT
   code->Print(std::cout);
 #endif
   F1 f = FUNCTION_CAST<F1>(code->entry());
   for (int i = 0; i < kNumCases; ++i) {
     int res =
         reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %d\n", i, res);
@@ skipping 46 matching lines @@
     __ jr(ra);
     __ nop();
   }
 
   __ bind(&done);
   __ Pop(ra);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->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) {
     int32_t res = reinterpret_cast<int32_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %d\n", i, res);
@@ skipping 70 matching lines @@
 
   __ bind(&done);
   __ Pop(ra);
   __ jr(ra);
   __ nop();
 
   __ bind(&end);
   __ Branch(&near_start);
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->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 < kSwitchTableCases; ++i) {
     int res =
         reinterpret_cast<int>(CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %d\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 static uint32_t run_lsa(uint32_t rt, uint32_t rs, int8_t sa) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   MacroAssembler assembler(isolate, nullptr, 0,
                            v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assembler;
 
   __ Lsa(v0, a0, a1, sa);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
-  assembler.GetCode(&desc);
+  assembler.GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   F1 f = FUNCTION_CAST<F1>(code->entry());
 
   uint32_t res = reinterpret_cast<uint32_t>(
       CALL_GENERATED_CODE(isolate, f, rt, rs, 0, 0, 0));
 
   return res;
 }
@@ skipping 109 matching lines @@
                       v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assm;
 
   __ mtc1(a0, f4);
   GenerateConvertInstructionFunc(masm);
   __ mfc1(v0, f2);
   __ 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>());
 
   F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
 
   return reinterpret_cast<RET_TYPE>(
       CALL_GENERATED_CODE(isolate, f, x, 0, 0, 0, 0));
 }
 
 TEST(cvt_s_w_Trunc_uw_s) {
@@ skipping 84 matching lines @@
   HandleScope scope(isolate);
   MacroAssembler assm(isolate, nullptr, 0,
                       v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assm;
 
   GenerateOverflowInstructions(masm, valLeft, valRight);
   __ 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>());
 
   F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
 
   int32_t r =
       reinterpret_cast<int32_t>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   DCHECK(r == 0 || r == 1);
   return r;
@@ skipping 408 matching lines @@
   __ pop(s6);
   __ jr(ra);
   __ nop();
 
   handle_dnan(f10, &handle_mind_nan, &back_mind_nan);
   handle_dnan(f12, &handle_maxd_nan, &back_maxd_nan);
   handle_snan(f14, &handle_mins_nan, &back_mins_nan);
   handle_snan(f16, &handle_maxs_nan, &back_maxs_nan);
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->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.e = inputse[i];
     test.f = inputsf[i];
 
     CALL_GENERATED_CODE(isolate, f, &test, 0, 0, 0, 0);
@@ skipping 15 matching lines @@
   MacroAssembler assm(isolate, nullptr, 0,
                       v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assm;
   IN_TYPE res;
 
   GenerateUnalignedInstructionFunc(masm, in_offset, out_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>());
 
   F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
 
   MemCopy(memory_buffer + in_offset, &value, sizeof(IN_TYPE));
   CALL_GENERATED_CODE(isolate, f, memory_buffer, 0, 0, 0, 0);
   MemCopy(&res, memory_buffer + out_offset, sizeof(IN_TYPE));
 
   return res == value;
@@ skipping 227 matching lines @@
   HandleScope scope(isolate);
   MacroAssembler assm(isolate, nullptr, 0,
                       v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assm;
 
   GenerateSltuInstructionFunc(masm, rd);
   __ 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>());
 
   F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
   int32_t res = reinterpret_cast<int32_t>(
       CALL_GENERATED_CODE(isolate, f, rs, rd, 0, 0, 0));
   return res == 1;
 }
 
 TEST(Sltu) {
@@ skipping 74 matching lines @@
 
   __ bind(&ool_max_aab);
   __ Float32MaxOutOfLine(a, a, b);
   __ Branch(&done_max_aab);
 
   __ bind(&ool_max_aba);
   __ Float32MaxOutOfLine(a, b, a);
   __ Branch(&done_max_aba);
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->GetCode(masm->isolate(), &desc);
   Handle<Code> code = masm->isolate()->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   return FUNCTION_CAST<::F4>(code->entry());
 }
 
 TEST(macro_float_minmax_f32) {
@@ skipping 122 matching lines @@
 
   __ bind(&ool_max_aab);
   __ Float64MaxOutOfLine(a, a, b);
   __ Branch(&done_max_aab);
 
   __ bind(&ool_max_aba);
   __ Float64MaxOutOfLine(a, b, a);
   __ Branch(&done_max_aba);
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->GetCode(masm->isolate(), &desc);
   Handle<Code> code = masm->isolate()->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 #ifdef DEBUG
   OFStream os(stdout);
   code->Print(os);
 #endif
   return FUNCTION_CAST<::F4>(code->entry());
 }
 
 TEST(macro_float_minmax_f64) {
@@ skipping 59 matching lines @@
 
   CHECK_MINMAX(0.0, nan_a, nan_a, nan_a);
   CHECK_MINMAX(nan_a, 0.0, nan_a, nan_a);
   CHECK_MINMAX(nan_a, nan_b, nan_a, nan_a);
   CHECK_MINMAX(nan_b, nan_a, nan_b, nan_b);
 
 #undef CHECK_MINMAX
 }
 
 #undef __