Begin using the virtual frame for assignment statements of the form:...

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 142 matching lines @@
 }
 
 
 // Spill any register if possible, making its reference count zero.
 Register VirtualFrame::SpillAnyRegister() {
   // Find the leftmost (ordered by register code), least
   // internally-referenced register whose internal reference count matches
   // its external reference count (so that spilling it from the frame frees
   // it for use).
   int min_count = kMaxInt;
-  int best_register_code = no_reg.code();
+  int best_register_code = no_reg.code_;
 
   for (int i = 0; i < RegisterFile::kNumRegisters; i++) {
     int count = frame_registers_.count(i);
     if (count < min_count && count == cgen_->allocator()->count(i)) {
       min_count = count;
       best_register_code = i;
     }
   }
 
-  if (best_register_code != no_reg.code()) {
+  if (best_register_code != no_reg.code_) {
     // Spill all occurrences of the register.  There are min_count
     // occurrences, stop when we've spilled them all to avoid syncing
     // elements unnecessarily.
     int i = 0;
     while (min_count > 0) {
       ASSERT(i < elements_.length());
       if (elements_[i].is_register() &&
           elements_[i].reg().code() == best_register_code) {
         // Found an instance of the best_register being used in the frame.
         // Spill it.
@@ skipping 156 matching lines @@
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(tmp);
     }
     cgen_->allocator()->Unuse(tmp);
   }
 }
 
 
+void VirtualFrame::StoreToFrameSlotAt(int index) {

[William Hesse, 2008/11/28 10:32:45]

So this changelist enables the register and memory types, and also the constant
type, since there is no extra processing for the constant type?  Should it be
commented that this correctly handles constants, since there is no explicit
mention of it in the code?

[Kevin Millikin (Chromium), 2008/11/28 12:19:08]

It is expected to correctly handle constants.

+  // 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.
+  ASSERT(index < elements_.length());
+  FrameElement top = elements_[elements_.length() - 1];
+
+  // The virtual frame slot is now of the same type and has the same value
+  // as the frame top.
+  elements_[index] = top;

[William Hesse, 2008/11/28 10:32:45]

Don't we need to unuse elements_[index] if it is a register here?

[Kevin Millikin (Chromium), 2008/11/28 12:19:08]

Yes.  Good catch.

+
+  if (top.is_memory()) {
+    // Emit code to store memory values into the required frame slot.
+    Register tmp = cgen_->allocator()->Allocate();
+    ASSERT(!tmp.is(no_reg));

[William Hesse, 2008/11/28 10:32:45]

Will we actually need error handling code in the future, to deal with the case
that the allocator fails?
Or did we decide that the allocator must always be able to succeed, by spilling,
because we will never have all regs externally used?

[Kevin Millikin (Chromium), 2008/11/28 12:19:08]

We don't have a good way to handle that yet.  I'm trying to put these assertions
everywhere it could occur and we can address it when it does.

The only way it can happen is if we are in new-codegen code (using the frame)
and we have all registers referenced from outside the frame.  That doesn't
happen right now, because we never use more than one non-frame register (as a
temporary) yet.

Statically, we can guarantee that it can't happen, but I'm not sure what's the
best way to enforce that in the code other than assertions and good tests....

+    __ mov(tmp, Top());
+    __ mov(Operand(ebp, fp_relative(index)), tmp);
+    cgen_->allocator()->Unuse(tmp);
+  } else {
+    // We haven't actually written the value to memory.
+    elements_[index].clear_sync();
+
+    if (top.is_register()) {
+      // Establish another frame-internal reference to the register.
+      Use(top.reg());
+    }
+  }
+}
+
+
 void VirtualFrame::PushTryHandler(HandlerType type) {
   // Grow the expression stack by handler size less two (the return address
   // is already pushed by a call instruction, and PushTryHandler from the
   // macro assembler will leave the top of stack in the eax register to be
   // pushed separately).
   Adjust(kHandlerSize - 2);
   __ PushTryHandler(IN_JAVASCRIPT, type);
   // TODO(1222589): remove the reliance of PushTryHandler on a cached TOS
   EmitPush(eax);
 }
@@ skipping 28 matching lines @@
 void VirtualFrame::CallCodeObject(Handle<Code> code,
                                   RelocInfo::Mode rmode,
                                   int frame_arg_count) {
   PrepareForCall(frame_arg_count);
   __ call(code, rmode);
 }
 
 
 void VirtualFrame::Drop(int count) {
   ASSERT(height() >= count);
+  int num_virtual_elements = (elements_.length() - 1) - stack_pointer_;
 
-  // Discard elements above the stack pointer.
-  while (count > 0 && stack_pointer_ < elements_.length() - 1) {
-    FrameElement last = elements_.RemoveLast();
-    if (last.is_register()) {
-      Unuse(last.reg());
-    }
+  // 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 the rest of the elements and lower the stack pointer.
-  Forget(count);
-  if (count > 0) {
-    __ add(Operand(esp), Immediate(count * 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());
+    }
   }
 }
 
 
 void VirtualFrame::Drop() { Drop(1); }
 
 
 void VirtualFrame::EmitPop(Register reg) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
   stack_pointer_--;
@@ skipping 41 matching lines @@
   elements_.Add(register_element);
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
   FrameElement constant_element(value, FrameElement::NOT_SYNCED);
   elements_.Add(constant_element);
 }
 
 
+#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