Fix jump targets on ARM to merge virtual frames (really this time)....

src/arm/virtual-frame-arm.h

 // 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 89 matching lines @@
 
   // Construct an initial virtual frame on entry to a JS function.
   inline VirtualFrame();
 
   // Construct an invalid virtual frame, used by JumpTargets.
   inline VirtualFrame(InvalidVirtualFrameInitializer* dummy);
 
   // Construct a virtual frame as a clone of an existing one.
   explicit inline VirtualFrame(VirtualFrame* original);
 
-  inline CodeGenerator* cgen();
+  inline CodeGenerator* cgen() const;
   inline MacroAssembler* masm();
 
   // The number of elements on the virtual frame.
-  int element_count() { return element_count_; }
+  int element_count() const { return element_count_; }
 
   // The height of the virtual expression stack.
-  inline int height();
+  inline int height() const;
 
   bool is_used(int num) {
     switch (num) {
       case 0: {  // r0.
         return kR0InUse[top_of_stack_state_];
       }
       case 1: {  // r1.
         return kR1InUse[top_of_stack_state_];
       }
       case 2:
@@ skipping 27 matching lines @@
   // the frame after a runtime call).  No code is emitted except to bring the
   // frame to a spilled state.
   void Forget(int count) {
     SpillAll();
     element_count_ -= count;
   }
 
   // Spill all values from the frame to memory.
   void SpillAll();
 
-  void AssertIsSpilled() {
+  void AssertIsSpilled() const {
     ASSERT(top_of_stack_state_ == NO_TOS_REGISTERS);
     ASSERT(register_allocation_map_ == 0);
   }
 
   void AssertIsNotSpilled() {
     ASSERT(!SpilledScope::is_spilled());
   }
 
   // Spill all occurrences of a specific register from the frame.
   void Spill(Register reg) {
     UNIMPLEMENTED();
   }
 
   // Spill all occurrences of an arbitrary register if possible.  Return the
   // register spilled or no_reg if it was not possible to free any register
   // (ie, they all have frame-external references).  Unimplemented.
   Register SpillAnyRegister();
 
   // Make this virtual frame have a state identical to an expected virtual
   // frame.  As a side effect, code may be emitted to make this frame match
   // the expected one.
-  void MergeTo(VirtualFrame* expected);
+  void MergeTo(const VirtualFrame* expected, Condition cond = al);
 
   // Detach a frame from its code generator, perhaps temporarily.  This
   // tells the register allocator that it is free to use frame-internal
   // registers.  Used when the code generator's frame is switched from this
   // one to NULL by an unconditional jump.
   void DetachFromCodeGenerator() {
     AssertIsSpilled();
   }
 
   // (Re)attach a frame to its code generator.  This informs the register
@@ skipping 221 matching lines @@
   int element_count_;
   TopOfStack top_of_stack_state_:3;
   int register_allocation_map_:kNumberOfAllocatedRegisters;
 
   // The index of the element that is at the processor's stack pointer
   // (the sp register).  For now since everything is in memory it is given
   // by the number of elements on the not-very-virtual stack frame.
   int stack_pointer() { return element_count_ - 1; }
 
   // The number of frame-allocated locals and parameters respectively.
-  inline int parameter_count();
-  inline int local_count();
+  inline int parameter_count() const;
+  inline int local_count() const;
 
   // The index of the element that is at the processor's frame pointer
   // (the fp register).  The parameters, receiver, function, and context
   // are below the frame pointer.
-  inline int frame_pointer();
+  inline int frame_pointer() const;
 
   // The index of the first parameter.  The receiver lies below the first
   // parameter.
   int param0_index() { return 1; }
 
   // The index of the context slot in the frame.  It is immediately
   // below the frame pointer.
   inline int context_index();
 
   // The index of the function slot in the frame.  It is below the frame
   // pointer and context slot.
   inline int function_index();
 
   // The index of the first local.  Between the frame pointer and the
   // locals lies the return address.
-  inline int local0_index();
+  inline int local0_index() const;
 
   // The index of the base of the expression stack.
-  inline int expression_base_index();
+  inline int expression_base_index() const;
 
   // Convert a frame index into a frame pointer relative offset into the
   // actual stack.
   inline int fp_relative(int index);
 
   // Spill all elements in registers. Spill the top spilled_args elements
   // on the frame.  Sync all other frame elements.
   // Then drop dropped_args elements from the virtual frame, to match
   // the effect of an upcoming call that will drop them from the stack.
   void PrepareForCall(int spilled_args, int dropped_args);
 
   // If all top-of-stack registers are in use then the lowest one is pushed
   // onto the physical stack and made free.
   void EnsureOneFreeTOSRegister();
 
   // Emit instructions to get the top of stack state from where we are to where
   // we want to be.
-  void MergeTOSTo(TopOfStack expected_state);
+  void MergeTOSTo(TopOfStack expected_state, Condition cond);
 
-  inline bool Equals(VirtualFrame* other);
+  inline bool Equals(const VirtualFrame* other);
 
   friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_VIRTUAL_FRAME_ARM_H_