Cleanup of isolate(), FACTORY and HEAP usage in ia32/codegen-ia32.cc

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 531 matching lines @@
     ASSERT(value->handle()->IsSmi());
   }
   value->set_untagged_int32(false);
   value->set_type_info(TypeInfo::Smi());
 }
 
 
 void CodeGenerator::ConvertInt32ResultToNumber(Result* value) {
   ASSERT(value->is_untagged_int32());
   if (value->is_register()) {
+    Isolate* isolate = masm()->isolate();
     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 (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+    if (isolate->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 (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+    if (isolate->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 (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+    if (!isolate->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());
+  Isolate* isolate = masm()->isolate();
+  Factory* factory = isolate->factory();
 
   // 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 &&
-      masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+      isolate->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 53 matching lines @@
       ? EAGER_ARGUMENTS_ALLOCATION
       : LAZY_ARGUMENTS_ALLOCATION;
 }
 
 
 Result CodeGenerator::StoreArgumentsObject(bool initial) {
   ArgumentsAllocationMode mode = ArgumentsMode();
   ASSERT(mode != NO_ARGUMENTS_ALLOCATION);
 
   Comment cmnt(masm_, "[ store arguments object");
+
+  Factory* factory = masm()->isolate()->factory();
   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 108 matching lines @@
     __ test(value.reg(), Operand(value.reg()));
     dest->false_target()->Branch(zero);
     __ 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 {
+    Factory* factory = masm()->isolate()->factory();
     // 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 72 matching lines @@
 
 
 void DeferredInlineBinaryOperation::JumpToConstantRhs(Condition cond,
                                                       Smi* smi_value) {
   smi_value_ = smi_value;
   __ j(cond, &constant_rhs_);
 }
 
 
 void DeferredInlineBinaryOperation::Generate() {
+  Isolate* isolate = masm()->isolate();
+  Factory* factory = isolate->factory();
   // Registers are not saved implicitly for this stub, so we should not
   // tread on the registers that were not passed to us.
-  if (masm()->isolate()->cpu_features()->IsSupported(SSE2) &&
+  if (isolate->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 1933 matching lines @@
       if (IsUnsafeSmi(right_side->handle())) {
         right_side->ToRegister();
         __ cmp(left_reg, Operand(right_side->reg()));
       } else {
         __ cmp(Operand(left_reg), Immediate(right_side->handle()));
       }
       left_side->Unuse();
       right_side->Unuse();
       dest->Split(cc);
     } else {
+      Isolate* isolate = masm()->isolate();
       // Only the case where the left side could possibly be a non-smi is left.
       JumpTarget is_smi;
       if (cc == equal) {
         // We can do the equality comparison before the smi check.
         __ cmp(Operand(left_reg), Immediate(right_side->handle()));
         dest->true_target()->Branch(equal);
         __ test(left_reg, Immediate(kSmiTagMask));
         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 &&
-          masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+          isolate->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(isolate->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 215 matching lines @@
   // x.apply(y, arguments).
   // If the arguments object of the scope has not been allocated,
   // and x.apply is Function.prototype.apply, this optimization
   // just copies y and the arguments of the current function on the
   // 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());
 
+  Isolate* isolate = masm()->isolate();
+  Factory* factory = isolate->factory();
   // 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(masm()->isolate()->builtins()->builtin(
+      Handle<Code> apply_code(isolate->builtins()->builtin(
           Builtins::kFunctionApply));
       __ 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 989 matching lines @@
   DecrementLoopNesting();
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ ForInStatement");
   CodeForStatementPosition(node);
 
+  Factory* factory = masm()->isolate()->factory();
+
   JumpTarget primitive;
   JumpTarget jsobject;
   JumpTarget fixed_array;
   JumpTarget entry(JumpTarget::BIDIRECTIONAL);
   JumpTarget end_del_check;
   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 241 matching lines @@
   exit.Bind();
 }
 
 
 void CodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* node) {
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ TryFinallyStatement");
   CodeForStatementPosition(node);
 
+  Isolate* isolate = masm()->isolate();
+  Factory* factory = isolate->factory();
+
   // State: Used to keep track of reason for entering the finally
   // block. Should probably be extended to hold information for
   // break/continue from within the try block.
   enum { FALLING, THROWING, JUMPING };
 
   JumpTarget try_block;
   JumpTarget finally_block;
 
   try_block.Call();
 
@@ skipping 38 matching lines @@
   // 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(Isolate::k_handler_address,
-                                    masm()->isolate());
+                                    isolate);
 
   // 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 194 matching lines @@
 
   } else if (slot->var()->mode() == Variable::CONST) {
     // 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");
+    Factory* factory = masm()->isolate()->factory();
     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 143 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());
+        Factory* factory = masm()->isolate()->factory();
+        __ 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 456 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()) {
+  Isolate* isolate = masm()->isolate();
+  if (node->constant_elements()->map() ==
+          isolate->heap()->fixed_cow_array_map()) {
     FastCloneShallowArrayStub stub(
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS, length);
     clone = frame_->CallStub(&stub, 3);
-    Counters* counters = masm()->isolate()->counters();
+    Counters* counters = isolate->counters();
     __ 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);
   }
@@ skipping 355 matching lines @@
   property.GetValue();
 }
 
 
 void CodeGenerator::VisitCall(Call* node) {
   ASSERT(!in_safe_int32_mode());
   Comment cmnt(masm_, "[ Call");
 
   Expression* function = node->expression();
   ZoneList<Expression*>* args = node->arguments();
+  Factory* factory = masm()->isolate()->factory();
 
   // Check if the function is a variable or a property.
   Variable* var = function->AsVariableProxy()->AsVariable();
   Property* property = function->AsProperty();
 
   // ------------------------------------------------------------------------
   // Fast-case: Use inline caching.
   // ---
   // According to ECMA-262, section 11.2.3, page 44, the function to call
   // must be resolved after the arguments have been evaluated. The IC code
   // automatically handles this by loading the arguments before the function
   // is resolved in cache misses (this also holds for megamorphic calls).
   // ------------------------------------------------------------------------
 
   if (var != NULL && var->is_possibly_eval()) {
     // ----------------------------------
     // JavaScript example: 'eval(arg)'  // eval is not known to be shadowed
     // ----------------------------------
 
     // 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 310 matching lines @@
                                 &need_conversion_,
                                 &need_conversion_,
                                 &index_out_of_range_,
                                 STRING_INDEX_IS_NUMBER) {}
 
   StringCharCodeAtGenerator* fast_case_generator() {
     return &char_code_at_generator_;
   }
 
   virtual void Generate() {
+    Factory* factory = masm()->isolate()->factory();
     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 176 matching lines @@
   destination()->Split(equal);
 }
 
 
 void CodeGenerator::GenerateFastAsciiArrayJoin(ZoneList<Expression*>* args) {
   Label bailout, done, one_char_separator, long_separator,
       non_trivial_array, not_size_one_array, loop, loop_condition,
       loop_1, loop_1_condition, loop_2, loop_2_entry, loop_3, loop_3_entry;
 
   ASSERT(args->length() == 2);
+  Factory* factory = masm()->isolate()->factory();
   // We will leave the separator on the stack until the end of the function.
   Load(args->at(1));
   // Load this to eax (= array)
   Load(args->at(0));
   Result array_result = frame_->Pop();
   array_result.ToRegister(eax);
   frame_->SpillAll();
 
   // All aliases of the same register have disjoint lifetimes.
   Register array = eax;
@@ skipping 24 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 80 matching lines @@
   DeferredIsStringWrapperSafeForDefaultValueOf(Register object,
                                                Register map_result,
                                                Register scratch1,
                                                Register scratch2)
       : object_(object),
         map_result_(map_result),
         scratch1_(scratch1),
         scratch2_(scratch2) { }
 
   virtual void Generate() {
+    Factory* factory = masm()->isolate()->factory();
     Label false_result;
 
     // 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 153 matching lines @@
 
   __ bind(&exit);
   result.set_type_info(TypeInfo::Smi());
   if (FLAG_debug_code) __ AbortIfNotSmi(result.reg());
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
+  Factory* factory = masm()->isolate()->factory();
   JumpTarget leave, null, function, non_function_constructor;
   Load(args->at(0));  // Load the object.
   Result obj = frame_->Pop();
   obj.ToRegister();
   frame_->Spill(obj.reg());
 
   // If the object is a smi, we return null.
   __ test(obj.reg(), Immediate(kSmiTagMask));
   null.Branch(zero);
 
@@ skipping 21 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 101 matching lines @@
   __ mov(ebp_as_smi.reg(), Operand(ebp));
   frame_->Push(&ebp_as_smi);
 }
 
 
 void CodeGenerator::GenerateRandomHeapNumber(
     ZoneList<Expression*>* args) {
   ASSERT(args->length() == 0);
   frame_->SpillAll();
 
+  Isolate* isolate = masm()->isolate();
+
   Label slow_allocate_heapnumber;
   Label heapnumber_allocated;
 
   __ AllocateHeapNumber(edi, ebx, ecx, &slow_allocate_heapnumber);
   __ jmp(&heapnumber_allocated);
 
   __ bind(&slow_allocate_heapnumber);
   // Allocate a heap number.
   __ CallRuntime(Runtime::kNumberAlloc, 0);
   __ mov(edi, eax);
 
   __ bind(&heapnumber_allocated);
 
   __ PrepareCallCFunction(0, ebx);
-  __ CallCFunction(ExternalReference::random_uint32_function(masm()->isolate()),
+  __ CallCFunction(ExternalReference::random_uint32_function(isolate),
                    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 (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+  if (isolate->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 277 matching lines @@
   __ CallRuntime(Runtime::kSwapElements, 3);
 }
 
 
 void CodeGenerator::GenerateSwapElements(ZoneList<Expression*>* args) {
   // Note: this code assumes that indices are passed are within
   // elements' bounds and refer to valid (not holes) values.
   Comment cmnt(masm_, "[ GenerateSwapElements");
 
   ASSERT_EQ(3, args->length());
+  Factory* factory = masm()->isolate()->factory();
 
   Load(args->at(0));
   Load(args->at(1));
   Load(args->at(2));
 
   Result index2 = frame_->Pop();
   index2.ToRegister();
 
   Result index1 = frame_->Pop();
   index1.ToRegister();
@@ skipping 19 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);
+  Isolate* isolate = masm()->isolate();
   Load(args->at(0));
   Load(args->at(1));
-  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+  if (!isolate->cpu_features()->IsSupported(SSE2)) {
     Result res = frame_->CallRuntime(Runtime::kMath_pow, 2);
     frame_->Push(&res);
   } else {
+    Factory* factory = isolate->factory();
     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());
     frame()->PushElementAt(1);
     Result base = frame()->Pop();
     base.ToRegister();
@@ skipping 17 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 87 matching lines @@
   Result result = frame_->CallStub(&stub, 1);
   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));
+  Isolate* isolate = masm()->isolate();
 
-  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
+  if (!isolate->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());
+           isolate->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 121 matching lines @@
     // Call the C runtime function.
     Result answer = frame_->CallRuntime(function, arg_count);
     frame_->Push(&answer);
   }
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
   Comment cmnt(masm_, "[ UnaryOperation");
 
+  Factory* factory = masm()->isolate()->factory();
   Token::Value op = node->op();
 
   if (op == Token::NOT) {
     // Swap the true and false targets but keep the same actual label
     // as the fall through.
     destination()->Invert();
     LoadCondition(node->expression(), destination(), true);
     // Swap the labels back.
     destination()->Invert();
 
@@ skipping 27 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 770 matching lines @@
   bool left_already_loaded = false;
 
   // Get the expressions from the node.
   Expression* left = node->left();
   Expression* right = node->right();
   Token::Value op = node->op();
   // To make typeof testing for natives implemented in JavaScript really
   // efficient, we generate special code for expressions of the form:
   // 'typeof <expression> == <string>'.
   UnaryOperation* operation = left->AsUnaryOperation();
+  Isolate* isolate = masm()->isolate();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
   if ((op == Token::EQ || op == Token::EQ_STRICT) &&
       (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 63 matching lines @@
     Load(right);
   }
   Comparison(node, cc, strict, destination());
 }
 
 
 void CodeGenerator::VisitCompareToNull(CompareToNull* node) {
   ASSERT(!in_safe_int32_mode());
   Comment cmnt(masm_, "[ CompareToNull");
 
+  Factory* factory = masm()->isolate()->factory();
   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(masm()->isolate()->builtins()->builtin(
+  Isolate* isolate = masm()->isolate();
+  Handle<Code> ic(isolate->builtins()->builtin(
       Builtins::kLoadIC_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.
-  Counters* counters = masm()->isolate()->counters();
+  Counters* counters = isolate->counters();
   if (is_contextual_) {
     masm_->mov(is_dont_delete_ ? edx : ecx, -delta_to_patch_site);
     __ IncrementCounter(counters->named_load_global_inline_miss(), 1);
     if (is_dont_delete_) {
       __ IncrementCounter(counters->dont_delete_hint_miss(), 1);
     }
   } else {
     masm_->test(eax, Immediate(-delta_to_patch_site));
     __ IncrementCounter(counters->named_load_inline_miss(), 1);
   }
@@ skipping 17 matching lines @@
 
  private:
   Label patch_site_;
   Register dst_;
   Register receiver_;
   Register key_;
 };
 
 
 void DeferredReferenceGetKeyedValue::Generate() {
+  Isolate* isolate = masm()->isolate();
   if (!receiver_.is(eax)) {
     // Register eax is available for key.
     if (!key_.is(eax)) {
       __ mov(eax, key_);
     }
     if (!receiver_.is(edx)) {
       __ mov(edx, receiver_);
     }
   } else if (!key_.is(edx)) {
     // Register edx is available for receiver.
     if (!receiver_.is(edx)) {
       __ mov(edx, receiver_);
     }
     if (!key_.is(eax)) {
       __ mov(eax, key_);
     }
   } 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(masm()->isolate()->builtins()->builtin(
+  Handle<Code> ic(isolate->builtins()->builtin(
       Builtins::kKeyedLoadIC_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));
-  Counters* counters = masm()->isolate()->counters();
+  Counters* counters = isolate->counters();
   __ IncrementCounter(counters->keyed_load_inline_miss(), 1);
 
   if (!dst_.is(eax)) __ mov(dst_, eax);
 }
 
 
 class DeferredReferenceSetKeyedValue: public DeferredCode {
  public:
   DeferredReferenceSetKeyedValue(Register value,
                                  Register key,
@@ skipping 16 matching lines @@
   Register value_;
   Register key_;
   Register receiver_;
   Register scratch_;
   Label patch_site_;
   StrictModeFlag strict_mode_;
 };
 
 
 void DeferredReferenceSetKeyedValue::Generate() {
-  Counters* counters = masm()->isolate()->counters();
+  Isolate* isolate = masm()->isolate();
+  Counters* counters = isolate->counters();
   __ 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_);
@@ skipping 34 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(masm()->isolate()->builtins()->builtin(
+  Handle<Code> ic(isolate->builtins()->builtin(
       (strict_mode_ == kStrictMode) ? Builtins::kKeyedStoreIC_Initialize_Strict
                                     : Builtins::kKeyedStoreIC_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
@@ skipping 243 matching lines @@
   // against an invalid map.  In the inline cache code, we patch the map
   // check if appropriate.
   if (loop_nesting() > 0) {
     Comment cmnt(masm_, "[ Inlined load from keyed Property");
 
     // Use a fresh temporary to load the elements without destroying
     // the receiver which is needed for the deferred slow case.
     Result elements = allocator()->Allocate();
     ASSERT(elements.is_valid());
 
+    Isolate* isolate = masm()->isolate();
+    Factory* factory = isolate->factory();
+
     Result key = frame_->Pop();
     Result receiver = frame_->Pop();
     key.ToRegister();
     receiver.ToRegister();
 
     // If key and receiver are shared registers on the frame, their values will
     // be automatically saved and restored when going to deferred code.
     // The result is in elements, which is guaranteed non-shared.
     DeferredReferenceGetKeyedValue* deferred =
         new DeferredReferenceGetKeyedValue(elements.reg(),
                                            receiver.reg(),
                                            key.reg());
 
     __ 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(masm_->isolate()->counters()->keyed_load_inline(), 1);
+    __ IncrementCounter(isolate->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 279 matching lines @@
   // esp[8]: Second argument, source pointer.
   // esp[4]: First argument, destination pointer.
   // esp[0]: return address
 
   const int kDestinationOffset = 1 * kPointerSize;
   const int kSourceOffset = 2 * kPointerSize;
   const int kSizeOffset = 3 * kPointerSize;
 
   int stack_offset = 0;  // Update if we change the stack height.
 
+  Isolate* isolate = masm.isolate();
+  Counters* counters = isolate->counters();
+
   if (FLAG_debug_code) {
     __ cmp(Operand(esp, kSizeOffset + stack_offset),
            Immediate(kMinComplexMemCopy));
     Label ok;
     __ j(greater_equal, &ok);
     __ int3();
     __ bind(&ok);
   }
-  if (masm.isolate()->cpu_features()->IsSupported(SSE2)) {
+  if (isolate->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(masm.isolate()->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(masm.isolate()->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(masm.isolate()->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