Adds Nip() function, makes UnloadReference() work without spilling

src/virtual-frame-ia32.cc

 // Copyright 2008 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 392 matching lines @@
 
   // Mergable frames have all elements in locations, either memory or
   // register.  We thus have a series of to-memory and to-register moves.
   // First perform all to-memory moves, register-to-memory moves because
   // they can free registers and constant-to-memory moves because they do
   // not use registers.
   MergeMoveRegistersToMemory(expected);
   MergeMoveRegistersToRegisters(expected);
   MergeMoveMemoryToRegisters(expected);
 
+  int height_difference = stack_pointer_ - expected->stack_pointer_;
+  if (stack_pointer_ > expected->stack_pointer_) {
+#ifdef DEBUG
+    for (int i = stack_pointer_; i > expected->stack_pointer_; i--) {
+      ASSERT(!elements_[i].is_memory());
+      ASSERT(!elements_[i].is_synced());
+    }
+#endif
+    __ add(Operand(esp), Immediate(height_difference * kPointerSize));
+    stack_pointer_ = expected->stack_pointer_;
+  } else if (stack_pointer_ < expected->stack_pointer_) {
+    // Put valid data on the stack, that will only be accessed by GC.
+    while (stack_pointer_ < expected->stack_pointer_) {
+      __ push(Immediate(Smi::FromInt(0)));
+      stack_pointer_++;
+    }
+  }
+
   // At this point, the frames should be identical.
   // TODO(): Consider an "equals" method for frames.
   ASSERT(stack_pointer_ == expected->stack_pointer_);
 #ifdef DEBUG
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement expect = expected->elements_[i];
     if (!expect.is_valid()) {
       ASSERT(!elements_[i].is_valid());
     } else if (expect.is_memory()) {
       ASSERT(elements_[i].is_memory());
@@ skipping 244 matching lines @@
     }
   }
 }
 
 
 void VirtualFrame::SetElementAt(int index, Result* value) {
   int frame_index = elements_.length() - index - 1;
   ASSERT(frame_index >= 0);
   ASSERT(frame_index < elements_.length());
   ASSERT(value->is_valid());
+  FrameElement target = elements_[frame_index];
 
-  // TODO(): if the element is backed by the same register or the same
-  // constant, consider preserving the sync bit.
-  if (elements_[frame_index].is_register()) {
-    Unuse(elements_[frame_index].reg());
+  if (target.is_register()) {
+    Unuse(target.reg());
   }
 
   if (value->is_register()) {
     Use(value->reg());
-    elements_[frame_index] =
-        FrameElement::RegisterElement(value->reg(),
-                                      FrameElement::NOT_SYNCED);
+    // Write the new value to the frame, if it is changed.
+    // Otherwise, if target equals value, keep its current sync state.
+    if (!target.is_register() ||
+        !value->reg().is(target.reg())) {
+      elements_[frame_index] =
+          FrameElement::RegisterElement(value->reg(),
+                                        FrameElement::NOT_SYNCED);
+    }
   } else {
     ASSERT(value->is_constant());
-    elements_[frame_index] =
-        FrameElement::ConstantElement(value->handle(),
-                                      FrameElement::NOT_SYNCED);
+    // Write the new value to the frame element, if it is a change.
+    // Otherwise, do nothing, and keep the current sync state.
+    if (!target.is_constant() ||
+        !value->handle().is_identical_to(target.handle())) {
+      elements_[frame_index] =
+          FrameElement::ConstantElement(value->handle(),
+                                        FrameElement::NOT_SYNCED);
+    }
   }
-
   value->Unuse();
 }
 
 
 void VirtualFrame::SaveContextRegister() {
   FrameElement current = elements_[context_index()];
   ASSERT(current.is_register() || current.is_memory());
   if (!current.is_register() || !current.reg().is(esi)) {
     if (current.is_register()) {
       Unuse(current.reg());
@@ skipping 294 matching lines @@
   if (result->is_register()) {
     Push(result->reg());
   } else {
     ASSERT(result->is_constant());
     Push(result->handle());
   }
   result->Unuse();
 }
 
 
+void VirtualFrame::Nip(int num_dropped) {
+  ASSERT(num_dropped >= 0);
+  if (num_dropped == 0) return;
+  Result tos = Pop();
+  if (num_dropped > 1) {
+    Drop(num_dropped - 1);
+  }
+  SetElementAt(0, &tos);
+}
+
+
 #ifdef DEBUG
 bool VirtualFrame::IsSpilled() {
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].is_memory()) {
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal