Factor out a commonly used code sequence to DropAndMove(Location, Register)

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 131 matching lines @@
   switch (source.type()) {
     case Location::NOWHERE:
       UNREACHABLE();
     case Location::TEMP:
       __ pop(Operand(rbp, SlotOffset(destination)));
       break;
   }
 }
 
 
+void FastCodeGenerator::DropAndMove(Location destination, Register source) {
+  switch (destination.type()) {
+    case Location::NOWHERE:
+      __ addq(rsp, Immediate(kPointerSize));
+      break;
+    case Location::TEMP:
+      __ movq(Operand(rsp, 0), source);
+      break;
+  }
+}
+
+
 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.
 }
 
 
@@ skipping 57 matching lines @@
     // Use inline caching. Variable name is passed in rcx and the global
     // object on the stack.
     __ push(CodeGenerator::GlobalObject());
     __ Move(rcx, expr->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.
-    switch (expr->location().type()) {
-      case Location::NOWHERE:
-        __ addq(rsp, Immediate(kPointerSize));
-        break;
-      case Location::TEMP:
-        // Replace the global object with the result.
-        __ movq(Operand(rsp, 0), rax);
-        break;
-    }
-
+    DropAndMove(expr->location(), rax);
   } else {
     Comment cmnt(masm_, "Stack slot");
     Move(expr->location(), rewrite->AsSlot());
   }
 }
 
 
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   Label boilerplate_exists;
@@ skipping 212 matching lines @@
     } else {
       ASSERT(rhs->location().is_temporary());
       Visit(rhs);
       __ 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.
-    switch (expr->location().type()) {
-      case Location::NOWHERE:
-        __ addq(rsp, Immediate(kPointerSize));
-        break;
-      case Location::TEMP:
-        __ movq(Operand(rsp, 0), rax);
-        break;
-    }
+    DropAndMove(expr->location(), rax);
   } else {
     // Local or parameter assignment.
 
     // Code for the right-hand-side expression depends on its type.
     if (rhs->AsLiteral() != NULL) {
       // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
       // discarded result.  Always perform the assignment.
       __ Move(kScratchRegister, rhs->AsLiteral()->handle());
       __ movq(Operand(rbp, SlotOffset(var->slot())), kScratchRegister);
       Move(expr->location(), kScratchRegister);
@@ skipping 74 matching lines @@
   }
   // 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, RelocInfo::CODE_TARGET_CONTEXT);
   // Restore context register.
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
   // Discard the function left on TOS.
-  switch (expr->location().type()) {
-    case Location::NOWHERE:
-      __ addq(rsp, Immediate(kPointerSize));
-      break;
-    case Location::TEMP:
-      __ movq(Operand(rsp, 0), rax);
-      break;
-  }
+  DropAndMove(expr->location(), rax);
 }
 
 
 void FastCodeGenerator::VisitCallNew(CallNew* node) {
   Comment cmnt(masm_, "[ CallNew");
   // According to ECMA-262, section 11.2.2, page 44, the function
   // expression in new calls must be evaluated before the
   // arguments.
   // Push function on the stack.
   Visit(node->expression());
@@ skipping 19 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.
-  switch (node->location().type()) {
-    case Location::TEMP:
-      __ movq(Operand(rsp, 0), rax);
-      break;
-    case Location::NOWHERE:
-      __ addq(rsp, Immediate(kPointerSize));
-      break;
-  }
+  DropAndMove(node->location(), rax);
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
   Runtime::Function* function = expr->function();
 
   ASSERT(function != NULL);
 
@@ skipping 81 matching lines @@
   } else {
     Visit(right);
     Move(destination, right->location());
   }
 
   __ bind(&done);
 }
 
 
 } }  // namespace v8::internal