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

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 381 matching lines @@
       SpillElementAt(i);
     }
   }
 
   delete[] new_elements;
 }
 
 
 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
   // they can free registers and constant-to-memory moves because they do
   // 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());
@@ skipping 42 matching lines @@
       } else {
         // Source is constant.
         __ Set(target.reg(), Immediate(source.handle()));
       }
       Use(target.reg());
       elements_[i] = target;
     }
   }
 
   // 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));
 }
 
 
 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()) {
@@ skipping 283 matching lines @@
 
 #ifdef DEBUG
 bool VirtualFrame::IsSpilled() {
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].is_memory()) {
       return false;
     }
   }
   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 __
 
 } }  // namespace v8::internal