Experimental: more code generator changes....

src/virtual-frame-ia32.h

 // 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 33 matching lines @@
 
   // Construct a Result whose value is a compile-time constant.
   Result(Handle<Object> value, CodeGenerator * cgen) :
       type_(CONSTANT),
       cgen_(cgen) {
     data_.handle_ = value.location();
   }
 
   ~Result() {
     // We have called Unuse() before Result goes out of scope.
-    ASSERT(reg_.is(no_reg));
+    ASSERT(!is_register() || reg().is(no_reg));
   }
 
   void Unuse();
 
   bool is_register() const { return type() == REGISTER; }
   bool is_constant() const { return type() == CONSTANT; }
 
   Register reg() const {
     ASSERT(type() == REGISTER);
     return data_.reg_;
@@ skipping 139 matching lines @@
 
   // Spill a register if possible.  Return the register spilled or no_reg if
   // it was not possible to spill one.
   Register SpillAnyRegister();
 
   // True if an arbitrary frame of the same size could be merged to this
   // one.  Requires all values to be in a unique register or memory
   // location.
   bool IsMergable();
 
+  // True if making the frame mergable via MakeMergable will generate code.
+  // This differs from !IsMergable() because there are some non-mergable
+  // frames that can be made mergable simply by changing internal state (eg,
+  // forgetting about constants that are synced to memory) without
+  // generating code.
+  bool RequiresMergeCode();
+
   // Ensure that this frame is in a state where an arbitrary frame of the
   // right size could be merged to it.  May emit code.
   void MakeMergable();
 
   // Make this virtual frame have a state identical to an expected virtual
   // frame.  As a side effect, code may be emitted to make this frame match
   // the expected one.
   void MergeTo(VirtualFrame* expected);
 
+  // Detach a frame from its code generator, perhaps temporarily.  This
+  // tells the register allocator that it is free to use frame-internal
+  // registers.  Used when the code generator's frame is switched from this
+  // one to NULL by an unconditional jump.
+  void DetachFromCodeGenerator();
+
+  // (Re)attach a frame to its code generator.  This informs the register
+  // allocator that the frame-internal register references are active again.
+  // Used when a code generator's frame is switched from NULL to this one by
+  // binding a label.
+  void AttachToCodeGenerator();
+
   // Emit code for the physical JS entry and exit frame sequences.  After
   // calling Enter, the virtual frame is ready for use; and after calling
   // Exit it should not be used.  Note that Enter does not allocate space in
   // the physical frame for storing frame-allocated locals.
   void Enter();
   void Exit();
 
   // Allocate and initialize the frame-allocated locals.  The eax register
   // us clobbered.
   void AllocateStackSlots(int count);
@@ skipping 190 matching lines @@
 
   // Spill the topmost elements of the frame to memory (eg, they are the
   // arguments to a call) and all registers.
   void PrepareForCall(int count);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_