Experimental: for forward CFG edges, generate the code to merge to an...

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 291 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 
 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();
-  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);

[William Hesse, 2009/01/15 12:21:54]

Can you put an assert in, that the frame is its cgen's current frame?

[Kevin Millikin (Chromium), 2009/01/15 13:08:18]

Done.

   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, &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 13 matching lines @@
   MergeMoveMemoryToRegisters(expected);
 
   int height_difference = stack_pointer_ - expected->stack_pointer_;
   if (stack_pointer_ > expected->stack_pointer_) {
 #ifdef DEBUG
     for (int i = stack_pointer_; i > expected->stack_pointer_; i--) {
       ASSERT(!elements_[i].is_memory());
       ASSERT(!elements_[i].is_synced());
     }
 #endif
+    ASSERT(!cgen_->has_cc());
     __ add(Operand(esp), Immediate(height_difference * kPointerSize));
     stack_pointer_ = expected->stack_pointer_;
   } else if (stack_pointer_ < expected->stack_pointer_) {
     // Put valid data on the stack, that will only be accessed by GC.
     while (stack_pointer_ < expected->stack_pointer_) {
       __ push(Immediate(Smi::FromInt(0)));
       stack_pointer_++;
     }
   }
 
@@ skipping 117 matching lines @@
           // pointer downward.
           if (stack_pointer_ > i) {
             // Sync elements between i and stack pointer, and bring
             // stack pointer down to i.
 #ifdef DEBUG
             // In debug builds check to ensure this is safe.
             for (int j = stack_pointer_; j > i; j--) {
               ASSERT(!elements_[j].is_memory());
             }
 #endif
-            __ add(Operand(esp),
-                   Immediate((stack_pointer_ - i) * kPointerSize));
+            int difference = stack_pointer_ - i;
+            ASSERT(!cgen_->has_cc());
+            __ add(Operand(esp), Immediate(difference * kPointerSize));
             stack_pointer_ = i;
-            }
+          }
           stack_pointer_--;
           __ pop(target.reg());
         }
       } else {
         // Source is constant.
         __ Set(target.reg(), Immediate(source.handle()));
         if (target.is_synced()) {
           SyncElementAt(i);
         }
       }
@@ skipping 351 matching lines @@
 
 
 void VirtualFrame::Drop(int count) {
   ASSERT(height() >= count);
   int num_virtual_elements = (elements_.length() - 1) - stack_pointer_;
 
   // Emit code to lower the stack pointer if necessary.
   if (num_virtual_elements < count) {
     int num_dropped = count - num_virtual_elements;
     stack_pointer_ -= num_dropped;
+    ASSERT(!cgen_->has_cc());
     __ add(Operand(esp), Immediate(num_dropped * kPointerSize));
   }
 
   // Discard elements from the virtual frame and free any registers.
   for (int i = 0; i < count; i++) {
     FrameElement dropped = elements_.RemoveLast();
     if (dropped.is_register()) {
       Unuse(dropped.reg());
     }
   }
 }
 
 
 Result VirtualFrame::Pop() {
   FrameElement popped = elements_.RemoveLast();
   bool pop_needed = (stack_pointer_ == elements_.length());
 
   if (popped.is_constant()) {
     if (pop_needed) {
       stack_pointer_--;
+      ASSERT(!cgen_->has_cc());
       __ add(Operand(esp), Immediate(kPointerSize));
     }
     return Result(popped.handle(), cgen_);
   } else if (popped.is_register()) {
     Unuse(popped.reg());
     if (pop_needed) {
       stack_pointer_--;
+      ASSERT(!cgen_->has_cc());
       __ add(Operand(esp), Immediate(kPointerSize));
     }
     return Result(popped.reg(), cgen_);
   } else {
     ASSERT(popped.is_memory());
     Result temp = cgen_->allocator()->Allocate();
     ASSERT(temp.is_valid());
     ASSERT(pop_needed);
     stack_pointer_--;
     __ pop(temp.reg());
@@ skipping 84 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal