Experimental: remove the cc_reg_ state from the code generator. There...

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 178 matching lines @@
 // The element must be on the physical stack, or the first
 // element below the stack pointer (created by a single push).
 void VirtualFrame::RawSyncElementAt(int index) {
   FrameElement element = elements_[index];
 
   if (!element.is_synced()) {
     if (index <= stack_pointer_) {
       // Write elements below the stack pointer to their (already allocated)
       // actual frame location.
       if (element.is_constant()) {
-        ASSERT(!cgen_->has_cc());
         __ Set(Operand(ebp, fp_relative(index)), Immediate(element.handle()));
       } else {
         ASSERT(element.is_register());
         __ mov(Operand(ebp, fp_relative(index)), element.reg());
       }
     } else {
       // Push elements above the stack pointer to allocate space and sync
       // them.  Space should have already been allocated in the actual frame
       // for all the elements below this one.
       ASSERT(index == stack_pointer_ + 1);
@@ skipping 96 matching lines @@
 
   return false;
 }
 
 
 void VirtualFrame::MakeMergable() {
   Comment cmnt(masm_, "[ Make frame mergable");
   // We should always be merging the code generator's current frame to an
   // expected frame.
   ASSERT(cgen_->frame() == this);
-  ASSERT(!cgen_->has_cc());
   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 61 matching lines @@
   delete[] new_elements;
   ASSERT(cgen_->HasValidEntryRegisters());
 }
 
 
 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_->has_cc());
 
   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.
@@ skipping 249 matching lines @@
   Drop(height());
 
   // Validate state: The expression stack should be empty and the
   // stack pointer should have been updated to reflect this.
   ASSERT(height() == 0);
   ASSERT(stack_pointer_ == expression_base_index() - 1);
 }
 
 
 void VirtualFrame::AllocateStackSlots(int count) {
-  ASSERT(!cgen_->has_cc());
   ASSERT(height() == 0);
   local_count_ = count;
 
   if (count > 0) {
     Comment cmnt(masm_, "[ Allocate space for locals");
     // The locals are initialized to a constant (the undefined value), but
     // we sync them with the actual frame to allocate space for spilling
     // them later.  First sync everything above the stack pointer so we can
     // use pushes to allocate and initialize the locals.
     SyncRange(stack_pointer_ + 1, elements_.length());
@@ skipping 238 matching lines @@
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ call(code, rmode);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 void VirtualFrame::Drop(int count) {
-  ASSERT(!cgen_->has_cc());
   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;
     __ 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() {
-  ASSERT(!cgen_->has_cc());
   FrameElement popped = elements_.RemoveLast();
   bool pop_needed = (stack_pointer_ == elements_.length());
 
   if (popped.is_constant()) {
     if (pop_needed) {
       stack_pointer_--;
       __ add(Operand(esp), Immediate(kPointerSize));
     }
     return Result(popped.handle(), cgen_);
   } else if (popped.is_register()) {
@@ skipping 97 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal