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

test/cctest/test-macro-assembler-mips64.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 89 matching lines @@
 
   __ Ld(a4, MemOperand(a0, offsetof(T, r7)));
   __ nop();
   __ ByteSwapUnsigned(a4, a4, 4);
   __ Sd(a4, MemOperand(a0, offsetof(T, r7)));
 
   __ 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 = 0x5612FFCD9D327ACC;
   t.r2 = 0x781A15C3;
   t.r3 = 0xFCDE;
   t.r4 = 0x9F;
   t.r5 = 0x9F;
   t.r6 = 0xFCDE;
   t.r7 = 0xC81A15C3;
@@ skipping 31 matching lines @@
     // Load constant.
     __ li(a5, Operand(refConstants[i]));
     __ Sd(a5, MemOperand(a4));
     __ Daddu(a4, a4, Operand(kPointerSize));
   }
 
   __ 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>());
 
   ::F f = FUNCTION_CAST< ::F>(code->entry());
   (void)CALL_GENERATED_CODE(isolate, f, reinterpret_cast<int64_t>(result), 0, 0,
                             0, 0);
   // Check results.
   for (int i = 0; i < 64; i++) {
     CHECK(refConstants[i] == result[i]);
   }
@@ skipping 24 matching lines @@
   __ jr(a4);
   __ nop();
   __ stop("invalid");
   __ stop("invalid");
   __ stop("invalid");
   __ stop("invalid");
   __ stop("invalid");
 
 
   CodeDesc desc;
-  masm->GetCode(&desc);
+  masm->GetCode(isolate, &desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   ::F f = FUNCTION_CAST< ::F>(code->entry());
   (void)CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0);
   // Check results.
 }
 
 
 TEST(jump_tables4) {
@@ skipping 37 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) {
     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 53 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) {
     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 71 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) {
     int64_t res = reinterpret_cast<int64_t>(
         CALL_GENERATED_CODE(isolate, f, i, 0, 0, 0, 0));
     ::printf("f(%d) = %" PRId64 "\n", i, res);
     CHECK_EQ(values[i], res);
   }
 }
 
 static uint64_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());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, rt, rs, 0, 0, 0));
 
   return res;
 }
@@ skipping 61 matching lines @@
   HandleScope scope(isolate);
   MacroAssembler assembler(isolate, nullptr, 0,
                            v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assembler;
 
   __ Dlsa(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>());
 
   ::F f = FUNCTION_CAST<::F>(code->entry());
 
   uint64_t res = reinterpret_cast<uint64_t>(
       CALL_GENERATED_CODE(isolate, f, rt, rs, 0, 0, 0));
 
   return res;
 }
@@ skipping 131 matching lines @@
   MacroAssembler assm(isolate, nullptr, 0,
                       v8::internal::CodeObjectRequired::kYes);
   MacroAssembler* masm = &assm;
 
   GenerateConvertInstructionFunc(masm);
   __ dmfc1(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_uw_Trunc_uw_s) {
@@ skipping 152 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());
 
   int64_t r =
       reinterpret_cast<int64_t>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
 
   DCHECK(r == 0 || r == 1);
   return r;
@@ skipping 660 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 344 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());
   int64_t res = reinterpret_cast<int64_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 __