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

src/arm/fast-codegen-arm.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 135 matching lines @@
     case Location::NOWHERE:
       UNREACHABLE();
     case Location::TEMP:
       __ pop(ip);
       __ str(ip, MemOperand(fp, SlotOffset(destination)));
       break;
   }
 }
 
 
+void FastCodeGenerator::DropAndMove(Location destination, Register source) {
+  switch (destination.type()) {
+    case Location::NOWHERE:
+      __ pop();
+      break;
+    case Location::TEMP:
+      __ str(source, MemOperand(sp));
+      break;
+  }
+}
+
+
 void FastCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   // Call the runtime to declare the globals.
   // The context is the first argument.
   __ mov(r1, Operand(pairs));
   __ mov(r0, Operand(Smi::FromInt(is_eval_ ? 1 : 0)));
   __ stm(db_w, sp, cp.bit() | r1.bit() | r0.bit());
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
 }
 
@@ skipping 46 matching lines @@
   Expression* rewrite = expr->var()->rewrite();
   if (rewrite == NULL) {
     Comment cmnt(masm_, "Global variable");
     // Use inline caching. Variable name is passed in r2 and the global
     // object on the stack.
     __ ldr(ip, CodeGenerator::GlobalObject());
     __ push(ip);
     __ mov(r2, Operand(expr->name()));
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
-    switch (expr->location().type()) {
-      case Location::NOWHERE:
-        __ pop();
-        break;
-      case Location::TEMP:
-        // Replace the global object with the result.
-        __ str(r0, MemOperand(sp));
-        break;
-    }
-
+    DropAndMove(expr->location(), r0);
   } else {
     Comment cmnt(masm_, "Stack slot");
     Move(expr->location(), rewrite->AsSlot());
   }
 }
 
 
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   Label boilerplate_exists;
@@ skipping 207 matching lines @@
       ASSERT(rhs->location().is_temporary());
       Visit(rhs);
       __ pop(r0);
     }
     __ mov(r2, Operand(var->name()));
     __ ldr(ip, CodeGenerator::GlobalObject());
     __ push(ip);
     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:
-        __ pop();
-        break;
-      case Location::TEMP:
-        __ str(r0, MemOperand(sp));
-        break;
-    }
-
+    DropAndMove(expr->location(), r0);
   } 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.
       __ mov(ip, Operand(rhs->AsLiteral()->handle()));
       __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
       Move(expr->location(), ip);
@@ skipping 76 matching lines @@
     ASSERT(args->at(i)->location().is_temporary());
   }
   // 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.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
-  switch (expr->location().type()) {
-    case Location::NOWHERE:
-      __ pop();
-      break;
-    case Location::TEMP:
-      __ str(r0, MemOperand(sp));
-      break;
-  }
+  DropAndMove(expr->location(), r0);
 }
 
 
 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 18 matching lines @@
 
   // Load function, arg_count into r1 and r0.
   __ mov(r0, Operand(arg_count));
   // Function is in esp[arg_count + 1].
   __ ldr(r1, MemOperand(sp, (arg_count + 1) * kPointerSize));
 
   Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
   __ Call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
 
   // Replace function on TOS with result in r0, or pop it.
-  switch (node->location().type()) {
-    case Location::TEMP:
-      __ str(r0, MemOperand(sp, 0));
-      break;
-    case Location::NOWHERE:
-      __ pop();
-      break;
-  }
+  DropAndMove(node->location(), r0);
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
   Runtime::Function* function = expr->function();
 
   ASSERT(function != NULL);
 
@@ skipping 50 matching lines @@
     Move(destination, right->AsLiteral());
   } else {
     Visit(right);
     Move(destination, right->location());
   }
 
   __ bind(&done);
 }
 
 } }  // namespace v8::internal