Some cleanup of the toplevel code generator:...

src/x64/fast-codegen-x64.cc

 // Copyright 2009 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 184 matching lines @@
     }
     // Check that the size of the code used for returning matches what is
     // expected by the debugger.
     ASSERT_EQ(Assembler::kJSReturnSequenceLength,
             masm_->SizeOfCodeGeneratedSince(&check_exit_codesize));
 #endif
   }
 }
 
 
-void FastCodeGenerator::Move(Expression::Context context, Register source) {
+void FastCodeGenerator::Apply(Expression::Context context,
+                              Slot* slot,
+                              Register scratch) {
+  switch (context) {
+    case Expression::kUninitialized:
+      UNREACHABLE();
+    case Expression::kEffect:
+      break;
+    case Expression::kValue: {
+      MemOperand location = EmitSlotSearch(slot, scratch);
+      __ push(location);
+      break;
+    }
+    case Expression::kTest:
+    case Expression::kValueTest:
+    case Expression::kTestValue:
+      Move(scratch, slot);
+      Apply(context, scratch);
+      break;
+  }
+}
+
+
+void FastCodeGenerator::Apply(Expression::Context context, Literal* lit) {
   switch (context) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:
       break;
     case Expression::kValue:
-      __ push(source);
+      __ Push(lit->handle());
       break;
     case Expression::kTest:
-      TestAndBranch(source, true_label_, false_label_);
+    case Expression::kValueTest:
+    case Expression::kTestValue:
+      __ Move(rax, lit->handle());
+      Apply(context, rax);
       break;
-    case Expression::kValueTest: {
-      Label discard;
-      __ push(source);
-      TestAndBranch(source, true_label_, &discard);
-      __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
-      __ jmp(false_label_);
-      break;
-    }
-    case Expression::kTestValue: {
-      Label discard;
-      __ push(source);
-      TestAndBranch(source, &discard, false_label_);
-      __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
-      __ jmp(true_label_);
-      break;
-    }
   }
 }
 
 
-void FastCodeGenerator::MoveTOS(Expression::Context context) {
+void FastCodeGenerator::ApplyTOS(Expression::Context context) {
   switch (context) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:
       __ Drop(1);
       break;
     case Expression::kValue:
       break;
     case Expression::kTest:
       __ pop(rax);
       TestAndBranch(rax, true_label_, false_label_);
       break;
     case Expression::kValueTest: {
       Label discard;
       __ movq(rax, Operand(rsp, 0));
       TestAndBranch(rax, true_label_, &discard);
       __ bind(&discard);
       __ Drop(1);
       __ jmp(false_label_);
+      break;
+    }
+    case Expression::kTestValue: {
+      Label discard;
+      __ movq(rax, Operand(rsp, 0));
+      TestAndBranch(rax, &discard, false_label_);
+      __ bind(&discard);
+      __ Drop(1);
+      __ jmp(true_label_);
+    }
+  }
+}
+
+
+void FastCodeGenerator::DropAndApply(int count,
+                                     Expression::Context context,
+                                     Register reg) {
+  ASSERT(count > 0);
+  ASSERT(!reg.is(rsp));
+  switch (context) {
+    case Expression::kUninitialized:
+      UNREACHABLE();
+    case Expression::kEffect:
+      __ Drop(count);
+      break;
+    case Expression::kValue:
+      if (count > 1) __ Drop(count - 1);
+      __ movq(Operand(rsp, 0), reg);
+      break;
+    case Expression::kTest:
+      __ Drop(count);
+      TestAndBranch(reg, true_label_, false_label_);
+      break;
+    case Expression::kValueTest: {
+      Label discard;
+      if (count > 1) __ Drop(count - 1);
+      __ movq(Operand(rsp, 0), reg);
+      TestAndBranch(reg, true_label_, &discard);
+      __ bind(&discard);
+      __ Drop(1);
+      __ jmp(false_label_);
       break;
     }
     case Expression::kTestValue: {
       Label discard;
-      __ movq(rax, Operand(rsp, 0));
-      TestAndBranch(rax, &discard, false_label_);
+      if (count > 1) __ Drop(count - 1);
+      __ movq(Operand(rsp, 0), reg);
+      TestAndBranch(reg, &discard, false_label_);
       __ bind(&discard);
       __ Drop(1);
       __ jmp(true_label_);
+      break;
     }
   }
 }
 
 
 MemOperand FastCodeGenerator::EmitSlotSearch(Slot* slot, Register scratch) {
   switch (slot->type()) {
     case Slot::PARAMETER:
     case Slot::LOCAL:
       return Operand(rbp, SlotOffset(slot));
@@ skipping 10 matching lines @@
   return Operand(rax, 0);
 }
 
 
 void FastCodeGenerator::Move(Register destination, Slot* source) {
   MemOperand location = EmitSlotSearch(source, destination);
   __ movq(destination, location);
 }
 
 
-void FastCodeGenerator::Move(Expression::Context context,
-                             Slot* source,
-                             Register scratch) {
-  switch (context) {
-    case Expression::kUninitialized:
-      UNREACHABLE();
-    case Expression::kEffect:
-      break;
-    case Expression::kValue: {
-      MemOperand location = EmitSlotSearch(source, scratch);
-      __ push(location);
-      break;
-    }
-    case Expression::kTest:
-    case Expression::kValueTest:
-    case Expression::kTestValue:
-      Move(scratch, source);
-      Move(context, scratch);
-      break;
-  }
-}
-
-
-void FastCodeGenerator::Move(Expression::Context context, Literal* expr) {
-  switch (context) {
-    case Expression::kUninitialized:
-      UNREACHABLE();
-    case Expression::kEffect:
-      break;
-    case Expression::kValue:
-      __ Push(expr->handle());
-      break;
-    case Expression::kTest:
-    case Expression::kValueTest:
-    case Expression::kTestValue:
-      __ Move(rax, expr->handle());
-      Move(context, rax);
-      break;
-  }
-}
-
-
 void FastCodeGenerator::Move(Slot* dst,
                              Register src,
                              Register scratch1,
                              Register scratch2) {
   ASSERT(dst->type() != Slot::LOOKUP);  // Not yet implemented.
   ASSERT(!scratch1.is(src) && !scratch2.is(src));
   MemOperand location = EmitSlotSearch(dst, scratch1);
   __ movq(location, src);
   // Emit the write barrier code if the location is in the heap.
   if (dst->type() == Slot::CONTEXT) {
     int offset = FixedArray::kHeaderSize + dst->index() * kPointerSize;
     __ RecordWrite(scratch1, offset, src, scratch2);
   }
 }
 
 
-void FastCodeGenerator::DropAndMove(Expression::Context context,
-                                    Register source,
-                                    int drop_count) {
-  ASSERT(drop_count > 0);
-  switch (context) {
-    case Expression::kUninitialized:
-      UNREACHABLE();
-    case Expression::kEffect:
-      __ addq(rsp, Immediate(drop_count * kPointerSize));
-      break;
-    case Expression::kValue:
-      if (drop_count > 1) {
-        __ addq(rsp, Immediate((drop_count - 1) * kPointerSize));
-      }
-      __ movq(Operand(rsp, 0), source);
-      break;
-    case Expression::kTest:
-      ASSERT(!source.is(rsp));
-      __ addq(rsp, Immediate(drop_count * kPointerSize));
-      TestAndBranch(source, true_label_, false_label_);
-      break;
-    case Expression::kValueTest: {
-      Label discard;
-      if (drop_count > 1) {
-        __ addq(rsp, Immediate((drop_count - 1) * kPointerSize));
-      }
-      __ movq(Operand(rsp, 0), source);
-      TestAndBranch(source, true_label_, &discard);
-      __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
-      __ jmp(false_label_);
-      break;
-    }
-    case Expression::kTestValue: {
-      Label discard;
-      __ movq(Operand(rsp, 0), source);
-      TestAndBranch(source, &discard, false_label_);
-      __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
-      __ jmp(true_label_);
-      break;
-    }
-  }
-}
-
-
 void FastCodeGenerator::TestAndBranch(Register source,
                                       Label* true_label,
                                       Label* false_label) {
   ASSERT_NE(NULL, true_label);
   ASSERT_NE(NULL, false_label);
   // Use the shared ToBoolean stub to compile the value in the register into
   // control flow to the code generator's true and false labels.  Perform
   // the fast checks assumed by the stub.
 
   // The undefined value is false.
@@ skipping 109 matching lines @@
       }
 
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
 
       // Absence of a test rax instruction following the call
       // indicates that none of the load was inlined.
 
       // Value in rax is ignored (declarations are statements).  Receiver
       // and key on stack are discarded.
-      __ addq(rsp, Immediate(2 * kPointerSize));
+      __ Drop(2);
     }
   }
 }
 
 
 void FastCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   // Call the runtime to declare the globals.
   __ push(rsi);  // The context is the first argument.
   __ Push(pairs);
   __ Push(Smi::FromInt(is_eval_ ? 1 : 0));
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
 }
 
 
 void FastCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
   // Build the function boilerplate and instantiate it.
   Handle<JSFunction> boilerplate =
       Compiler::BuildBoilerplate(expr, script_, this);
   if (HasStackOverflow()) return;
 
   ASSERT(boilerplate->IsBoilerplate());
 
   // Create a new closure.
   __ push(rsi);
   __ Push(boilerplate);
   __ CallRuntime(Runtime::kNewClosure, 2);
-  Move(expr->context(), rax);
+  Apply(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
   Comment cmnt(masm_, "[ VariableProxy");
   EmitVariableLoad(expr->var(), expr->context());
 }
 
 
 void FastCodeGenerator::EmitVariableLoad(Variable* var,
                                           Expression::Context context) {
   Expression* rewrite = var->rewrite();
   if (rewrite == NULL) {
     ASSERT(var->is_global());
     Comment cmnt(masm_, "Global variable");
     // Use inline caching. Variable name is passed in rcx and the global
     // object on the stack.
     __ push(CodeGenerator::GlobalObject());
     __ Move(rcx, var->name());
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     // A test rax instruction following the call is used by the IC to
     // indicate that the inobject property case was inlined.  Ensure there
     // is no test rax instruction here.
     __ nop();
 
-    DropAndMove(context, rax);
+    DropAndApply(1, context, rax);
   } else if (rewrite->AsSlot() != NULL) {
     Slot* slot = rewrite->AsSlot();
     if (FLAG_debug_code) {
       switch (slot->type()) {
         case Slot::LOCAL:
         case Slot::PARAMETER: {
           Comment cmnt(masm_, "Stack slot");
           break;
         }
         case Slot::CONTEXT: {
           Comment cmnt(masm_, "Context slot");
           break;
         }
         case Slot::LOOKUP:
           UNIMPLEMENTED();
           break;
       }
     }
-    Move(context, slot, rax);
+    Apply(context, slot, rax);
   } else {
-    // A variable has been rewritten into an explicit access to
-    // an object property.
+    Comment cmnt(masm_, "Variable rewritten to property");
+    // A variable has been rewritten into an explicit access to an object
+    // property.
     Property* property = rewrite->AsProperty();
     ASSERT_NOT_NULL(property);
 
-    // Currently the only parameter expressions that can occur are
-    // on the form "slot[literal]".
+    // The only property expressions that can occur are of the form
+    // "slot[literal]".
 
-    // Check that the object is in a slot.
+    // Assert that the object is in a slot.
     Variable* object = property->obj()->AsVariableProxy()->AsVariable();
     ASSERT_NOT_NULL(object);
     Slot* object_slot = object->slot();
     ASSERT_NOT_NULL(object_slot);
 
     // Load the object.
-    Move(Expression::kValue, object_slot, rax);
+    MemOperand object_loc = EmitSlotSearch(object_slot, rax);
+    __ push(object_loc);
 
-    // Check that the key is a smi.
+    // Assert that the key is a smi.
     Literal* key_literal = property->key()->AsLiteral();
     ASSERT_NOT_NULL(key_literal);
     ASSERT(key_literal->handle()->IsSmi());
 
     // Load the key.
-    Move(Expression::kValue, key_literal);
+    __ Push(key_literal->handle());
 
-    // Do a KEYED property load.
+    // Do a keyed property load.
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
-    // Notice: We must not have a "test rax, ..." instruction after
-    // the call. It is treated specially by the LoadIC code.
+    // Notice: We must not have a "test rax, ..." instruction after the
+    // call. It is treated specially by the LoadIC code.
 
     // Drop key and object left on the stack by IC, and push the result.
-    DropAndMove(context, rax, 2);
+    DropAndApply(2, context, rax);
   }
 }
 
 
 void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
   Comment cmnt(masm_, "[ RegExpLiteral");
   Label done;
   // Registers will be used as follows:
   // rdi = JS function.
   // rbx = literals array.
   // rax = regexp literal.
   __ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
   int literal_offset =
     FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ movq(rax, FieldOperand(rbx, literal_offset));
   __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, &done);
   // Create regexp literal using runtime function
   // Result will be in rax.
   __ push(rbx);
   __ Push(Smi::FromInt(expr->literal_index()));
   __ Push(expr->pattern());
   __ Push(expr->flags());
   __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   // Label done:
   __ bind(&done);
-  Move(expr->context(), rax);
+  Apply(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   __ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ push(FieldOperand(rdi, JSFunction::kLiteralsOffset));
   __ Push(Smi::FromInt(expr->literal_index()));
   __ Push(expr->constant_properties());
   if (expr->depth() > 1) {
@@ skipping 55 matching lines @@
         __ CallRuntime(Runtime::kDefineAccessor, 4);
         __ movq(rax, Operand(rsp, 0));  // Restore result into rax.
         break;
       default: UNREACHABLE();
     }
   }
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:
-      if (result_saved) __ addq(rsp, Immediate(kPointerSize));
+      if (result_saved) __ Drop(1);
       break;
     case Expression::kValue:
       if (!result_saved) __ push(rax);
       break;
     case Expression::kTest:
       if (result_saved) __ pop(rax);
       TestAndBranch(rax, true_label_, false_label_);
       break;
     case Expression::kValueTest: {
       Label discard;
       if (!result_saved) __ push(rax);
       TestAndBranch(rax, true_label_, &discard);
       __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
+      __ Drop(1);
       __ jmp(false_label_);
       break;
     }
     case Expression::kTestValue: {
       Label discard;
       if (!result_saved) __ push(rax);
       TestAndBranch(rax, &discard, false_label_);
       __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
+      __ Drop(1);
       __ jmp(true_label_);
       break;
     }
   }
 }
 
 
 void FastCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
   __ movq(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
@@ skipping 35 matching lines @@
     __ movq(FieldOperand(rbx, offset), rax);
 
     // Update the write barrier for the array store.
     __ RecordWrite(rbx, offset, rax, rcx);
   }
 
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:
-      if (result_saved) __ addq(rsp, Immediate(kPointerSize));
+      if (result_saved) __ Drop(1);
       break;
     case Expression::kValue:
       if (!result_saved) __ push(rax);
       break;
     case Expression::kTest:
       if (result_saved) __ pop(rax);
       TestAndBranch(rax, true_label_, false_label_);
       break;
     case Expression::kValueTest: {
       Label discard;
       if (!result_saved) __ push(rax);
       TestAndBranch(rax, true_label_, &discard);
       __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
+      __ Drop(1);
       __ jmp(false_label_);
       break;
     }
     case Expression::kTestValue: {
       Label discard;
       if (!result_saved) __ push(rax);
       TestAndBranch(rax, &discard, false_label_);
       __ bind(&discard);
-      __ addq(rsp, Immediate(kPointerSize));
+      __ Drop(1);
       __ jmp(true_label_);
       break;
     }
   }
 }
 
 
 void FastCodeGenerator::EmitNamedPropertyLoad(Property* prop,
                                               Expression::Context context) {
   SetSourcePosition(prop->position());
   Literal* key = prop->key()->AsLiteral();
   __ Move(rcx, key->handle());
   Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
   __ Call(ic, RelocInfo::CODE_TARGET);
-  Move(context, rax);
+  Apply(context, rax);
 }
 
 
 void FastCodeGenerator::EmitKeyedPropertyLoad(Property* prop,
                                               Expression::Context context) {
   SetSourcePosition(prop->position());
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
   __ Call(ic, RelocInfo::CODE_TARGET);
-  Move(context, rax);
+  Apply(context, rax);
 }
 
 
 void FastCodeGenerator::EmitCompoundAssignmentOp(Token::Value op,
                                                  Expression::Context context) {
   GenericBinaryOpStub stub(op,
                            NO_OVERWRITE,
                            NO_GENERIC_BINARY_FLAGS);
   __ CallStub(&stub);
-  Move(context, rax);
+  Apply(context, rax);
 }
 
 
 void FastCodeGenerator::EmitVariableAssignment(Variable* var,
                                                Expression::Context context) {
   ASSERT(var != NULL);
   ASSERT(var->is_global() || var->slot() != NULL);
   if (var->is_global()) {
     // Assignment to a global variable.  Use inline caching for the
     // assignment.  Right-hand-side value is passed in rax, variable name in
     // rcx, and the global object on the stack.
     __ pop(rax);
     __ Move(rcx, var->name());
     __ push(CodeGenerator::GlobalObject());
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET);
     // Overwrite the global object on the stack with the result if needed.
-    DropAndMove(context, rax);
+    DropAndApply(1, context, rax);
 
   } else if (var->slot() != NULL) {
     Slot* slot = var->slot();
     switch (slot->type()) {
       case Slot::LOCAL:
       case Slot::PARAMETER: {
         Operand target = Operand(rbp, SlotOffset(slot));
         switch (context) {
           case Expression::kUninitialized:
             UNREACHABLE();
@@ skipping 11 matching lines @@
             __ pop(rax);
             __ movq(target, rax);
             TestAndBranch(rax, true_label_, false_label_);
             break;
           case Expression::kValueTest: {
             Label discard;
             __ movq(rax, Operand(rsp, 0));
             __ movq(target, rax);
             TestAndBranch(rax, true_label_, &discard);
             __ bind(&discard);
-            __ addq(rsp, Immediate(kPointerSize));
+            __ Drop(1);
             __ jmp(false_label_);
             break;
           }
           case Expression::kTestValue: {
             Label discard;
             __ movq(rax, Operand(rsp, 0));
             __ movq(target, rax);
             TestAndBranch(rax, &discard, false_label_);
             __ bind(&discard);
-            __ addq(rsp, Immediate(kPointerSize));
+            __ Drop(1);
             __ jmp(true_label_);
             break;
           }
         }
         break;
       }
 
       case Slot::CONTEXT: {
         MemOperand target = EmitSlotSearch(slot, rcx);
         __ pop(rax);
         __ movq(target, rax);
 
         // RecordWrite may destroy all its register arguments.
         if (context == Expression::kValue) {
           __ push(rax);
         } else if (context != Expression::kEffect) {
           __ movq(rdx, rax);
         }
         int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
         __ RecordWrite(rcx, offset, rax, rbx);
-        if (context != Expression::kEffect &&
-            context != Expression::kValue) {
-          Move(context, rdx);
+        if (context != Expression::kEffect && context != Expression::kValue) {
+          Apply(context, rdx);
         }
         break;
       }
 
       case Slot::LOOKUP:
         UNREACHABLE();
         break;
     }
   } else {
     // Variables rewritten as properties are not treated as variables in
@@ skipping 23 matching lines @@
   __ Call(ic, RelocInfo::CODE_TARGET);
 
   // If the assignment ends an initialization block, revert to fast case.
   if (expr->ends_initialization_block()) {
     __ push(rax);  // Result of assignment, saved even if not needed.
     __ push(Operand(rsp, kPointerSize));  // Receiver is under value.
     __ CallRuntime(Runtime::kToFastProperties, 1);
     __ pop(rax);
   }
 
-  DropAndMove(expr->context(), rax);
+  DropAndApply(1, expr->context(), rax);
 }
 
 
 void FastCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) {
   // Assignment to a property, using a keyed store IC.
 
   // If the assignment starts a block of assignments to the same object,
   // change to slow case to avoid the quadratic behavior of repeatedly
   // adding fast properties.
   if (expr->starts_initialization_block()) {
@@ skipping 12 matching lines @@
   // If the assignment ends an initialization block, revert to fast case.
   if (expr->ends_initialization_block()) {
     __ push(rax);  // Result of assignment, saved even if not needed.
     // Reciever is under the key and value.
     __ push(Operand(rsp, 2 * kPointerSize));
     __ CallRuntime(Runtime::kToFastProperties, 1);
     __ pop(rax);
   }
 
   // Receiver and key are still on stack.
-  __ addq(rsp, Immediate(2 * kPointerSize));
-  Move(expr->context(), rax);
+  DropAndApply(2, expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitProperty(Property* expr) {
   Comment cmnt(masm_, "[ Property");
   Expression* key = expr->key();
-  uint32_t dummy;
 
   // Record the source position for the property load.
   SetSourcePosition(expr->position());
 
   // Evaluate receiver.
   Visit(expr->obj());
 
-
-  if (key->AsLiteral() != NULL && key->AsLiteral()->handle()->IsSymbol() &&
-      !String::cast(*(key->AsLiteral()->handle()))->AsArrayIndex(&dummy)) {
-    // Do a NAMED property load.
-    // The IC expects the property name in rcx and the receiver on the stack.
+  if (key->IsPropertyName()) {
+    // Do a named property load.  The IC expects the property name in rcx
+    // and the receiver on the stack.
     __ Move(rcx, key->AsLiteral()->handle());
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
     // By emitting a nop we make sure that we do not have a "test rax,..."
     // instruction after the call it is treated specially by the LoadIC code.
     __ nop();
+    DropAndApply(1, expr->context(), rax);
   } else {
-    // Do a KEYED property load.
+    // Do a keyed property load.
     Visit(expr->key());
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
-    // Notice: We must not have a "test rax, ..." instruction after
-    // the call. It is treated specially by the LoadIC code.
-
-    // Drop key left on the stack by IC.
-    __ addq(rsp, Immediate(kPointerSize));
+    // Notice: We must not have a "test rax, ..." instruction after the
+    // call. It is treated specially by the LoadIC code.
+    __ nop();
+    // Drop key and receiver left on the stack by IC.
+    DropAndApply(2, expr->context(), rax);
   }
-  DropAndMove(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::EmitCallWithIC(Call* expr,
                                        Handle<Object> ignored,
                                        RelocInfo::Mode mode) {
   // Code common for calls using the IC.
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
   // Record source position for debugger.
   SetSourcePosition(expr->position());
   // Call the IC initialization code.
   Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
                                                          NOT_IN_LOOP);
   __ call(ic, mode);
   // Restore context register.
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
   // Discard the function left on TOS.
-  DropAndMove(expr->context(), rax);
+  DropAndApply(1, expr->context(), rax);
 }
 
 
 void FastCodeGenerator::EmitCallWithStub(Call* expr) {
   // Code common for calls using the call stub.
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
   }
   // Record source position for debugger.
   SetSourcePosition(expr->position());
   CallFunctionStub stub(arg_count, NOT_IN_LOOP);
   __ CallStub(&stub);
   // Restore context register.
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
   // Discard the function left on TOS.
-  DropAndMove(expr->context(), rax);
+  DropAndApply(1, expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitCall(Call* expr) {
   Comment cmnt(masm_, "[ Call");
   Expression* fun = expr->expression();
   Variable* var = fun->AsVariableProxy()->AsVariable();
 
   if (var != NULL && var->is_possibly_eval()) {
     // Call to the identifier 'eval'.
@@ skipping 23 matching lines @@
       Visit(prop->obj());
       Visit(prop->key());
       // Record source code position for IC call.
       SetSourcePosition(prop->position());
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
       // By emitting a nop we make sure that we do not have a "test rax,..."
       // instruction after the call it is treated specially by the LoadIC code.
       __ nop();
       // Drop key left on the stack by IC.
-      __ addq(rsp, Immediate(kPointerSize));
+      __ Drop(1);
       // Pop receiver.
       __ pop(rbx);
       // Push result (function).
       __ push(rax);
       // Push receiver object on stack.
       if (prop->is_synthetic()) {
         __ push(CodeGenerator::GlobalObject());
       } else {
         __ push(rbx);
       }
@@ skipping 48 matching lines @@
 
   // Load function, arg_count into rdi and rax.
   __ Set(rax, arg_count);
   // Function is in rsp[arg_count + 1].
   __ movq(rdi, Operand(rsp, rax, times_pointer_size, kPointerSize));
 
   Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
   __ Call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
 
   // Replace function on TOS with result in rax, or pop it.
-  DropAndMove(expr->context(), rax);
+  DropAndApply(1, expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
 
   if (expr->is_jsruntime()) {
     // Prepare for calling JS runtime function.
     __ Push(expr->name());
     __ movq(rax, CodeGenerator::GlobalObject());
     __ push(FieldOperand(rax, GlobalObject::kBuiltinsOffset));
   }
 
   // Push the arguments ("left-to-right").
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
 
   if (expr->is_jsruntime()) {
     // Call the JS runtime function.
     Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
                                                            NOT_IN_LOOP);
     __ call(ic, RelocInfo::CODE_TARGET);
     // Restore context register.
     __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
     // Discard the function left on TOS.
-    DropAndMove(expr->context(), rax);
+    DropAndApply(1, expr->context(), rax);
   } else {
     __ CallRuntime(expr->function(), arg_count);
-    Move(expr->context(), rax);
+    Apply(expr->context(), rax);
   }
 }
 
 
 void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::VOID: {
       Comment cmnt(masm_, "[ UnaryOperation (VOID)");
       Visit(expr->expression());
       ASSERT_EQ(Expression::kEffect, expr->expression()->context());
@@ skipping 102 matching lines @@
         __ push(rsi);
         __ Push(proxy->name());
         __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
         __ push(rax);
       } else {
         // This expression cannot throw a reference error at the top level.
         Visit(expr->expression());
       }
 
       __ CallRuntime(Runtime::kTypeof, 1);
-      Move(expr->context(), rax);
+      Apply(expr->context(), rax);
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCountOperation(CountOperation* expr) {
@@ skipping 79 matching lines @@
   // Store the value returned in rax.
   switch (assign_type) {
     case VARIABLE:
       __ push(rax);
       if (expr->is_postfix()) {
         EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
                                Expression::kEffect);
         // For all contexts except kEffect: We have the result on
         // top of the stack.
         if (expr->context() != Expression::kEffect) {
-          MoveTOS(expr->context());
+          ApplyTOS(expr->context());
         }
       } else {
         EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
                                expr->context());
       }
       break;
     case NAMED_PROPERTY: {
       __ Move(rcx, prop->key()->AsLiteral()->handle());
       Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
       // This nop signals to the IC that there is no inlined code at the call
       // site for it to patch.
       __ nop();
       if (expr->is_postfix()) {
         __ Drop(1);  // Result is on the stack under the receiver.
         if (expr->context() != Expression::kEffect) {
-          MoveTOS(expr->context());
+          ApplyTOS(expr->context());
         }
       } else {
-        DropAndMove(expr->context(), rax);
+        DropAndApply(1, expr->context(), rax);
       }
       break;
     }
     case KEYED_PROPERTY: {
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
       // This nop signals to the IC that there is no inlined code at the call
       // site for it to patch.
       __ nop();
       if (expr->is_postfix()) {
         __ Drop(2);  // Result is on the stack under the key and the receiver.
         if (expr->context() != Expression::kEffect) {
-          MoveTOS(expr->context());
+          ApplyTOS(expr->context());
         }
       } else {
-        DropAndMove(expr->context(), rax, 2);
+        DropAndApply(2, expr->context(), rax);
       }
       break;
     }
   }
 }
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   Comment cmnt(masm_, "[ BinaryOperation");
   switch (expr->op()) {
     case Token::COMMA:
@@ skipping 21 matching lines @@
     case Token::SAR: {
       ASSERT_EQ(Expression::kValue, expr->left()->context());
       ASSERT_EQ(Expression::kValue, expr->right()->context());
 
       Visit(expr->left());
       Visit(expr->right());
       GenericBinaryOpStub stub(expr->op(),
                                NO_OVERWRITE,
                                NO_GENERIC_BINARY_FLAGS);
       __ CallStub(&stub);
-      Move(expr->context(), rax);
+      Apply(expr->context(), rax);
 
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCompareOperation(CompareOperation* expr) {
@@ skipping 147 matching lines @@
       break;
   }
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 void FastCodeGenerator::VisitThisFunction(ThisFunction* expr) {
   __ movq(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
-  Move(expr->context(), rax);
+  Apply(expr->context(), rax);
 }
 
 
 Register FastCodeGenerator::result_register() { return rax; }
 
 
 Register FastCodeGenerator::context_register() { return rsi; }
 
 
 void FastCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
@@ skipping 38 matching lines @@
   __ movq(Operand(rsp, 0), rdx);
   // And return.
   __ ret(0);
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal