Inline some simple member functions of VirtualFrame.

src/virtual-frame.cc

 // Copyright 2009 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 17 matching lines @@
 #include "v8.h"
 
 #include "codegen-inl.h"
 #include "register-allocator-inl.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
-VirtualFrame::SpilledScope::SpilledScope(CodeGenerator* cgen)
-    : cgen_(cgen),
-      previous_state_(cgen->in_spilled_code()) {
-  ASSERT(cgen->has_valid_frame());
-  cgen->frame()->SpillAll();
-  cgen->set_in_spilled_code(true);
-}
-
-
-VirtualFrame::SpilledScope::~SpilledScope() {
-  cgen_->set_in_spilled_code(previous_state_);
-}
-
-
 // When cloned, a frame is a deep copy of the original.
 VirtualFrame::VirtualFrame(VirtualFrame* original)
     : cgen_(original->cgen_),
       masm_(original->masm_),
       elements_(original->elements_.capacity()),
       parameter_count_(original->parameter_count_),
       local_count_(original->local_count_),
       stack_pointer_(original->stack_pointer_),
       frame_pointer_(original->frame_pointer_) {
   // Copy all the elements from the original.
@@ skipping 56 matching lines @@
   ASSERT(count >= 0);
   ASSERT(stack_pointer_ == elements_.length() - 1);
 
   for (int i = 0; i < count; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
   stack_pointer_ += count;
 }
 
 
-// Modify the state of the virtual frame to match the actual frame by
-// removing elements from the top of the virtual frame.  The elements will
-// be externally popped from the actual frame (eg, by a runtime call).  No
-// code is emitted.
-void VirtualFrame::Forget(int count) {
-  ASSERT(count >= 0);
-  ASSERT(stack_pointer_ == elements_.length() - 1);
-
-  stack_pointer_ -= count;
-  ForgetElements(count);
-}
-
-
 void VirtualFrame::ForgetElements(int count) {
   ASSERT(count >= 0);
   ASSERT(elements_.length() >= count);
 
   for (int i = 0; i < count; i++) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       // A hack to properly count register references for the code
       // generator's current frame and also for other frames.  The
       // same code appears in PrepareMergeTo.
       if (cgen_->frame() == this) {
         Unuse(last.reg());
       } else {
         register_locations_[last.reg().code()] = kIllegalIndex;
       }
     }
   }
 }
 
 
-void VirtualFrame::Use(Register reg, int index) {
-  ASSERT(register_locations_[reg.code()] == kIllegalIndex);
-  register_locations_[reg.code()] = index;
-  cgen_->allocator()->Use(reg);
-}
-
-
-void VirtualFrame::Unuse(Register reg) {
-  ASSERT(register_locations_[reg.code()] != kIllegalIndex);
-  register_locations_[reg.code()] = kIllegalIndex;
-  cgen_->allocator()->Unuse(reg);
-}
-
-
-void VirtualFrame::Spill(Register target) {
-  if (is_used(target)) {
-    SpillElementAt(register_index(target));
-  }
-}
-
-
 // If there are any registers referenced only by the frame, spill one.
 Register VirtualFrame::SpillAnyRegister() {
   // Find the leftmost (ordered by register code) register whose only
   // reference is in the frame.
   for (int i = 0; i < kNumRegisters; i++) {
     if (is_used(i) && cgen_->allocator()->count(i) == 1) {
       Register result = { i };
       Spill(result);
       ASSERT(!cgen_->allocator()->is_used(result));
       return result;
@@ skipping 186 matching lines @@
     ASSERT(value->is_constant());
     elements_[frame_index] =
         FrameElement::ConstantElement(value->handle(),
                                       FrameElement::NOT_SYNCED);
   }
   value->Unuse();
 }
 
 
 void VirtualFrame::PushFrameSlotAt(int index) {
-  FrameElement new_element = CopyElementAt(index);
-  elements_.Add(new_element);
-}
-
-
-Result VirtualFrame::CallStub(CodeStub* stub, int arg_count) {
-  PrepareForCall(arg_count, arg_count);
-  return RawCallStub(stub);
+  elements_.Add(CopyElementAt(index));
 }
 
 
 void VirtualFrame::Push(Register reg, StaticType static_type) {
   if (is_used(reg)) {
     int index = register_index(reg);
     FrameElement element = CopyElementAt(index);
     ASSERT(static_type.merge(element.static_type()) == element.static_type());
     elements_.Add(element);
   } else {
     Use(reg, elements_.length());
     FrameElement element =
         FrameElement::RegisterElement(reg,
                                       FrameElement::NOT_SYNCED,
                                       static_type);
     elements_.Add(element);
   }
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
   FrameElement element =
       FrameElement::ConstantElement(value, FrameElement::NOT_SYNCED);
   elements_.Add(element);
 }
 
 
-void VirtualFrame::Push(Result* result) {
-  if (result->is_register()) {
-    Push(result->reg(), result->static_type());
-  } else {
-    ASSERT(result->is_constant());
-    Push(result->handle());
-  }
-  result->Unuse();
-}
-
-
 void VirtualFrame::Nip(int num_dropped) {
   ASSERT(num_dropped >= 0);
   if (num_dropped == 0) return;
   Result tos = Pop();
   if (num_dropped > 1) {
     Drop(num_dropped - 1);
   }
   SetElementAt(0, &tos);
 }
 
@@ skipping 27 matching lines @@
 // Specialization of List::ResizeAdd to non-inlined version for FrameElements.
 // The function ResizeAdd becomes a real function, whose implementation is the
 // inlined ResizeAddInternal.
 template <>
 void List<FrameElement,
           FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element) {
   ResizeAddInternal(element);
 }
 
 } }  // namespace v8::internal