Size reduction of VirtualFrame objects. Remove the code generator and...

src/virtual-frame.cc

 // Copyright 2009 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 19 matching lines @@
 #include "codegen-inl.h"
 #include "register-allocator-inl.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 // When cloned, a frame is a deep copy of the original.
 VirtualFrame::VirtualFrame(VirtualFrame* original)
-    : cgen_(original->cgen_),
-      masm_(original->masm_),
-      elements_(original->elements_),
-      parameter_count_(original->parameter_count_),
-      local_count_(original->local_count_),
-      stack_pointer_(original->stack_pointer_),
-      frame_pointer_(original->frame_pointer_) {
+    : elements_(original->elements_),
+      stack_pointer_(original->stack_pointer_) {
   // Copy register locations from original.
   memcpy(&register_locations_,
          original->register_locations_,
          sizeof(register_locations_));
 }
 
 
 FrameElement VirtualFrame::CopyElementAt(int index) {
   ASSERT(index >= 0);
   ASSERT(index < elements_.length());
@@ skipping 54 matching lines @@
 void VirtualFrame::ForgetElements(int count) {
   ASSERT(count >= 0);
   ASSERT(elements_.length() >= count);
 
   for (int i = 0; i < count; i++) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       // A hack to properly count register references for the code
       // generator's current frame and also for other frames.  The
       // same code appears in PrepareMergeTo.
-      if (cgen_->frame() == this) {
+      if (cgen()->frame() == this) {
         Unuse(last.reg());
       } else {
         register_locations_[last.reg().code()] = kIllegalIndex;
       }
     }
   }
 }
 
 
 // If there are any registers referenced only by the frame, spill one.
 Register VirtualFrame::SpillAnyRegister() {
   // Find the leftmost (ordered by register code) register whose only
   // reference is in the frame.
   for (int i = 0; i < kNumRegisters; i++) {
-    if (is_used(i) && cgen_->allocator()->count(i) == 1) {
+    if (is_used(i) && cgen()->allocator()->count(i) == 1) {
       Register result = { i };
       Spill(result);
-      ASSERT(!cgen_->allocator()->is_used(result));
+      ASSERT(!cgen()->allocator()->is_used(result));
       return result;
     }
   }
   return no_reg;
 }
 
 
 // Make the type of the element at a given index be MEMORY.
 void VirtualFrame::SpillElementAt(int index) {
   if (!elements_[index].is_valid()) return;
@@ skipping 43 matching lines @@
     if (!target.is_valid() ||
         (target.is_memory() && !source.is_memory() && source.is_synced())) {
       // No code needs to be generated to invalidate valid elements.
       // No code needs to be generated to move values to memory if
       // they are already synced.  We perform those moves here, before
       // merging.
       if (source.is_register()) {
         // If the frame is the code generator's current frame, we have
         // to decrement both the frame-internal and global register
         // counts.
-        if (cgen_->frame() == this) {
+        if (cgen()->frame() == this) {
           Unuse(source.reg());
         } else {
           register_locations_[source.reg().code()] = kIllegalIndex;
         }
       }
       elements_[i] = target;
     } else if (target.is_register() && !target.is_synced() &&
                !source.is_memory()) {
       // If an element's target is a register that doesn't need to be
       // synced, and the element is not in memory, then the sync state
@@ skipping 148 matching lines @@
   Result tos = Pop();
   if (num_dropped > 1) {
     Drop(num_dropped - 1);
   }
   SetElementAt(0, &tos);
 }
 
 
 bool VirtualFrame::Equals(VirtualFrame* other) {
 #ifdef DEBUG
-  // These are sanity checks in debug builds, but we do not need to
-  // use them to distinguish frames at merge points.
-  if (cgen_ != other->cgen_) return false;
-  if (masm_ != other->masm_) return false;
-  if (parameter_count_ != other->parameter_count_) return false;
-  if (local_count_ != other->local_count_) return false;
-  if (frame_pointer_ != other->frame_pointer_) return false;
-
   for (int i = 0; i < kNumRegisters; i++) {
     if (register_locations_[i] != other->register_locations_[i]) {
       return false;
     }
   }
   if (elements_.length() != other->elements_.length()) return false;
 #endif
   if (stack_pointer_ != other->stack_pointer_) return false;
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].Equals(other->elements_[i])) return false;
   }
 
   return true;
 }
 
 
 // Specialization of List::ResizeAdd to non-inlined version for FrameElements.
 // The function ResizeAdd becomes a real function, whose implementation is the
 // inlined ResizeAddInternal.
 template <>
 void List<FrameElement,
           FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element) {
   ResizeAddInternal(element);
 }
 
 } }  // namespace v8::internal