Merge isolates to bleeding_edge.

test/cctest/test-assembler-arm.cc

 // Copyright 2010 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 47 matching lines @@
   InitializeVM();
   v8::HandleScope scope;
 
   Assembler assm(NULL, 0);
 
   __ add(r0, r0, Operand(r1));
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
   assm.GetCode(&desc);
-  Object* code = Heap::CreateCode(
+  Object* code = HEAP->CreateCode(
       desc,
       Code::ComputeFlags(Code::STUB),
-      Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+      Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
   CHECK(code->IsCode());
 #ifdef DEBUG
   Code::cast(code)->Print();
 #endif
   F2 f = FUNCTION_CAST<F2>(Code::cast(code)->entry());
   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 3, 4, 0, 0, 0));
   ::printf("f() = %d\n", res);
   CHECK_EQ(7, res);
 }
 
@@ skipping 13 matching lines @@
   __ add(r0, r0, Operand(r1));
   __ sub(r1, r1, Operand(1));
 
   __ bind(&C);
   __ teq(r1, Operand(0, RelocInfo::NONE));
   __ b(ne, &L);
   __ mov(pc, Operand(lr));
 
   CodeDesc desc;
   assm.GetCode(&desc);
-  Object* code = Heap::CreateCode(
+  Object* code = HEAP->CreateCode(
       desc,
       Code::ComputeFlags(Code::STUB),
-      Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+      Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
   CHECK(code->IsCode());
 #ifdef DEBUG
   Code::cast(code)->Print();
 #endif
   F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 100, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
   CHECK_EQ(5050, res);
 }
 
@@ skipping 13 matching lines @@
   __ mul(r0, r1, r0);
   __ sub(r1, r1, Operand(1));
 
   __ bind(&C);
   __ teq(r1, Operand(0, RelocInfo::NONE));
   __ b(ne, &L);
   __ mov(pc, Operand(lr));
 
   // some relocated stuff here, not executed
   __ RecordComment("dead code, just testing relocations");
-  __ mov(r0, Operand(Factory::true_value()));
+  __ mov(r0, Operand(FACTORY->true_value()));
   __ RecordComment("dead code, just testing immediate operands");
   __ mov(r0, Operand(-1));
   __ mov(r0, Operand(0xFF000000));
   __ mov(r0, Operand(0xF0F0F0F0));
   __ mov(r0, Operand(0xFFF0FFFF));
 
   CodeDesc desc;
   assm.GetCode(&desc);
-  Object* code = Heap::CreateCode(
+  Object* code = HEAP->CreateCode(
       desc,
       Code::ComputeFlags(Code::STUB),
-      Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+      Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
   CHECK(code->IsCode());
 #ifdef DEBUG
   Code::cast(code)->Print();
 #endif
   F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 10, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
   CHECK_EQ(3628800, res);
 }
 
@@ skipping 24 matching lines @@
   __ mov(r2, Operand(r2, LSL, 2));
   __ strb(r2, MemOperand(r4, OFFSET_OF(T, c)));
   __ ldrsh(r2, MemOperand(r4, OFFSET_OF(T, s)));
   __ add(r0, r2, Operand(r0));
   __ mov(r2, Operand(r2, ASR, 3));
   __ strh(r2, MemOperand(r4, OFFSET_OF(T, s)));
   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
   CodeDesc desc;
   assm.GetCode(&desc);
-  Object* code = Heap::CreateCode(
+  Object* code = HEAP->CreateCode(
       desc,
       Code::ComputeFlags(Code::STUB),
-      Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+      Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
   CHECK(code->IsCode());
 #ifdef DEBUG
   Code::cast(code)->Print();
 #endif
   F3 f = FUNCTION_CAST<F3>(Code::cast(code)->entry());
   t.i = 100000;
   t.c = 10;
   t.s = 1000;
   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0));
   ::printf("f() = %d\n", res);
@@ skipping 25 matching lines @@
     float y;
   } T;
   T t;
 
   // Create a function that accepts &t, and loads, manipulates, and stores
   // the doubles and floats.
   Assembler assm(NULL, 0);
   Label L, C;
 
 
-  if (CpuFeatures::IsSupported(VFP3)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(VFP3)) {
     CpuFeatures::Scope scope(VFP3);
 
     __ mov(ip, Operand(sp));
     __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
     __ sub(fp, ip, Operand(4));
 
     __ mov(r4, Operand(r0));
     __ vldr(d6, r4, OFFSET_OF(T, a));
     __ vldr(d7, r4, OFFSET_OF(T, b));
     __ vadd(d5, d6, d7);
@@ skipping 45 matching lines @@
     __ vneg(d0, d1);
     __ vstr(d0, r4, OFFSET_OF(T, m));
     __ vldr(d1, r4, OFFSET_OF(T, n));
     __ vneg(d0, d1);
     __ vstr(d0, r4, OFFSET_OF(T, n));
 
     __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 
     CodeDesc desc;
     assm.GetCode(&desc);
-    Object* code = Heap::CreateCode(
+    Object* code = HEAP->CreateCode(
         desc,
         Code::ComputeFlags(Code::STUB),
-        Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+        Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
     CHECK(code->IsCode());
 #ifdef DEBUG
     Code::cast(code)->Print();
 #endif
     F3 f = FUNCTION_CAST<F3>(Code::cast(code)->entry());
     t.a = 1.5;
     t.b = 2.75;
     t.c = 17.17;
     t.d = 0.0;
     t.e = 0.0;
@@ skipping 24 matching lines @@
 }
 
 
 TEST(5) {
   // Test the ARMv7 bitfield instructions.
   InitializeVM();
   v8::HandleScope scope;
 
   Assembler assm(NULL, 0);
 
-  if (CpuFeatures::IsSupported(ARMv7)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(ARMv7)) {
     CpuFeatures::Scope scope(ARMv7);
     // On entry, r0 = 0xAAAAAAAA = 0b10..10101010.
     __ ubfx(r0, r0, 1, 12);  // 0b00..010101010101 = 0x555
     __ sbfx(r0, r0, 0, 5);   // 0b11..111111110101 = -11
     __ bfc(r0, 1, 3);        // 0b11..111111110001 = -15
     __ mov(r1, Operand(7));
     __ bfi(r0, r1, 3, 3);    // 0b11..111111111001 = -7
     __ mov(pc, Operand(lr));
 
     CodeDesc desc;
     assm.GetCode(&desc);
-    Object* code = Heap::CreateCode(
+    Object* code = HEAP->CreateCode(
         desc,
         Code::ComputeFlags(Code::STUB),
-        Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+        Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
     CHECK(code->IsCode());
 #ifdef DEBUG
     Code::cast(code)->Print();
 #endif
     F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
     int res = reinterpret_cast<int>(
                 CALL_GENERATED_CODE(f, 0xAAAAAAAA, 0, 0, 0, 0));
     ::printf("f() = %d\n", res);
     CHECK_EQ(-7, res);
   }
 }
 
 
 TEST(6) {
   // Test saturating instructions.
   InitializeVM();
   v8::HandleScope scope;
 
   Assembler assm(NULL, 0);
 
-  if (CpuFeatures::IsSupported(ARMv7)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(ARMv7)) {
     CpuFeatures::Scope scope(ARMv7);
     __ usat(r1, 8, Operand(r0));           // Sat 0xFFFF to 0-255 = 0xFF.
     __ usat(r2, 12, Operand(r0, ASR, 9));  // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
     __ usat(r3, 1, Operand(r0, LSL, 16));  // Sat (0xFFFF<<16) to 0-1 = 0x0.
     __ add(r0, r1, Operand(r2));
     __ add(r0, r0, Operand(r3));
     __ mov(pc, Operand(lr));
 
     CodeDesc desc;
     assm.GetCode(&desc);
-    Object* code = Heap::CreateCode(
+    Object* code = HEAP->CreateCode(
         desc,
         Code::ComputeFlags(Code::STUB),
-        Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+        Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
     CHECK(code->IsCode());
 #ifdef DEBUG
     Code::cast(code)->Print();
 #endif
     F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
     int res = reinterpret_cast<int>(
                 CALL_GENERATED_CODE(f, 0xFFFF, 0, 0, 0, 0));
     ::printf("f() = %d\n", res);
     CHECK_EQ(382, res);
   }
 }
 
 
 enum VCVTTypes {
   s32_f64,
   u32_f64
 };
 
 static void TestRoundingMode(VCVTTypes types,
                              VFPRoundingMode mode,
                              double value,
                              int expected,
                              bool expected_exception = false) {
   InitializeVM();
   v8::HandleScope scope;
 
   Assembler assm(NULL, 0);
 
-  if (CpuFeatures::IsSupported(VFP3)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(VFP3)) {
     CpuFeatures::Scope scope(VFP3);
 
     Label wrong_exception;
 
     __ vmrs(r1);
     // Set custom FPSCR.
     __ bic(r2, r1, Operand(kVFPRoundingModeMask | kVFPExceptionMask));
     __ orr(r2, r2, Operand(mode));
     __ vmsr(r2);
 
@@ skipping 23 matching lines @@
     __ mov(pc, Operand(lr));
 
     // The exception behaviour is not what we expected.
     // Load a special value and return.
     __ bind(&wrong_exception);
     __ mov(r0, Operand(11223344));
     __ mov(pc, Operand(lr));
 
     CodeDesc desc;
     assm.GetCode(&desc);
-    Object* code = Heap::CreateCode(
+    Object* code = HEAP->CreateCode(
         desc,
         Code::ComputeFlags(Code::STUB),
-        Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
+        Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();
     CHECK(code->IsCode());
 #ifdef DEBUG
     Code::cast(code)->Print();
 #endif
     F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
     int res = reinterpret_cast<int>(
                 CALL_GENERATED_CODE(f, 0, 0, 0, 0, 0));
     ::printf("res = %d\n", res);
     CHECK_EQ(expected, res);
   }
@@ skipping 103 matching lines @@
   TestRoundingMode(u32_f64, RN, static_cast<double>(kMaxInt), kMaxInt);
   TestRoundingMode(u32_f64, RN, (kMaxInt + 0.49), kMaxInt);
   TestRoundingMode(u32_f64, RN, (kMaxInt + 0.5),
                                 static_cast<uint32_t>(kMaxInt) + 1);
   TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.49), kMaxUInt);
   TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.5), kMaxUInt, true);
   TestRoundingMode(u32_f64, RN, (kMaxUInt + 1.0), kMaxUInt, true);
 }
 
 #undef __