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

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 25 matching lines @@
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm())
 
 void VirtualFrame::PopToR1R0() {
   // Shuffle things around so the top of stack is in r0 and r1.
   MergeTOSTo(R0_R1_TOS);
   // Pop the two registers off the stack so they are detached from the frame.
-  element_count_ -= 2;
+  LowerHeight(2);
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::PopToR1() {
   // Shuffle things around so the top of stack is only in r1.
   MergeTOSTo(R1_TOS);
   // Pop the register off the stack so it is detached from the frame.
-  element_count_ -= 1;
+  LowerHeight(1);
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::PopToR0() {
   // Shuffle things around so the top of stack only in r0.
   MergeTOSTo(R0_TOS);
   // Pop the register off the stack so it is detached from the frame.
-  element_count_ -= 1;
+  LowerHeight(1);
   top_of_stack_state_ = NO_TOS_REGISTERS;
 }
 
 
 void VirtualFrame::MergeTo(const VirtualFrame* expected, Condition cond) {
   if (Equals(expected)) return;
+  ASSERT(expected->IsCompatibleWith(this));
+  MergeTOSTo(expected->top_of_stack_state_, cond);
+  ASSERT(register_allocation_map_ == expected->register_allocation_map_);
+}
+
+
+void VirtualFrame::MergeTo(VirtualFrame* expected, Condition cond) {
+  if (Equals(expected)) return;
+  expected->tos_known_smi_map_ &= tos_known_smi_map_;
   MergeTOSTo(expected->top_of_stack_state_, cond);
   ASSERT(register_allocation_map_ == expected->register_allocation_map_);
 }
 
 
 void VirtualFrame::MergeTOSTo(
     VirtualFrame::TopOfStack expected_top_of_stack_state, Condition cond) {
 #define CASE_NUMBER(a, b) ((a) * TOS_STATES + (b))
   switch (CASE_NUMBER(top_of_stack_state_, expected_top_of_stack_state)) {
     case CASE_NUMBER(NO_TOS_REGISTERS, NO_TOS_REGISTERS):
@@ skipping 332 matching lines @@
   // Discard elements from the virtual frame and free any registers.
   int num_virtual_elements = kVirtualElements[top_of_stack_state_];
   while (num_virtual_elements > 0) {
     Pop();
     num_virtual_elements--;
     count--;
     if (count == 0) return;
   }
   if (count == 0) return;
   __ add(sp, sp, Operand(count * kPointerSize));
-  element_count_ -= count;
+  LowerHeight(count);
 }
 
 
 void VirtualFrame::Pop() {
   if (top_of_stack_state_ == NO_TOS_REGISTERS) {
     __ add(sp, sp, Operand(kPointerSize));
   } else {
     top_of_stack_state_ = kStateAfterPop[top_of_stack_state_];
   }
-  element_count_--;
+  LowerHeight(1);
 }
 
 
 void VirtualFrame::EmitPop(Register reg) {
   ASSERT(!is_used(RegisterAllocator::ToNumber(reg)));
   if (top_of_stack_state_ == NO_TOS_REGISTERS) {
     __ pop(reg);
   } else {
     __ mov(reg, kTopRegister[top_of_stack_state_]);
     top_of_stack_state_ = kStateAfterPop[top_of_stack_state_];
   }
-  element_count_--;
+  LowerHeight(1);
 }
 
 
 void VirtualFrame::SpillAllButCopyTOSToR0() {
   switch (top_of_stack_state_) {
     case NO_TOS_REGISTERS:
       __ ldr(r0, MemOperand(sp, 0));
       break;
     case R0_TOS:
       __ push(r0);
@@ skipping 87 matching lines @@
       case R1_R0_TOS:
         __ push(r0);
         __ mov(r0, r1);
         // r0 and r1 contains the same value. Prefer state with r0 holding TOS.
         top_of_stack_state_ = R0_R1_TOS;
         break;
       default:
         UNREACHABLE();
     }
   }
-  element_count_++;
+  RaiseHeight(1, tos_known_smi_map_ & 1);
 }
 
 
 void VirtualFrame::Dup2() {
   if (SpilledScope::is_spilled()) {
     __ ldr(ip, MemOperand(sp, kPointerSize));
     __ push(ip);
     __ ldr(ip, MemOperand(sp, kPointerSize));
     __ push(ip);
   } else {
@@ skipping 18 matching lines @@
         top_of_stack_state_ = R0_R1_TOS;
         break;
       case R1_R0_TOS:
         __ Push(r0, r1);
         top_of_stack_state_ = R1_R0_TOS;
         break;
       default:
         UNREACHABLE();
     }
   }
-  element_count_ += 2;
+  RaiseHeight(2, tos_known_smi_map_ & 3);
 }
 
 
 Register VirtualFrame::PopToRegister(Register but_not_to_this_one) {
   ASSERT(but_not_to_this_one.is(r0) ||
          but_not_to_this_one.is(r1) ||
          but_not_to_this_one.is(no_reg));
-  element_count_--;
+  LowerHeight(1);
   if (top_of_stack_state_ == NO_TOS_REGISTERS) {
     if (but_not_to_this_one.is(r0)) {
       __ pop(r1);
       return r1;
     } else {
       __ pop(r0);
       return r0;
     }
   } else {
     Register answer = kTopRegister[top_of_stack_state_];
     ASSERT(!answer.is(but_not_to_this_one));
     top_of_stack_state_ = kStateAfterPop[top_of_stack_state_];
     return answer;
   }
 }
 
 
 void VirtualFrame::EnsureOneFreeTOSRegister() {
   if (kVirtualElements[top_of_stack_state_] == kMaxTOSRegisters) {
     __ 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_++;
+void VirtualFrame::EmitPush(Register reg, TypeInfo info) {
+  RaiseHeight(1, info.IsSmi() ? 1 : 0);
   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()) {
@@ skipping 12 matching lines @@
     }
   }
   EnsureOneFreeTOSRegister();
   top_of_stack_state_ = kStateAfterPush[top_of_stack_state_];
   Register dest = kTopRegister[top_of_stack_state_];
   __ Move(dest, reg);
 }
 
 
 void VirtualFrame::SetElementAt(Register reg, int this_far_down) {
+  if (this_far_down < kTOSKnownSmiMapSize) {
+    tos_known_smi_map_ &= ~(1 << this_far_down);
+  }
   if (this_far_down == 0) {
     Pop();
     Register dest = GetTOSRegister();
     if (dest.is(reg)) {
       // We already popped one item off the top of the stack.  If the only
       // free register is the one we were asked to push then we have been
       // asked to push a register that was already in use, which cannot
       // happen.  It therefore folows that there are two free TOS registers:
       ASSERT(top_of_stack_state_ == NO_TOS_REGISTERS);
       dest = dest.is(r0) ? r1 : r0;
@@ skipping 20 matching lines @@
 
 
 Register VirtualFrame::GetTOSRegister() {
   if (SpilledScope::is_spilled()) return r0;
 
   EnsureOneFreeTOSRegister();
   return kTopRegister[kStateAfterPush[top_of_stack_state_]];
 }
 
 
-void VirtualFrame::EmitPush(Operand operand) {
-  element_count_++;
+void VirtualFrame::EmitPush(Operand operand, TypeInfo info) {
+  RaiseHeight(1, info.IsSmi() ? 1 : 0);
   if (SpilledScope::is_spilled()) {
     __ mov(r0, operand);
     __ push(r0);
     return;
   }
   EnsureOneFreeTOSRegister();
   top_of_stack_state_ = kStateAfterPush[top_of_stack_state_];
   __ mov(kTopRegister[top_of_stack_state_], operand);
 }
 
 
-void VirtualFrame::EmitPush(MemOperand operand) {
-  element_count_++;
+void VirtualFrame::EmitPush(MemOperand operand, TypeInfo info) {
+  RaiseHeight(1, info.IsSmi() ? 1 : 0);
   if (SpilledScope::is_spilled()) {
     __ ldr(r0, operand);
     __ push(r0);
     return;
   }
   EnsureOneFreeTOSRegister();
   top_of_stack_state_ = kStateAfterPush[top_of_stack_state_];
   __ ldr(kTopRegister[top_of_stack_state_], operand);
 }
 
 
 void VirtualFrame::EmitPushRoot(Heap::RootListIndex index) {
-  element_count_++;
+  RaiseHeight(1, 0);
   if (SpilledScope::is_spilled()) {
     __ LoadRoot(r0, index);
     __ push(r0);
     return;
   }
   EnsureOneFreeTOSRegister();
   top_of_stack_state_ = kStateAfterPush[top_of_stack_state_];
   __ LoadRoot(kTopRegister[top_of_stack_state_], index);
 }
 
@@ skipping 28 matching lines @@
       break;
   }
   ASSERT(register_allocation_map_ == 0);  // Not yet implemented.
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM