MIPS: Try to use Push instead of push sequences whenever possible.

src/mips/builtins-mips.cc

 // Copyright 2012 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 283 matching lines @@
     __ CallRuntime(Runtime::kNewStringWrapper, 1);
   }
   __ Ret();
 }
 
 
 static void CallRuntimePassFunction(MacroAssembler* masm,
                                     Runtime::FunctionId function_id) {
   FrameScope scope(masm, StackFrame::INTERNAL);
   // Push a copy of the function onto the stack.
-  __ push(a1);
-  // Push call kind information.
-  __ push(t1);
-  // Function is also the parameter to the runtime call.
-  __ push(a1);
+  // Push call kind information and function as parameter to the runtime call.
+  __ Push(a1, t1, a1);
 
   __ CallRuntime(function_id, 1);
-  // Restore call kind information.
-  __ pop(t1);
-  // Restore receiver.
-  __ pop(a1);
+  // Restore call kind information and receiver.
+  __ Pop(a1, t1);
 }
 
 
 static void GenerateTailCallToSharedCode(MacroAssembler* masm) {
   __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
   __ lw(a2, FieldMemOperand(a2, SharedFunctionInfo::kCodeOffset));
   __ Addu(at, a2, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ Jump(at);
 }
 
@@ skipping 89 matching lines @@
         Label allocate;
         // Decrease generous allocation count.
         __ lw(a3, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
         MemOperand constructor_count =
            FieldMemOperand(a3, SharedFunctionInfo::kConstructionCountOffset);
         __ lbu(t0, constructor_count);
         __ Subu(t0, t0, Operand(1));
         __ sb(t0, constructor_count);
         __ Branch(&allocate, ne, t0, Operand(zero_reg));
 
-        __ Push(a1, a2);
-
-        __ push(a1);  // Constructor.
+        __ Push(a1, a2, a1);  // a1 = Constructor.
         // The call will replace the stub, so the countdown is only done once.
         __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
 
-        __ pop(a2);
-        __ pop(a1);
+        __ Pop(a1, a2);
 
         __ bind(&allocate);
       }
 
       // Now allocate the JSObject on the heap.
       // a1: constructor function
       // a2: initial map
       __ lbu(a3, FieldMemOperand(a2, Map::kInstanceSizeOffset));
       __ Allocate(a3, t4, t5, t6, &rt_call, SIZE_IN_WORDS);
 
@@ skipping 796 matching lines @@
     __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
     // Make a2 the space we have left. The stack might already be overflowed
     // here which will cause a2 to become negative.
     __ subu(a2, sp, a2);
     // Check if the arguments will overflow the stack.
     __ sll(t3, v0, kPointerSizeLog2 - kSmiTagSize);
     __ Branch(&okay, gt, a2, Operand(t3));  // Signed comparison.
 
     // Out of stack space.
     __ lw(a1, MemOperand(fp, kFunctionOffset));
-    __ push(a1);
-    __ push(v0);
+    __ Push(a1, v0);
     __ InvokeBuiltin(Builtins::APPLY_OVERFLOW, CALL_FUNCTION);
     // End of stack check.
 
     // Push current limit and index.
     __ bind(&okay);
     __ push(v0);  // Limit.
     __ mov(a1, zero_reg);  // Initial index.
     __ push(a1);
 
     // Get the receiver.
@@ skipping 60 matching lines @@
     // Copy all arguments from the array to the stack.
     Label entry, loop;
     __ lw(a0, MemOperand(fp, kIndexOffset));
     __ Branch(&entry);
 
     // Load the current argument from the arguments array and push it to the
     // stack.
     // a0: current argument index
     __ bind(&loop);
     __ lw(a1, MemOperand(fp, kArgsOffset));
-    __ push(a1);
-    __ push(a0);
+    __ Push(a1, a0);
 
     // Call the runtime to access the property in the arguments array.
     __ CallRuntime(Runtime::kGetProperty, 2);
     __ push(v0);
 
     // Use inline caching to access the arguments.
     __ lw(a0, MemOperand(fp, kIndexOffset));
     __ Addu(a0, a0, Operand(1 << kSmiTagSize));
     __ sw(a0, MemOperand(fp, kIndexOffset));
 
@@ skipping 175 matching lines @@
   __ bind(&dont_adapt_arguments);
   __ Jump(a3);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS