Experimental: this is a substantial change to allow the virtual frame...

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 113 matching lines @@
   cgen_->allocator()->Use(reg);
 }
 
 
 void VirtualFrame::Unuse(Register reg) {
   frame_registers_.Unuse(reg);
   cgen_->allocator()->Unuse(reg);
 }
 
 
-// Spill any register if possible, making its reference count zero.
+void VirtualFrame::Spill(Register target) {
+  for (int i = 0; i < elements_.length(); i++) {
+    if (elements_[i].is_register() && elements_[i].reg().is(target)) {
+      SpillElementAt(i);
+    }
+  }
+}
+
+
+// Spill any register if possible, making its external reference count zero.
 Register VirtualFrame::SpillAnyRegister() {
   // Find the leftmost (ordered by register code), least
   // internally-referenced register whose internal reference count matches
   // its external reference count (so that spilling it from the frame frees
   // it for use).
   int min_count = kMaxInt;
   int best_register_code = no_reg.code_;
 
   for (int i = 0; i < RegisterFile::kNumRegisters; i++) {
     int count = frame_registers_.count(i);
     if (count < min_count && count == cgen_->allocator()->count(i)) {
       min_count = count;
       best_register_code = i;
     }
   }
 
-  if (best_register_code != no_reg.code_) {
-    // Spill all occurrences of the register.  There are min_count
-    // occurrences, stop when we have spilled them all to avoid syncing
-    // elements unnecessarily.
-    int i = 0;
-    while (min_count > 0) {
-      ASSERT(i < elements_.length());
-      if (elements_[i].is_register() &&
-          elements_[i].reg().code() == best_register_code) {
-        // Found an instance of the best_register being used in the frame.
-        // Spill it.
-        SpillElementAt(i);
-        min_count--;
-      }
-      i++;
-    }
+  Register result = { best_register_code };
+  if (result.is_valid()) {
+    Spill(result);
+    ASSERT(!cgen_->allocator()->is_used(result));
   }
-
-  ASSERT(cgen_->allocator()->count(best_register_code) == 0);
-  Register result = { best_register_code };
   return result;
 }
 
 
 // Spill an element, making its type be MEMORY.
 // Does not decrement usage counts, if element is a register.
 void VirtualFrame::RawSpillElementAt(int index) {
   SyncElementAt(index);
   // The element is now in memory.
   elements_[index] = FrameElement::MemoryElement();
@@ skipping 89 matching lines @@
     } else {
       SyncElementAt(i);
     }
   }
 
   // Forget the frame elements that will be popped by the call.
   Forget(frame_arg_count);
 }
 
 
-bool VirtualFrame::IsMergable() {
-  // We cannot merge to a frame that has constants as elements, because an
-  // arbitrary frame may not have the same constants at those locations.  We
-  // cannot merge to a frame that has registers that are mulitply referenced
-  // in the frame, because an arbitrary frame might not exhibit the same
-  // sharing.  Thus, a frame is mergable if all elements are in memory or a
-  // register and no register is multiply referenced.
-  for (int i = 0; i < RegisterFile::kNumRegisters; i++) {
-    if (frame_registers_.count(i) > 1) {
-      return false;
-    }
-  }
-
-  for (int i = 0; i < elements_.length(); i++) {
-    if (!elements_[i].is_memory() && !elements_[i].is_register()) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-
 bool VirtualFrame::RequiresMergeCode() {
   // A frame requires merge code to be generated in the event that
   // there are duplicated non-synched registers or else elements not
   // in a (memory or register) location in the frame.  We look for
   // non-synced non-location elements and count occurrences of
   // non-synced registers.
   RegisterFile non_synced_regs;
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement element = elements_[i];
     if (!element.is_synced()) {
@@ skipping 11 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();
+  ASSERT(cgen_->HasValidEntryRegisters());
+  cgen_->SetFrame(this);
+  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.)
+  // 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.
   FrameElement* new_elements = new FrameElement[elements_.length()];
   FrameElement memory_element = FrameElement::MemoryElement();
   for (int i = elements_.length() - 1; i >= 0; i--) {
     FrameElement element = elements_[i];
     if (element.is_constant() ||
         (element.is_register() &&
-         frame_registers_.count(element.reg().code()) > 1)) {
+         frame_registers_.count(element.reg()) > 1)) {
       // A simple strategy is to locate these elements in memory if they are
       // synced (avoiding a spill right now) and otherwise to prefer a
       // register for them.
       if (element.is_synced()) {
         new_elements[i] = memory_element;
       } else {
         Result fresh = cgen_->allocator()->AllocateWithoutSpilling();
         if (fresh.is_valid()) {
           // We immediately record the frame's use of the register so that
           // it will not be allocated again.
@@ skipping 35 matching lines @@
       if (!source.is_memory()) {
         // Spilling a source register would decrement its reference count,
         // but we have already done that when computing new target elements,
         // so we use a raw spill.
         RawSpillElementAt(i);
       }
     }
   }
 
   delete[] new_elements;
+  ASSERT(cgen_->HasValidEntryRegisters());
+  cgen_->SetFrame(original_frame);
+  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_ == 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
@@ skipping 54 matching lines @@
       FrameElement source = elements_[i];
       FrameElement target = expected->elements_[i];
       if (source.is_register() && target.is_register()) {
         if (target.reg().is(source.reg())) {
           if (target.is_synced() && !source.is_synced()) {
             SyncElementAt(i);
           }
           elements_[i] = target;
         } else {
           // We need to move source to target.
-          if (frame_registers_.is_used(target.reg().code())) {
+          if (frame_registers_.is_used(target.reg())) {
             // The move is blocked because the target contains valid data.
             // If we are stuck with only cycles remaining, then we spill source.
             // Otherwise, we just need more iterations.
             if (should_break_cycles) {
               SpillElementAt(i);
               should_break_cycles = false;
             } else {  // Record a blocked move.
               if (!any_moves_blocked) {
                 first_move_blocked = i;
               }
@@ skipping 231 matching lines @@
 
     if (top.is_register()) {
       // Establish another frame-internal reference to the register.
       Use(top.reg());
     }
   }
 }
 
 
 void VirtualFrame::PushTryHandler(HandlerType type) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   // Grow the expression stack by handler size less two (the return address
   // is already pushed by a call instruction, and PushTryHandler from the
   // macro assembler will leave the top of stack in the eax register to be
   // pushed separately).
   Adjust(kHandlerSize - 2);
   __ PushTryHandler(IN_JAVASCRIPT, type);
   // TODO(1222589): remove the reliance of PushTryHandler on a cached TOS
   EmitPush(eax);
 }
 
 
 void VirtualFrame::CallStub(CodeStub* stub, int frame_arg_count) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallStub(stub);
 }
 
 
+Result VirtualFrame::CallStub(CodeStub* stub,
+                              Result* arg0,
+                              Result* arg1,
+                              int frame_arg_count) {
+  arg0->Unuse();
+  arg1->Unuse();
+  CallStub(stub, frame_arg_count);
+  Result result = cgen_->allocator()->Allocate(eax);
+  ASSERT(result.is_valid());
+  return result;
+}
+
+
 void VirtualFrame::CallRuntime(Runtime::Function* f, int frame_arg_count) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallRuntime(f, frame_arg_count);
 }
 
 
 void VirtualFrame::CallRuntime(Runtime::FunctionId id, int frame_arg_count) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallRuntime(id, frame_arg_count);
 }
 
 
 void VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
                                  InvokeFlag flag,
                                  int frame_arg_count) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ InvokeBuiltin(id, flag);
 }
 
 
 void VirtualFrame::CallCodeObject(Handle<Code> code,
                                   RelocInfo::Mode rmode,
                                   int frame_arg_count) {
+  ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ call(code, rmode);
 }
 
 
 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;
     __ 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());
     }
   }
 }
 
 
 void VirtualFrame::Drop() { Drop(1); }
 
 
-/*
-We need comparison with literal to work.
-It will get Result, is register or constant.
-Pop gives it this, from register, constant, memory, or
-reference to slot.
-
-In comparison to literal, we need register case to work.
-We need non-smi stub to exit and return with a non-spilled frame.
-*/
-
-
 Result VirtualFrame::Pop() {
   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()) {
     Unuse(popped.reg());
     if (pop_needed) {
       stack_pointer_--;
       __ 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());
     return temp;
   }
 }
 
+
 void VirtualFrame::EmitPop(Register reg) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
 }
 
 
 void VirtualFrame::EmitPop(Operand operand) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
@@ skipping 58 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal