Merge isolates to bleeding_edge.

src/ia32/codegen-ia32.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 136 matching lines @@
       masm_(masm),
       info_(NULL),
       frame_(NULL),
       allocator_(NULL),
       state_(NULL),
       loop_nesting_(0),
       in_safe_int32_mode_(false),
       safe_int32_mode_enabled_(true),
       function_return_is_shadowed_(false),
       in_spilled_code_(false),
-      jit_cookie_((FLAG_mask_constants_with_cookie) ? V8::RandomPrivate() : 0) {
+      jit_cookie_((FLAG_mask_constants_with_cookie) ?
+                  V8::RandomPrivate(Isolate::Current()) : 0) {
 }
 
 
 // Calling conventions:
 // ebp: caller's frame pointer
 // esp: stack pointer
 // edi: called JS function
 // esi: callee's context
 
 void CodeGenerator::Generate(CompilationInfo* info) {
   // Record the position for debugging purposes.
   CodeForFunctionPosition(info->function());
   Comment cmnt(masm_, "[ function compiled by virtual frame code generator");
 
   // Initialize state.
   info_ = info;
   ASSERT(allocator_ == NULL);
   RegisterAllocator register_allocator(this);
   allocator_ = &register_allocator;
   ASSERT(frame_ == NULL);
   frame_ = new VirtualFrame();
   set_in_spilled_code(false);
 
   // Adjust for function-level loop nesting.
   ASSERT_EQ(0, loop_nesting_);
   loop_nesting_ = info->is_in_loop() ? 1 : 0;
 
-  JumpTarget::set_compiling_deferred_code(false);
+  Isolate::Current()->set_jump_target_compiling_deferred_code(false);
 
   {
     CodeGenState state(this);
 
     // Entry:
     // Stack: receiver, arguments, return address.
     // ebp: caller's frame pointer
     // esp: stack pointer
     // edi: called JS function
     // esi: callee's context
@@ skipping 81 matching lines @@
 
     // Store the arguments object.  This must happen after context
     // initialization because the arguments object may be stored in
     // the context.
     if (ArgumentsMode() != NO_ARGUMENTS_ALLOCATION) {
       StoreArgumentsObject(true);
     }
 
     // Initialize ThisFunction reference if present.
     if (scope()->is_function_scope() && scope()->function() != NULL) {
-      frame_->Push(Factory::the_hole_value());
+      frame_->Push(FACTORY->the_hole_value());
       StoreToSlot(scope()->function()->AsSlot(), NOT_CONST_INIT);
     }
 
 
     // Initialize the function return target after the locals are set
     // up, because it needs the expected frame height from the frame.
     function_return_.set_direction(JumpTarget::BIDIRECTIONAL);
     function_return_is_shadowed_ = false;
 
     // Generate code to 'execute' declarations and initialize functions
@@ skipping 15 matching lines @@
       // Ignore the return value.
     }
     CheckStack();
 
     // Compile the body of the function in a vanilla state. Don't
     // bother compiling all the code if the scope has an illegal
     // redeclaration.
     if (!scope()->HasIllegalRedeclaration()) {
       Comment cmnt(masm_, "[ function body");
 #ifdef DEBUG
-      bool is_builtin = Bootstrapper::IsActive();
+      bool is_builtin = info->isolate()->bootstrapper()->IsActive();
       bool should_trace =
           is_builtin ? FLAG_trace_builtin_calls : FLAG_trace_calls;
       if (should_trace) {
         frame_->CallRuntime(Runtime::kDebugTrace, 0);
         // Ignore the return value.
       }
 #endif
       VisitStatements(info->function()->body());
 
       // Handle the return from the function.
       if (has_valid_frame()) {
         // If there is a valid frame, control flow can fall off the end of
         // the body.  In that case there is an implicit return statement.
         ASSERT(!function_return_is_shadowed_);
         CodeForReturnPosition(info->function());
         frame_->PrepareForReturn();
-        Result undefined(Factory::undefined_value());
+        Result undefined(FACTORY->undefined_value());
         if (function_return_.is_bound()) {
           function_return_.Jump(&undefined);
         } else {
           function_return_.Bind(&undefined);
           GenerateReturnSequence(&undefined);
         }
       } else if (function_return_.is_linked()) {
         // If the return target has dangling jumps to it, then we have not
         // yet generated the return sequence.  This can happen when (a)
         // control does not flow off the end of the body so we did not
@@ skipping 11 matching lines @@
   loop_nesting_ = 0;
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
   if (!HasStackOverflow()) {
-    JumpTarget::set_compiling_deferred_code(true);
+    info->isolate()->set_jump_target_compiling_deferred_code(true);
     ProcessDeferred();
-    JumpTarget::set_compiling_deferred_code(false);
+    info->isolate()->set_jump_target_compiling_deferred_code(false);
   }
 
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
   allocator_ = NULL;
 }
 
 
 Operand CodeGenerator::SlotOperand(Slot* slot, Register tmp) {
   // Currently, this assertion will fail if we try to assign to
@@ skipping 163 matching lines @@
 void CodeGenerator::ConvertInt32ResultToNumber(Result* value) {
   ASSERT(value->is_untagged_int32());
   if (value->is_register()) {
     Register val = value->reg();
     JumpTarget done;
     __ add(val, Operand(val));
     done.Branch(no_overflow, value);
     __ sar(val, 1);
     // If there was an overflow, bits 30 and 31 of the original number disagree.
     __ xor_(val, 0x80000000u);
-    if (CpuFeatures::IsSupported(SSE2)) {
+    if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ cvtsi2sd(xmm0, Operand(val));
     } else {
       // Move val to ST[0] in the FPU
       // Push and pop are safe with respect to the virtual frame because
       // all synced elements are below the actual stack pointer.
       __ push(val);
       __ fild_s(Operand(esp, 0));
       __ pop(val);
     }
     Result scratch = allocator_->Allocate();
     ASSERT(scratch.is_register());
     Label allocation_failed;
     __ AllocateHeapNumber(val, scratch.reg(),
                           no_reg, &allocation_failed);
     VirtualFrame* clone = new VirtualFrame(frame_);
     scratch.Unuse();
-    if (CpuFeatures::IsSupported(SSE2)) {
+    if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ movdbl(FieldOperand(val, HeapNumber::kValueOffset), xmm0);
     } else {
       __ fstp_d(FieldOperand(val, HeapNumber::kValueOffset));
     }
     done.Jump(value);
 
     // Establish the virtual frame, cloned from where AllocateHeapNumber
     // jumped to allocation_failed.
     RegisterFile empty_regs;
     SetFrame(clone, &empty_regs);
     __ bind(&allocation_failed);
-    if (!CpuFeatures::IsSupported(SSE2)) {
+    if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
       // Pop the value from the floating point stack.
       __ fstp(0);
     }
     unsafe_bailout_->Jump();
 
     done.Bind(value);
   } else {
     ASSERT(value->is_constant());
   }
   value->set_untagged_int32(false);
   value->set_type_info(TypeInfo::Integer32());
 }
 
 
 void CodeGenerator::Load(Expression* expr) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   ASSERT(!in_spilled_code());
 
   // If the expression should be a side-effect-free 32-bit int computation,
   // compile that SafeInt32 path, and a bailout path.
   if (!in_safe_int32_mode() &&
       safe_int32_mode_enabled() &&
       expr->side_effect_free() &&
       expr->num_bit_ops() > 2 &&
-      CpuFeatures::IsSupported(SSE2)) {
+      Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     BreakTarget unsafe_bailout;
     JumpTarget done;
     unsafe_bailout.set_expected_height(frame_->height());
     LoadInSafeInt32Mode(expr, &unsafe_bailout);
     done.Jump();
 
     if (unsafe_bailout.is_linked()) {
       unsafe_bailout.Bind();
       LoadWithSafeInt32ModeDisabled(expr);
     }
     done.Bind();
   } else {
     JumpTarget true_target;
     JumpTarget false_target;
     ControlDestination dest(&true_target, &false_target, true);
     LoadCondition(expr, &dest, false);
 
     if (dest.false_was_fall_through()) {
       // The false target was just bound.
       JumpTarget loaded;
-      frame_->Push(Factory::false_value());
+      frame_->Push(FACTORY->false_value());
       // There may be dangling jumps to the true target.
       if (true_target.is_linked()) {
         loaded.Jump();
         true_target.Bind();
-        frame_->Push(Factory::true_value());
+        frame_->Push(FACTORY->true_value());
         loaded.Bind();
       }
 
     } else if (dest.is_used()) {
       // There is true, and possibly false, control flow (with true as
       // the fall through).
       JumpTarget loaded;
-      frame_->Push(Factory::true_value());
+      frame_->Push(FACTORY->true_value());
       if (false_target.is_linked()) {
         loaded.Jump();
         false_target.Bind();
-        frame_->Push(Factory::false_value());
+        frame_->Push(FACTORY->false_value());
         loaded.Bind();
       }
 
     } else {
       // We have a valid value on top of the frame, but we still may
       // have dangling jumps to the true and false targets from nested
       // subexpressions (eg, the left subexpressions of the
       // short-circuited boolean operators).
       ASSERT(has_valid_frame());
       if (true_target.is_linked() || false_target.is_linked()) {
         JumpTarget loaded;
         loaded.Jump();  // Don't lose the current TOS.
         if (true_target.is_linked()) {
           true_target.Bind();
-          frame_->Push(Factory::true_value());
+          frame_->Push(FACTORY->true_value());
           if (false_target.is_linked()) {
             loaded.Jump();
           }
         }
         if (false_target.is_linked()) {
           false_target.Bind();
-          frame_->Push(Factory::false_value());
+          frame_->Push(FACTORY->false_value());
         }
         loaded.Bind();
       }
     }
   }
   ASSERT(has_valid_frame());
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
@@ skipping 57 matching lines @@
 
 Result CodeGenerator::StoreArgumentsObject(bool initial) {
   ArgumentsAllocationMode mode = ArgumentsMode();
   ASSERT(mode != NO_ARGUMENTS_ALLOCATION);
 
   Comment cmnt(masm_, "[ store arguments object");
   if (mode == LAZY_ARGUMENTS_ALLOCATION && initial) {
     // When using lazy arguments allocation, we store the arguments marker value
     // as a sentinel indicating that the arguments object hasn't been
     // allocated yet.
-    frame_->Push(Factory::arguments_marker());
+    frame_->Push(FACTORY->arguments_marker());
   } else {
     ArgumentsAccessStub stub(is_strict_mode()
         ? ArgumentsAccessStub::NEW_STRICT
         : ArgumentsAccessStub::NEW_NON_STRICT);
     frame_->PushFunction();
     frame_->PushReceiverSlotAddress();
     frame_->Push(Smi::FromInt(scope()->num_parameters()));
     Result result = frame_->CallStub(&stub, 3);
     frame_->Push(&result);
   }
@@ skipping 11 matching lines @@
     // We have to skip storing into the arguments slot if it has
     // already been written to. This can happen if the a function
     // has a local variable named 'arguments'.
     LoadFromSlot(arguments->AsSlot(), NOT_INSIDE_TYPEOF);
     Result probe = frame_->Pop();
     if (probe.is_constant()) {
       // We have to skip updating the arguments object if it has
       // been assigned a proper value.
       skip_arguments = !probe.handle()->IsArgumentsMarker();
     } else {
-      __ cmp(Operand(probe.reg()), Immediate(Factory::arguments_marker()));
+      __ cmp(Operand(probe.reg()), Immediate(FACTORY->arguments_marker()));
       probe.Unuse();
       done.Branch(not_equal);
     }
   }
   if (!skip_arguments) {
     StoreToSlot(arguments->AsSlot(), NOT_CONST_INIT);
     if (mode == LAZY_ARGUMENTS_ALLOCATION) done.Bind();
   }
   if (shadow != NULL) {
     StoreToSlot(shadow->AsSlot(), NOT_CONST_INIT);
@@ skipping 110 matching lines @@
     __ test(value.reg(), Immediate(kSmiTagMask));
     dest->true_target()->Branch(zero);
     __ fldz();
     __ fld_d(FieldOperand(value.reg(), HeapNumber::kValueOffset));
     __ FCmp();
     value.Unuse();
     dest->Split(not_zero);
   } else {
     // Fast case checks.
     // 'false' => false.
-    __ cmp(value.reg(), Factory::false_value());
+    __ cmp(value.reg(), FACTORY->false_value());
     dest->false_target()->Branch(equal);
 
     // 'true' => true.
-    __ cmp(value.reg(), Factory::true_value());
+    __ cmp(value.reg(), FACTORY->true_value());
     dest->true_target()->Branch(equal);
 
     // 'undefined' => false.
-    __ cmp(value.reg(), Factory::undefined_value());
+    __ cmp(value.reg(), FACTORY->undefined_value());
     dest->false_target()->Branch(equal);
 
     // Smi => false iff zero.
     STATIC_ASSERT(kSmiTag == 0);
     __ test(value.reg(), Operand(value.reg()));
     dest->false_target()->Branch(zero);
     __ test(value.reg(), Immediate(kSmiTagMask));
     dest->true_target()->Branch(zero);
 
     // Call the stub for all other cases.
@@ skipping 50 matching lines @@
   TypeInfo right_info_;
   OverwriteMode mode_;
   Label answer_out_of_range_;
   Label non_smi_input_;
   Label constant_rhs_;
   Smi* smi_value_;
 };
 
 
 Label* DeferredInlineBinaryOperation::NonSmiInputLabel() {
-  if (Token::IsBitOp(op_) && CpuFeatures::IsSupported(SSE2)) {
+  if (Token::IsBitOp(op_) &&
+      Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     return &non_smi_input_;
   } else {
     return entry_label();
   }
 }
 
 
 void DeferredInlineBinaryOperation::JumpToAnswerOutOfRange(Condition cond) {
   __ j(cond, &answer_out_of_range_);
 }
 
 
 void DeferredInlineBinaryOperation::JumpToConstantRhs(Condition cond,
                                                       Smi* smi_value) {
   smi_value_ = smi_value;
   __ j(cond, &constant_rhs_);
 }
 
 
 void DeferredInlineBinaryOperation::Generate() {
   // Registers are not saved implicitly for this stub, so we should not
   // tread on the registers that were not passed to us.
-  if (CpuFeatures::IsSupported(SSE2) &&
+  if (Isolate::Current()->cpu_features()->IsSupported(SSE2) &&
       ((op_ == Token::ADD) ||
        (op_ == Token::SUB) ||
        (op_ == Token::MUL) ||
        (op_ == Token::DIV))) {
     CpuFeatures::Scope use_sse2(SSE2);
     Label call_runtime, after_alloc_failure;
     Label left_smi, right_smi, load_right, do_op;
     if (!left_info_.IsSmi()) {
       __ test(left_, Immediate(kSmiTagMask));
       __ j(zero, &left_smi);
       if (!left_info_.IsNumber()) {
         __ cmp(FieldOperand(left_, HeapObject::kMapOffset),
-               Factory::heap_number_map());
+               FACTORY->heap_number_map());
         __ j(not_equal, &call_runtime);
       }
       __ movdbl(xmm0, FieldOperand(left_, HeapNumber::kValueOffset));
       if (mode_ == OVERWRITE_LEFT) {
         __ mov(dst_, left_);
       }
       __ jmp(&load_right);
 
       __ bind(&left_smi);
     } else {
       if (FLAG_debug_code) __ AbortIfNotSmi(left_);
     }
     __ SmiUntag(left_);
     __ cvtsi2sd(xmm0, Operand(left_));
     __ SmiTag(left_);
     if (mode_ == OVERWRITE_LEFT) {
       Label alloc_failure;
       __ push(left_);
       __ AllocateHeapNumber(dst_, left_, no_reg, &after_alloc_failure);
       __ pop(left_);
     }
 
     __ bind(&load_right);
     if (!right_info_.IsSmi()) {
       __ test(right_, Immediate(kSmiTagMask));
       __ j(zero, &right_smi);
       if (!right_info_.IsNumber()) {
         __ cmp(FieldOperand(right_, HeapObject::kMapOffset),
-               Factory::heap_number_map());
+               FACTORY->heap_number_map());
         __ j(not_equal, &call_runtime);
       }
       __ movdbl(xmm1, FieldOperand(right_, HeapNumber::kValueOffset));
       if (mode_ == OVERWRITE_RIGHT) {
         __ mov(dst_, right_);
       } else if (mode_ == NO_OVERWRITE) {
         Label alloc_failure;
         __ push(left_);
         __ AllocateHeapNumber(dst_, left_, no_reg, &after_alloc_failure);
         __ pop(left_);
@@ skipping 73 matching lines @@
   }
 
   __ bind(&non_smi_input_);
 
   if (rhs_is_constant) {
     __ bind(&constant_rhs_);
     // In this case the input is a heap object and it is in the dst_ register.
     // The left_ and right_ registers have not been initialized yet.
     __ mov(right_, Immediate(smi_value_));
     __ mov(left_, Operand(dst_));
-    if (!CpuFeatures::IsSupported(SSE2)) {
+    if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
       __ jmp(entry_label());
       return;
     } else {
       CpuFeatures::Scope use_sse2(SSE2);
       __ JumpIfNotNumber(dst_, left_info_, entry_label());
       __ ConvertToInt32(dst_, left_, dst_, left_info_, entry_label());
       __ SmiUntag(right_);
     }
   } else {
     // We know we have SSE2 here because otherwise the label is not linked (see
@@ skipping 92 matching lines @@
   // Put a heap number pointer in left_.
   __ bind(&answer_out_of_range_);
   SaveRegisters();
   if (mode_ == OVERWRITE_LEFT) {
     __ test(left_, Immediate(kSmiTagMask));
     __ j(not_zero, &allocation_ok);
   }
   // This trashes right_.
   __ AllocateHeapNumber(left_, right_, no_reg, &after_alloc_failure2);
   __ bind(&allocation_ok);
-  if (CpuFeatures::IsSupported(SSE2) && op_ != Token::SHR) {
+  if (Isolate::Current()->cpu_features()->IsSupported(SSE2) &&
+      op_ != Token::SHR) {
     CpuFeatures::Scope use_sse2(SSE2);
     ASSERT(Token::IsBitOp(op_));
     // Signed conversion.
     __ cvtsi2sd(xmm0, Operand(dst_));
     __ movdbl(FieldOperand(left_, HeapNumber::kValueOffset), xmm0);
   } else {
     if (op_ == Token::SHR) {
       __ push(Immediate(0));  // High word of unsigned value.
       __ push(dst_);
       __ fild_d(Operand(esp, 0));
@@ skipping 221 matching lines @@
     return frame_->CallStub(stub, left, right);
   } else {
     frame_->Push(left);
     frame_->Push(right);
     return frame_->CallStub(stub, 2);
   }
 }
 
 
 bool CodeGenerator::FoldConstantSmis(Token::Value op, int left, int right) {
-  Object* answer_object = Heap::undefined_value();
+  Object* answer_object = HEAP->undefined_value();
   switch (op) {
     case Token::ADD:
       if (Smi::IsValid(left + right)) {
         answer_object = Smi::FromInt(left + right);
       }
       break;
     case Token::SUB:
       if (Smi::IsValid(left - right)) {
         answer_object = Smi::FromInt(left - right);
       }
@@ skipping 51 matching lines @@
           unsigned_left >>= shift_amount;
         }
         ASSERT(Smi::IsValid(static_cast<int32_t>(unsigned_left)));
         answer_object = Smi::FromInt(static_cast<int32_t>(unsigned_left));
         break;
       }
     default:
       UNREACHABLE();
       break;
   }
-  if (answer_object == Heap::undefined_value()) {
+  if (answer_object->IsUndefined()) {
     return false;
   }
   frame_->Push(Handle<Object>(answer_object));
   return true;
 }
 
 
 void CodeGenerator::JumpIfBothSmiUsingTypeInfo(Result* left,
                                                Result* right,
                                                JumpTarget* both_smi) {
@@ skipping 1428 matching lines @@
         dest->false_target()->Branch(zero);
       } else {
         // Do the smi check, then the comparison.
         __ test(left_reg, Immediate(kSmiTagMask));
         is_smi.Branch(zero, left_side, right_side);
       }
 
       // Jump or fall through to here if we are comparing a non-smi to a
       // constant smi.  If the non-smi is a heap number and this is not
       // a loop condition, inline the floating point code.
-      if (!is_loop_condition && CpuFeatures::IsSupported(SSE2)) {
+      if (!is_loop_condition &&
+          Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
         // Right side is a constant smi and left side has been checked
         // not to be a smi.
         CpuFeatures::Scope use_sse2(SSE2);
         JumpTarget not_number;
         __ cmp(FieldOperand(left_reg, HeapObject::kMapOffset),
-               Immediate(Factory::heap_number_map()));
+               Immediate(FACTORY->heap_number_map()));
         not_number.Branch(not_equal, left_side);
         __ movdbl(xmm1,
                   FieldOperand(left_reg, HeapNumber::kValueOffset));
         int value = Smi::cast(*right_val)->value();
         if (value == 0) {
           __ xorpd(xmm0, xmm0);
         } else {
           Result temp = allocator()->Allocate();
           __ mov(temp.reg(), Immediate(value));
           __ cvtsi2sd(xmm0, Operand(temp.reg()));
@@ skipping 45 matching lines @@
                                    Result* operand,
                                    Result* left_side,
                                    Result* right_side,
                                    JumpTarget* not_numbers) {
   // Perform check if operand is not known to be a number.
   if (!operand->type_info().IsNumber()) {
     Label done;
     __ test(operand->reg(), Immediate(kSmiTagMask));
     __ j(zero, &done);
     __ cmp(FieldOperand(operand->reg(), HeapObject::kMapOffset),
-           Immediate(Factory::heap_number_map()));
+           Immediate(FACTORY->heap_number_map()));
     not_numbers->Branch(not_equal, left_side, right_side, not_taken);
     __ bind(&done);
   }
 }
 
 
 // Load a comparison operand to the FPU stack. This assumes that the operand has
 // already been checked and is a number.
 static void LoadComparisonOperand(MacroAssembler* masm_,
                                   Result* operand) {
@@ skipping 46 matching lines @@
     __ SmiUntag(operand->reg());
     __ cvtsi2sd(xmm_reg, Operand(operand->reg()));
     __ SmiTag(operand->reg());
   } else {
     // Operand type not known, check for smi or heap number.
     Label smi;
     __ test(operand->reg(), Immediate(kSmiTagMask));
     __ j(zero, &smi);
     if (!operand->type_info().IsNumber()) {
       __ cmp(FieldOperand(operand->reg(), HeapObject::kMapOffset),
-             Immediate(Factory::heap_number_map()));
+             Immediate(FACTORY->heap_number_map()));
       not_numbers->Branch(not_equal, left_side, right_side, taken);
     }
     __ movdbl(xmm_reg, FieldOperand(operand->reg(), HeapNumber::kValueOffset));
     __ jmp(&done);
 
     __ bind(&smi);
     // Comvert smi to float and keep the original smi.
     __ SmiUntag(operand->reg());
     __ cvtsi2sd(xmm_reg, Operand(operand->reg()));
     __ SmiTag(operand->reg());
     __ jmp(&done);
   }
   __ bind(&done);
 }
 
 
 void CodeGenerator::GenerateInlineNumberComparison(Result* left_side,
                                                    Result* right_side,
                                                    Condition cc,
                                                    ControlDestination* dest) {
   ASSERT(left_side->is_register());
   ASSERT(right_side->is_register());
 
   JumpTarget not_numbers;
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope use_sse2(SSE2);
 
     // Load left and right operand into registers xmm0 and xmm1 and compare.
     LoadComparisonOperandSSE2(masm_, left_side, xmm0, left_side, right_side,
                               &not_numbers);
     LoadComparisonOperandSSE2(masm_, right_side, xmm1, left_side, right_side,
                               &not_numbers);
     __ ucomisd(xmm0, xmm1);
   } else {
     Label check_right, compare;
@@ skipping 61 matching lines @@
   // stack, as receiver and arguments, and calls x.
   // In the implementation comments, we call x the applicand
   // and y the receiver.
   ASSERT(ArgumentsMode() == LAZY_ARGUMENTS_ALLOCATION);
   ASSERT(arguments->IsArguments());
 
   // Load applicand.apply onto the stack. This will usually
   // give us a megamorphic load site. Not super, but it works.
   Load(applicand);
   frame()->Dup();
-  Handle<String> name = Factory::LookupAsciiSymbol("apply");
+  Handle<String> name = FACTORY->LookupAsciiSymbol("apply");
   frame()->Push(name);
   Result answer = frame()->CallLoadIC(RelocInfo::CODE_TARGET);
   __ nop();
   frame()->Push(&answer);
 
   // Load the receiver and the existing arguments object onto the
   // expression stack. Avoid allocating the arguments object here.
   Load(receiver);
   LoadFromSlot(scope()->arguments()->AsSlot(), NOT_INSIDE_TYPEOF);
 
@@ skipping 11 matching lines @@
   // from the stack. This also deals with cases where a local variable
   // named 'arguments' has been introduced.
   frame_->Dup();
   Result probe = frame_->Pop();
   { VirtualFrame::SpilledScope spilled_scope;
     Label slow, done;
     bool try_lazy = true;
     if (probe.is_constant()) {
       try_lazy = probe.handle()->IsArgumentsMarker();
     } else {
-      __ cmp(Operand(probe.reg()), Immediate(Factory::arguments_marker()));
+      __ cmp(Operand(probe.reg()), Immediate(FACTORY->arguments_marker()));
       probe.Unuse();
       __ j(not_equal, &slow);
     }
 
     if (try_lazy) {
       Label build_args;
       // Get rid of the arguments object probe.
       frame_->Drop();  // Can be called on a spilled frame.
       // Stack now has 3 elements on it.
       // Contents of stack at this point:
@@ skipping 15 matching lines @@
       __ j(below, &build_args);
 
       // Check that applicand.apply is Function.prototype.apply.
       __ mov(eax, Operand(esp, kPointerSize));
       __ test(eax, Immediate(kSmiTagMask));
       __ j(zero, &build_args);
       __ CmpObjectType(eax, JS_FUNCTION_TYPE, ecx);
       __ j(not_equal, &build_args);
       __ mov(ecx, FieldOperand(eax, JSFunction::kCodeEntryOffset));
       __ sub(Operand(ecx), Immediate(Code::kHeaderSize - kHeapObjectTag));
-      Handle<Code> apply_code(Builtins::builtin(Builtins::FunctionApply));
+      Handle<Code> apply_code(Isolate::Current()->builtins()->builtin(
+          Builtins::FunctionApply));
       __ cmp(Operand(ecx), Immediate(apply_code));
       __ j(not_equal, &build_args);
 
       // Check that applicand is a function.
       __ mov(edi, Operand(esp, 2 * kPointerSize));
       __ test(edi, Immediate(kSmiTagMask));
       __ j(zero, &build_args);
       __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
       __ j(not_equal, &build_args);
 
@@ skipping 206 matching lines @@
     frame_->EmitPush(Immediate(var->name()));
     // Declaration nodes are always introduced in one of two modes.
     ASSERT(node->mode() == Variable::VAR || node->mode() == Variable::CONST);
     PropertyAttributes attr = node->mode() == Variable::VAR ? NONE : READ_ONLY;
     frame_->EmitPush(Immediate(Smi::FromInt(attr)));
     // Push initial value, if any.
     // Note: For variables we must not push an initial value (such as
     // 'undefined') because we may have a (legal) redeclaration and we
     // must not destroy the current value.
     if (node->mode() == Variable::CONST) {
-      frame_->EmitPush(Immediate(Factory::the_hole_value()));
+      frame_->EmitPush(Immediate(FACTORY->the_hole_value()));
     } else if (node->fun() != NULL) {
       Load(node->fun());
     } else {
       frame_->EmitPush(Immediate(Smi::FromInt(0)));  // no initial value!
     }
     Result ignored = frame_->CallRuntime(Runtime::kDeclareContextSlot, 4);
     // Ignore the return value (declarations are statements).
     return;
   }
 
   ASSERT(!var->is_global());
 
   // If we have a function or a constant, we need to initialize the variable.
   Expression* val = NULL;
   if (node->mode() == Variable::CONST) {
-    val = new Literal(Factory::the_hole_value());
+    val = new Literal(FACTORY->the_hole_value());
   } else {
     val = node->fun();  // NULL if we don't have a function
   }
 
   if (val != NULL) {
     {
       // Set the initial value.
       Reference target(this, node->proxy());
       Load(val);
       target.SetValue(NOT_CONST_INIT);
@@ skipping 760 matching lines @@
   JumpTarget exit;
 
   // Get the object to enumerate over (converted to JSObject).
   LoadAndSpill(node->enumerable());
 
   // Both SpiderMonkey and kjs ignore null and undefined in contrast
   // to the specification.  12.6.4 mandates a call to ToObject.
   frame_->EmitPop(eax);
 
   // eax: value to be iterated over
-  __ cmp(eax, Factory::undefined_value());
+  __ cmp(eax, FACTORY->undefined_value());
   exit.Branch(equal);
-  __ cmp(eax, Factory::null_value());
+  __ cmp(eax, FACTORY->null_value());
   exit.Branch(equal);
 
   // Stack layout in body:
   // [iteration counter (smi)] <- slot 0
   // [length of array]         <- slot 1
   // [FixedArray]              <- slot 2
   // [Map or 0]                <- slot 3
   // [Object]                  <- slot 4
 
   // Check if enumerable is already a JSObject
@@ skipping 18 matching lines @@
   // guarantee cache validity, call the runtime system to check cache
   // validity or get the property names in a fixed array.
   JumpTarget call_runtime;
   JumpTarget loop(JumpTarget::BIDIRECTIONAL);
   JumpTarget check_prototype;
   JumpTarget use_cache;
   __ mov(ecx, eax);
   loop.Bind();
   // Check that there are no elements.
   __ mov(edx, FieldOperand(ecx, JSObject::kElementsOffset));
-  __ cmp(Operand(edx), Immediate(Factory::empty_fixed_array()));
+  __ cmp(Operand(edx), Immediate(FACTORY->empty_fixed_array()));
   call_runtime.Branch(not_equal);
   // Check that instance descriptors are not empty so that we can
   // check for an enum cache.  Leave the map in ebx for the subsequent
   // prototype load.
   __ mov(ebx, FieldOperand(ecx, HeapObject::kMapOffset));
   __ mov(edx, FieldOperand(ebx, Map::kInstanceDescriptorsOffset));
-  __ cmp(Operand(edx), Immediate(Factory::empty_descriptor_array()));
+  __ cmp(Operand(edx), Immediate(FACTORY->empty_descriptor_array()));
   call_runtime.Branch(equal);
   // Check that there in an enum cache in the non-empty instance
   // descriptors.  This is the case if the next enumeration index
   // field does not contain a smi.
   __ mov(edx, FieldOperand(edx, DescriptorArray::kEnumerationIndexOffset));
   __ test(edx, Immediate(kSmiTagMask));
   call_runtime.Branch(zero);
   // For all objects but the receiver, check that the cache is empty.
   __ cmp(ecx, Operand(eax));
   check_prototype.Branch(equal);
   __ mov(edx, FieldOperand(edx, DescriptorArray::kEnumCacheBridgeCacheOffset));
-  __ cmp(Operand(edx), Immediate(Factory::empty_fixed_array()));
+  __ cmp(Operand(edx), Immediate(FACTORY->empty_fixed_array()));
   call_runtime.Branch(not_equal);
   check_prototype.Bind();
   // Load the prototype from the map and loop if non-null.
   __ mov(ecx, FieldOperand(ebx, Map::kPrototypeOffset));
-  __ cmp(Operand(ecx), Immediate(Factory::null_value()));
+  __ cmp(Operand(ecx), Immediate(FACTORY->null_value()));
   loop.Branch(not_equal);
   // The enum cache is valid.  Load the map of the object being
   // iterated over and use the cache for the iteration.
   __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));
   use_cache.Jump();
 
   call_runtime.Bind();
   // Call the runtime to get the property names for the object.
   frame_->EmitPush(eax);  // push the Object (slot 4) for the runtime call
   frame_->CallRuntime(Runtime::kGetPropertyNamesFast, 1);
 
   // If we got a map from the runtime call, we can do a fast
   // modification check. Otherwise, we got a fixed array, and we have
   // to do a slow check.
   // eax: map or fixed array (result from call to
   // Runtime::kGetPropertyNamesFast)
   __ mov(edx, Operand(eax));
   __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
-  __ cmp(ecx, Factory::meta_map());
+  __ cmp(ecx, FACTORY->meta_map());
   fixed_array.Branch(not_equal);
 
   use_cache.Bind();
   // Get enum cache
   // eax: map (either the result from a call to
   // Runtime::kGetPropertyNamesFast or has been fetched directly from
   // the object)
   __ mov(ecx, Operand(eax));
 
   __ mov(ecx, FieldOperand(ecx, Map::kInstanceDescriptorsOffset));
@@ skipping 171 matching lines @@
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   bool has_unlinks = false;
   for (int i = 0; i < shadows.length(); i++) {
     shadows[i]->StopShadowing();
     has_unlinks = has_unlinks || shadows[i]->is_linked();
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // Get an external reference to the handler address.
-  ExternalReference handler_address(Top::k_handler_address);
+  ExternalReference handler_address(Isolate::k_handler_address);
 
   // Make sure that there's nothing left on the stack above the
   // handler structure.
   if (FLAG_debug_code) {
     __ mov(eax, Operand::StaticVariable(handler_address));
     __ cmp(esp, Operand(eax));
     __ Assert(equal, "stack pointer should point to top handler");
   }
 
   // If we can fall off the end of the try block, unlink from try chain.
@@ skipping 105 matching lines @@
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   int nof_unlinks = 0;
   for (int i = 0; i < shadows.length(); i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // Get an external reference to the handler address.
-  ExternalReference handler_address(Top::k_handler_address);
+  ExternalReference handler_address(Isolate::k_handler_address);
 
   // If we can fall off the end of the try block, unlink from the try
   // chain and set the state on the frame to FALLING.
   if (has_valid_frame()) {
     // The next handler address is on top of the frame.
     STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
     frame_->EmitPop(Operand::StaticVariable(handler_address));
     frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
 
     // Fake a top of stack value (unneeded when FALLING) and set the
     // state in ecx, then jump around the unlink blocks if any.
-    frame_->EmitPush(Immediate(Factory::undefined_value()));
+    frame_->EmitPush(Immediate(FACTORY->undefined_value()));
     __ Set(ecx, Immediate(Smi::FromInt(FALLING)));
     if (nof_unlinks > 0) {
       finally_block.Jump();
     }
   }
 
   // Generate code to unlink and set the state for the (formerly)
   // shadowing targets that have been jumped to.
   for (int i = 0; i < shadows.length(); i++) {
     if (shadows[i]->is_linked()) {
@@ skipping 22 matching lines @@
       STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
       frame_->EmitPop(Operand::StaticVariable(handler_address));
       frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
 
       if (i == kReturnShadowIndex) {
         // If this target shadowed the function return, materialize
         // the return value on the stack.
         frame_->EmitPush(eax);
       } else {
         // Fake TOS for targets that shadowed breaks and continues.
-        frame_->EmitPush(Immediate(Factory::undefined_value()));
+        frame_->EmitPush(Immediate(FACTORY->undefined_value()));
       }
       __ Set(ecx, Immediate(Smi::FromInt(JUMPING + i)));
       if (--nof_unlinks > 0) {
         // If this is not the last unlink block, jump around the next.
         finally_block.Jump();
       }
     }
   }
 
   // --- Finally block ---
@@ skipping 87 matching lines @@
     FastNewClosureStub stub(
         function_info->strict_mode() ? kStrictMode : kNonStrictMode);
     frame()->EmitPush(Immediate(function_info));
     return frame()->CallStub(&stub, 1);
   } else {
     // Call the runtime to instantiate the function based on the
     // shared function info.
     frame()->EmitPush(esi);
     frame()->EmitPush(Immediate(function_info));
     frame()->EmitPush(Immediate(pretenure
-                                ? Factory::true_value()
-                                : Factory::false_value()));
+                                ? FACTORY->true_value()
+                                : FACTORY->false_value()));
     return frame()->CallRuntime(Runtime::kNewClosure, 3);
   }
 }
 
 
 void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) {
   Comment cmnt(masm_, "[ FunctionLiteral");
   ASSERT(!in_safe_int32_mode());
   // Build the function info and instantiate it.
   Handle<SharedFunctionInfo> function_info =
@@ skipping 87 matching lines @@
     // Const slots may contain 'the hole' value (the constant hasn't been
     // initialized yet) which needs to be converted into the 'undefined'
     // value.
     //
     // We currently spill the virtual frame because constants use the
     // potentially unsafe direct-frame access of SlotOperand.
     VirtualFrame::SpilledScope spilled_scope;
     Comment cmnt(masm_, "[ Load const");
     Label exit;
     __ mov(ecx, SlotOperand(slot, ecx));
-    __ cmp(ecx, Factory::the_hole_value());
+    __ cmp(ecx, FACTORY->the_hole_value());
     __ j(not_equal, &exit);
-    __ mov(ecx, Factory::undefined_value());
+    __ mov(ecx, FACTORY->undefined_value());
     __ bind(&exit);
     frame()->EmitPush(ecx);
 
   } else if (slot->type() == Slot::PARAMETER) {
     frame()->PushParameterAt(slot->index());
 
   } else if (slot->type() == Slot::LOCAL) {
     frame()->PushLocalAt(slot->index());
 
   } else {
@@ skipping 29 matching lines @@
       result = StoreArgumentsObject(false);
     }
     frame()->Push(&result);
     return;
   }
   ASSERT(result.is_register());
   // The loaded value is in a register. If it is the sentinel that
   // indicates that we haven't loaded the arguments object yet, we
   // need to do it now.
   JumpTarget exit;
-  __ cmp(Operand(result.reg()), Immediate(Factory::arguments_marker()));
+  __ cmp(Operand(result.reg()), Immediate(FACTORY->arguments_marker()));
   frame()->Push(&result);
   exit.Branch(not_equal);
 
   result = StoreArgumentsObject(false);
   frame()->SetElementAt(0, &result);
   result.Unuse();
   exit.Bind();
   return;
 }
 
@@ skipping 33 matching lines @@
   if (s != NULL && s->is_eval_scope()) {
     // Loop up the context chain.  There is no frame effect so it is
     // safe to use raw labels here.
     Label next, fast;
     if (!context.is(tmp.reg())) {
       __ mov(tmp.reg(), context);
     }
     __ bind(&next);
     // Terminate at global context.
     __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
-           Immediate(Factory::global_context_map()));
+           Immediate(FACTORY->global_context_map()));
     __ j(equal, &fast);
     // Check that extension is NULL.
     __ cmp(ContextOperand(tmp.reg(), Context::EXTENSION_INDEX), Immediate(0));
     slow->Branch(not_equal, not_taken);
     // Load next context in chain.
     __ mov(tmp.reg(), ContextOperand(tmp.reg(), Context::CLOSURE_INDEX));
     __ mov(tmp.reg(), FieldOperand(tmp.reg(), JSFunction::kContextOffset));
     __ jmp(&next);
     __ bind(&fast);
   }
@@ skipping 39 matching lines @@
     if (potential_slot != NULL) {
       // Generate fast case for locals that rewrite to slots.
       // Allocate a fresh register to use as a temp in
       // ContextSlotOperandCheckExtensions and to hold the result
       // value.
       *result = allocator()->Allocate();
       ASSERT(result->is_valid());
       __ mov(result->reg(),
              ContextSlotOperandCheckExtensions(potential_slot, *result, slow));
       if (potential_slot->var()->mode() == Variable::CONST) {
-        __ cmp(result->reg(), Factory::the_hole_value());
+        __ cmp(result->reg(), FACTORY->the_hole_value());
         done->Branch(not_equal, result);
-        __ mov(result->reg(), Factory::undefined_value());
+        __ mov(result->reg(), FACTORY->undefined_value());
       }
       done->Jump(result);
     } else if (rewrite != NULL) {
       // Generate fast case for calls of an argument function.
       Property* property = rewrite->AsProperty();
       if (property != NULL) {
         VariableProxy* obj_proxy = property->obj()->AsVariableProxy();
         Literal* key_literal = property->key()->AsLiteral();
         if (obj_proxy != NULL &&
             key_literal != NULL &&
@@ skipping 66 matching lines @@
       // Only the first const initialization must be executed (the slot
       // still contains 'the hole' value). When the assignment is executed,
       // the code is identical to a normal store (see below).
       //
       // We spill the frame in the code below because the direct-frame
       // access of SlotOperand is potentially unsafe with an unspilled
       // frame.
       VirtualFrame::SpilledScope spilled_scope;
       Comment cmnt(masm_, "[ Init const");
       __ mov(ecx, SlotOperand(slot, ecx));
-      __ cmp(ecx, Factory::the_hole_value());
+      __ cmp(ecx, FACTORY->the_hole_value());
       exit.Branch(not_equal);
     }
 
     // We must execute the store.  Storing a variable must keep the (new)
     // value on the stack. This is necessary for compiling assignment
     // expressions.
     //
     // Note: We will reach here even with slot->var()->mode() ==
     // Variable::CONST because of const declarations which will initialize
     // consts to 'the hole' value and by doing so, end up calling this code.
@@ skipping 150 matching lines @@
   if (!boilerplate_.is(eax)) __ mov(boilerplate_, eax);
 }
 
 
 class DeferredAllocateInNewSpace: public DeferredCode {
  public:
   DeferredAllocateInNewSpace(int size,
                              Register target,
                              int registers_to_save = 0)
     : size_(size), target_(target), registers_to_save_(registers_to_save) {
-    ASSERT(size >= kPointerSize && size <= Heap::MaxObjectSizeInNewSpace());
+    ASSERT(size >= kPointerSize && size <= HEAP->MaxObjectSizeInNewSpace());
     ASSERT_EQ(0, registers_to_save & target.bit());
     set_comment("[ DeferredAllocateInNewSpace");
   }
   void Generate();
 
  private:
   int size_;
   Register target_;
   int registers_to_save_;
 };
@@ skipping 40 matching lines @@
   Result boilerplate = allocator_->Allocate();
   ASSERT(boilerplate.is_valid());
   int literal_offset =
       FixedArray::kHeaderSize + node->literal_index() * kPointerSize;
   __ mov(boilerplate.reg(), FieldOperand(literals.reg(), literal_offset));
 
   // Check whether we need to materialize the RegExp object.  If so,
   // jump to the deferred code passing the literals array.
   DeferredRegExpLiteral* deferred =
       new DeferredRegExpLiteral(boilerplate.reg(), literals.reg(), node);
-  __ cmp(boilerplate.reg(), Factory::undefined_value());
+  __ cmp(boilerplate.reg(), FACTORY->undefined_value());
   deferred->Branch(equal);
   deferred->BindExit();
 
   // Register of boilerplate contains RegExp object.
 
   Result tmp = allocator()->Allocate();
   ASSERT(tmp.is_valid());
 
   int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
 
@@ skipping 137 matching lines @@
 
   // Load the literals array of the function.
   __ mov(literals.reg(),
          FieldOperand(literals.reg(), JSFunction::kLiteralsOffset));
 
   frame_->Push(&literals);
   frame_->Push(Smi::FromInt(node->literal_index()));
   frame_->Push(node->constant_elements());
   int length = node->values()->length();
   Result clone;
-  if (node->constant_elements()->map() == Heap::fixed_cow_array_map()) {
+  if (node->constant_elements()->map() == HEAP->fixed_cow_array_map()) {
     FastCloneShallowArrayStub stub(
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS, length);
     clone = frame_->CallStub(&stub, 3);
-    __ IncrementCounter(&Counters::cow_arrays_created_stub, 1);
+    __ IncrementCounter(COUNTERS->cow_arrays_created_stub(), 1);
   } else if (node->depth() > 1) {
     clone = frame_->CallRuntime(Runtime::kCreateArrayLiteral, 3);
   } else if (length > FastCloneShallowArrayStub::kMaximumClonedLength) {
     clone = frame_->CallRuntime(Runtime::kCreateArrayLiteralShallow, 3);
   } else {
     FastCloneShallowArrayStub stub(
         FastCloneShallowArrayStub::CLONE_ELEMENTS, length);
     clone = frame_->CallStub(&stub, 3);
   }
   frame_->Push(&clone);
@@ skipping 382 matching lines @@
 
     // In a call to eval, we first call %ResolvePossiblyDirectEval to
     // resolve the function we need to call and the receiver of the
     // call.  Then we call the resolved function using the given
     // arguments.
 
     // Prepare the stack for the call to the resolved function.
     Load(function);
 
     // Allocate a frame slot for the receiver.
-    frame_->Push(Factory::undefined_value());
+    frame_->Push(FACTORY->undefined_value());
 
     // Load the arguments.
     int arg_count = args->length();
     for (int i = 0; i < arg_count; i++) {
       Load(args->at(i));
       frame_->SpillTop();
     }
 
     // Result to hold the result of the function resolution and the
     // final result of the eval call.
@@ skipping 11 matching lines @@
       // ResolvePossiblyDirectEvalNoLookup by pushing the loaded
       // function, the first argument to the eval call and the
       // receiver.
       Result fun = LoadFromGlobalSlotCheckExtensions(var->AsSlot(),
                                                      NOT_INSIDE_TYPEOF,
                                                      &slow);
       frame_->Push(&fun);
       if (arg_count > 0) {
         frame_->PushElementAt(arg_count);
       } else {
-        frame_->Push(Factory::undefined_value());
+        frame_->Push(FACTORY->undefined_value());
       }
       frame_->PushParameterAt(-1);
 
       // Push the strict mode flag.
       frame_->Push(Smi::FromInt(strict_mode_flag()));
 
       // Resolve the call.
       result =
           frame_->CallRuntime(Runtime::kResolvePossiblyDirectEvalNoLookup, 4);
 
       done.Jump(&result);
       slow.Bind();
     }
 
     // Prepare the stack for the call to ResolvePossiblyDirectEval by
     // pushing the loaded function, the first argument to the eval
     // call and the receiver.
     frame_->PushElementAt(arg_count + 1);
     if (arg_count > 0) {
       frame_->PushElementAt(arg_count);
     } else {
-      frame_->Push(Factory::undefined_value());
+      frame_->Push(FACTORY->undefined_value());
     }
     frame_->PushParameterAt(-1);
 
     // Push the strict mode flag.
     frame_->Push(Smi::FromInt(strict_mode_flag()));
 
     // Resolve the call.
     result = frame_->CallRuntime(Runtime::kResolvePossiblyDirectEval, 4);
 
     // If we generated fast-case code bind the jump-target where fast
@@ skipping 273 matching lines @@
   //   2 (array): Arguments to the format string.
   ASSERT_EQ(args->length(), 3);
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (ShouldGenerateLog(args->at(0))) {
     Load(args->at(1));
     Load(args->at(2));
     frame_->CallRuntime(Runtime::kLog, 2);
   }
 #endif
   // Finally, we're expected to leave a value on the top of the stack.
-  frame_->Push(Factory::undefined_value());
+  frame_->Push(FACTORY->undefined_value());
 }
 
 
 void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   Load(args->at(0));
   Result value = frame_->Pop();
   value.ToRegister();
   ASSERT(value.is_valid());
   __ test(value.reg(), Immediate(kSmiTagMask | kSmiSignMask));
@@ skipping 22 matching lines @@
     return &char_code_at_generator_;
   }
 
   virtual void Generate() {
     VirtualFrameRuntimeCallHelper call_helper(frame_state());
     char_code_at_generator_.GenerateSlow(masm(), call_helper);
 
     __ bind(&need_conversion_);
     // Move the undefined value into the result register, which will
     // trigger conversion.
-    __ Set(result_, Immediate(Factory::undefined_value()));
+    __ Set(result_, Immediate(FACTORY->undefined_value()));
     __ jmp(exit_label());
 
     __ bind(&index_out_of_range_);
     // When the index is out of range, the spec requires us to return
     // NaN.
-    __ Set(result_, Immediate(Factory::nan_value()));
+    __ Set(result_, Immediate(FACTORY->nan_value()));
     __ jmp(exit_label());
   }
 
  private:
   Register result_;
 
   Label need_conversion_;
   Label index_out_of_range_;
 
   StringCharCodeAtGenerator char_code_at_generator_;
