Allow non-spilled frames into VisitCompareOperation, and allow them...

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 32 matching lines @@
 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() {
-  ASSERT(!reg().is(no_reg));
-  cgen_->allocator()->Unuse(reg());
-  data_.reg_ = no_reg;
+  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.
 
 // On entry to a function, the virtual frame already contains the receiver,
 // the parameters, and a return address.  All frame elements are in memory.
 VirtualFrame::VirtualFrame(CodeGenerator* cgen)
     : cgen_(cgen),
@@ skipping 441 matching lines @@
   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())) {
-        // 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 (source.is_register() && target.is_register()) {
+        if (target.reg().is(source.reg())) {
           if (target.is_synced() && !source.is_synced()) {
             SyncElementAt(i);
           }
           elements_[i] = target;
-          __ mov(target.reg(), source.reg());
-          any_moves_made = true;
+        } else {
+          // 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.
+            if (target.is_synced() && !source.is_synced()) {
+              SyncElementAt(i);
+            }
+            Use(target.reg());
+            Unuse(source.reg());
+            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;
     }
   } while (any_moves_blocked);
@@ skipping 335 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal