ARM: Track Smis on top 4 stack positions and Smi loop variables....

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 136 matching lines @@
   }
 
   // Add extra in-memory elements to the top of the frame to match an actual
   // frame (eg, the frame after an exception handler is pushed).  No code is
   // emitted.
   void Adjust(int count);
 
   // Forget elements from the top of the frame to match an actual frame (eg,
   // 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;
-  }
+  void Forget(int count);
 
   // Spill all values from the frame to memory.
   void SpillAll();
 
   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, Condition cond = al);
   void MergeTo(const VirtualFrame* expected, Condition cond = al);
 
+  // Checks whether this frame can be branched to by the other frame.
+  bool IsCompatibleWith(const VirtualFrame* other) const {
+    return (tos_known_smi_map_ & (~other->tos_known_smi_map_)) == 0;
+  }
+
   // 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
   // allocator that the frame-internal register references are active again.
@@ skipping 28 matching lines @@
     return MemOperand(sp, 0);
   }
 
   // An element of the expression stack as an assembly operand.
   MemOperand ElementAt(int index) {
     int adjusted_index = index - kVirtualElements[top_of_stack_state_];
     ASSERT(adjusted_index >= 0);
     return MemOperand(sp, adjusted_index * kPointerSize);
   }
 
+  bool KnownSmiAt(int index) {
+    if (index >= kTOSKnownSmiMapSize) return false;
+    return (tos_known_smi_map_ & (1 << index)) != 0;
+  }
+
   // A frame-allocated local as an assembly operand.
   inline MemOperand LocalAt(int index);
 
   // Push the address of the receiver slot on the frame.
   void PushReceiverSlotAddress();
 
   // The function frame slot.
   MemOperand Function() { return MemOperand(fp, kFunctionOffset); }
 
   // The context frame slot.
@@ skipping 98 matching lines @@
   void PopToR1R0();
 
   // Takes the top element and puts it in r1.
   void PopToR1();
 
   // Takes the top element and puts it in r0.
   void PopToR0();
 
   // Push an element on top of the expression stack and emit a
   // corresponding push instruction.
-  void EmitPush(Register reg);
-  void EmitPush(Operand operand);
-  void EmitPush(MemOperand operand);
+  void EmitPush(Register reg, TypeInfo type_info = TypeInfo::Unknown());
+  void EmitPush(Operand operand, TypeInfo type_info = TypeInfo::Unknown());
+  void EmitPush(MemOperand operand, TypeInfo type_info = TypeInfo::Unknown());
   void EmitPushRoot(Heap::RootListIndex index);
 
   // Overwrite the nth thing on the stack.  If the nth position is in a
   // register then this turns into a mov, otherwise an str.  Afterwards
   // you can still use the register even if it is a register that can be
   // used for TOS (r0 or r1).
   void SetElementAt(Register reg, int this_far_down);
 
   // Get a register which is free and which must be immediately used to
   // push on the top of the stack.
@@ skipping 44 matching lines @@
 
   static Register AllocatedRegister(int r) {
     ASSERT(r >= 0 && r < kNumberOfAllocatedRegisters);
     return kAllocatedRegisters[r];
   }
 
   // The number of elements on the stack frame.
   int element_count_;
   TopOfStack top_of_stack_state_:3;
   int register_allocation_map_:kNumberOfAllocatedRegisters;
+  static const int kTOSKnownSmiMapSize = 4;
+  unsigned tos_known_smi_map_:kTOSKnownSmiMapSize;
 
   // 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() const;
   inline int local_count() const;
 
@@ skipping 34 matching lines @@
   // 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, Condition cond = al);
 
   inline bool Equals(const VirtualFrame* other);
 
+  inline void LowerHeight(int count) {
+    element_count_ -= count;
+    if (count >= kTOSKnownSmiMapSize) {
+      tos_known_smi_map_ = 0;
+    } else {
+      tos_known_smi_map_ >>= count;
+    }
+  }
+
+  inline void RaiseHeight(int count, unsigned known_smi_map = 0) {
+    ASSERT(known_smi_map < (1u << count));
+    element_count_ += count;
+    if (count >= kTOSKnownSmiMapSize) {
+      tos_known_smi_map_ = known_smi_map;
+    } else {
+      tos_known_smi_map_ = ((tos_known_smi_map_ << count) | known_smi_map);
+    }
+  }
+
   friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_VIRTUAL_FRAME_ARM_H_