Experimental: introduce factory functions for the FrameElement type....

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 79 matching lines @@
 // On entry to a function, the virtual frame already contains the receiver,
 // the parameters, and a return address.  All frame elements are in memory.
 VirtualFrame::VirtualFrame(CodeGenerator* cgen)
     : cgen_(cgen),
       masm_(cgen->masm()),
       elements_(0),
       parameter_count_(cgen->scope()->num_parameters()),
       local_count_(0),
       stack_pointer_(parameter_count_ + 1),  // 0-based index of TOS.
       frame_pointer_(kIllegalIndex) {
-  FrameElement memory_element;
   for (int i = 0; i < parameter_count_ + 2; i++) {
-    elements_.Add(memory_element);
+    elements_.Add(FrameElement::MemoryElement());
   }
 }
 
 
 // When cloned, a frame is a deep copy of the original.
 VirtualFrame::VirtualFrame(VirtualFrame* original)
     : cgen_(original->cgen_),
       masm_(original->masm_),
       elements_(original->elements_.length()),
       parameter_count_(original->parameter_count_),
@@ skipping 10 matching lines @@
 
 // Modify the state of the virtual frame to match the actual frame by adding
 // extra in-memory elements to the top of the virtual frame.  The extra
 // elements will be externally materialized on the actual frame (eg, by
 // pushing an exception handler).  No code is emitted.
 void VirtualFrame::Adjust(int count) {
   ASSERT(count >= 0);
   ASSERT(stack_pointer_ == elements_.length() - 1);
 
   for (int i = 0; i < count; i++) {
-    elements_.Add(FrameElement());
+    elements_.Add(FrameElement::MemoryElement());
   }
   stack_pointer_ += count;
 }
 
 
 // Modify the state of the virtual frame to match the actual frame by
 // removing elements from the top of the virtual frame.  The elements will
 // be externally popped from the actual frame (eg, by a runtime call).  No
 // code is emitted.
 void VirtualFrame::Forget(int count) {
@@ skipping 101 matching lines @@
 
 
 // Spill an element, making its type be MEMORY.  If it is a register the
 // reference count is not decremented, so it must be done externally.
 void VirtualFrame::RawSpillElementAt(int index) {
   if (index > stack_pointer_ + 1) {
     SyncRange(stack_pointer_ + 1, index);
   }
   SyncElementAt(index);
   // The element is now in memory.
-  FrameElement memory_element;
-  elements_[index] = memory_element;
+  elements_[index] = FrameElement::MemoryElement();
 }
 
 
 // Make the type of the element at a given index be MEMORY.  We can only
 // allocate space in the actual frame for the virtual element immediately
 // above the stack pointer.
 void VirtualFrame::SpillElementAt(int index) {
   if (elements_[index].is_register()) {
     Unuse(elements_[index].reg());
   }
@@ skipping 98 matching lines @@
 
 void VirtualFrame::MakeMergable() {
   Comment cmnt(masm_, "[ Make frame mergable");
   // Remove constants from the frame and ensure that no registers are
   // multiply referenced within the frame.  Allocate elements to their
   // new locations from the top down so that the topmost elements have
   // a chance to be in registers, then fill them into memory from the
   // bottom up.  (NB: Currently when spilling registers that are
   // multiply referenced, it is the lowermost occurrence that gets to
   // stay in the register.)
+
+  // The elements of new_elements are initially invalid.
   FrameElement* new_elements = new FrameElement[elements_.length()];
-  FrameElement memory_element;
+  FrameElement memory_element = FrameElement::MemoryElement();
   for (int i = elements_.length() - 1; i >= 0; i--) {
     FrameElement element = elements_[i];
     if (element.is_constant() ||
         (element.is_register() &&
          frame_registers_.count(element.reg().code()) > 1)) {
       // A simple strategy is to locate these elements in memory if they are
       // synced (avoiding a spill right now) and otherwise to prefer a
       // register for them.
       if (element.is_synced()) {
         new_elements[i] = memory_element;
       } else {
         Register reg = cgen_->allocator()->AllocateWithoutSpilling();
         if (reg.is(no_reg)) {
           new_elements[i] = memory_element;
         } else {
-          FrameElement register_element(reg, FrameElement::NOT_SYNCED);
-          new_elements[i] = register_element;
+          new_elements[i] =
+              FrameElement::RegisterElement(reg, FrameElement::NOT_SYNCED);
         }
       }
 
       // We have not moved register references, but record that we will so
       // that we do not unnecessarily spill the last reference within the
       // frame.
       if (element.is_register()) {
         Unuse(element.reg());
       }
     } else {
@@ skipping 259 matching lines @@
   local_count_ = 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());
     Handle<Object> undefined = Factory::undefined_value();
-    FrameElement initial_value(undefined, FrameElement::SYNCED);
+    FrameElement initial_value =
+        FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
     Register temp = cgen_->allocator()->Allocate();
     __ Set(temp, Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(temp);
     }
     cgen_->allocator()->Unuse(temp);
   }
 }
 
 
 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
     // register location.
     Register temp = cgen_->allocator()->Allocate();
     ASSERT(!temp.is(no_reg));
-    FrameElement new_element(temp, FrameElement::NOT_SYNCED);
+    FrameElement new_element
+        = FrameElement::RegisterElement(temp, FrameElement::NOT_SYNCED);
     Use(temp);
     elements_[index] = new_element;
     Use(temp);
     elements_.Add(new_element);
 
     // Finally, move the element at the index into its new location.
     elements_[index].set_sync();
     __ mov(temp, Operand(ebp, fp_relative(index)));
 
     cgen_->allocator()->Unuse(temp);
@@ skipping 164 matching lines @@
 void VirtualFrame::EmitPop(Operand operand) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(operand);
 }
 
 
 void VirtualFrame::EmitPush(Register reg) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
-  elements_.Add(FrameElement());
+  elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(reg);
 }
 
 
 void VirtualFrame::EmitPush(Operand operand) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
-  elements_.Add(FrameElement());
+  elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(operand);
 }
 
 
 void VirtualFrame::EmitPush(Immediate immediate) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
-  FrameElement memory_element;
-  elements_.Add(memory_element);
+  elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 void VirtualFrame::Push(Register reg) {
-  FrameElement register_element(reg, FrameElement::NOT_SYNCED);
   Use(reg);
-  elements_.Add(register_element);
+  elements_.Add(FrameElement::RegisterElement(reg,
+                                              FrameElement::NOT_SYNCED));
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
-  FrameElement constant_element(value, FrameElement::NOT_SYNCED);
-  elements_.Add(constant_element);
+  elements_.Add(FrameElement::ConstantElement(value,
+                                              FrameElement::NOT_SYNCED));
 }
 
 
 #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