Add an elements_.length() accessor to the VirtualFrame class and use...

src/ia32/virtual-frame-ia32.cc

Index: src/ia32/virtual-frame-ia32.cc
===================================================================
--- src/ia32/virtual-frame-ia32.cc	(revision 2033)
+++ src/ia32/virtual-frame-ia32.cc	(working copy)
@@ -155,7 +155,7 @@
 // [min(stack_pointer_ + 1,begin), end].
 void VirtualFrame::SyncRange(int begin, int end) {
   ASSERT(begin >= 0);
-  ASSERT(end < elements_.length());
+  ASSERT(end < element_count());
   // Sync elements below the range if they have not been materialized
   // on the stack.
   int start = Min(begin, stack_pointer_ + 1);
@@ -175,12 +175,12 @@
 
 void VirtualFrame::MakeMergable(int mergable_elements) {
   if (mergable_elements == JumpTarget::kAllElements) {
-    mergable_elements = elements_.length();
+    mergable_elements = element_count();
   }
-  ASSERT(mergable_elements <= elements_.length());
+  ASSERT(mergable_elements <= element_count());
 
-  int start_index = elements_.length() - mergable_elements;
-  for (int i = start_index; i < elements_.length(); i++) {
+  int start_index = element_count() - mergable_elements;
+  for (int i = start_index; i < element_count(); i++) {
     FrameElement element = elements_[i];
 
     if (element.is_constant() || element.is_copy()) {
@@ -280,7 +280,7 @@
   // of the index of the frame element esi is caching or kIllegalIndex
   // if esi has not been disturbed.
   int esi_caches = kIllegalIndex;
-  for (int i = elements_.length() - 1; i >= 0; i--) {
+  for (int i = element_count() - 1; i >= 0; i--) {
     FrameElement target = expected->elements_[i];
     if (target.is_register()) continue;  // Handle registers later.
     if (target.is_memory()) {
@@ -481,7 +481,7 @@
   // Store the function in the frame.  The frame owns the register
   // reference now (ie, it can keep it in edi or spill it later).
   Push(edi);
-  SyncElementAt(elements_.length() - 1);
+  SyncElementAt(element_count() - 1);
   cgen()->allocator()->Unuse(edi);
 }
 
@@ -498,7 +498,7 @@
   // debugger. See VisitReturnStatement for the full return sequence.
   __ mov(esp, Operand(ebp));
   stack_pointer_ = frame_pointer();
-  for (int i = elements_.length() - 1; i > stack_pointer_; i--) {
+  for (int i = element_count() - 1; i > stack_pointer_; i--) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       Unuse(last.reg());
@@ -517,7 +517,7 @@
     // we sync them with the actual frame to allocate space for spilling
     // them later.  First sync everything above the stack pointer so we can
     // use pushes to allocate and initialize the locals.
-    SyncRange(stack_pointer_ + 1, elements_.length() - 1);
+    SyncRange(stack_pointer_ + 1, element_count() - 1);
     Handle<Object> undefined = Factory::undefined_value();
     FrameElement initial_value =
         FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
@@ -560,7 +560,7 @@
   int new_backing_index = kIllegalIndex;
   if (original.is_copied()) {
     // Verify it is copied, and find first copy.
-    for (int i = index + 1; i < elements_.length(); i++) {
+    for (int i = index + 1; i < element_count(); i++) {
       if (elements_[i].is_copy() && elements_[i].index() == index) {
         new_backing_index = i;
         break;
@@ -601,7 +601,7 @@
         FrameElement::RegisterElement(backing_reg, FrameElement::NOT_SYNCED);
   }
   // Update the other copies.
-  for (int i = new_backing_index + 1; i < elements_.length(); i++) {
+  for (int i = new_backing_index + 1; i < element_count(); i++) {
     if (elements_[i].is_copy() && elements_[i].index() == index) {
       elements_[i].set_index(new_backing_index);
       elements_[new_backing_index].set_copied();
@@ -613,7 +613,7 @@
 
 void VirtualFrame::TakeFrameSlotAt(int index) {
   ASSERT(index >= 0);
-  ASSERT(index <= elements_.length());
+  ASSERT(index <= element_count());
   FrameElement original = elements_[index];
   int new_backing_store_index = InvalidateFrameSlotAt(index);
   if (new_backing_store_index != kIllegalIndex) {
@@ -630,13 +630,13 @@
       FrameElement new_element =
           FrameElement::RegisterElement(fresh.reg(),
                                         FrameElement::NOT_SYNCED);
-      Use(fresh.reg(), elements_.length());
+      Use(fresh.reg(), element_count());
       elements_.Add(new_element);
       __ mov(fresh.reg(), Operand(ebp, fp_relative(index)));
       break;
     }
     case FrameElement::REGISTER:
-      Use(original.reg(), elements_.length());
+      Use(original.reg(), element_count());
       // Fall through.
     case FrameElement::CONSTANT:
     case FrameElement::COPY:
@@ -655,9 +655,9 @@
   // a given index.  The value on top of the frame is left in place.
   // This is a duplicating operation, so it can create copies.
   ASSERT(index >= 0);
-  ASSERT(index < elements_.length());
+  ASSERT(index < element_count());
 
-  int top_index = elements_.length() - 1;
+  int top_index = element_count() - 1;
   FrameElement top = elements_[top_index];
   FrameElement original = elements_[index];
   if (top.is_copy() && top.index() == index) return;
@@ -724,7 +724,7 @@
 
       // All the copies of the old backing element (including the top
       // element) become copies of the new backing element.
-      for (int i = backing_index + 1; i < elements_.length(); i++) {
+      for (int i = backing_index + 1; i < element_count(); i++) {
         if (elements_[i].is_copy() && elements_[i].index() == backing_index) {
           elements_[i].set_index(index);
         }
@@ -976,7 +976,7 @@
 
 void VirtualFrame::Drop(int count) {
   ASSERT(height() >= count);
-  int num_virtual_elements = (elements_.length() - 1) - stack_pointer_;
+  int num_virtual_elements = (element_count() - 1) - stack_pointer_;
 
   // Emit code to lower the stack pointer if necessary.
   if (num_virtual_elements < count) {
@@ -997,7 +997,7 @@
 
 Result VirtualFrame::Pop() {
   FrameElement element = elements_.RemoveLast();
-  int index = elements_.length();
+  int index = element_count();
   ASSERT(element.is_valid());
 
   bool pop_needed = (stack_pointer_ == index);
@@ -1052,7 +1052,7 @@
 
 
 void VirtualFrame::EmitPop(Register reg) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
@@ -1060,7 +1060,7 @@
 
 
 void VirtualFrame::EmitPop(Operand operand) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(operand);
@@ -1068,7 +1068,7 @@
 
 
 void VirtualFrame::EmitPush(Register reg) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(reg);
@@ -1076,7 +1076,7 @@
 
 
 void VirtualFrame::EmitPush(Operand operand) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(operand);
@@ -1084,7 +1084,7 @@
 
 
 void VirtualFrame::EmitPush(Immediate immediate) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);