Get rid of LoadAndSpill on ARM since Load() knows whether it is...

src/arm/virtual-frame-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 22 matching lines @@
 #include "register-allocator-inl.h"
 #include "scopes.h"
 #include "virtual-frame-inl.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm())
 
 void VirtualFrame::PopToR1R0() {
-  VirtualFrame where_to_go = *this;
   // Shuffle things around so the top of stack is in r0 and r1.
-  where_to_go.top_of_stack_state_ = R0_R1_TOS;
-  MergeTo(&where_to_go);
+  MergeTOSTo(R0_R1_TOS);
   // Pop the two registers off the stack so they are detached from the frame.
   element_count_ -= 2;
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::PopToR1() {
-  VirtualFrame where_to_go = *this;
   // Shuffle things around so the top of stack is only in r1.
-  where_to_go.top_of_stack_state_ = R1_TOS;
-  MergeTo(&where_to_go);
+  MergeTOSTo(R1_TOS);
   // Pop the register off the stack so it is detached from the frame.
   element_count_ -= 1;
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::PopToR0() {
-  VirtualFrame where_to_go = *this;
   // Shuffle things around so the top of stack only in r0.
-  where_to_go.top_of_stack_state_ = R0_TOS;
-  MergeTo(&where_to_go);
+  MergeTOSTo(R0_TOS);
   // Pop the register off the stack so it is detached from the frame.
   element_count_ -= 1;
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::MergeTo(const VirtualFrame* expected, Condition cond) {
   if (Equals(expected)) return;
   MergeTOSTo(expected->top_of_stack_state_, cond);
   ASSERT(register_allocation_map_ == expected->register_allocation_map_);
@@ skipping 187 matching lines @@
 void VirtualFrame::PushTryHandler(HandlerType type) {
   // Grow the expression stack by handler size less one (the return
   // address in lr is already counted by a call instruction).
   Adjust(kHandlerSize - 1);
   __ PushTryHandler(IN_JAVASCRIPT, type);
 }
 
 
 void VirtualFrame::CallJSFunction(int arg_count) {
   // InvokeFunction requires function in r1.
-  EmitPop(r1);
+  PopToR1();
+  SpillAll();
 
   // +1 for receiver.
   Forget(arg_count + 1);
   ASSERT(cgen()->HasValidEntryRegisters());
   ParameterCount count(arg_count);
   __ InvokeFunction(r1, count, CALL_FUNCTION);
   // Restore the context.
   __ ldr(cp, Context());
 }
 
@@ skipping 337 matching lines @@
     __ push(kBottomRegister[top_of_stack_state_]);
     top_of_stack_state_ = kStateAfterPush[top_of_stack_state_];
     top_of_stack_state_ = kStateAfterPop[top_of_stack_state_];
   }
   ASSERT(kVirtualElements[top_of_stack_state_] != kMaxTOSRegisters);
 }
 
 
 void VirtualFrame::EmitPush(Register reg) {
   element_count_++;
-  if (SpilledScope::is_spilled()) {
+  if (reg.is(cp)) {
+    // If we are pushing cp then we are about to make a call and things have to
+    // be pushed to the physical stack.  There's nothing to be gained my moving
+    // to a TOS register and then pushing that, we might as well push to the
+    // physical stack immediately.
+    MergeTOSTo(NO_TOS_REGISTERS);
     __ push(reg);
     return;
   }
+  if (SpilledScope::is_spilled()) {
+    ASSERT(top_of_stack_state_ == NO_TOS_REGISTERS);
+    __ push(reg);
+    return;
+  }
   if (top_of_stack_state_ == NO_TOS_REGISTERS) {
     if (reg.is(r0)) {
       top_of_stack_state_ = R0_TOS;
       return;
     }
     if (reg.is(r1)) {
       top_of_stack_state_ = R1_TOS;
       return;
     }
   }
@@ skipping 114 matching lines @@
       break;
   }
   ASSERT(register_allocation_map_ == 0);  // Not yet implemented.
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM