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

src/ia32/virtual-frame-ia32.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 137 matching lines @@
     }
   }
   elements_[index].set_sync();
 }
 
 
 // Clear the dirty bits for the range of elements in
 // [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);
 
   // If positive we have to adjust the stack pointer.
   int delta = end - stack_pointer_;
   if (delta > 0) {
     stack_pointer_ = end;
     __ sub(Operand(esp), Immediate(delta * kPointerSize));
   }
 
   for (int i = start; i <= end; i++) {
     if (!elements_[i].is_synced()) SyncElementBelowStackPointer(i);
   }
 }
 
 
 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()) {
       if (element.is_synced()) {
         // Just spill.
         elements_[i] = FrameElement::MemoryElement();
       } else {
         // Allocate to a register.
         FrameElement backing_element;  // Invalid if not a copy.
         if (element.is_copy()) {
@@ skipping 79 matching lines @@
   // Move registers, constants, and copies to memory.  Perform moves
   // from the top downward in the frame in order to leave the backing
   // stores of copies in registers.
   //
   // Moving memory-backed copies to memory requires a spare register
   // for the memory-to-memory moves.  Since we are performing a merge,
   // we use esi (which is already saved in the frame).  We keep track
   // 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()) {
       FrameElement source = elements_[i];
       switch (source.type()) {
         case FrameElement::INVALID:
           // Not a legal merge move.
           UNREACHABLE();
           break;
 
@@ skipping 180 matching lines @@
   __ mov(ebp, Operand(esp));
 
   // Store the context in the frame.  The context is kept in esi and a
   // copy is stored in the frame.  The external reference to esi
   // remains.
   EmitPush(esi);
 
   // 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);
 }
 
 
 void VirtualFrame::Exit() {
   Comment cmnt(masm(), "[ Exit JS frame");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
 
   // Avoid using the leave instruction here, because it is too
   // short. We need the return sequence to be a least the size of a
   // call instruction to support patching the exit code in the
   // 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());
     }
   }
 
   EmitPop(ebp);
 }
 
 
 void VirtualFrame::AllocateStackSlots() {
   int count = local_count();
   if (count > 0) {
     Comment cmnt(masm(), "[ Allocate space for locals");
     // The locals are initialized to a constant (the undefined value), but
     // 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);
     Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ Set(temp.reg(), Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(temp.reg());
@@ skipping 22 matching lines @@
 }
 
 
 int VirtualFrame::InvalidateFrameSlotAt(int index) {
   FrameElement original = elements_[index];
 
   // Is this element the backing store of any copies?
   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;
       }
     }
   }
 
   if (new_backing_index == kIllegalIndex) {
     // No copies found, return kIllegalIndex.
     if (original.is_register()) {
@@ skipping 20 matching lines @@
   elements_[index] = FrameElement::InvalidElement();
   // Set the new backing element.
   if (elements_[new_backing_index].is_synced()) {
     elements_[new_backing_index] =
         FrameElement::RegisterElement(backing_reg, FrameElement::SYNCED);
   } else {
     elements_[new_backing_index] =
         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();
     }
   }
   return new_backing_index;
 }
 
 
 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) {
     elements_.Add(CopyElementAt(new_backing_store_index));
     return;
   }
 
   switch (original.type()) {
     case FrameElement::MEMORY: {
       // Emit code to load the original element's data into a register.
       // Push that register as a FrameElement on top of the frame.
       Result fresh = cgen()->allocator()->Allocate();
       ASSERT(fresh.is_valid());
       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:
       original.clear_sync();
       elements_.Add(original);
       break;
     case FrameElement::INVALID:
       UNREACHABLE();
       break;
   }
 }
 
 
 void VirtualFrame::StoreToFrameSlotAt(int index) {
   // Store the value on top of the frame to the virtual frame slot at
   // 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;
   ASSERT(top.is_valid());
 
   InvalidateFrameSlotAt(index);
 
   // InvalidateFrameSlotAt can potentially change any frame element, due
   // to spilling registers to allocate temporaries in order to preserve
   // the copy-on-write semantics of aliased elements.  Reload top from
@@ skipping 46 matching lines @@
       // The old backing element becomes a copy of the new backing
       // element.
       FrameElement new_element = CopyElementAt(index);
       elements_[backing_index] = new_element;
       if (backing_element.is_synced()) {
         elements_[backing_index].set_sync();
       }
 
       // 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);
         }
       }
     }
     return;
   }
 
   // Move the top element to the stored-to slot and replace it (the
   // top element) with a copy.
@@ skipping 231 matching lines @@
   __ Set(num_args.reg(), Immediate(arg_count));
 
   function.Unuse();
   num_args.Unuse();
   return RawCallCodeObject(ic, RelocInfo::CONSTRUCT_CALL);
 }
 
 
 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) {
     int num_dropped = count - num_virtual_elements;
     stack_pointer_ -= num_dropped;
     __ add(Operand(esp), Immediate(num_dropped * kPointerSize));
   }
 
   // Discard elements from the virtual frame and free any registers.
   for (int i = 0; i < count; i++) {
     FrameElement dropped = elements_.RemoveLast();
     if (dropped.is_register()) {
       Unuse(dropped.reg());
     }
   }
 }
 
 
 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);
   if (pop_needed) {
     stack_pointer_--;
     if (element.is_memory()) {
       Result temp = cgen()->allocator()->Allocate();
       ASSERT(temp.is_valid());
       temp.set_static_type(element.static_type());
       __ pop(temp.reg());
@@ skipping 34 matching lines @@
   } else if (element.is_register()) {
     return Result(element.reg(), element.static_type());
   } else {
     ASSERT(element.is_constant());
     return Result(element.handle());
   }
 }
 
 
 void VirtualFrame::EmitPop(Register reg) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
 }
 
 
 void VirtualFrame::EmitPop(Operand operand) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(operand);
 }
 
 
 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);
 }
 
 
 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);
 }
 
 
 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);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal