Experimental: push the new code generator infrastructure into the...

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 254 matching lines @@
       SyncElementAt(i);
     }
   }
 
   // Forget the frame elements that will be popped by the call.
   Forget(frame_arg_count);
 }
 
 
 bool VirtualFrame::RequiresMergeCode() {
-  // A frame requires merge code to be generated in the event that
-  // there are duplicated non-synched registers or else elements not
-  // in a (memory or register) location in the frame.  We look for
-  // non-synced non-location elements and count occurrences of
-  // non-synced registers.
+  // A frame requires code to be generated to make the frame mergable if
+  // there are duplicated non-synched registers or else valid elements not
+  // in a (memory or register) location in the frame.  We look for valid
+  // non-synced non-location elements and count occurrences of non-synced
+  // registers.
   RegisterFile non_synced_regs;
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement element = elements_[i];
-    if (!element.is_synced()) {
+    if (element.is_valid() && !element.is_synced()) {
       if (element.is_register()) {
         non_synced_regs.Use(elements_[i].reg());
       } else if (!element.is_memory()) {
         // Not memory or register and not synced.
         return true;
       }
     }
   }
 
   for (int i = 0; i < RegisterFile::kNumRegisters; i++) {
@@ skipping 60 matching lines @@
     } else {
       // The element is in memory or a singly-frame-referenced register.
       new_elements[i] = element;
     }
   }
 
   // Perform the moves.
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement source = elements_[i];
     FrameElement target = new_elements[i];
-    ASSERT(target.is_register() || target.is_memory());
+    ASSERT(!target.is_valid() || target.is_register() || target.is_memory());
     if (target.is_register()) {
       if (source.is_constant()) {
         __ Set(target.reg(), Immediate(source.handle()));
       } else if (source.is_register() && !source.reg().is(target.reg())) {
         __ mov(target.reg(), source.reg());
       }
       elements_[i] = target;
-    } else {
-      // The target is memory.
+    } else if (target.is_memory()) {
       if (!source.is_memory()) {
         // Spilling a source register would decrement its reference count,
         // but we have already done that when computing new target elements,
         // so we use a raw spill.
         RawSpillElementAt(i);
       }
     }
+    // Invalid elements do not need to be moved.
   }
 
   delete[] new_elements;
   ASSERT(cgen_->HasValidEntryRegisters());
   cgen_->SetFrame(original_frame);
   ASSERT(cgen_->HasValidEntryRegisters());
 }
 
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
@@ skipping 12 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);
 
   // 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_memory()) {
+    if (!expect.is_valid()) {
+      ASSERT(!elements_[i].is_valid());
+    } else if (expect.is_memory()) {
       ASSERT(elements_[i].is_memory());
       ASSERT(elements_[i].is_synced() && expect.is_synced());
     } else if (expect.is_register()) {
       ASSERT(elements_[i].is_register());
       ASSERT(elements_[i].reg().is(expect.reg()));
       ASSERT(elements_[i].is_synced() == expect.is_synced());
     } else {
       ASSERT(expect.is_constant());
       ASSERT(elements_[i].is_constant());
       ASSERT(elements_[i].handle().location() ==
@@ skipping 214 matching lines @@
     __ Set(temp.reg(), Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(temp.reg());
     }
   }
 }
 
 
+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());
+
+  // 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 (value->is_register()) {
+    Use(value->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);
+  }
+
+  value->Unuse();
+}
+
+
 void VirtualFrame::LoadFrameSlotAt(int index) {
   ASSERT(index >= 0);
   ASSERT(index < elements_.length());
 
   FrameElement element = elements_[index];
 
   if (element.is_memory()) {
     ASSERT(index <= stack_pointer_);
     // Eagerly load memory elements into a register.  The element at
     // the index and the new top of the frame are backed by the same
@@ skipping 17 matching lines @@
     ASSERT(element.is_register() || element.is_constant());
     if (element.is_register()) {
       Use(element.reg());
     }
     element.clear_sync();
     elements_.Add(element);
   }
 }
 
 
+void VirtualFrame::TakeFrameSlotAt(int index) {
+  LoadFrameSlotAt(index);
+
+  if (elements_[index].is_register()) {
+    Unuse(elements_[index].reg());
+  }
+  elements_[index] = FrameElement::InvalidElement();
+}
+
+
 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.
   ASSERT(index >= 0);
   ASSERT(index < elements_.length());
   FrameElement top = elements_[elements_.length() - 1];
 
   if (elements_[index].is_register()) {
     Unuse(elements_[index].reg());
   }
   // The virtual frame slot will be of the same type and have the same value
   // as the frame top.
   elements_[index] = top;
 
   if (top.is_memory()) {
+    // TODO(): consider allocating the slot to a register.
+    //
     // Emit code to store memory values into the required frame slot.
     Result temp = cgen_->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ mov(temp.reg(), Top());
     __ mov(Operand(ebp, fp_relative(index)), temp.reg());
   } else {
     // We have not actually written the value to memory.
     elements_[index].clear_sync();
 
     if (top.is_register()) {
@@ skipping 18 matching lines @@
 
 
 void VirtualFrame::CallStub(CodeStub* stub, int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallStub(stub);
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub,
+                              Result* arg,
+                              int frame_arg_count) {
+  arg->Unuse();
+  CallStub(stub, frame_arg_count);
+  Result result = cgen_->allocator()->Allocate(eax);
+  ASSERT(result.is_valid());
+  return result;
+}
+
+
+Result VirtualFrame::CallStub(CodeStub* stub,
                               Result* arg0,
                               Result* arg1,
                               int frame_arg_count) {
   arg0->Unuse();
   arg1->Unuse();
   CallStub(stub, frame_arg_count);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
@@ skipping 155 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal