Make whether or not a Code object should be created by masm explicit

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 42 matching lines @@
 // clang-format off
 
 
 #define __ assm.
 
 TEST(MIPS0) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // 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(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);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   __ mov(a1, a0);
   __ li(v0, 0);
   __ b(&C);
   __ nop();
 
   __ bind(&L);
   __ addu(v0, v0, a1);
   __ addiu(a1, a1, -1);
@@ skipping 15 matching lines @@
       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);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label exit, error;
 
   // ----- Test all instructions.
 
   // Test lui, ori, and addiu, used in the li pseudo-instruction.
   // This way we can then safely load registers with chosen values.
 
   __ ori(a4, zero_reg, 0);
   __ lui(a4, 0x1234);
@@ skipping 149 matching lines @@
     float fc;
     float fd;
     float fe;
     float ff;
     float fg;
   } T;
   T t;
 
   // Create a function that accepts &t, and loads, manipulates, and stores
   // the doubles t.a ... t.f.
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label L, C;
 
   // Double precision floating point instructions.
   __ ldc1(f4, MemOperand(a0, offsetof(T, a)) );
   __ ldc1(f6, MemOperand(a0, offsetof(T, b)) );
   __ add_d(f8, f4, f6);
   __ sdc1(f8, MemOperand(a0, offsetof(T, c)) );  // c = a + b.
 
   __ mov_d(f10, f8);  // c
   __ neg_d(f12, f6);  // -b
@@ skipping 318 matching lines @@
     double c;
     double d;
     double e;
     double f;
     int32_t result;
   } T;
   T t;
 
   // Create a function that accepts &t, and loads, manipulates, and stores
   // the doubles t.a ... t.f.
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label neither_is_nan, less_than, outa_here;
 
   __ ldc1(f4, MemOperand(a0, offsetof(T, a)) );
   __ ldc1(f6, MemOperand(a0, offsetof(T, b)) );
   if (kArchVariant != kMips64r6) {
     __ c(UN, D, f4, f6);
     __ bc1f(&neither_is_nan);
   } else {
     __ cmp(UN, L, f2, f4, f6);
     __ bc1eqz(&neither_is_nan, f2);
@@ skipping 67 matching lines @@
       int32_t result_rotrv_4;
       int32_t result_rotrv_8;
       int32_t result_rotrv_12;
       int32_t result_rotrv_16;
       int32_t result_rotrv_20;
       int32_t result_rotrv_24;
       int32_t result_rotrv_28;
     } T;
     T t;
 
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     // Basic word load.
     __ lw(a4, MemOperand(a0, offsetof(T, input)) );
 
     // ROTR instruction (called through the Ror macro).
     __ Ror(a5, a4, 0x0004);
     __ Ror(a6, a4, 0x0008);
     __ Ror(a7, a4, 0x000c);
     __ Ror(t0, a4, 0x0010);
     __ Ror(t1, a4, 0x0014);
@@ skipping 63 matching lines @@
   }
 }
 
 
 TEST(MIPS9) {
   // Test BRANCH improvements.
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
   Label exit, exit2, exit3;
 
   __ Branch(&exit, ge, a0, Operand(zero_reg));
   __ Branch(&exit2, ge, a0, Operand(0x00001FFF));
   __ Branch(&exit3, ge, a0, Operand(0x0001FFFF));
 
   __ bind(&exit);
   __ bind(&exit2);
   __ bind(&exit3);
   __ jr(ra);
@@ skipping 276 matching lines @@
   typedef struct {
       int32_t  x;
       int32_t  y;
       int32_t  y1;
       int32_t  y2;
       int32_t  y3;
       int32_t  y4;
   } T;
   T t;
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ mov(t2, fp);  // Save frame pointer.
   __ mov(fp, a0);  // Access struct T by fp.
   __ lw(a4, MemOperand(a0, offsetof(T, y)));
   __ lw(a7, MemOperand(a0, offsetof(T, y4)));
 
   __ addu(a5, a4, a7);
   __ subu(t0, a4, a7);
   __ nop();
   __ push(a4);  // These instructions disappear after opt.
@@ skipping 68 matching lines @@
   typedef struct {
     double cvt_big_out;
     double cvt_small_out;
     uint32_t trunc_big_out;
     uint32_t trunc_small_out;
     uint32_t cvt_big_in;
     uint32_t cvt_small_in;
   } T;
   T t;
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ sw(a4, MemOperand(a0, offsetof(T, cvt_small_in)));
   __ Cvt_d_uw(f10, a4);
   __ sdc1(f10, MemOperand(a0, offsetof(T, cvt_small_out)));
 
   __ Trunc_uw_d(f10, f10, f4);
   __ swc1(f10, MemOperand(a0, offsetof(T, trunc_small_out)));
 
   __ sw(a4, MemOperand(a0, offsetof(T, cvt_big_in)));
   __ Cvt_d_uw(f8, a4);
@@ skipping 56 matching lines @@
     ROUND_STRUCT_ELEMENT(round)
     ROUND_STRUCT_ELEMENT(floor)
     ROUND_STRUCT_ELEMENT(ceil)
     ROUND_STRUCT_ELEMENT(trunc)
     ROUND_STRUCT_ELEMENT(cvt)
   } T;
   T t;
 
 #undef ROUND_STRUCT_ELEMENT
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // Save FCSR.
   __ cfc1(a1, FCSR);
   // Disable FPU exceptions.
   __ ctc1(zero_reg, FCSR);
 #define RUN_ROUND_TEST(x) \
   __ ldc1(f0, MemOperand(a0, offsetof(T, round_up_in))); \
   __ x##_w_d(f0, f0); \
   __ swc1(f0, MemOperand(a0, offsetof(T, x##_up_out))); \
   \
@@ skipping 195 matching lines @@
   CHECK_EQ(static_cast<int64_t>(0x000000003333bbccL), t.r6);
 }
 
 
 // ----------------------mips64r6 specific tests----------------------
 TEST(seleqz_selnez) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test {
       int a;
       int b;
       int c;
       int d;
       double e;
       double f;
       double g;
       double h;
@@ skipping 81 matching lines @@
   }
 }
 
 
 
 TEST(min_max) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       double a;
       double b;
       double c;
       double d;
       float e;
       float f;
       float g;
       float h;
@@ skipping 56 matching lines @@
   }
 }
 
 
 TEST(rint_d)  {
   if (kArchVariant == kMips64r6) {
     const int kTableLength = 30;
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       double a;
       double b;
       int fcsr;
     }TestFloat;
 
     TestFloat test;
     double inputs[kTableLength] = {18446744073709551617.0,
       4503599627370496.0, -4503599627370496.0,
@@ skipping 82 matching lines @@
     }
   }
 }
 
 
 TEST(sel) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test {
       double dd;
       double ds;
       double dt;
       float fd;
       float fs;
       float ft;
     } Test;
 
@@ skipping 53 matching lines @@
   }
 }
 
 
 TEST(rint_s)  {
   if (kArchVariant == kMips64r6) {
     const int kTableLength = 30;
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       float a;
       float b;
       int fcsr;
     }TestFloat;
 
     TestFloat test;
     float inputs[kTableLength] = {18446744073709551617.0,
       4503599627370496.0, -4503599627370496.0,
@@ skipping 85 matching lines @@
   }
 }
 
 
 TEST(mina_maxa) {
   if (kArchVariant == kMips64r6) {
     const int kTableLength = 15;
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
     const double double_nan = std::numeric_limits<double>::quiet_NaN();
     const float  float_nan = std::numeric_limits<float>::quiet_NaN();
 
     typedef struct test_float {
       double a;
       double b;
       double resd;
       double resd1;
       float c;
       float d;
@@ skipping 78 matching lines @@
 }
 
 
 
 // ----------------------mips64r2 specific tests----------------------
 TEST(trunc_l) {
   if (kArchVariant == kMips64r2) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
     const double dFPU64InvalidResult = static_cast<double>(kFPU64InvalidResult);
     typedef struct test_float {
       double a;
       float b;
       int64_t c;  // a trunc result
       int64_t d;  // b trunc result
     }Test;
     const int kTableLength = 15;
     double inputs_D[kTableLength] = {
         2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 39 matching lines @@
   }
 }
 
 
 TEST(movz_movn) {
   if (kArchVariant == kMips64r2) {
     const int kTableLength = 4;
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       int64_t rt;
       double a;
       double b;
       double bold;
       double b1;
       double bold1;
       float c;
       float d;
@@ skipping 107 matching lines @@
       test.srcf = inputs_S[i];
 
       for (int j = 0; j< 8; j++) {
         test.cc = condition_flags[j];
         if (test.cc == 0) {
           test.fcsr = 1 << 23;
         } else {
           test.fcsr = 1 << (24+condition_flags[j]);
         }
         HandleScope scope(isolate);
-        MacroAssembler assm(isolate, NULL, 0);
+        MacroAssembler assm(isolate, NULL, 0,
+                            v8::internal::CodeObjectRequired::kYes);
         __ ldc1(f2, MemOperand(a0, offsetof(TestFloat, srcd)) );
         __ lwc1(f4, MemOperand(a0, offsetof(TestFloat, srcf)) );
         __ lw(t1, MemOperand(a0, offsetof(TestFloat, fcsr)) );
         __ cfc1(t0, FCSR);
         __ ctc1(t1, FCSR);
         __ li(t2, 0x0);
         __ mtc1(t2, f12);
         __ mtc1(t2, f10);
         __ sdc1(f10, MemOperand(a0, offsetof(TestFloat, dstdold)) );
         __ swc1(f12, MemOperand(a0, offsetof(TestFloat, dstfold)) );
@@ skipping 33 matching lines @@
   }
 }
 
 
 
 // ----------------------tests for all archs--------------------------
 TEST(cvt_w_d) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     int32_t b;
     int fcsr;
   }Test;
   const int kTableLength = 24;
   double inputs[kTableLength] = {
       2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
       -2.1, -2.6, -2.5, -3.1, -3.6, -3.5,
@@ skipping 56 matching lines @@
       CHECK_EQ(test.b, outputs[j][i]);
     }
   }
 }
 
 
 TEST(trunc_w) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     float b;
     int32_t c;  // a trunc result
     int32_t d;  // b trunc result
   }Test;
   const int kTableLength = 15;
   double inputs_D[kTableLength] = {
       2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 36 matching lines @@
     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);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     float b;
     int32_t c;  // a trunc result
     int32_t d;  // b trunc result
   }Test;
   const int kTableLength = 15;
   double inputs_D[kTableLength] = {
       2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 36 matching lines @@
     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);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
     const double dFPU64InvalidResult = static_cast<double>(kFPU64InvalidResult);
     typedef struct test_float {
       double a;
       float b;
       int64_t c;
       int64_t d;
     }Test;
     const int kTableLength = 15;
     double inputs_D[kTableLength] = {
         2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 38 matching lines @@
       CHECK_EQ(test.d, test.c);
     }
 }
 
 
 TEST(sub) {
   const int kTableLength = 12;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     float a;
     float b;
     float resultS;
     double c;
     double d;
     double resultD;
   }TestFloat;
 
@@ skipping 52 matching lines @@
 
 TEST(sqrt_rsqrt_recip) {
   const int kTableLength = 4;
   const double deltaDouble = 2E-15;
   const float deltaFloat = 2E-7;
   const float sqrt2_s = sqrt(2);
   const double sqrt2_d = sqrt(2);
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     float a;
     float resultS;
     float resultS1;
     float resultS2;
     double c;
     double resultD;
     double resultD1;
     double resultD2;
@@ skipping 71 matching lines @@
     }
   }
 }
 
 
 TEST(neg) {
   const int kTableLength = 2;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     float a;
     float resultS;
     double c;
     double resultD;
   }TestFloat;
 
   TestFloat test;
   double inputs_D[kTableLength] = {
@@ skipping 33 matching lines @@
   }
 }
 
 
 
 TEST(mul) {
   const int kTableLength = 4;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     float a;
     float b;
     float resultS;
     double c;
     double d;
     double resultD;
   }TestFloat;
 
@@ skipping 38 matching lines @@
     CHECK_EQ(test.resultD, inputfs_D[i]*inputft_D[i]);
   }
 }
 
 
 TEST(mov) {
   const int kTableLength = 4;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     double b;
     float c;
     float d;
   }TestFloat;
 
   TestFloat test;
   double inputs_D[kTableLength] = {
@@ skipping 32 matching lines @@
     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);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     float b;
     int32_t c;  // a floor result
     int32_t d;  // b floor result
   }Test;
   const int kTableLength = 15;
   double inputs_D[kTableLength] = {
       2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 36 matching lines @@
     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);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
     const double dFPU64InvalidResult = static_cast<double>(kFPU64InvalidResult);
     typedef struct test_float {
       double a;
       float b;
       int64_t c;
       int64_t d;
     }Test;
     const int kTableLength = 15;
     double inputs_D[kTableLength] = {
         2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 36 matching lines @@
       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);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     float b;
     int32_t c;  // a floor result
     int32_t d;  // b floor result
   }Test;
   const int kTableLength = 15;
   double inputs_D[kTableLength] = {
       2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 36 matching lines @@
     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);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
     const double dFPU64InvalidResult = static_cast<double>(kFPU64InvalidResult);
     typedef struct test_float {
       double a;
       float b;
       int64_t c;
       int64_t d;
     }Test;
     const int kTableLength = 15;
     double inputs_D[kTableLength] = {
         2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
@@ skipping 369 matching lines @@
       float  fNegSubnorm;
       float  fNegZero;
       float  fPosInf;
       float  fPosNorm;
       float  fPosSubnorm;
       float  fPosZero;  } T;
     T t;
 
     // Create a function that accepts &t, and loads, manipulates, and stores
     // the doubles t.a ... t.f.
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     __ ldc1(f4, MemOperand(a0, offsetof(T, dSignalingNan)));
     __ class_d(f6, f4);
     __ sdc1(f6, MemOperand(a0, offsetof(T, dSignalingNan)));
 
     __ ldc1(f4, MemOperand(a0, offsetof(T, dQuietNan)));
     __ class_d(f6, f4);
     __ sdc1(f6, MemOperand(a0, offsetof(T, dQuietNan)));
 
     __ ldc1(f4, MemOperand(a0, offsetof(T, dNegInf)));
@@ skipping 128 matching lines @@
     CHECK_EQ(bit_cast<int32_t>(t.fPosSubnorm),   0x100);
     CHECK_EQ(bit_cast<int32_t>(t.fPosZero),      0x200);
   }
 }
 
 
 TEST(ABS) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     int64_t fir;
     double a;
     float b;
     double fcsr;
   } TestFloat;
 
   TestFloat test;
 
@@ skipping 77 matching lines @@
   (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);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     double a;
     double b;
     double c;
     float fa;
     float fb;
     float fc;
   } TestFloat;
 
@@ skipping 49 matching lines @@
   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);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       double dOp1;
       double dOp2;
       uint32_t dF;
       uint32_t dUn;
       uint32_t dEq;
       uint32_t dUeq;
       uint32_t dOlt;
       uint32_t dUlt;
@@ skipping 190 matching lines @@
     CHECK_EQ(test.fUle, 1U);
   }
 }
 
 
 TEST(CMP_COND_FMT) {
   if (kArchVariant == kMips64r6) {
     CcTest::InitializeVM();
     Isolate* isolate = CcTest::i_isolate();
     HandleScope scope(isolate);
-    MacroAssembler assm(isolate, NULL, 0);
+    MacroAssembler assm(isolate, NULL, 0,
+                        v8::internal::CodeObjectRequired::kYes);
 
     typedef struct test_float {
       double dOp1;
       double dOp2;
       double dF;
       double dUn;
       double dEq;
       double dUeq;
       double dOlt;
       double dUlt;
@@ skipping 195 matching lines @@
     CHECK_EQ(bit_cast<uint32_t>(test.fOle), fFalse);
     CHECK_EQ(bit_cast<uint32_t>(test.fUle), fTrue);
   }
 }
 
 
 TEST(CVT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test_float {
     float    cvt_d_s_in;
     double   cvt_d_s_out;
     int32_t  cvt_d_w_in;
     double   cvt_d_w_out;
     int64_t  cvt_d_l_in;
     double   cvt_d_l_out;
 
     float    cvt_l_s_in;
@@ skipping 177 matching lines @@
   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(DIV_FMT) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   typedef struct test {
     double dOp1;
     double dOp2;
     double dRes;
     float  fOp1;
     float  fOp2;
     float  fRes;
   } Test;
 
@@ skipping 99 matching lines @@
   (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);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ 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>());
 
@@ skipping 32 matching lines @@
                                               tc[i].bp));
     }
   }
 }
 
 
 uint64_t run_dalign(uint64_t rs_value, uint64_t rt_value, uint8_t bp) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ 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>());
 
@@ skipping 37 matching lines @@
   }
 }
 
 
 uint64_t PC;  // The program counter.
 
 uint64_t run_aluipc(int16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ aluipc(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
@@ skipping 33 matching lines @@
       CHECK_EQ(expected_res, res);
     }
   }
 }
 
 
 uint64_t run_auipc(int16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ auipc(v0, offset);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
@@ skipping 33 matching lines @@
       CHECK_EQ(expected_res, res);
     }
   }
 }
 
 
 uint64_t run_lwpc(int offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // 256k instructions; 2^8k
   // addiu t3, a4, 0xffff;  (0x250fffff)
   // ...
   // addiu t0, a4, 0x0000;  (0x250c0000)
   uint32_t addiu_start_1 = 0x25000000;
   for (int32_t i = 0xfffff; i >= 0xc0000; --i) {
     uint32_t addiu_new = addiu_start_1 + i;
     __ dd(addiu_new);
   }
@@ skipping 55 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_lwupc(int offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // 256k instructions; 2^8k
   // addiu t3, a4, 0xffff;  (0x250fffff)
   // ...
   // addiu t0, a4, 0x0000;  (0x250c0000)
   uint32_t addiu_start_1 = 0x25000000;
   for (int32_t i = 0xfffff; i >= 0xc0000; --i) {
     uint32_t addiu_new = addiu_start_1 + i;
     __ dd(addiu_new);
   }
@@ skipping 55 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_jic(int16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label get_program_counter, stop_execution;
   __ push(ra);
   __ li(v0, 0);
   __ li(t1, 0x66);
 
   __ addiu(v0, v0, 0x1);        // <-- offset = -32
   __ addiu(v0, v0, 0x2);
   __ addiu(v0, v0, 0x10);
   __ addiu(v0, v0, 0x20);
@@ skipping 60 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_beqzc(int32_t value, int32_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label stop_execution;
   __ li(v0, 0);
   __ li(t1, 0x66);
 
   __ addiu(v0, v0, 0x1);        // <-- offset = -8
   __ addiu(v0, v0, 0x2);
   __ addiu(v0, v0, 0x10);
   __ addiu(v0, v0, 0x20);
   __ beq(v0, t1, &stop_execution);
@@ skipping 52 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_jialc(int16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label main_block, get_program_counter;
   __ push(ra);
   __ li(v0, 0);
   __ beq(v0, v0, &main_block);
   __ nop();
 
   // Block 1
   __ addiu(v0, v0, 0x1);        // <-- offset = -40
   __ addiu(v0, v0, 0x2);
@@ skipping 73 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_addiupc(int32_t imm19) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ addiupc(v0, imm19);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
@@ skipping 33 matching lines @@
       CHECK_EQ(expected_res, res);
     }
   }
 }
 
 
 uint64_t run_ldpc(int offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   // 256k instructions; 2 * 2^7k = 2^8k
   // addiu t3, a4, 0xffff;  (0x250fffff)
   // ...
   // addiu t0, a4, 0x0000;  (0x250c0000)
   uint32_t addiu_start_1 = 0x25000000;
   for (int32_t i = 0xfffff; i >= 0xc0000; --i) {
     uint32_t addiu_new = addiu_start_1 + i;
     __ dd(addiu_new);
   }
@@ skipping 54 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 int64_t run_bc(int32_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label continue_1, stop_execution;
   __ push(ra);
   __ li(v0, 0);
   __ li(t8, 0);
   __ li(t9, 2);   // Condition for the stopping execution.
 
   uint32_t instruction_addiu = 0x24420001;  // addiu v0, v0, 1
   for (int32_t i = -100; i <= -11; ++i) {
     __ dd(instruction_addiu);
@@ skipping 60 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 int64_t run_balc(int32_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   Label continue_1, stop_execution;
   __ push(ra);
   __ li(v0, 0);
   __ li(t8, 0);
   __ li(t9, 2);   // Condition for stopping execution.
 
   __ beq(t8, t8, &continue_1);
   __ nop();
 
@@ skipping 60 matching lines @@
       CHECK_EQ(tc[i].expected_res, res);
     }
   }
 }
 
 
 uint64_t run_dsll(uint64_t rt_value, uint16_t sa_value) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ dsll(v0, a0, sa_value);
   __ jr(ra);
   __ nop();
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
@@ skipping 27 matching lines @@
     CHECK_EQ(tc[i].expected_res,
             run_dsll(tc[i].rt_value, tc[i].sa_value));
   }
 }
 
 
 uint64_t run_bal(int16_t offset) {
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, NULL, 0);
+  MacroAssembler assm(isolate, NULL, 0, v8::internal::CodeObjectRequired::kYes);
 
   __ mov(t0, ra);
   __ bal(offset);       // Equivalent for "BGEZAL zero_reg, offset".
   __ nop();
 
   __ mov(ra, t0);
   __ jr(ra);
   __ nop();
 
   __ li(v0, 1);
@@ skipping 35 matching lines @@
 
 
 TEST(Trampoline) {
   // Private member of Assembler class.
   static const int kMaxBranchOffset = (1 << (18 - 1)) - 1;
 
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
-  MacroAssembler assm(isolate, nullptr, 0);
+  MacroAssembler assm(isolate, nullptr, 0,
+                      v8::internal::CodeObjectRequired::kYes);
   Label done;
   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);
   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(res, 0);
 }
 
 
 #undef __