Inline part of RawSyncElementAt, improve PrepareForCall

src/virtual-frame.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 194 matching lines @@
   if (elements_[index].is_copied()) {
     new_element.set_copied();
   }
   if (elements_[index].is_register()) {
     Unuse(elements_[index].reg());
   }
   elements_[index] = new_element;
 }
 
 
-// Clear the dirty bits for the range of elements in [begin, end).
+// 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());
-  for (int i = begin; i < end; i++) {
-    RawSyncElementAt(i);
+  if (begin > stack_pointer_) {
+    // Elements between stack_pointer_ + 1 and begin must also be synced.
+    for (int i = stack_pointer_ + 1; i < end; i++) {
+      SyncElementByPushing(i);
+    }
+  } else if (end <= stack_pointer_ + 1) {
+    for (int i = begin; i < end; i++) {
+      if (!elements_[i].is_synced()) {
+          SyncElementBelowStackPointer(i);
+      }
+    }
+  } else {
+    // Split into two ranges that each satisfy a condition above.
+    SyncRange(begin, stack_pointer_ + 1);
+    SyncRange(stack_pointer_ + 1, end);
   }
 }
 
 
 // Clear the dirty bit for the element at a given index.
 void VirtualFrame::SyncElementAt(int index) {
-  if (index > stack_pointer_ + 1) {
-    SyncRange(stack_pointer_ + 1, index);
+  if (index <= stack_pointer_) {
+    if (!elements_[index].is_synced()) {
+      SyncElementBelowStackPointer(index);
+    }
+  } else {
+    for (int i = stack_pointer_ + 1; i <= index; i++) {
+      SyncElementByPushing(i);
+    }
   }
-  RawSyncElementAt(index);
 }
 
 
 // Make the type of all elements be MEMORY.
 void VirtualFrame::SpillAll() {
   for (int i = 0; i < elements_.length(); i++) {
     SpillElementAt(i);
   }
 }
 
@@ skipping 38 matching lines @@
     }
   }
 }
 
 
 void VirtualFrame::PrepareForCall(int spilled_args, int dropped_args) {
   ASSERT(height() >= dropped_args);
   ASSERT(height() >= spilled_args);
   ASSERT(dropped_args <= spilled_args);
 
-  int arg_base_index = elements_.length() - spilled_args;
-  // Spill the arguments.  We spill from the top down so that the
-  // backing stores of register copies will be spilled only after all
-  // the copies are spilled---it is better to spill via a
-  // register-to-memory move than a memory-to-memory move.
-  for (int i = elements_.length() - 1; i >= arg_base_index; i--) {
-    SpillElementAt(i);
-  }
-
-  // Below the arguments, spill registers and sync everything else.
-  // Syncing is necessary for the locals and parameters to give the
-  // debugger a consistent view of the frame.
-  for (int i = arg_base_index - 1; i >= 0; i--) {
-    FrameElement element = elements_[i];
-    if (element.is_register()) {
-      SpillElementAt(i);
-    } else if (element.is_valid()) {
-      SyncElementAt(i);
+  SyncRange(0, elements_.length());
+  // Spill registers.
+  for (int i = 0; i < kNumRegisters; i++) {
+    if (is_used(i)) {
+      SpillElementAt(register_locations_[i]);
     }
   }
 
+  // Spill the arguments.
+  for (int i = elements_.length() - spilled_args; i < elements_.length(); i++) {
+    if (!elements_[i].is_memory()) {
+      SpillElementAt(i);
+    }
+  }
+
   // Forget the frame elements that will be popped by the call.
   Forget(dropped_args);
 }
 
 
 void VirtualFrame::DetachFromCodeGenerator() {
   // Tell the global register allocator that it is free to reallocate all
   // register references contained in this frame.  The frame elements remain
   // register references, so the frame-internal reference count is not
   // decremented.
@@ skipping 225 matching lines @@
 #endif
   if (stack_pointer_ != other->stack_pointer_) return false;
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].Equals(other->elements_[i])) return false;
   }
 
   return true;
 }
 
 } }  // namespace v8::internal