Merge virtual frames by copying registers to 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 402 matching lines @@
   // not use registers.
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement source = elements_[i];
     FrameElement target = expected->elements_[i];
     if (target.is_memory() && !source.is_memory()) {
       ASSERT(source.is_register() || source.is_constant());
       SpillElementAt(i);
     }
   }
 
-  // Then register-to-register moves, not yet implemented.
-  for (int i = 0; i < elements_.length(); i++) {
-    FrameElement source = elements_[i];
-    FrameElement target = expected->elements_[i];
-    ASSERT(!source.is_register() || !target.is_register());
-  }
+  MergeMoveRegistersToRegisters(expected);
 
   // Finally, constant-to-register and memory-to-register.  We do these from
   // the top down so we can use pop for memory-to-register moves above the
   // expected stack pointer.
   for (int i = elements_.length() - 1; i >= 0; i--) {
     FrameElement source = elements_[i];
     FrameElement target = expected->elements_[i];
     if (target.is_register() && !source.is_register()) {
       ASSERT(source.is_constant() || source.is_memory());
       if (source.is_memory()) {
@@ skipping 45 matching lines @@
       ASSERT(elements_[i].is_constant());
       ASSERT(elements_[i].handle().location() ==
              expect.handle().location());
       ASSERT(elements_[i].is_synced() == expect.is_synced());
     }
   }
 #endif
 }
 
 
+void VirtualFrame::MergeMoveRegistersToRegisters(VirtualFrame *expected) {
+  int start = 0;
+  int end = elements_.length() - 1;
+  bool any_moves_blocked; // Did we fail to make some moves this iteration?
+  bool should_break_cycles = false;
+  bool any_moves_made; // Did we make any progress this iteration?
+  do {
+    any_moves_blocked = false;
+    any_moves_made = false;
+    int first_move_blocked = kIllegalIndex;
+    int last_move_blocked = kIllegalIndex;
+    for (int i = start; i <= end; i++) {
+      FrameElement source = elements_[i];
+      FrameElement target = expected->elements_[i];
+      if (source.is_register() && target.is_register &&
+          !target.reg().is(source.reg())) {

[Kevin Millikin (Chromium), 2008/12/14 13:05:04]

As we discussed, the source and targets could be the same register but with
different sync states.  In that case, the source's sync bit may need to be
cleared, or a move generated to set the target's sync bit.

[William Hesse, 2008/12/15 13:43:59]

Done.

+        // We need to move source to target.
+        if (frame_registers_.is_used(target.reg().code())) {
+          // The move is blocked because the target contains valid data.
+          // If we are stuck with only cycles remaining, then we spill source.
+          // Otherwise, we just need more iterations.
+          if (should_break_cycles) {
+            SpillElementAt(i);
+            should_break_cycles = false;
+          } else {  // Record a blocked move.
+            if (!any_moves_blocked) {
+              first_move_blocked = i;
+            }
+            last_move_blocked = i;
+            any_moves_blocked = true;
+          }
+        } else {
+          // The move is not blocked.  This frame element can be moved from
+          // its source register to its target register.
+          Use(target.reg());
+          Unuse(source.reg());
+          if (target.is_synced() && !source.is_synced()) {
+            SyncElementAt(i);

[Kevin Millikin (Chromium), 2008/12/14 13:05:04]

It seems better to call sync (which will work on the source register) before
changing the reference counts to reflect the transfer.

[William Hesse, 2008/12/15 13:43:59]

Done.

+          }
+          elements_[i] = target;
+          __ mov(target.reg(), source.reg());
+          any_moves_made = true;
+        }
+      }
+    }
+    // Update control flags for next iteration.
+    should_break_cycles = (any_moves_blocked && !any_moves_made);
+    if (any_moves_blocked) {
+      start = first_move_blocked;
+      end = last_move_blocked;

[iposva, 2008/12/12 18:13:03]

This is potentially a premature optimization. These stacks should never be very
large to start with.

[William Hesse, 2008/12/15 13:43:59]

You are right.  But should we actually remove it?  The locals could be big. 
Some people are passing big arrays as argument arrays.  Are they on the frame? 
Not removed, for now.

+    }
+  } while (any_moves_blocked);
+}
+
+
 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());
     }
   }
@@ skipping 285 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal