Inline part of RawSyncElementAt, improve PrepareForCall

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 39 matching lines @@
       frame_pointer_(kIllegalIndex) {
   for (int i = 0; i < parameter_count_ + 2; 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) {
+void VirtualFrame::SyncElementBelowStackPointer(int index) {
+  // Emit code to write elements below the stack pointer to their
+  // (already allocated) stack address.
+  ASSERT(index <= stack_pointer_);
   FrameElement element = elements_[index];
+  ASSERT(!element.is_synced());
+  switch (element.type()) {
+    case FrameElement::INVALID:
+      break;
 
-  if (!element.is_valid() || element.is_synced()) return;
+    case FrameElement::MEMORY:
+      // This function should not be called with synced elements.
+      // (memory elements are always synced).
+      UNREACHABLE();
+      break;
 
-  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:
+      __ mov(Operand(ebp, fp_relative(index)), element.reg());
+      break;
 
-      case FrameElement::REGISTER:
-        __ mov(Operand(ebp, fp_relative(index)), element.reg());
-        break;
+    case FrameElement::CONSTANT:
+      if (cgen_->IsUnsafeSmi(element.handle())) {
+        Result temp = cgen_->allocator()->Allocate();
+        ASSERT(temp.is_valid());
+        cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+        __ mov(Operand(ebp, fp_relative(index)), temp.reg());
+      } else {
+        __ Set(Operand(ebp, fp_relative(index)),
+               Immediate(element.handle()));
+      }
+      break;
 
-      case FrameElement::CONSTANT:
-        if (cgen_->IsUnsafeSmi(element.handle())) {
-          Result temp = cgen_->allocator()->Allocate();
-          ASSERT(temp.is_valid());
-          cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
-          __ mov(Operand(ebp, fp_relative(index)), temp.reg());
-        } else {
-          __ Set(Operand(ebp, fp_relative(index)),
-                 Immediate(element.handle()));
-        }
-        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());
-          __ mov(temp.reg(), Operand(ebp, fp_relative(backing_index)));
-          __ mov(Operand(ebp, fp_relative(index)), temp.reg());
-        } else {
-          ASSERT(backing_element.is_register());
-          __ mov(Operand(ebp, fp_relative(index)), backing_element.reg());
-        }
-        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());
+        __ mov(temp.reg(), Operand(ebp, fp_relative(backing_index)));
+        __ mov(Operand(ebp, fp_relative(index)), temp.reg());
+      } else {
+        ASSERT(backing_element.is_register());
+        __ mov(Operand(ebp, fp_relative(index)), backing_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);
-    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:
-        if (cgen_->IsUnsafeSmi(element.handle())) {
-          Result temp = cgen_->allocator()->Allocate();
-          ASSERT(temp.is_valid());
-          cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
-          __ push(temp.reg());
-        } else {
-          __ push(Immediate(element.handle()));
-        }
-        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()) {
-          __ push(Operand(ebp, fp_relative(backing_index)));
-        } else {
-          __ push(backing.reg());
-        }
-        break;
-      }
+      break;
     }
   }
-
   elements_[index].set_sync();
 }
 
+
+void VirtualFrame::SyncElementByPushing(int index) {
+  // Sync an element of the frame that is just above the stack pointer
+  // by pushing it.
+  ASSERT(index == stack_pointer_ + 1);
+  stack_pointer_++;
+  FrameElement element = elements_[index];
+
+  switch (element.type()) {
+    case FrameElement::INVALID:
+      __ push(Immediate(Smi::FromInt(0)));
+      break;
+
+    case FrameElement::MEMORY:
+      // No memory elements exist above the stack pointer.
+      UNREACHABLE();
+      break;
+
+    case FrameElement::REGISTER:
+      __ push(element.reg());
+      break;
+
+    case FrameElement::CONSTANT:
+      if (cgen_->IsUnsafeSmi(element.handle())) {
+        Result temp = cgen_->allocator()->Allocate();
+        ASSERT(temp.is_valid());
+        cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+        __ push(temp.reg());
+      } else {
+        __ push(Immediate(element.handle()));
+      }
+      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()) {
+        __ push(Operand(ebp, fp_relative(backing_index)));
+      } else {
+        __ push(backing.reg());
+      }
+      break;
+    }
+  }
+  elements_[index].set_sync();
+}
+
 
 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_) {
@@ skipping 812 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal