Experimental: use the Result class to manage the lifetime of registers...

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 17 matching lines @@
 #include "v8.h"
 
 #include "codegen.h"
 #include "codegen-inl.h"
 #include "virtual-frame.h"
 
 namespace v8 { namespace internal {
 
 #define __ masm_->
 
-
-// -------------------------------------------------------------------------
-// Result implementation.
-
-
-Result::Result(Register reg, CodeGenerator* cgen)
-  : type_(REGISTER),
-    cgen_(cgen) {
-  data_.reg_ = reg;
-  ASSERT(!reg.is(no_reg));
-  cgen_->allocator()->Use(reg);
-}
-
-
-void Result::Unuse() {
-  if (is_register()) {
-    cgen_->allocator()->Unuse(reg());
-  }
-  type_ = INVALID;
-}
-
-
-void Result::ToRegister() {
-  ASSERT(is_valid());
-  if (is_constant()) {
-    Register reg = cgen_->allocator()->Allocate();
-    ASSERT(!reg.is(no_reg));
-    cgen_->masm()->Set(reg, Immediate(handle()));
-    data_.reg_ = reg;
-    type_ = REGISTER;
-  }
-  ASSERT(is_register());
-}
-
-
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 VirtualFrame::SpilledScope::SpilledScope(CodeGenerator* cgen)
     : cgen_(cgen),
       previous_state_(cgen->in_spilled_code()) {
   ASSERT(cgen->frame() != NULL);
   cgen->frame()->SpillAll();
   cgen->set_in_spilled_code(true);
 }
@@ skipping 291 matching lines @@
   // 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::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)) {

[William Hesse, 2008/12/19 08:41:03]

Shouldn't we overload count() and is_used() to take
a Register, as well as a code?  We have so many occurrences
of is_used(x.reg().code()).

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

Good idea.  You want to do it :)

       // 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)) {
+        Result fresh = cgen_->allocator()->AllocateWithoutSpilling();
+        if (fresh.is_valid()) {
+          // We immediately record the frame's use of the register so that
+          // it will not be allocated again.
+          Use(fresh.reg());
+          new_elements[i] =
+              FrameElement::RegisterElement(fresh.reg(),
+                                            FrameElement::NOT_SYNCED);
+        } else {
           new_elements[i] = memory_element;
-        } else {
-          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 {
       // 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());
     if (target.is_register()) {
       if (source.is_constant()) {
-        // The allocator's register reference count was incremented by
-        // register allocation, so we only record the new reference in the
-        // frame.  The frame now owns the reference.
-        frame_registers_.Use(target.reg());
         __ Set(target.reg(), Immediate(source.handle()));
       } else if (source.is_register() && !source.reg().is(target.reg())) {
-        // The frame now owns the reference.
-        frame_registers_.Use(target.reg());
         __ mov(target.reg(), source.reg());
       }
       elements_[i] = target;
     } else {
       // The 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);
@@ skipping 244 matching lines @@
   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 =
         FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
-    Register temp = cgen_->allocator()->Allocate();
-    __ Set(temp, Immediate(undefined));
+    Result temp = cgen_->allocator()->Allocate();
+    ASSERT(temp.is_valid());
+    __ Set(temp.reg(), Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
-      __ push(temp);
+      __ push(temp.reg());
     }
-    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));
+    Result temp = cgen_->allocator()->Allocate();
+    ASSERT(temp.is_valid());
     FrameElement new_element
-        = FrameElement::RegisterElement(temp, FrameElement::NOT_SYNCED);
-    Use(temp);
+        = FrameElement::RegisterElement(temp.reg(),
+                                        FrameElement::NOT_SYNCED);
+    Use(temp.reg());
     elements_[index] = new_element;
-    Use(temp);
+    Use(temp.reg());
     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);
+    __ mov(temp.reg(), Operand(ebp, fp_relative(index)));
   } else {
     // For constants and registers, add an (unsynced) copy of the element to
     // the top of the frame.
     ASSERT(element.is_register() || element.is_constant());
     if (element.is_register()) {
       Use(element.reg());
     }
     element.clear_sync();
     elements_.Add(element);
   }
 }
 
 
 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()) {
     // Emit code to store memory values into the required frame slot.
-    Register temp = cgen_->allocator()->Allocate();
-    ASSERT(!temp.is(no_reg));
-    __ mov(temp, Top());
-    __ mov(Operand(ebp, fp_relative(index)), temp);
-    cgen_->allocator()->Unuse(temp);
+    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()) {
       // Establish another frame-internal reference to the register.
       Use(top.reg());
     }
   }
 }
@@ skipping 92 matching lines @@
     return Result(popped.handle(), cgen_);
   } else if (popped.is_register()) {
     Unuse(popped.reg());
     if (pop_needed) {
       stack_pointer_--;
       __ add(Operand(esp), Immediate(kPointerSize));
     }
     return Result(popped.reg(), cgen_);
   } else {
     ASSERT(popped.is_memory());
-    Register temp = cgen_->allocator()->Allocate();
-    ASSERT(!temp.is(no_reg));
+    Result temp = cgen_->allocator()->Allocate();
+    ASSERT(temp.is_valid());
     ASSERT(pop_needed);
     stack_pointer_--;
-    __ pop(temp);
-    // The register temp is double counted, by Allocate and Result(temp).
-    cgen_->allocator()->Unuse(temp);
-    return Result(temp, cgen_);
+    __ pop(temp.reg());
+    return temp;
   }
 }
 
 void VirtualFrame::EmitPop(Register reg) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
 }
 
@@ skipping 36 matching lines @@
                                               FrameElement::NOT_SYNCED));
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
   elements_.Add(FrameElement::ConstantElement(value,
                                               FrameElement::NOT_SYNCED));
 }
 
 
+void VirtualFrame::Push(Result* result) {
+  if (result->is_register()) {
+    Push(result->reg());
+  } else {
+    ASSERT(result->is_constant());
+    Push(result->handle());
+  }
+  result->Unuse();
+}
+
+
 #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