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

src/register-allocator-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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "codegen.h"
 #include "register-allocator.h"
 
 namespace v8 { namespace internal {
 
-void RegisterAllocator::Initialize() {
-  registers_.Reset();
-  registers_.Use(esp);
-  registers_.Use(ebp);
-  registers_.Use(esi);
-  registers_.Use(edi);
+// -------------------------------------------------------------------------
+// Result implementation.
+
+Result::Result(Register reg, CodeGenerator* cgen)
+  : type_(REGISTER),
+    cgen_(cgen) {
+  data_.reg_ = reg;
+  ASSERT(!reg.is(no_reg));
+  cgen_->allocator()->Use(reg);

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

Do we want Result(no_reg) to be INVALID?
This way, with the assert, is good, because it
can always be changed if we need it.

 }
 
 
-Register RegisterAllocator::AllocateWithoutSpilling() {
-  // Return the first free register, if any.
-  for (int i = 0; i < num_registers(); i++) {
-    if (!registers_.is_used(i)) {
-      Register result = { i };
-      registers_.Use(result);
-      return result;
-    }
+void Result::CopyTo(Result* destination) const {
+  destination->type_ = type();
+  destination->cgen_ = cgen_;
+
+  if (is_register()) {
+    destination->data_.reg_ = reg();
+    cgen_->allocator()->Use(reg());
+  } else if (is_constant()) {
+    destination->data_.handle_ = data_.handle_;
+  } else {
+    ASSERT(!is_valid());
   }
-  return no_reg;
 }
 
 
-Register RegisterAllocator::Allocate() {
-  Register result = AllocateWithoutSpilling();
-  if (result.is(no_reg)) {
+void Result::Unuse() {
+  if (is_register()) {
+    cgen_->allocator()->Unuse(reg());
+  }
+  type_ = INVALID;
+}
+
+
+void Result::ToRegister() {
+  ASSERT(is_valid());
+  if (is_constant()) {
+    Result fresh = cgen_->allocator()->Allocate();
+    ASSERT(fresh.is_valid());
+    cgen_->masm()->Set(fresh.reg(), Immediate(handle()));
+    // This result becomes a copy of the fresh one.
+    cgen_->allocator()->Use(fresh.reg());
+    type_ = REGISTER;
+    data_.reg_ = fresh.reg();
+  }
+  ASSERT(is_register());
+}
+
+
+// -------------------------------------------------------------------------
+// RegisterAllocator implementation.
+
+void RegisterAllocator::Initialize() {
+  registers_.Reset();
+  Use(esp);
+  Use(ebp);
+  Use(esi);
+  Use(edi);

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

Pretty sad, that we use all of these. :(

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

Those are the callee-save registers at JS function calls.  Of those, edi isn't
actually reserved.  We can free up esi too.

We have to come up with a better way to track reserved registers, too.

+}
+
+
+Result RegisterAllocator::AllocateWithoutSpilling() {
+  // Return the first free register, if any.
+  for (int i = 0; i < num_registers(); i++) {
+    if (!is_used(i)) {
+      Register free_reg = { i };
+      return Result(free_reg, cgen_);
+    }
+  }
+  return Result(cgen_);
+}
+
+
+Result RegisterAllocator::Allocate() {
+  Result result = AllocateWithoutSpilling();
+  if (!result.is_valid()) {
     // Ask the current frame to spill a register.
-    ASSERT(code_generator_->frame() != NULL);
-    result = code_generator_->frame()->SpillAnyRegister();
-    if (!result.is(no_reg)) {
-      ASSERT(!registers_.is_used(result.code()));
-      registers_.Use(result);
+    ASSERT(cgen_->frame() != NULL);
+    Register free_reg = cgen_->frame()->SpillAnyRegister();
+    if (free_reg.is_valid()) {
+      ASSERT(!is_used(free_reg.code()));
+      return Result(free_reg, cgen_);
     }
   }
   return result;
 }
 
 
 } }  // namespace v8::internal