Finish porting jump target changes to the ARM platform. The v8 test...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 188 matching lines @@
       for (int i = 0; i < scope_->num_parameters(); i++) {
         Variable* par = scope_->parameter(i);
         Slot* slot = par->slot();
         if (slot != NULL && slot->type() == Slot::CONTEXT) {
           // Save the arguments object pointer, if any.
           if (arguments_object_allocated && !arguments_object_saved) {
             frame_->Push(ecx);
             arguments_object_saved = true;
           }
           ASSERT(!scope_->is_global_scope());  // no parameters in global scope
-          __ mov(eax, frame_->Parameter(i));
+          __ mov(eax, frame_->ParameterAt(i));
           // Loads ecx with context; used below in RecordWrite.
           __ mov(SlotOperand(slot, ecx), eax);
           int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
           __ RecordWrite(ecx, offset, eax, ebx);
         }
       }
     }
 
     // This section stores the pointer to the arguments object that
     // was allocated and copied into above. If the address was not
@@ skipping 93 matching lines @@
   // (such as the variable referring to a named function expression).
   // We need to implement assignments to read-only variables.
   // Ideally, we should do this during AST generation (by converting
   // such assignments into expression statements); however, in general
   // we may not be able to make the decision until past AST generation,
   // that is when the entire program is known.
   ASSERT(slot != NULL);
   int index = slot->index();
   switch (slot->type()) {
     case Slot::PARAMETER:
-      return frame_->Parameter(index);
+      return frame_->ParameterAt(index);
 
     case Slot::LOCAL:
-      return frame_->Local(index);
+      return frame_->LocalAt(index);
 
     case Slot::CONTEXT: {
       // Follow the context chain if necessary.
       ASSERT(!tmp.is(esi));  // do not overwrite context register
       Register context = esi;
       int chain_length = scope()->ContextChainLength(slot->var()->scope());
       for (int i = chain_length; i-- > 0;) {
         // Load the closure.
         // (All contexts, even 'with' contexts, have a closure,
         // and it is the same for all contexts inside a function.
@@ skipping 33 matching lines @@
                                   JumpTarget* false_target,
                                   bool force_cc) {
   ASSERT(!has_cc());
 
   { CodeGenState new_state(this, typeof_state, true_target, false_target);
     Visit(x);
   }
 
   if (force_cc && frame_ != NULL && !has_cc()) {
     // Convert the TOS value to a boolean in the condition code register.
-    // Visiting an expression may possibly choose neither (a) to leave a
-    // value in the condition code register nor (b) to leave a value in TOS
-    // (eg, by compiling to only jumps to the targets).  In that case the
-    // code generated by ToBoolean is wrong because it assumes the value of
-    // the expression in TOS.  So long as there is always a value in TOS or
-    // the condition code register when control falls through to here (there
-    // is), the code generated by ToBoolean is dead and therefore safe.
     ToBoolean(true_target, false_target);
   }
 
   ASSERT(!force_cc || frame_ == NULL || has_cc());
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
   JumpTarget true_target(this);
   JumpTarget false_target(this);
   LoadCondition(x, typeof_state, &true_target, &false_target, false);
 
   if (has_cc()) {
     ASSERT(frame_ != NULL);
-    // convert cc_reg_ into a bool
+    // Convert cc_reg_ into a boolean value.
     JumpTarget loaded(this);
     JumpTarget materialize_true(this);
     materialize_true.Branch(cc_reg_);
     frame_->Push(Immediate(Factory::false_value()));
     loaded.Jump();
     materialize_true.Bind();
     frame_->Push(Immediate(Factory::true_value()));
     loaded.Bind();
     cc_reg_ = no_condition;
   }
 
   if (true_target.is_linked() || false_target.is_linked()) {
-    // we have at least one condition value
-    // that has been "translated" into a branch,
-    // thus it needs to be loaded explicitly again
+    // We have at least one condition value that has been "translated" into
+    // a branch, thus it needs to be loaded explicitly.
     JumpTarget loaded(this);
     if (frame_ != NULL) {
-      loaded.Jump();  // don't lose current TOS
+      loaded.Jump();  // Don't lose the current TOS.
     }
     bool both = true_target.is_linked() && false_target.is_linked();
-    // reincarnate "true", if necessary
+    // Load "true" if necessary.
     if (true_target.is_linked()) {
       true_target.Bind();
       frame_->Push(Immediate(Factory::true_value()));
     }
-    // if both "true" and "false" need to be reincarnated,
-    // jump across code for "false"
+    // If both "true" and "false" need to be reincarnated jump across the
+    // code for "false".
     if (both) {
       loaded.Jump();
     }
-    // reincarnate "false", if necessary
+    // Load "false" if necessary.
     if (false_target.is_linked()) {
       false_target.Bind();
       frame_->Push(Immediate(Factory::false_value()));
     }
-    // everything is loaded at this point
+    // A value is loaded on all paths reaching this point.
     loaded.Bind();
   }
+  ASSERT(frame_ != NULL);
   ASSERT(!has_cc());
 }
 
 
 void CodeGenerator::LoadGlobal() {
   frame_->Push(GlobalObject());
 }
 
 
 void CodeGenerator::LoadGlobalReceiver(Register scratch) {
@@ skipping 783 matching lines @@
   Major MajorKey() { return CallFunction; }
   int MinorKey() { return argc_; }
 };
 
 
 // Call the function just below TOS on the stack with the given
 // arguments. The receiver is the TOS.
 void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
                                           int position) {
   // Push the arguments ("left-to-right") on the stack.
-  for (int i = 0; i < args->length(); i++) {
+  int arg_count = args->length();
+  for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   // Record the position for debugging purposes.
   __ RecordPosition(position);
 
   // Use the shared code stub to call the function.
-  CallFunctionStub call_function(args->length());
-  frame_->CallStub(&call_function, args->length() + 1);
+  CallFunctionStub call_function(arg_count);
+  frame_->CallStub(&call_function, arg_count + 1);
 
   // Restore context and pop function from the stack.
   __ mov(esi, frame_->Context());
   __ mov(frame_->Top(), eax);
 }
 
 
 void CodeGenerator::Branch(bool if_true, JumpTarget* target) {
   ASSERT(has_cc());
   Condition cc = if_true ? cc_reg_ : NegateCondition(cc_reg_);
@@ skipping 117 matching lines @@
 
 
 void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
   Comment cmnt(masm_, "// EmptyStatement");
   // nothing to do
 }
 
 
 void CodeGenerator::VisitIfStatement(IfStatement* node) {
   Comment cmnt(masm_, "[ IfStatement");
-  // Generate different code depending on which
-  // parts of the if statement are present or not.
+  // Generate different code depending on which parts of the if statement
+  // are present or not.
   bool has_then_stm = node->HasThenStatement();
   bool has_else_stm = node->HasElseStatement();
 
   RecordStatementPosition(node);
   JumpTarget exit(this);
   if (has_then_stm && has_else_stm) {
     JumpTarget then(this);
     JumpTarget else_(this);
     // if (cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
@@ skipping 250 matching lines @@
   Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
     return;
   }
 
   JumpTarget next_test(this);
   JumpTarget fall_through(this);
   JumpTarget default_entry(this);
   JumpTarget default_exit(this);
-
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
   CaseClause* default_clause = NULL;
 
   for (int i = 0; i < length; i++) {
     CaseClause* clause = cases->at(i);
+    if (clause->is_default()) {
+      // Remember the default clause and compile it at the end.
+      default_clause = clause;
+      continue;
+    }
 
-    if (clause->is_default()) {
-      default_clause = clause;
+    Comment cmnt(masm_, "[ Case clause");
+    // Compile the test.
+    next_test.Bind();
+    next_test.Unuse();
+    // Duplicate TOS.
+    __ mov(eax, frame_->Top());
+    frame_->Push(eax);
+    Load(clause->label());
+    Comparison(equal, true);
+    Branch(false, &next_test);
+
+    // Before entering the body from the test, remove the switch value from
+    // the stack.
+    frame_->Drop();
+
+    // Label the body so that fall through is enabled.
+    if (i > 0 && cases->at(i - 1)->is_default()) {
+      default_exit.Bind();
     } else {
-      Comment cmnt(masm_, "[ Case clause");
+      fall_through.Bind();
+      fall_through.Unuse();
+    }
+    VisitStatements(clause->statements());
 
-      // Compile the test.
-      next_test.Bind();
-      next_test.Unuse();
-      // Duplicate TOS.
-      __ mov(eax, frame_->Top());
-      frame_->Push(eax);
-      Load(clause->label());
-      Comparison(equal, true);
-      Branch(false, &next_test);
-
-      // Before entering the body, remove the switch value from the stack.
-      frame_->Drop();
-
-      // Label the body so that fall through is enabled.
-      if (i > 0 && cases->at(i - 1)->is_default()) {
-        default_exit.Bind();
+    // If control flow can fall through from the body, jump to the next body
+    // or the end of the statement.
+    if (frame_ != NULL) {
+      if (i < length - 1 && cases->at(i + 1)->is_default()) {
+        default_entry.Jump();
       } else {
-        fall_through.Bind();
-        fall_through.Unuse();
-      }
-      VisitStatements(clause->statements());
-
-      // If control flow can fall through from the body jump to the
-      // next body or end of the statement.
-      if (frame_ != NULL) {
-        if (i < length - 1 && cases->at(i + 1)->is_default()) {
-          default_entry.Jump();
-        } else {
-          fall_through.Jump();
-        }
+        fall_through.Jump();
       }
     }
   }
 
-  // The final test removes the switch value.
+  // The final "test" removes the switch value.
   next_test.Bind();
   frame_->Drop();
 
   // If there is a default clause, compile it.
   if (default_clause != NULL) {
     Comment cmnt(masm_, "[ Default clause");
     default_entry.Bind();
     VisitStatements(default_clause->statements());
     // If control flow can fall out of the default and there is a case after
     // it, jump to that case's body.
@@ skipping 32 matching lines @@
         info = ALWAYS_TRUE;
       } else if (lit->IsFalse()) {
         info = ALWAYS_FALSE;
       }
     }
   }
 
   switch (node->type()) {
     case LoopStatement::DO_LOOP: {
       JumpTarget body(this);
-
       IncrementLoopNesting();
       // Label the body.
       if (info == ALWAYS_TRUE) {
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // There is no need, we will never jump back.
       } else {
         ASSERT(info == DONT_KNOW);
         body.Bind();
       }
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       Visit(node->body());
 
+      // Compile the "test".
       if (info == ALWAYS_TRUE) {
         if (frame_ != NULL) {
           // If control flow can fall off the end of the body, jump back to
           // the top.
           node->continue_target()->Jump();
         }
       } else if (info == ALWAYS_FALSE) {
         // If we have a continue in the body, we only have to bind its jump
         // target.
         if (node->continue_target()->is_linked()) {
           node->continue_target()->Bind();
         }
       } else {
         ASSERT(info == DONT_KNOW);
-        // We have to compile the test expression if we don't know its value
-        // and it can be reached by control flow falling out of the body or
-        // via continue.
+        // We have to compile the test expression if it can be reached by
+        // control flow falling out of the body or via continue.
         if (frame_ != NULL || node->continue_target()->is_linked()) {
           node->continue_target()->Bind();
           LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                         &body, node->break_target(), true);
           if (frame_ != NULL) {
             // A NULL frame here indicates that control flow did not fall
             // out of the test expression.
             Branch(true, &body);
           }
         }
       }
       break;
     }
 
     case LoopStatement::WHILE_LOOP: {
-
       JumpTarget body(this);
-
       IncrementLoopNesting();
       // Generate the loop header.
       if (info == ALWAYS_TRUE) {
         // Merely label the body with the continue target.
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // There is no need to even compile the test or body.
         break;
       } else {
         // Compile the test labeled with the continue target and label the
@@ skipping 98 matching lines @@
 
   // We keep stuff on the stack while the body is executing.
   // Record it, so that a break/continue crossing this statement
   // can restore the stack.
   const int kForInStackSize = 5 * kPointerSize;
   break_stack_height_ += kForInStackSize;
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->set_code_generator(this);
   node->continue_target()->set_code_generator(this);
 
+  JumpTarget primitive(this);
+  JumpTarget jsobject(this);
+  JumpTarget fixed_array(this);
   JumpTarget entry(this);
+  JumpTarget end_del_check(this);
   JumpTarget cleanup(this);
   JumpTarget exit(this);
-  JumpTarget primitive(this);
-  JumpTarget jsobject(this);
-  JumpTarget end_del_check(this);
-  JumpTarget fixed_array(this);
 
   // Get the object to enumerate over (converted to JSObject).
   Load(node->enumerable());
 
   // Both SpiderMonkey and kjs ignore null and undefined in contrast
   // to the specification.  12.6.4 mandates a call to ToObject.
   frame_->Pop(eax);
 
   // eax: value to be iterated over
   __ cmp(eax, Factory::undefined_value());
@@ skipping 15 matching lines @@
   __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
   __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
   __ cmp(ecx, FIRST_JS_OBJECT_TYPE);
   jsobject.Branch(above_equal);
 
   primitive.Bind();
   frame_->Push(eax);
   frame_->InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION, 1);
   // function call returns the value in eax, which is where we want it below
 
-
   jsobject.Bind();
-
   // Get the set of properties (as a FixedArray or Map).
   // eax: value to be iterated over
   frame_->Push(eax);  // push the object being iterated over (slot 4)
 
   frame_->Push(eax);  // push the Object (slot 4) for the runtime call
   frame_->CallRuntime(Runtime::kGetPropertyNamesFast, 1);
 
   // If we got a Map, we can do a fast modification check.
   // Otherwise, we got a FixedArray, and we have to do a slow check.
   // eax: map or fixed array (result from call to
@@ skipping 13 matching lines @@
   __ mov(edx, FieldOperand(ecx, DescriptorArray::kEnumCacheBridgeCacheOffset));
 
   frame_->Push(eax);  // <- slot 3
   frame_->Push(edx);  // <- slot 2
   __ mov(eax, FieldOperand(edx, FixedArray::kLengthOffset));
   __ shl(eax, kSmiTagSize);
   frame_->Push(eax);  // <- slot 1
   frame_->Push(Immediate(Smi::FromInt(0)));  // <- slot 0
   entry.Jump();
 
-
   fixed_array.Bind();
-
   // eax: fixed array (result from call to Runtime::kGetPropertyNamesFast)
   frame_->Push(Immediate(Smi::FromInt(0)));  // <- slot 3
   frame_->Push(eax);  // <- slot 2
 
   // Push the length of the array and the initial index onto the stack.
   __ mov(eax, FieldOperand(eax, FixedArray::kLengthOffset));
   __ shl(eax, kSmiTagSize);
   frame_->Push(eax);  // <- slot 1
   frame_->Push(Immediate(Smi::FromInt(0)));  // <- slot 0
 
   // Condition.
   entry.Bind();
-
   __ mov(eax, frame_->ElementAt(0));  // load the current count
   __ cmp(eax, frame_->ElementAt(1));  // compare to the array length
   cleanup.Branch(above_equal);
 
   // Get the i'th entry of the array.
   __ mov(edx, frame_->ElementAt(2));
   __ mov(ebx, Operand(edx, eax, times_2,
                       FixedArray::kHeaderSize - kHeapObjectTag));
 
   // Get the expected map from the stack or a zero map in the
@@ skipping 14 matching lines @@
   frame_->Push(frame_->ElementAt(4));  // push enumerable
   frame_->Push(ebx);  // push entry
   frame_->InvokeBuiltin(Builtins::FILTER_KEY, CALL_FUNCTION, 2);
   __ mov(ebx, Operand(eax));
 
   // If the property has been removed while iterating, we just skip it.
   __ cmp(ebx, Factory::null_value());
   node->continue_target()->Branch(equal);
 
   end_del_check.Bind();
-  // Store the entry in the 'each' expression and take another spin in the loop.
-  // edx: i'th entry of the enum cache (or string there of)
+  // Store the entry in the 'each' expression and take another spin in the
+  // loop.  edx: i'th entry of the enum cache (or string there of)
   frame_->Push(ebx);
   { Reference each(this, node->each());
     if (!each.is_illegal()) {
       if (each.size() > 0) {
         frame_->Push(frame_->ElementAt(each.size()));
       }
       // If the reference was to a slot we rely on the convenient property
       // that it doesn't matter whether a value (eg, ebx pushed above) is
       // right on top of or right underneath a zero-sized reference.
       each.SetValue(NOT_CONST_INIT);
@@ skipping 134 matching lines @@
       // break from (eg, for...in) may have left stuff on the stack.
       __ mov(edx, Operand::StaticVariable(handler_address));
       const int kNextOffset = StackHandlerConstants::kNextOffset +
           StackHandlerConstants::kAddressDisplacement;
       __ lea(esp, Operand(edx, kNextOffset));
       frame_->Forget(frame_->height() - handler_height);
 
       frame_->Pop(Operand::StaticVariable(handler_address));
       frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
       // next_sp popped.
-      JumpTarget* original_target = shadows[i]->original_target();
-      original_target->Jump();
+      shadows[i]->original_target()->Jump();
     }
   }
 
   exit.Bind();
 }
 
 
 void CodeGenerator::VisitTryFinally(TryFinally* node) {
   Comment cmnt(masm_, "[ TryFinally");
 
   // 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 exit(this);
   JumpTarget unlink(this);
   JumpTarget try_block(this);
   JumpTarget finally_block(this);
 
   try_block.Call();
 
   frame_->Push(eax);
   // In case of thrown exceptions, this is where we continue.
   __ Set(ecx, Immediate(Smi::FromInt(THROWING)));
   finally_block.Jump();
@@ skipping 94 matching lines @@
   // that a break/continue crossing this statement can restore the
   // stack.
   const int kFinallyStackSize = 2 * kPointerSize;
   break_stack_height_ += kFinallyStackSize;
 
   // Generate code for the statements in the finally block.
   VisitStatements(node->finally_block()->statements());
 
   break_stack_height_ -= kFinallyStackSize;
   if (frame_ != NULL) {
+    JumpTarget exit(this);
     // Restore state and return value or faked TOS.
     frame_->Pop(ecx);
     frame_->Pop(eax);
 
     // Generate code to jump to the right destination for all used
     // (formerly) shadowing targets.
     for (int i = 0; i <= nof_escapes; i++) {
       if (shadows[i]->is_bound()) {
         __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
         shadows[i]->original_target()->Branch(equal);
@@ skipping 282 matching lines @@
       case ObjectLiteral::Property::CONSTANT: break;
       case ObjectLiteral::Property::COMPUTED: {
         Handle<Object> key(property->key()->handle());
         Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
         if (key->IsSymbol()) {
           __ mov(eax, frame_->Top());
           frame_->Push(eax);
           Load(property->value());
           frame_->Pop(eax);
           __ Set(ecx, Immediate(key));
-          frame_->CallCode(ic, RelocInfo::CODE_TARGET, 0);
+          frame_->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
           frame_->Drop();
           // Ignore result.
           break;
         }
         // Fall through
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         __ mov(eax, frame_->Top());
         frame_->Push(eax);
         Load(property->key());
@@ skipping 177 matching lines @@
 
     // Push the name of the function and the receiver onto the stack.
     frame_->Push(Immediate(var->name()));
 
     // Pass the global object as the receiver and let the IC stub
     // patch the stack to use the global proxy as 'this' in the
     // invoked function.
     LoadGlobal();
 
     // Load the arguments.
-    for (int i = 0; i < args->length(); i++) {
+    int arg_count = args->length();
+    for (int i = 0; i < arg_count; i++) {
       Load(args->at(i));
     }
 
     // Setup the receiver register and call the IC initialization code.
-    Handle<Code> stub = ComputeCallInitialize(args->length());
+    Handle<Code> stub = ComputeCallInitialize(arg_count);
     __ RecordPosition(node->position());
-    frame_->CallCode(stub, RelocInfo::CODE_TARGET_CONTEXT, args->length() + 1);
+    frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET_CONTEXT,
+                           arg_count + 1);
     __ mov(esi, frame_->Context());
 
     // Overwrite the function on the stack with the result.
     __ mov(frame_->Top(), eax);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript example: 'with (obj) foo(1, 2, 3)'  // foo is in obj
     // ----------------------------------
@@ skipping 18 matching lines @@
     if (literal != NULL && literal->handle()->IsSymbol()) {
       // ------------------------------------------------------------------
       // JavaScript example: 'object.foo(1, 2, 3)' or 'map["key"](1, 2, 3)'
       // ------------------------------------------------------------------
 
       // Push the name of the function and the receiver onto the stack.
       frame_->Push(Immediate(literal->handle()));
       Load(property->obj());
 
       // Load the arguments.
-      for (int i = 0; i < args->length(); i++) Load(args->at(i));
+      int arg_count = args->length();
+      for (int i = 0; i < arg_count; i++) {
+        Load(args->at(i));
+      }
 
       // Call the IC initialization code.
-      Handle<Code> stub = ComputeCallInitialize(args->length());
+      Handle<Code> stub = ComputeCallInitialize(arg_count);
       __ RecordPosition(node->position());
-      frame_->CallCode(stub, RelocInfo::CODE_TARGET, args->length() + 1);
+      frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
       __ mov(esi, frame_->Context());
 
       // Overwrite the function on the stack with the result.
       __ mov(frame_->Top(), eax);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
@@ skipping 36 matching lines @@
   // evaluated.
 
   // Compute function to call and use the global object as the
   // receiver. There is no need to use the global proxy here because
   // it will always be replaced with a newly allocated object.
   Load(node->expression());
   LoadGlobal();
 
   // Push the arguments ("left-to-right") on the stack.
   ZoneList<Expression*>* args = node->arguments();
-  for (int i = 0; i < args->length(); i++) {
+  int arg_count = args->length();
+  for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   // Constructors are called with the number of arguments in register
   // eax for now. Another option would be to have separate construct
   // call trampolines per different arguments counts encountered.
-  __ Set(eax, Immediate(args->length()));
+  __ Set(eax, Immediate(arg_count));
 
   // Load the function into temporary function slot as per calling
   // convention.
-  __ mov(edi, frame_->ElementAt(args->length() + 1));
+  __ mov(edi, frame_->ElementAt(arg_count + 1));
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   __ RecordPosition(node->position());
   Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
-  frame_->CallCode(ic, RelocInfo::CONSTRUCT_CALL, args->length() + 1);
+  frame_->CallCodeObject(ic, RelocInfo::CONSTRUCT_CALL, args->length() + 1);
   // Discard the function and "push" the newly created object.
   __ mov(frame_->Top(), eax);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   Load(args->at(0));
   frame_->Pop(eax);
   __ test(eax, Immediate(kSmiTagMask));
@@ skipping 254 matching lines @@
 
   if (function == NULL) {
     // Prepare stack for calling JS runtime function.
     frame_->Push(Immediate(node->name()));
     // Push the builtins object found in the current global object.
     __ mov(edx, GlobalObject());
     frame_->Push(FieldOperand(edx, GlobalObject::kBuiltinsOffset));
   }
 
   // Push the arguments ("left-to-right").
-  for (int i = 0; i < args->length(); i++) {
+  int arg_count = args->length();
+  for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   if (function == NULL) {
     // Call the JS runtime function.
-    Handle<Code> stub = ComputeCallInitialize(args->length());
+    Handle<Code> stub = ComputeCallInitialize(arg_count);
     __ Set(eax, Immediate(args->length()));
-    frame_->CallCode(stub, RelocInfo::CODE_TARGET, args->length() + 1);
+    frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
     __ mov(esi, frame_->Context());
     __ mov(frame_->Top(), eax);
   } else {
     // Call the C runtime function.
-    frame_->CallRuntime(function, args->length());
+    frame_->CallRuntime(function, arg_count);
     frame_->Push(eax);
   }
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
   // Note that because of NOT and an optimization in comparison of a typeof
   // expression to a literal string, this function can fail to leave a value
   // on top of the frame or in the cc register.
   Comment cmnt(masm_, "[ UnaryOperation");
@@ skipping 692 matching lines @@
       // loads must not throw a reference error).
       Comment cmnt(masm, "[ Load from named Property");
       Handle<String> name(GetName());
       Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
       // Setup the name register.
       __ mov(ecx, name);
 
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       if (var != NULL) {
         ASSERT(var->is_global());
-        frame->CallCode(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
+        frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
       } else {
-        frame->CallCode(ic, RelocInfo::CODE_TARGET, 0);
+        frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       }
       frame->Push(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     case KEYED: {
       // TODO(1241834): Make sure that this it is safe to ignore the
       // distinction between expressions in a typeof and not in a typeof.
       Comment cmnt(masm, "[ Load from keyed Property");
       Property* property = expression_->AsProperty();
       ASSERT(property != NULL);
       __ RecordPosition(property->position());
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
 
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       if (var != NULL) {
         ASSERT(var->is_global());
-        frame->CallCode(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
+        frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
       } else {
-        frame->CallCode(ic, RelocInfo::CODE_TARGET, 0);
+        frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       }
       frame->Push(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
@@ skipping 83 matching lines @@
 
     case NAMED: {
       Comment cmnt(masm, "[ Store to named Property");
       // Call the appropriate IC code.
       Handle<String> name(GetName());
       Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
       // TODO(1222589): Make the IC grab the values from the stack.
       frame->Pop(eax);
       // Setup the name register.
       __ mov(ecx, name);
-      frame->CallCode(ic, RelocInfo::CODE_TARGET, 0);
+      frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       frame->Push(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     case KEYED: {
       Comment cmnt(masm, "[ Store to keyed Property");
       Property* property = expression_->AsProperty();
       ASSERT(property != NULL);
       __ RecordPosition(property->position());
       // Call IC code.
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       // TODO(1222589): Make the IC grab the values from the stack.
       frame->Pop(eax);
-      frame->CallCode(ic, RelocInfo::CODE_TARGET, 0);
+      frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       frame->Push(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
@@ skipping 1215 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal