Experimental: more code generator changes....

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 26 matching lines @@
 
 
 // -------------------------------------------------------------------------
 // Result implementation.
 
 
 Result::Result(Register reg, CodeGenerator* cgen)
   : type_(REGISTER),
     cgen_(cgen) {
   data_.reg_ = reg;
-  ASSERT(!reg().is(no_reg));
+  ASSERT(!reg.is(no_reg));
   cgen_->allocator()->Use(reg);
 }
 
 
 void Result::Unuse() {
   ASSERT(!reg().is(no_reg));
   cgen_->allocator()->Unuse(reg());
   data_.reg_ = no_reg;
 }
 
@@ skipping 175 matching lines @@
 
 // Clear the dirty bits for the range of elements in [begin, end).
 void VirtualFrame::SyncRange(int begin, int end) {
   ASSERT(begin >= 0);
   ASSERT(end <= elements_.length());
   for (int i = begin; i < end; i++) {
     SyncElementAt(i);
   }
 }
 
+
 // Make the type of all elements be MEMORY.
 void VirtualFrame::SpillAll() {
   for (int i = 0; i < elements_.length(); i++) {
     SpillElementAt(i);
   }
 }
 
 
 void VirtualFrame::PrepareForCall(int frame_arg_count) {
   ASSERT(height() >= frame_arg_count);
@@ skipping 36 matching lines @@
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].is_memory() && !elements_[i].is_register()) {
       return false;
     }
   }
 
   return true;
 }
 
 
+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.
+  RegisterFile non_synced_regs;
+  for (int i = 0; i < elements_.length(); i++) {
+    FrameElement element = elements_[i];
+    if (!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++) {
+    if (non_synced_regs.count(i) > 1) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
 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.)
   FrameElement* new_elements = new FrameElement[elements_.length()];
   FrameElement memory_element;
   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 {
-        // This code path is currently not triggered.  UNIMPLEMENTED is
-        // temporarily used to trap when it becomes active so we can test
-        // it.
-        UNIMPLEMENTED();
         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;
         }
       }
 
       // We have not moved register references, but record that we will so
@@ skipping 90 matching lines @@
               ASSERT(!elements_[j].is_memory());
             }
 #endif
             stack_pointer_ = i + 1;
             __ add(Operand(esp),
                    Immediate((stack_pointer_ - i) * kPointerSize));
           }
           stack_pointer_--;
           __ pop(target.reg());
         }
-        Use(target.reg());
-      } else if (source.is_constant()) {
-        // Not yet implemented.  When done, code in common with the
-        // memory-to-register just above case can be factored out.
-        UNIMPLEMENTED();
+      } else {
+        // Source is constant.
+        __ Set(target.reg(), Immediate(source.handle()));
       }
+      Use(target.reg());
       elements_[i] = target;
     }
   }
 
+  // At this point, the frames should be identical.
   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()) {
+      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() ==
+             expect.handle().location());
+      ASSERT(elements_[i].is_synced() == expect.is_synced());
+    }
+  }
+#endif
+}
+
+
+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.
+  for (int i = 0; i < elements_.length(); i++) {
+    if (elements_[i].is_register()) {
+      cgen_->allocator()->Unuse(elements_[i].reg());
+    }
+  }
+}
+
+
+void VirtualFrame::AttachToCodeGenerator() {
+  // Tell the global register allocator that the frame-internal register
+  // references are live again.
+  for (int i = 0; i < elements_.length(); i++) {
+    if (elements_[i].is_register()) {
+      cgen_->allocator()->Use(elements_[i].reg());
+    }
+  }
 }
 
 
 void VirtualFrame::Enter() {
   // Registers live on entry: esp, ebp, esi, edi.
   Comment cmnt(masm_, "[ Enter JS frame");
   EmitPush(ebp);
 
   frame_pointer_ = stack_pointer_;
   __ mov(ebp, Operand(esp));
 
-  // Store the context and the function in the frame.
-  Push(esi);
-  // The frame owns the register reference now.
-  cgen_->allocator()->Unuse(esi);
+  // Store the context in the frame.  The context is kept in esi, so the
+  // register reference is not owned by the frame (ie, the frame is not free
+  // to spill it).  This is implemented by making the in-frame value be
+  // memory.
+  EmitPush(esi);
 
+  // Store the function in the frame.  The frame owns the register reference
+  // now (ie, it can keep it in edi or spill it later).
   Push(edi);
   cgen_->allocator()->Unuse(edi);
 }
 
 
 void VirtualFrame::Exit() {
   Comment cmnt(masm_, "[ Exit JS frame");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
@@ skipping 245 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal