Experimental: this is a substantial change to allow the virtual frame...

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 21 matching lines @@
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // Result implementation.
 
 Result::Result(Register reg, CodeGenerator* cgen)
   : type_(REGISTER),
     cgen_(cgen) {
   data_.reg_ = reg;
-  ASSERT(!reg.is(no_reg));
+  ASSERT(reg.is_valid());
   cgen_->allocator()->Use(reg);
 }
 
 
 void Result::CopyTo(Result* destination) const {
   destination->type_ = type();
   destination->cgen_ = cgen_;
 
   if (is_register()) {
     destination->data_.reg_ = reg();
@@ skipping 14 matching lines @@
 }
 
 
 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();
+    *this = fresh;
   }
   ASSERT(is_register());
 }
 
 
+void Result::ToRegister(Register target) {
+  ASSERT(is_valid());
+  if (!is_register() || !reg().is(target)) {
+    Result fresh = cgen_->allocator()->Allocate(target);
+    ASSERT(fresh.is_valid());
+    if (is_register()) {
+      cgen_->masm()->mov(fresh.reg(), reg());
+    } else {
+      ASSERT(is_constant());
+      cgen_->masm()->Set(fresh.reg(), Immediate(handle()));
+    }
+    *this = fresh;
+  }

[William Hesse, 2008/12/22 13:55:21]

I think we are missing the case where this.reg() is target,
but target occurs multiple times in the frame.  We need to spill target in that
case, I think.

[Kevin Millikin (Chromium), 2008/12/22 14:40:00]

Yes, according to the comment in the header we do.  Fixed.

We still need to handle the case that the target register is multiply referenced
outside the frame (or otherwise unallocatable, which amounts to the same thing).

+  ASSERT(is_register());
+  ASSERT(reg().is(target));
+}
+
+
 // -------------------------------------------------------------------------
 // RegisterAllocator implementation.
 
 void RegisterAllocator::Initialize() {
   registers_.Reset();
   Use(esp);
   Use(ebp);
   Use(esi);
   Use(edi);

[William Hesse, 2008/12/22 13:55:21]

Aren't we going to need to unuse edi before the ValidRegisters check at
JumpTarget works?

[Kevin Millikin (Chromium), 2008/12/22 14:40:00]

We can't jump before Enter is called on the frame.  That seems reasonable.

 }
 
 
 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(cgen_->frame() != NULL);
     Register free_reg = cgen_->frame()->SpillAnyRegister();
     if (free_reg.is_valid()) {
-      ASSERT(!is_used(free_reg.code()));
+      ASSERT(!is_used(free_reg));
       return Result(free_reg, cgen_);
     }
   }
   return result;
 }
 
 
+Result RegisterAllocator::Allocate(Register target) {
+  // If the target is not referenced, it can simply be allocated.
+  if (!is_used(target)) {
+    return Result(target, cgen_);
+  }
+  // If the target is only referenced in the frame, it can be spilled and
+  // then allocated.
+  ASSERT(cgen_->frame() != NULL);
+  if (count(target) == cgen_->frame()->register_count(target)) {
+    cgen_->frame()->Spill(target);
+    ASSERT(!is_used(target));
+    return Result(target, cgen_);
+  }
+  // Otherwise (if it's referenced outside the frame) we cannot allocate it.
+  return Result(cgen_);
+}
+
+
 } }  // namespace v8::internal