Experimental: a quick hack to allow different live values to flow down...

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 290 matching lines @@
 }
 
 
 void VirtualFrame::MakeMergable() {
   Comment cmnt(masm_, "[ Make frame mergable");
   // We can call MakeMergable on a frame that is not the code generator's
   // current frame, which will leave the global register counts out of sync
   // with the frame.  We simply save the current frame and restore it at the
   // end of this function.  We should find a better way to deal with this.
   VirtualFrame* original_frame = cgen_->frame();
-  ASSERT(cgen_->HasValidEntryRegisters());
-  cgen_->SetFrame(this);
+  RegisterFile non_frame_registers;
+  non_frame_registers.Use(esi);
+  non_frame_registers.Use(ebp);
+  non_frame_registers.Use(esp);
+  cgen_->SetFrame(this, &non_frame_registers);
   ASSERT(cgen_->HasValidEntryRegisters());
 
   // Remove constants from the frame and ensure that no registers are
   // multiply referenced within the frame.  Allocate elements to their new
   // locations from the top down so that the topmost elements have a chance
   // to be in registers, then fill them into memory from the bottom up.
   // (NB: Currently when spilling registers that are multiply referenced, it
   // is the lowermost occurrence that gets to stay in the register.)
 
   // The elements of new_elements are initially invalid.
@@ skipping 53 matching lines @@
         // but we have already done that when computing new target elements,
         // so we use a raw spill.
         RawSpillElementAt(i);
       }
     }
     // Invalid elements do not need to be moved.
   }
 
   delete[] new_elements;
   ASSERT(cgen_->HasValidEntryRegisters());
-  cgen_->SetFrame(original_frame);
-  ASSERT(cgen_->HasValidEntryRegisters());
+  cgen_->SetFrame(original_frame, &non_frame_registers);
 }
 
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
   Comment cmnt(masm_, "[ Merge frame");
   // We should always be merging the code generator's current frame to an
   // expected frame.
   ASSERT(cgen_->frame() == this);
 
   ASSERT(cgen_ == expected->cgen_);
@@ skipping 653 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal