Experimental: thread live register references to deferred code....

src/virtual-frame-ia32.cc

Index: src/virtual-frame-ia32.cc
===================================================================
--- src/virtual-frame-ia32.cc	(revision 969)
+++ src/virtual-frame-ia32.cc	(working copy)
@@ -399,13 +399,6 @@
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
   Comment cmnt(masm_, "[ Merge frame");
-  ASSERT(cgen_ == expected->cgen_);
-  ASSERT(masm_ == expected->masm_);
-  ASSERT(elements_.length() == expected->elements_.length());
-  ASSERT(parameter_count_ == expected->parameter_count_);
-  ASSERT(local_count_ == expected->local_count_);
-  ASSERT(frame_pointer_ == expected->frame_pointer_);
-
   // Mergable frames have all elements in locations, either memory or
   // register.  We thus have a series of to-memory and to-register moves.
   // First perform all to-memory moves, register-to-memory moves because
@@ -468,26 +461,7 @@
   }
 
   // At this point, the frames should be identical.
-  ASSERT(stack_pointer_ == expected->stack_pointer_);
-#ifdef DEBUG
-  for (int i = 0; i < elements_.length(); i++) {
-    FrameElement expect = expected->elements_[i];
-    if (expect.is_memory()) {
-      ASSERT(elements_[i].is_memory());
-      ASSERT(elements_[i].is_synced() && expect.is_synced());
-    } else if (expect.is_register()) {
-      ASSERT(elements_[i].is_register());
-      ASSERT(elements_[i].reg().is(expect.reg()));
-      ASSERT(elements_[i].is_synced() == expect.is_synced());
-    } else {
-      ASSERT(expect.is_constant());
-      ASSERT(elements_[i].is_constant());
-      ASSERT(elements_[i].handle().location() ==
-             expect.handle().location());
-      ASSERT(elements_[i].is_synced() == expect.is_synced());
-    }
-  }
-#endif
+  ASSERT(Equals(expected));
 }
 
 
@@ -791,6 +765,37 @@
   }
   return true;
 }
+
+
+bool VirtualFrame::Equals(VirtualFrame* other) {
+  if (cgen_ != other->cgen_) return false;
+  if (masm_ != other->masm_) return false;
+  if (elements_.length() != other->elements_.length()) return false;
+  if (parameter_count_ != other->parameter_count_) return false;
+  if (local_count_ != other->local_count_) return false;
+  if (frame_pointer_ != other->frame_pointer_) return false;
+  if (stack_pointer_ != other->stack_pointer_) return false;
+
+  for (int i = 0; i < elements_.length(); i++) {
+    FrameElement element = other->elements_[i];
+    if (element.is_memory()) {
+      if (!elements_[i].is_memory()) return false;
+      if (!elements_[i].is_synced() || !element.is_synced()) return false;
+    } else if (element.is_register()) {
+      if (!elements_[i].is_register()) return false;
+      if (!elements_[i].reg().is(element.reg())) return false;
+      if (elements_[i].is_synced() != element.is_synced()) return false;
+    } else {
+      if (!element.is_constant()) return false;
+      if (!elements_[i].is_constant()) return false;
+      if (elements_[i].handle().location() != element.handle().location()) {
+        return false;
+      }
+      if (elements_[i].is_synced() != element.is_synced()) return false;
+    }
+  }
+  return true;
+}
 #endif
 
 #undef __