@@ skipping 102 matching lines @@
 
     __ bind(&need_conversion_);
     // Move smi zero into the result register, which will trigger
     // conversion.
     __ Set(result_, Immediate(Smi::FromInt(0)));
     __ jmp(exit_label());
 
     __ bind(&index_out_of_range_);
     // When the index is out of range, the spec requires us to return
     // the empty string.
-    __ Set(result_, Immediate(Factory::empty_string()));
+    __ Set(result_, Immediate(FACTORY->empty_string()));
     __ jmp(exit_label());
   }
 
  private:
   Register result_;
 
   Label need_conversion_;
   Label index_out_of_range_;
 
   StringCharAtGenerator char_at_generator_;
@@ skipping 97 matching lines @@
 
   // Check that the array has fast elements.
   __ test_b(FieldOperand(scratch, Map::kBitField2Offset),
             1 << Map::kHasFastElements);
   __ j(zero, &bailout);
 
   // If the array has length zero, return the empty string.
   __ mov(array_length, FieldOperand(array, JSArray::kLengthOffset));
   __ sar(array_length, 1);
   __ j(not_zero, &non_trivial_array);
-  __ mov(result_operand, Factory::empty_string());
+  __ mov(result_operand, FACTORY->empty_string());
   __ jmp(&done);
 
   // Save the array length.
   __ bind(&non_trivial_array);
   __ mov(array_length_operand, array_length);
 
   // Save the FixedArray containing array's elements.
   // End of array's live range.
   elements = array;
   __ mov(elements, FieldOperand(array, JSArray::kElementsOffset));
@@ skipping 190 matching lines @@
          FieldOperand(string, SeqAsciiString::kHeaderSize));
   __ CopyBytes(string, result_pos, string_length, scratch);
   __ add(Operand(index), Immediate(1));
 
   __ cmp(index, array_length_operand);
   __ j(less, &loop_3);  // End while (index < length).
   __ jmp(&done);
 
 
   __ bind(&bailout);
-  __ mov(result_operand, Factory::undefined_value());
+  __ mov(result_operand, FACTORY->undefined_value());
   __ bind(&done);
   __ mov(eax, result_operand);
   // Drop temp values from the stack, and restore context register.
   __ add(Operand(esp), Immediate(2 * kPointerSize));
 
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
   frame_->Drop(1);
   frame_->Push(&array_result);
 }
 
@@ skipping 20 matching lines @@
 void CodeGenerator::GenerateIsObject(ZoneList<Expression*>* args) {
   // This generates a fast version of:
   // (typeof(arg) === 'object' || %_ClassOf(arg) == 'RegExp')
   ASSERT(args->length() == 1);
   Load(args->at(0));
   Result obj = frame_->Pop();
   obj.ToRegister();
 
   __ test(obj.reg(), Immediate(kSmiTagMask));
   destination()->false_target()->Branch(zero);
-  __ cmp(obj.reg(), Factory::null_value());
+  __ cmp(obj.reg(), FACTORY->null_value());
   destination()->true_target()->Branch(equal);
 
   Result map = allocator()->Allocate();
   ASSERT(map.is_valid());
   __ mov(map.reg(), FieldOperand(obj.reg(), HeapObject::kMapOffset));
   // Undetectable objects behave like undefined when tested with typeof.
   __ test_b(FieldOperand(map.reg(), Map::kBitFieldOffset),
             1 << Map::kIsUndetectable);
   destination()->false_target()->Branch(not_zero);
   // Do a range test for JSObject type.  We can't use
@@ skipping 50 matching lines @@
 
     // Check that map is loaded as expected.
     if (FLAG_debug_code) {
       __ cmp(map_result_, FieldOperand(object_, HeapObject::kMapOffset));
       __ Assert(equal, "Map not in expected register");
     }
 
     // Check for fast case object. Generate false result for slow case object.
     __ mov(scratch1_, FieldOperand(object_, JSObject::kPropertiesOffset));
     __ mov(scratch1_, FieldOperand(scratch1_, HeapObject::kMapOffset));
-    __ cmp(scratch1_, Factory::hash_table_map());
+    __ cmp(scratch1_, FACTORY->hash_table_map());
     __ j(equal, &false_result);
 
     // Look for valueOf symbol in the descriptor array, and indicate false if
     // found. The type is not checked, so if it is a transition it is a false
     // negative.
     __ mov(map_result_,
            FieldOperand(map_result_, Map::kInstanceDescriptorsOffset));
     __ mov(scratch1_, FieldOperand(map_result_, FixedArray::kLengthOffset));
     // map_result_: descriptor array
     // scratch1_: length of descriptor array
     // Calculate the end of the descriptor array.
     STATIC_ASSERT(kSmiTag == 0);
     STATIC_ASSERT(kSmiTagSize == 1);
     STATIC_ASSERT(kPointerSize == 4);
     __ lea(scratch1_,
            Operand(map_result_, scratch1_, times_2, FixedArray::kHeaderSize));
     // Calculate location of the first key name.
     __ add(Operand(map_result_),
            Immediate(FixedArray::kHeaderSize +
                      DescriptorArray::kFirstIndex * kPointerSize));
     // Loop through all the keys in the descriptor array. If one of these is the
     // symbol valueOf the result is false.
     Label entry, loop;
     __ jmp(&entry);
     __ bind(&loop);
     __ mov(scratch2_, FieldOperand(map_result_, 0));
-    __ cmp(scratch2_, Factory::value_of_symbol());
+    __ cmp(scratch2_, FACTORY->value_of_symbol());
     __ j(equal, &false_result);
     __ add(Operand(map_result_), Immediate(kPointerSize));
     __ bind(&entry);
     __ cmp(map_result_, Operand(scratch1_));
     __ j(not_equal, &loop);
 
     // Reload map as register map_result_ was used as temporary above.
     __ mov(map_result_, FieldOperand(object_, HeapObject::kMapOffset));
 
     // If a valueOf property is not found on the object check that it's
@@ skipping 194 matching lines @@
   // instance class name from there.
   __ mov(obj.reg(),
          FieldOperand(obj.reg(), JSFunction::kSharedFunctionInfoOffset));
   __ mov(obj.reg(),
          FieldOperand(obj.reg(), SharedFunctionInfo::kInstanceClassNameOffset));
   frame_->Push(&obj);
   leave.Jump();
 
   // Functions have class 'Function'.
   function.Bind();
-  frame_->Push(Factory::function_class_symbol());
+  frame_->Push(FACTORY->function_class_symbol());
   leave.Jump();
 
   // Objects with a non-function constructor have class 'Object'.
   non_function_constructor.Bind();
-  frame_->Push(Factory::Object_symbol());
+  frame_->Push(FACTORY->Object_symbol());
   leave.Jump();
 
   // Non-JS objects have class null.
   null.Bind();
-  frame_->Push(Factory::null_value());
+  frame_->Push(FACTORY->null_value());
 
   // All done.
   leave.Bind();
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   JumpTarget leave;
   Load(args->at(0));  // Load the object.
@@ skipping 121 matching lines @@
 
   __ bind(&heapnumber_allocated);
 
   __ PrepareCallCFunction(0, ebx);
   __ CallCFunction(ExternalReference::random_uint32_function(), 0);
 
   // Convert 32 random bits in eax to 0.(32 random bits) in a double
   // by computing:
   // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
   // This is implemented on both SSE2 and FPU.
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope fscope(SSE2);
     __ mov(ebx, Immediate(0x49800000));  // 1.0 x 2^20 as single.
     __ movd(xmm1, Operand(ebx));
     __ movd(xmm0, Operand(eax));
     __ cvtss2sd(xmm1, xmm1);
     __ pxor(xmm0, xmm1);
     __ subsd(xmm0, xmm1);
     __ movdbl(FieldOperand(edi, HeapNumber::kValueOffset), xmm0);
   } else {
     // 0x4130000000000000 is 1.0 x 2^20 as a double.
@@ skipping 196 matching lines @@
 }
 
 
 void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) {
   ASSERT_EQ(2, args->length());
 
   ASSERT_NE(NULL, args->at(0)->AsLiteral());
   int cache_id = Smi::cast(*(args->at(0)->AsLiteral()->handle()))->value();
 
   Handle<FixedArray> jsfunction_result_caches(
-      Top::global_context()->jsfunction_result_caches());
+      Isolate::Current()->global_context()->jsfunction_result_caches());
   if (jsfunction_result_caches->length() <= cache_id) {
     __ Abort("Attempt to use undefined cache.");
-    frame_->Push(Factory::undefined_value());
+    frame_->Push(FACTORY->undefined_value());
     return;
   }
 
   Load(args->at(1));
   Result key = frame_->Pop();
   key.ToRegister();
 
   Result cache = allocator()->Allocate();
   ASSERT(cache.is_valid());
   __ mov(cache.reg(), ContextOperand(esi, Context::GLOBAL_INDEX));
@@ skipping 96 matching lines @@
   // has no indexed interceptor.
   __ CmpObjectType(object.reg(), FIRST_JS_OBJECT_TYPE, tmp1.reg());
   deferred->Branch(below);
   __ test_b(FieldOperand(tmp1.reg(), Map::kBitFieldOffset),
             KeyedLoadIC::kSlowCaseBitFieldMask);
   deferred->Branch(not_zero);
 
   // Check the object's elements are in fast case and writable.
   __ mov(tmp1.reg(), FieldOperand(object.reg(), JSObject::kElementsOffset));
   __ cmp(FieldOperand(tmp1.reg(), HeapObject::kMapOffset),
-         Immediate(Factory::fixed_array_map()));
+         Immediate(FACTORY->fixed_array_map()));
   deferred->Branch(not_equal);
 
   // Smi-tagging is equivalent to multiplying by 2.
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   // Check that both indices are smis.
   __ mov(tmp2.reg(), index1.reg());
   __ or_(tmp2.reg(), Operand(index2.reg()));
   __ test(tmp2.reg(), Immediate(kSmiTagMask));
@@ skipping 20 matching lines @@
   __ InNewSpace(tmp1.reg(), tmp2.reg(), equal, &done);
   // Possible optimization: do a check that both values are Smis
   // (or them and test against Smi mask.)
 
   __ mov(tmp2.reg(), tmp1.reg());
   __ RecordWriteHelper(tmp2.reg(), index1.reg(), object.reg());
   __ RecordWriteHelper(tmp1.reg(), index2.reg(), object.reg());
   __ bind(&done);
 
   deferred->BindExit();
-  frame_->Push(Factory::undefined_value());
+  frame_->Push(FACTORY->undefined_value());
 }
 
 
 void CodeGenerator::GenerateCallFunction(ZoneList<Expression*>* args) {
   Comment cmnt(masm_, "[ GenerateCallFunction");
 
   ASSERT(args->length() >= 2);
 
   int n_args = args->length() - 2;  // for receiver and function.
   Load(args->at(0));  // receiver
   for (int i = 0; i < n_args; i++) {
     Load(args->at(i + 1));
   }
   Load(args->at(n_args + 1));  // function
   Result result = frame_->CallJSFunction(n_args);
   frame_->Push(&result);
 }
 
 
 // Generates the Math.pow method. Only handles special cases and
 // branches to the runtime system for everything else. Please note
 // that this function assumes that the callsite has executed ToNumber
 // on both arguments.
 void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
   Load(args->at(0));
   Load(args->at(1));
-  if (!CpuFeatures::IsSupported(SSE2)) {
+  if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     Result res = frame_->CallRuntime(Runtime::kMath_pow, 2);
     frame_->Push(&res);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     Label allocate_return;
     // Load the two operands while leaving the values on the frame.
     frame()->Dup();
     Result exponent = frame()->Pop();
     exponent.ToRegister();
     frame()->Spill(exponent.reg());
@@ skipping 20 matching lines @@
     __ j(not_zero, &base_nonsmi);
 
     // Optimized version when y is an integer.
     Label powi;
     __ SmiUntag(base.reg());
     __ cvtsi2sd(xmm0, Operand(base.reg()));
     __ jmp(&powi);
     // exponent is smi and base is a heapnumber.
     __ bind(&base_nonsmi);
     __ cmp(FieldOperand(base.reg(), HeapObject::kMapOffset),
-           Factory::heap_number_map());
+           FACTORY->heap_number_map());
     call_runtime.Branch(not_equal);
 
     __ movdbl(xmm0, FieldOperand(base.reg(), HeapNumber::kValueOffset));
 
     // Optimized version of pow if y is an integer.
     __ bind(&powi);
     __ SmiUntag(exponent.reg());
 
     // Save exponent in base as we need to check if exponent is negative later.
     // We know that base and exponent are in different registers.
@@ skipping 30 matching lines @@
     __ ucomisd(xmm0, xmm1);
     call_runtime.Branch(equal);
     __ divsd(xmm3, xmm1);
     __ movsd(xmm1, xmm3);
     __ jmp(&allocate_return);
 
     // exponent (or both) is a heapnumber - no matter what we should now work
     // on doubles.
     __ bind(&exponent_nonsmi);
     __ cmp(FieldOperand(exponent.reg(), HeapObject::kMapOffset),
-           Factory::heap_number_map());
+           FACTORY->heap_number_map());
     call_runtime.Branch(not_equal);
     __ movdbl(xmm1, FieldOperand(exponent.reg(), HeapNumber::kValueOffset));
     // Test if exponent is nan.
     __ ucomisd(xmm1, xmm1);
     call_runtime.Branch(parity_even);
 
     Label base_not_smi;
     Label handle_special_cases;
     __ test(base.reg(), Immediate(kSmiTagMask));
     __ j(not_zero, &base_not_smi);
     __ SmiUntag(base.reg());
     __ cvtsi2sd(xmm0, Operand(base.reg()));
     __ jmp(&handle_special_cases);
     __ bind(&base_not_smi);
     __ cmp(FieldOperand(base.reg(), HeapObject::kMapOffset),
-           Factory::heap_number_map());
+           FACTORY->heap_number_map());
     call_runtime.Branch(not_equal);
     __ mov(answer.reg(), FieldOperand(base.reg(), HeapNumber::kExponentOffset));
     __ and_(answer.reg(), HeapNumber::kExponentMask);
     __ cmp(Operand(answer.reg()), Immediate(HeapNumber::kExponentMask));
     // base is NaN or +/-Infinity
     call_runtime.Branch(greater_equal);
     __ movdbl(xmm0, FieldOperand(base.reg(), HeapNumber::kValueOffset));
 
     // base is in xmm0 and exponent is in xmm1.
     __ bind(&handle_special_cases);
@@ skipping 88 matching lines @@
   frame_->Push(&result);
 }
 
 
 // Generates the Math.sqrt method. Please note - this function assumes that
 // the callsite has executed ToNumber on the argument.
 void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) {
   ASSERT_EQ(args->length(), 1);
   Load(args->at(0));
 
-  if (!CpuFeatures::IsSupported(SSE2)) {
+  if (!Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     Result result = frame()->CallRuntime(Runtime::kMath_sqrt, 1);
     frame()->Push(&result);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     // Leave original value on the frame if we need to call runtime.
     frame()->Dup();
     Result result = frame()->Pop();
     result.ToRegister();
     frame()->Spill(result.reg());
     Label runtime;
     Label non_smi;
     Label load_done;
     JumpTarget end;
 
     __ test(result.reg(), Immediate(kSmiTagMask));
     __ j(not_zero, &non_smi);
     __ SmiUntag(result.reg());
     __ cvtsi2sd(xmm0, Operand(result.reg()));
     __ jmp(&load_done);
     __ bind(&non_smi);
     __ cmp(FieldOperand(result.reg(), HeapObject::kMapOffset),
-           Factory::heap_number_map());
+           FACTORY->heap_number_map());
     __ j(not_equal, &runtime);
     __ movdbl(xmm0, FieldOperand(result.reg(), HeapNumber::kValueOffset));
 
     __ bind(&load_done);
     __ sqrtsd(xmm0, xmm0);
     // A copy of the virtual frame to allow us to go to runtime after the
     // JumpTarget jump.
     Result scratch = allocator()->Allocate();
     VirtualFrame* clone = new VirtualFrame(frame());
     __ AllocateHeapNumber(result.reg(), scratch.reg(), no_reg, &runtime);
@@ skipping 85 matching lines @@
 
 
 void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
   ASSERT(!in_safe_int32_mode());
   if (CheckForInlineRuntimeCall(node)) {
     return;
   }
 
   ZoneList<Expression*>* args = node->arguments();
   Comment cmnt(masm_, "[ CallRuntime");
-  Runtime::Function* function = node->function();
+  const Runtime::Function* function = node->function();
 
   if (function == NULL) {
     // Push the builtins object found in the current global object.
     Result temp = allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ mov(temp.reg(), GlobalObjectOperand());
     __ mov(temp.reg(), FieldOperand(temp.reg(), GlobalObject::kBuiltinsOffset));
     frame_->Push(&temp);
   }
 
@@ skipping 62 matching lines @@
         // variable.  Sync the virtual frame eagerly so we can push the
         // arguments directly into place.
         frame_->SyncRange(0, frame_->element_count() - 1);
         frame_->EmitPush(esi);
         frame_->EmitPush(Immediate(variable->name()));
         Result answer = frame_->CallRuntime(Runtime::kDeleteContextSlot, 2);
         frame_->Push(&answer);
       } else {
         // Default: Result of deleting non-global, not dynamically
         // introduced variables is false.
-        frame_->Push(Factory::false_value());
+        frame_->Push(FACTORY->false_value());
       }
     } else {
       // Default: Result of deleting expressions is true.
       Load(node->expression());  // may have side-effects
-      frame_->SetElementAt(0, Factory::true_value());
+      frame_->SetElementAt(0, FACTORY->true_value());
     }
 
   } else if (op == Token::TYPEOF) {
     // Special case for loading the typeof expression; see comment on
     // LoadTypeofExpression().
     LoadTypeofExpression(node->expression());
     Result answer = frame_->CallRuntime(Runtime::kTypeof, 1);
     frame_->Push(&answer);
 
   } else if (op == Token::VOID) {
     Expression* expression = node->expression();
     if (expression && expression->AsLiteral() && (
         expression->AsLiteral()->IsTrue() ||
         expression->AsLiteral()->IsFalse() ||
         expression->AsLiteral()->handle()->IsNumber() ||
         expression->AsLiteral()->handle()->IsString() ||
         expression->AsLiteral()->handle()->IsJSRegExp() ||
         expression->AsLiteral()->IsNull())) {
       // Omit evaluating the value of the primitive literal.
       // It will be discarded anyway, and can have no side effect.
-      frame_->Push(Factory::undefined_value());
+      frame_->Push(FACTORY->undefined_value());
     } else {
       Load(node->expression());
-      frame_->SetElementAt(0, Factory::undefined_value());
+      frame_->SetElementAt(0, FACTORY->undefined_value());
     }
 
   } else {
     if (in_safe_int32_mode()) {
       Visit(node->expression());
       Result value = frame_->Pop();
       ASSERT(value.is_untagged_int32());
       // Registers containing an int32 value are not multiply used.
       ASSERT(!value.is_register() || !frame_->is_used(value.reg()));
       value.ToRegister();
@@ skipping 781 matching lines @@
       (operation != NULL && operation->op() == Token::TYPEOF) &&
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
     // Load the operand and move it to a register.
     LoadTypeofExpression(operation->expression());
     Result answer = frame_->Pop();
     answer.ToRegister();
 
-    if (check->Equals(Heap::number_symbol())) {
+    if (check->Equals(HEAP->number_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->true_target()->Branch(zero);
       frame_->Spill(answer.reg());
       __ mov(answer.reg(), FieldOperand(answer.reg(), HeapObject::kMapOffset));
-      __ cmp(answer.reg(), Factory::heap_number_map());
+      __ cmp(answer.reg(), FACTORY->heap_number_map());
       answer.Unuse();
       destination()->Split(equal);
 
-    } else if (check->Equals(Heap::string_symbol())) {
+    } else if (check->Equals(HEAP->string_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
 
       // It can be an undetectable string object.
       Result temp = allocator()->Allocate();
       ASSERT(temp.is_valid());
       __ mov(temp.reg(), FieldOperand(answer.reg(), HeapObject::kMapOffset));
       __ test_b(FieldOperand(temp.reg(), Map::kBitFieldOffset),
                 1 << Map::kIsUndetectable);
       destination()->false_target()->Branch(not_zero);
       __ CmpInstanceType(temp.reg(), FIRST_NONSTRING_TYPE);
       temp.Unuse();
       answer.Unuse();
       destination()->Split(below);
 
-    } else if (check->Equals(Heap::boolean_symbol())) {
-      __ cmp(answer.reg(), Factory::true_value());
+    } else if (check->Equals(HEAP->boolean_symbol())) {
+      __ cmp(answer.reg(), FACTORY->true_value());
       destination()->true_target()->Branch(equal);
-      __ cmp(answer.reg(), Factory::false_value());
+      __ cmp(answer.reg(), FACTORY->false_value());
       answer.Unuse();
       destination()->Split(equal);
 
-    } else if (check->Equals(Heap::undefined_symbol())) {
-      __ cmp(answer.reg(), Factory::undefined_value());
+    } else if (check->Equals(HEAP->undefined_symbol())) {
+      __ cmp(answer.reg(), FACTORY->undefined_value());
       destination()->true_target()->Branch(equal);
 
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
 
       // It can be an undetectable object.
       frame_->Spill(answer.reg());
       __ mov(answer.reg(), FieldOperand(answer.reg(), HeapObject::kMapOffset));
       __ test_b(FieldOperand(answer.reg(), Map::kBitFieldOffset),
                 1 << Map::kIsUndetectable);
       answer.Unuse();
       destination()->Split(not_zero);
 
-    } else if (check->Equals(Heap::function_symbol())) {
+    } else if (check->Equals(HEAP->function_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
       frame_->Spill(answer.reg());
       __ CmpObjectType(answer.reg(), JS_FUNCTION_TYPE, answer.reg());
       destination()->true_target()->Branch(equal);
       // Regular expressions are callable so typeof == 'function'.
       __ CmpInstanceType(answer.reg(), JS_REGEXP_TYPE);
       answer.Unuse();
       destination()->Split(equal);
-    } else if (check->Equals(Heap::object_symbol())) {
+    } else if (check->Equals(HEAP->object_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
-      __ cmp(answer.reg(), Factory::null_value());
+      __ cmp(answer.reg(), FACTORY->null_value());
       destination()->true_target()->Branch(equal);
 
       Result map = allocator()->Allocate();
       ASSERT(map.is_valid());
       // Regular expressions are typeof == 'function', not 'object'.
       __ CmpObjectType(answer.reg(), JS_REGEXP_TYPE, map.reg());
       destination()->false_target()->Branch(equal);
 
       // It can be an undetectable object.
       __ test_b(FieldOperand(map.reg(), Map::kBitFieldOffset),
@@ skipping 22 matching lines @@
     if (check->value() == 2147483648.0) {  // 0x80000000.
       Load(left);
       left_already_loaded = true;
       Result lhs = frame_->Pop();
       lhs.ToRegister();
       __ test(lhs.reg(), Immediate(kSmiTagMask));
       destination()->true_target()->Branch(zero);  // All Smis are less.
       Result scratch = allocator()->Allocate();
       ASSERT(scratch.is_valid());
       __ mov(scratch.reg(), FieldOperand(lhs.reg(), HeapObject::kMapOffset));
-      __ cmp(scratch.reg(), Factory::heap_number_map());
+      __ cmp(scratch.reg(), FACTORY->heap_number_map());
       JumpTarget not_a_number;
       not_a_number.Branch(not_equal, &lhs);
       __ mov(scratch.reg(),
              FieldOperand(lhs.reg(), HeapNumber::kExponentOffset));
       __ cmp(Operand(scratch.reg()), Immediate(0xfff00000));
       not_a_number.Branch(above_equal, &lhs);  // It's a negative NaN or -Inf.
       const uint32_t borderline_exponent =
           (HeapNumber::kExponentBias + 31) << HeapNumber::kExponentShift;
       __ cmp(Operand(scratch.reg()), Immediate(borderline_exponent));
       scratch.Unuse();
@@ skipping 66 matching lines @@
 }
 
 
 void CodeGenerator::VisitCompareToNull(CompareToNull* node) {
   ASSERT(!in_safe_int32_mode());
   Comment cmnt(masm_, "[ CompareToNull");
 
   Load(node->expression());
   Result operand = frame_->Pop();
   operand.ToRegister();
-  __ cmp(operand.reg(), Factory::null_value());
+  __ cmp(operand.reg(), FACTORY->null_value());
   if (node->is_strict()) {
     operand.Unuse();
     destination()->Split(equal);
   } else {
     // The 'null' value is only equal to 'undefined' if using non-strict
     // comparisons.
     destination()->true_target()->Branch(equal);
-    __ cmp(operand.reg(), Factory::undefined_value());
+    __ cmp(operand.reg(), FACTORY->undefined_value());
     destination()->true_target()->Branch(equal);
     __ test(operand.reg(), Immediate(kSmiTagMask));
     destination()->false_target()->Branch(equal);
 
     // It can be an undetectable object.
     // Use a scratch register in preference to spilling operand.reg().
     Result temp = allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ mov(temp.reg(),
            FieldOperand(operand.reg(), HeapObject::kMapOffset));
@@ skipping 52 matching lines @@
   bool is_contextual_;
   bool is_dont_delete_;
 };
 
 
 void DeferredReferenceGetNamedValue::Generate() {
   if (!receiver_.is(eax)) {
     __ mov(eax, receiver_);
   }
   __ Set(ecx, Immediate(name_));
-  Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
+  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
+      Builtins::LoadIC_Initialize));
   RelocInfo::Mode mode = is_contextual_
       ? RelocInfo::CODE_TARGET_CONTEXT
       : RelocInfo::CODE_TARGET;
   __ call(ic, mode);
   // The call must be followed by:
   // - a test eax instruction to indicate that the inobject property
   //   case was inlined.
   // - a mov ecx or mov edx instruction to indicate that the
   //   contextual property load was inlined.
   //
   // Store the delta to the map check instruction here in the test
   // instruction.  Use masm_-> instead of the __ macro since the
   // latter can't return a value.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   if (is_contextual_) {
     masm_->mov(is_dont_delete_ ? edx : ecx, -delta_to_patch_site);
-    __ IncrementCounter(&Counters::named_load_global_inline_miss, 1);
+    __ IncrementCounter(COUNTERS->named_load_global_inline_miss(), 1);
     if (is_dont_delete_) {
-      __ IncrementCounter(&Counters::dont_delete_hint_miss, 1);
+      __ IncrementCounter(COUNTERS->dont_delete_hint_miss(), 1);
     }
   } else {
     masm_->test(eax, Immediate(-delta_to_patch_site));
-    __ IncrementCounter(&Counters::named_load_inline_miss, 1);
+    __ IncrementCounter(COUNTERS->named_load_inline_miss(), 1);
   }
 
   if (!dst_.is(eax)) __ mov(dst_, eax);
 }
 
 
 class DeferredReferenceGetKeyedValue: public DeferredCode {
  public:
   explicit DeferredReferenceGetKeyedValue(Register dst,
                                           Register receiver,
@@ skipping 33 matching lines @@
     }
   } else {
     __ xchg(edx, eax);
   }
   // Calculate the delta from the IC call instruction to the map check
   // cmp instruction in the inlined version.  This delta is stored in
   // a test(eax, delta) instruction after the call so that we can find
   // it in the IC initialization code and patch the cmp instruction.
   // This means that we cannot allow test instructions after calls to
   // KeyedLoadIC stubs in other places.
-  Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
+  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
+      Builtins::KeyedLoadIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
   // The delta from the start of the map-compare instruction to the
   // test instruction.  We use masm_-> directly here instead of the __
   // macro because the macro sometimes uses macro expansion to turn
   // into something that can't return a value.  This is encountered
   // when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   masm_->test(eax, Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
+  __ IncrementCounter(COUNTERS->keyed_load_inline_miss(), 1);
 
   if (!dst_.is(eax)) __ mov(dst_, eax);
 }
 
 
 class DeferredReferenceSetKeyedValue: public DeferredCode {
  public:
   DeferredReferenceSetKeyedValue(Register value,
                                  Register key,
                                  Register receiver,
@@ skipping 15 matching lines @@
   Register value_;
   Register key_;
   Register receiver_;
   Register scratch_;
   Label patch_site_;
   StrictModeFlag strict_mode_;
 };
 
 
 void DeferredReferenceSetKeyedValue::Generate() {
-  __ IncrementCounter(&Counters::keyed_store_inline_miss, 1);
+  __ IncrementCounter(COUNTERS->keyed_store_inline_miss(), 1);
   // Move value_ to eax, key_ to ecx, and receiver_ to edx.
   Register old_value = value_;
 
   // First, move value to eax.
   if (!value_.is(eax)) {
     if (key_.is(eax)) {
       // Move key_ out of eax, preferably to ecx.
       if (!value_.is(ecx) && !receiver_.is(ecx)) {
         __ mov(ecx, key_);
         key_ = ecx;
@@ skipping 33 matching lines @@
       }
     }
   } else {  // Key is not in edx or ecx.
     if (!receiver_.is(edx)) {
       __ mov(edx, receiver_);
     }
     __ mov(ecx, key_);
   }
 
   // Call the IC stub.
-  Handle<Code> ic(Builtins::builtin(
+  Handle<Code> ic(Isolate::Current()->builtins()->builtin(
       (strict_mode_ == kStrictMode) ? Builtins::KeyedStoreIC_Initialize_Strict
                                     : Builtins::KeyedStoreIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
   // The delta from the start of the map-compare instruction to the
   // test instruction.  We use masm_-> directly here instead of the
   // __ macro because the macro sometimes uses macro expansion to turn
   // into something that can't return a value.  This is encountered
   // when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   masm_->test(eax, Immediate(-delta_to_patch_site));
   // Restore value (returned from store IC) register.
   if (!old_value.is(eax)) __ mov(old_value, eax);
 }
 
 
 Result CodeGenerator::EmitNamedLoad(Handle<String> name, bool is_contextual) {
 #ifdef DEBUG
   int original_height = frame()->height();
 #endif
 
   bool contextual_load_in_builtin =
       is_contextual &&
-      (Bootstrapper::IsActive() ||
+      (Isolate::Current()->bootstrapper()->IsActive() ||
        (!info_->closure().is_null() && info_->closure()->IsBuiltin()));
 
   Result result;
   // Do not inline in the global code or when not in loop.
   if (scope()->is_global_scope() ||
       loop_nesting() == 0 ||
       contextual_load_in_builtin) {
     Comment cmnt(masm(), "[ Load from named Property");
     frame()->Push(name);
 
@@ skipping 25 matching lines @@
       // Check that the receiver is a heap object.
       __ test(receiver.reg(), Immediate(kSmiTagMask));
       deferred->Branch(zero);
     }
 
     __ bind(deferred->patch_site());
     // This is the map check instruction that will be patched (so we can't
     // use the double underscore macro that may insert instructions).
     // Initially use an invalid map to force a failure.
     masm()->cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
-                Immediate(Factory::null_value()));
+                Immediate(FACTORY->null_value()));
     // This branch is always a forwards branch so it's always a fixed size
     // which allows the assert below to succeed and patching to work.
     deferred->Branch(not_equal);
 
     // The delta from the patch label to the actual load must be
     // statically known.
     ASSERT(masm()->SizeOfCodeGeneratedSince(deferred->patch_site()) ==
            LoadIC::kOffsetToLoadInstruction);
 
     if (is_contextual) {
       // Load the (initialy invalid) cell and get its value.
-      masm()->mov(result.reg(), Factory::null_value());
+      masm()->mov(result.reg(), FACTORY->null_value());
       if (FLAG_debug_code) {
         __ cmp(FieldOperand(result.reg(), HeapObject::kMapOffset),
-               Factory::global_property_cell_map());
+               FACTORY->global_property_cell_map());
         __ Assert(equal, "Uninitialized inlined contextual load");
       }
       __ mov(result.reg(),
              FieldOperand(result.reg(), JSGlobalPropertyCell::kValueOffset));
+      __ cmp(result.reg(), FACTORY->the_hole_value());
+      deferred->Branch(equal);
       bool is_dont_delete = false;
       if (!info_->closure().is_null()) {
         // When doing lazy compilation we can check if the global cell
         // already exists and use its "don't delete" status as a hint.
         AssertNoAllocation no_gc;
         v8::internal::GlobalObject* global_object =
             info_->closure()->context()->global();
         LookupResult lookup;
         global_object->LocalLookupRealNamedProperty(*name, &lookup);
         if (lookup.IsProperty() && lookup.type() == NORMAL) {
           ASSERT(lookup.holder() == global_object);
           ASSERT(global_object->property_dictionary()->ValueAt(
               lookup.GetDictionaryEntry())->IsJSGlobalPropertyCell());
           is_dont_delete = lookup.IsDontDelete();
         }
       }
       deferred->set_is_dont_delete(is_dont_delete);
       if (!is_dont_delete) {
-        __ cmp(result.reg(), Factory::the_hole_value());
+        __ cmp(result.reg(), FACTORY->the_hole_value());
         deferred->Branch(equal);
       } else if (FLAG_debug_code) {
-        __ cmp(result.reg(), Factory::the_hole_value());
+        __ cmp(result.reg(), FACTORY->the_hole_value());
         __ Check(not_equal, "DontDelete cells can't contain the hole");
       }
-      __ IncrementCounter(&Counters::named_load_global_inline, 1);
+      __ IncrementCounter(COUNTERS->named_load_global_inline(), 1);
       if (is_dont_delete) {
-        __ IncrementCounter(&Counters::dont_delete_hint_hit, 1);
+        __ IncrementCounter(COUNTERS->dont_delete_hint_hit(), 1);
       }
     } else {
       // The initial (invalid) offset has to be large enough to force a 32-bit
       // instruction encoding to allow patching with an arbitrary offset.  Use
       // kMaxInt (minus kHeapObjectTag).
       int offset = kMaxInt;
       masm()->mov(result.reg(), FieldOperand(receiver.reg(), offset));
-      __ IncrementCounter(&Counters::named_load_inline, 1);
+      __ IncrementCounter(COUNTERS->named_load_inline(), 1);
     }
 
     deferred->BindExit();
   }
   ASSERT(frame()->height() == original_height - 1);
   return result;
 }
 
 
 Result CodeGenerator::EmitNamedStore(Handle<String> name, bool is_contextual) {
@@ skipping 25 matching lines @@
 
     // Check that the receiver is a heap object.
     __ test(receiver.reg(), Immediate(kSmiTagMask));
     slow.Branch(zero, &value, &receiver);
 
     // This is the map check instruction that will be patched (so we can't
     // use the double underscore macro that may insert instructions).
     // Initially use an invalid map to force a failure.
     __ bind(&patch_site);
     masm()->cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
-                Immediate(Factory::null_value()));
+                Immediate(FACTORY->null_value()));
     // This branch is always a forwards branch so it's always a fixed size
     // which allows the assert below to succeed and patching to work.
     slow.Branch(not_equal, &value, &receiver);
 
     // The delta from the patch label to the store offset must be
     // statically known.
     ASSERT(masm()->SizeOfCodeGeneratedSince(&patch_site) ==
            StoreIC::kOffsetToStoreInstruction);
 
     // The initial (invalid) offset has to be large enough to force a 32-bit
@@ skipping 89 matching lines @@
     __ test(receiver.reg(), Immediate(kSmiTagMask));
     deferred->Branch(zero);
 
     // Check that the receiver has the expected map.
     // Initially, use an invalid map. The map is patched in the IC
     // initialization code.
     __ bind(deferred->patch_site());
     // Use masm-> here instead of the double underscore macro since extra
     // coverage code can interfere with the patching.
     masm_->cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
-               Immediate(Factory::null_value()));
+               Immediate(FACTORY->null_value()));
     deferred->Branch(not_equal);
 
     // Check that the key is a smi.
     if (!key.is_smi()) {
       __ test(key.reg(), Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
     } else {
       if (FLAG_debug_code) __ AbortIfNotSmi(key.reg());
     }
 
     // Get the elements array from the receiver.
     __ mov(elements.reg(),
            FieldOperand(receiver.reg(), JSObject::kElementsOffset));
     __ AssertFastElements(elements.reg());
 
     // Check that the key is within bounds.
     __ cmp(key.reg(),
            FieldOperand(elements.reg(), FixedArray::kLengthOffset));
     deferred->Branch(above_equal);
 
     // Load and check that the result is not the hole.
     // Key holds a smi.
     STATIC_ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
     __ mov(elements.reg(),
            FieldOperand(elements.reg(),
                         key.reg(),
                         times_2,
                         FixedArray::kHeaderSize));
     result = elements;
-    __ cmp(Operand(result.reg()), Immediate(Factory::the_hole_value()));
+    __ cmp(Operand(result.reg()), Immediate(FACTORY->the_hole_value()));
     deferred->Branch(equal);
-    __ IncrementCounter(&Counters::keyed_load_inline, 1);
+    __ IncrementCounter(COUNTERS->keyed_load_inline(), 1);
 
     deferred->BindExit();
   } else {
     Comment cmnt(masm_, "[ Load from keyed Property");
     result = frame_->CallKeyedLoadIC(RelocInfo::CODE_TARGET);
     // Make sure that we do not have a test instruction after the
     // call.  A test instruction after the call is used to
     // indicate that we have generated an inline version of the
     // keyed load.  The explicit nop instruction is here because
     // the push that follows might be peep-hole optimized away.
@@ skipping 71 matching lines @@
       deferred->Branch(not_zero);
     }
 
     __ bind(&in_new_space);
     // Bind the deferred code patch site to be able to locate the fixed
     // array map comparison.  When debugging, we patch this comparison to
     // always fail so that we will hit the IC call in the deferred code
     // which will allow the debugger to break for fast case stores.
     __ bind(deferred->patch_site());
     __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
-           Immediate(Factory::fixed_array_map()));
+           Immediate(FACTORY->fixed_array_map()));
     deferred->Branch(not_equal);
 
     // Check that the key is within bounds.  Both the key and the length of
     // the JSArray are smis (because the fixed array check above ensures the
     // elements are in fast case). Use unsigned comparison to handle negative
     // keys.
     __ cmp(key.reg(),
            FieldOperand(receiver.reg(), JSArray::kLengthOffset));
     deferred->Branch(above_equal);
 
     // Store the value.
     __ mov(FixedArrayElementOperand(tmp.reg(), key.reg()), result.reg());
-    __ IncrementCounter(&Counters::keyed_store_inline, 1);
+    __ IncrementCounter(COUNTERS->keyed_store_inline(), 1);
 
     deferred->BindExit();
   } else {
     result = frame()->CallKeyedStoreIC(strict_mode_flag());
     // Make sure that we do not have a test instruction after the
     // call.  A test instruction after the call is used to
     // indicate that we have generated an inline version of the
     // keyed store.
     __ nop();
   }
@@ skipping 182 matching lines @@
   int stack_offset = 0;  // Update if we change the stack height.
 
   if (FLAG_debug_code) {
     __ cmp(Operand(esp, kSizeOffset + stack_offset),
            Immediate(kMinComplexMemCopy));
     Label ok;
     __ j(greater_equal, &ok);
     __ int3();
     __ bind(&ok);
   }
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (Isolate::Current()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope enable(SSE2);
     __ push(edi);
     __ push(esi);
     stack_offset += 2 * kPointerSize;
     Register dst = edi;
     Register src = esi;
     Register count = ecx;
     __ mov(dst, Operand(esp, stack_offset + kDestinationOffset));
     __ mov(src, Operand(esp, stack_offset + kSourceOffset));
     __ mov(count, Operand(esp, stack_offset + kSizeOffset));
 
 
     __ movdqu(xmm0, Operand(src, 0));
     __ movdqu(Operand(dst, 0), xmm0);
     __ mov(edx, dst);
     __ and_(edx, 0xF);
     __ neg(edx);
     __ add(Operand(edx), Immediate(16));
     __ add(dst, Operand(edx));
     __ add(src, Operand(edx));
     __ sub(Operand(count), edx);
 
     // edi is now aligned. Check if esi is also aligned.
     Label unaligned_source;
     __ test(Operand(src), Immediate(0x0F));
     __ j(not_zero, &unaligned_source);
     {
-      __ IncrementCounter(&Counters::memcopy_aligned, 1);
+      __ IncrementCounter(COUNTERS->memcopy_aligned(), 1);
       // Copy loop for aligned source and destination.
       __ mov(edx, count);
       Register loop_count = ecx;
       Register count = edx;
       __ shr(loop_count, 5);
       {
         // Main copy loop.
         Label loop;
         __ bind(&loop);
         __ prefetch(Operand(src, 0x20), 1);
@@ skipping 27 matching lines @@
       __ mov(eax, Operand(esp, stack_offset + kDestinationOffset));
       __ pop(esi);
       __ pop(edi);
       __ ret(0);
     }
     __ Align(16);
     {
       // Copy loop for unaligned source and aligned destination.
       // If source is not aligned, we can't read it as efficiently.
       __ bind(&unaligned_source);
-      __ IncrementCounter(&Counters::memcopy_unaligned, 1);
+      __ IncrementCounter(COUNTERS->memcopy_unaligned(), 1);
       __ mov(edx, ecx);
       Register loop_count = ecx;
       Register count = edx;
       __ shr(loop_count, 5);
       {
         // Main copy loop
         Label loop;
         __ bind(&loop);
         __ prefetch(Operand(src, 0x20), 1);
         __ movdqu(xmm0, Operand(src, 0x00));
@@ skipping 23 matching lines @@
       __ movdqu(xmm0, Operand(src, count, times_1, -0x10));
       __ movdqu(Operand(dst, count, times_1, -0x10), xmm0);
 
       __ mov(eax, Operand(esp, stack_offset + kDestinationOffset));
       __ pop(esi);
       __ pop(edi);
       __ ret(0);
     }
 
   } else {
-    __ IncrementCounter(&Counters::memcopy_noxmm, 1);
+    __ IncrementCounter(COUNTERS->memcopy_noxmm(), 1);
     // SSE2 not supported. Unlikely to happen in practice.
     __ push(edi);
     __ push(esi);
     stack_offset += 2 * kPointerSize;
     __ cld();
     Register dst = edi;
     Register src = esi;
     Register count = ecx;
     __ mov(dst, Operand(esp, stack_offset + kDestinationOffset));
     __ mov(src, Operand(esp, stack_offset + kSourceOffset));
@@ skipping 40 matching lines @@
   memcpy(chunk->GetStartAddress(), desc.buffer, desc.instr_size);
   CPU::FlushICache(chunk->GetStartAddress(), desc.instr_size);
   return FUNCTION_CAST<MemCopyFunction>(chunk->GetStartAddress());
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32