Inline part of RawSyncElementAt, improve PrepareForCall

src/virtual-frame-arm.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 40 matching lines @@
       frame_pointer_(kIllegalIndex) {
   for (int i = 0; i < parameter_count_ + 1; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
   for (int i = 0; i < kNumRegisters; i++) {
     register_locations_[i] = kIllegalIndex;
   }
 }
 
 
-// Clear the dirty bit for the element at a given index if it is a
-// valid element.  The stack address corresponding to the element must
-// be allocated on the physical stack, or the first element above the
-// stack pointer so it can be allocated by a single push instruction.
-void VirtualFrame::RawSyncElementAt(int index) {
-  FrameElement element = elements_[index];
-
-  if (!element.is_valid() || element.is_synced()) return;
-
-  if (index <= stack_pointer_) {
-    // Emit code to write elements below the stack pointer to their
-    // (already allocated) stack address.
-    switch (element.type()) {
-      case FrameElement::INVALID:  // Fall through.
-      case FrameElement::MEMORY:
-        // There was an early bailout for invalid and synced elements
-        // (memory elements are always synced).
-        UNREACHABLE();
-        break;
-
-      case FrameElement::REGISTER:
-        __ str(element.reg(), MemOperand(fp, fp_relative(index)));
-        break;
-
-      case FrameElement::CONSTANT: {
-        Result temp = cgen_->allocator()->Allocate();
-        ASSERT(temp.is_valid());
-        __ mov(temp.reg(), Operand(element.handle()));
-        __ str(temp.reg(), MemOperand(fp, fp_relative(index)));
-        break;
-      }
-
-      case FrameElement::COPY: {
-        int backing_index = element.index();
-        FrameElement backing_element = elements_[backing_index];
-        if (backing_element.is_memory()) {
-          Result temp = cgen_->allocator()->Allocate();
-          ASSERT(temp.is_valid());
-          __ ldr(temp.reg(), MemOperand(fp, fp_relative(backing_index)));
-          __ str(temp.reg(), MemOperand(fp, fp_relative(index)));
-        } else {
-          ASSERT(backing_element.is_register());
-          __ str(backing_element.reg(), MemOperand(fp, fp_relative(index)));
-        }
-        break;
-      }
-    }
-
-  } 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);
-    stack_pointer_++;
-    switch (element.type()) {
-      case FrameElement::INVALID:  // Fall through.
-      case FrameElement::MEMORY:
-        // There was an early bailout for invalid and synced elements
-        // (memory elements are always synced).
-        UNREACHABLE();
-        break;
-
-      case FrameElement::REGISTER:
-        __ push(element.reg());
-        break;
-
-      case FrameElement::CONSTANT: {
-        Result temp = cgen_->allocator()->Allocate();
-        ASSERT(temp.is_valid());
-        __ mov(temp.reg(), Operand(element.handle()));
-        __ push(temp.reg());
-        break;
-      }
-
-      case FrameElement::COPY: {
-        int backing_index = element.index();
-        FrameElement backing = elements_[backing_index];
-        ASSERT(backing.is_memory() || backing.is_register());
-        if (backing.is_memory()) {
-          Result temp = cgen_->allocator()->Allocate();
-          ASSERT(temp.is_valid());
-          __ ldr(temp.reg(), MemOperand(fp, fp_relative(backing_index)));
-          __ push(temp.reg());
-        } else {
-          __ push(backing.reg());
-        }
-        break;
-      }
-    }
-  }
-
-  elements_[index].set_sync();
+void VirtualFrame::SyncElementBelowStackPointer(int index) {
+  UNREACHABLE();
 }
 
 
+void VirtualFrame::SyncElementByPushing(int index) {
+  UNREACHABLE();
+}
+
+
 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);
 
   // Adjust the stack pointer upward (toward the top of the virtual
   // frame) if necessary.
   if (stack_pointer_ < expected->stack_pointer_) {
     int difference = expected->stack_pointer_ - stack_pointer_;
@@ skipping 305 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(reg);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal