Size reduction of VirtualFrame objects. Remove the code generator and...

src/ia32/virtual-frame-ia32.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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "codegen-inl.h"
 #include "register-allocator-inl.h"
 #include "scopes.h"
 
 namespace v8 { namespace internal {
 
-#define __ ACCESS_MASM(masm_)
+#define __ ACCESS_MASM(masm())
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 // On entry to a function, the virtual frame already contains the receiver,
 // the parameters, and a return address.  All frame elements are in memory.
-VirtualFrame::VirtualFrame(CodeGenerator* cgen)
-    : cgen_(cgen),
-      masm_(cgen->masm()),
-      elements_(cgen->scope()->num_parameters()
-                + cgen->scope()->num_stack_slots()
-                + kPreallocatedElements),
-      parameter_count_(cgen->scope()->num_parameters()),
-      local_count_(0),
-      stack_pointer_(parameter_count_ + 1),  // 0-based index of TOS.
-      frame_pointer_(kIllegalIndex) {
-  for (int i = 0; i < parameter_count_ + 2; i++) {
+VirtualFrame::VirtualFrame()
+    : elements_(parameter_count() + local_count() + kPreallocatedElements),
+      stack_pointer_(parameter_count() + 1) {  // 0-based index of TOS.
+  for (int i = 0; i <= stack_pointer_; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
   for (int i = 0; i < kNumRegisters; i++) {
     register_locations_[i] = kIllegalIndex;
   }
 }
 
 
 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;
 
     case FrameElement::MEMORY:
       // This function should not be called with synced elements.
       // (memory elements are always synced).
       UNREACHABLE();
       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();
+      if (cgen()->IsUnsafeSmi(element.handle())) {
+        Result temp = cgen()->allocator()->Allocate();
         ASSERT(temp.is_valid());
-        cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+        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();
+        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;
     }
   }
@@ skipping 16 matching lines @@
     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();
+      if (cgen()->IsUnsafeSmi(element.handle())) {
+        Result temp = cgen()->allocator()->Allocate();
         ASSERT(temp.is_valid());
-        cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+        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());
@@ skipping 44 matching lines @@
     if (element.is_constant() || element.is_copy()) {
       if (element.is_synced()) {
         // Just spill.
         elements_[i] = FrameElement::MemoryElement();
       } else {
         // Allocate to a register.
         FrameElement backing_element;  // Invalid if not a copy.
         if (element.is_copy()) {
           backing_element = elements_[element.index()];
         }
-        Result fresh = cgen_->allocator()->Allocate();
+        Result fresh = cgen()->allocator()->Allocate();
         ASSERT(fresh.is_valid());
         elements_[i] =
             FrameElement::RegisterElement(fresh.reg(),
                                           FrameElement::NOT_SYNCED);
         Use(fresh.reg(), i);
 
         // Emit a move.
         if (element.is_constant()) {
-          if (cgen_->IsUnsafeSmi(element.handle())) {
-            cgen_->LoadUnsafeSmi(fresh.reg(), element.handle());
+          if (cgen()->IsUnsafeSmi(element.handle())) {
+            cgen()->LoadUnsafeSmi(fresh.reg(), element.handle());
           } else {
             __ Set(fresh.reg(), Immediate(element.handle()));
           }
         } else {
           ASSERT(element.is_copy());
           // Copies are only backed by register or memory locations.
           if (backing_element.is_register()) {
             // The backing store may have been spilled by allocating,
             // but that's OK.  If it was, the value is right where we
             // want it.
@@ skipping 14 matching lines @@
       // the high water mark.  They cannot be copied because copes are
       // always higher than their backing store and copies are not
       // allowed above the water mark.
       elements_[i].clear_copied();
     }
   }
 }
 
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
-  Comment cmnt(masm_, "[ Merge frame");
+  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()->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_;
     stack_pointer_ = expected->stack_pointer_;
     __ sub(Operand(esp), Immediate(difference * kPointerSize));
   }
 
   MergeMoveRegistersToMemory(expected);
@@ skipping 42 matching lines @@
 
         case FrameElement::REGISTER:
           Unuse(source.reg());
           if (!source.is_synced()) {
             __ mov(Operand(ebp, fp_relative(i)), source.reg());
           }
           break;
 
         case FrameElement::CONSTANT:
           if (!source.is_synced()) {
-            if (cgen_->IsUnsafeSmi(source.handle())) {
+            if (cgen()->IsUnsafeSmi(source.handle())) {
               esi_caches = i;
-              cgen_->LoadUnsafeSmi(esi, source.handle());
+              cgen()->LoadUnsafeSmi(esi, source.handle());
               __ mov(Operand(ebp, fp_relative(i)), esi);
             } else {
               __ Set(Operand(ebp, fp_relative(i)), Immediate(source.handle()));
             }
           }
           break;
 
         case FrameElement::COPY:
           if (!source.is_synced()) {
             int backing_index = source.index();
@@ skipping 83 matching lines @@
         case FrameElement::REGISTER:
           ASSERT(source.reg().is(target_reg));
           continue;  // Go to next iteration.  Skips Use(target_reg) below.
           break;
         case FrameElement::MEMORY:
           ASSERT(index <= stack_pointer_);
           __ mov(target_reg, Operand(ebp, fp_relative(index)));
           break;
 
         case FrameElement::CONSTANT:
-          if (cgen_->IsUnsafeSmi(source.handle())) {
-            cgen_->LoadUnsafeSmi(target_reg, source.handle());
+          if (cgen()->IsUnsafeSmi(source.handle())) {
+            cgen()->LoadUnsafeSmi(target_reg, source.handle());
           } else {
            __ Set(target_reg, Immediate(source.handle()));
           }
           break;
 
         case FrameElement::COPY: {
           int backing_index = source.index();
           FrameElement backing = elements_[backing_index];
           ASSERT(backing.is_memory() || backing.is_register());
           if (backing.is_memory()) {
@@ skipping 24 matching lines @@
       }
       Use(target_reg, index);
       elements_[index] = target;
     }
   }
 }
 
 
 void VirtualFrame::Enter() {
   // Registers live on entry: esp, ebp, esi, edi.
-  Comment cmnt(masm_, "[ Enter JS frame");
+  Comment cmnt(masm(), "[ Enter JS frame");
 
 #ifdef DEBUG
   // Verify that edi contains a JS function.  The following code
   // relies on eax being available for use.
   __ test(edi, Immediate(kSmiTagMask));
   __ Check(not_zero,
            "VirtualFrame::Enter - edi is not a function (smi check).");
   __ CmpObjectType(edi, JS_FUNCTION_TYPE, eax);
   __ Check(equal,
            "VirtualFrame::Enter - edi is not a function (map check).");
 #endif
 
   EmitPush(ebp);
 
-  frame_pointer_ = stack_pointer_;
   __ mov(ebp, Operand(esp));
 
   // Store the context in the frame.  The context is kept in esi and a
   // copy is stored in the frame.  The external reference to esi
   // remains.
   EmitPush(esi);
 
   // Store the function in the frame.  The frame owns the register
   // reference now (ie, it can keep it in edi or spill it later).
   Push(edi);
   SyncElementAt(elements_.length() - 1);
-  cgen_->allocator()->Unuse(edi);
+  cgen()->allocator()->Unuse(edi);
 }
 
 
 void VirtualFrame::Exit() {
-  Comment cmnt(masm_, "[ Exit JS frame");
+  Comment cmnt(masm(), "[ Exit JS frame");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
 
   // Avoid using the leave instruction here, because it is too
   // short. We need the return sequence to be a least the size of a
   // call instruction to support patching the exit code in the
   // debugger. See VisitReturnStatement for the full return sequence.
   __ mov(esp, Operand(ebp));
-  stack_pointer_ = frame_pointer_;
+  stack_pointer_ = frame_pointer();
   for (int i = elements_.length() - 1; i > stack_pointer_; i--) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       Unuse(last.reg());
     }
   }
 
-  frame_pointer_ = kIllegalIndex;
   EmitPop(ebp);
 }
 
 
-void VirtualFrame::AllocateStackSlots(int count) {
+void VirtualFrame::AllocateStackSlots() {
   ASSERT(height() == 0);
-  local_count_ = count;
 
+  int count = local_count();
   if (count > 0) {
-    Comment cmnt(masm_, "[ Allocate space for locals");
+    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() - 1);
     Handle<Object> undefined = Factory::undefined_value();
     FrameElement initial_value =
         FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
-    Result temp = cgen_->allocator()->Allocate();
+    Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ Set(temp.reg(), Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(temp.reg());
     }
   }
 }
 
 
 void VirtualFrame::SaveContextRegister() {
   ASSERT(elements_[context_index()].is_memory());
   __ mov(Operand(ebp, fp_relative(context_index())), esi);
 }
 
 
 void VirtualFrame::RestoreContextRegister() {
   ASSERT(elements_[context_index()].is_memory());
   __ mov(esi, Operand(ebp, fp_relative(context_index())));
 }
 
 
 void VirtualFrame::PushReceiverSlotAddress() {
-  Result temp = cgen_->allocator()->Allocate();
+  Result temp = cgen()->allocator()->Allocate();
   ASSERT(temp.is_valid());
   __ lea(temp.reg(), ParameterAt(-1));
   Push(&temp);
 }
 
 
 int VirtualFrame::InvalidateFrameSlotAt(int index) {
   FrameElement original = elements_[index];
 
   // Is this element the backing store of any copies?
@@ skipping 13 matching lines @@
     if (original.is_register()) {
       Unuse(original.reg());
     }
     elements_[index] = FrameElement::InvalidElement();
     return kIllegalIndex;
   }
 
   // This is the backing store of copies.
   Register backing_reg;
   if (original.is_memory()) {
-    Result fresh = cgen_->allocator()->Allocate();
+    Result fresh = cgen()->allocator()->Allocate();
     ASSERT(fresh.is_valid());
     Use(fresh.reg(), new_backing_index);
     backing_reg = fresh.reg();
     __ mov(backing_reg, Operand(ebp, fp_relative(index)));
   } else {
     // The original was in a register.
     backing_reg = original.reg();
     register_locations_[backing_reg.code()] = new_backing_index;
   }
   // Invalidate the element at index.
@@ skipping 24 matching lines @@
   int new_backing_store_index = InvalidateFrameSlotAt(index);
   if (new_backing_store_index != kIllegalIndex) {
     elements_.Add(CopyElementAt(new_backing_store_index));
     return;
   }
 
   switch (original.type()) {
     case FrameElement::MEMORY: {
       // Emit code to load the original element's data into a register.
       // Push that register as a FrameElement on top of the frame.
-      Result fresh = cgen_->allocator()->Allocate();
+      Result fresh = cgen()->allocator()->Allocate();
       ASSERT(fresh.is_valid());
       FrameElement new_element =
           FrameElement::RegisterElement(fresh.reg(),
                                         FrameElement::NOT_SYNCED);
       Use(fresh.reg(), elements_.length());
       elements_.Add(new_element);
       __ mov(fresh.reg(), Operand(ebp, fp_relative(index)));
       break;
     }
     case FrameElement::REGISTER:
@@ skipping 53 matching lines @@
       if (backing_element.is_memory()) {
         // Because sets of copies are canonicalized to be backed by
         // their lowest frame element, and because memory frame
         // elements are backed by the corresponding stack address, we
         // have to move the actual value down in the stack.
         //
         // TODO(209): considering allocating the stored-to slot to the
         // temp register.  Alternatively, allow copies to appear in
         // any order in the frame and lazily move the value down to
         // the slot.
-        Result temp = cgen_->allocator()->Allocate();
+        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 {
         register_locations_[backing_element.reg().code()] = index;
         if (backing_element.is_synced()) {
           // If the element is a register, we will not actually move
           // anything on the stack but only update the virtual frame
           // element.
           backing_element.clear_sync();
@@ skipping 26 matching lines @@
   if (top.is_memory()) {
     // TODO(209): consider allocating the stored-to slot to the temp
     // register.  Alternatively, allow copies to appear in any order
     // in the frame and lazily move the value down to the slot.
     FrameElement new_top = CopyElementAt(index);
     new_top.set_sync();
     elements_[top_index] = new_top;
 
     // The sync state of the former top element is correct (synced).
     // Emit code to move the value down in the frame.
-    Result temp = cgen_->allocator()->Allocate();
+    Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ mov(temp.reg(), Operand(esp, 0));
     __ mov(Operand(ebp, fp_relative(index)), temp.reg());
   } else if (top.is_register()) {
     register_locations_[top.reg().code()] = index;
     // The stored-to slot has the (unsynced) register reference and
     // the top element becomes a copy.  The sync state of the top is
     // preserved.
     FrameElement new_top = CopyElementAt(index);
     if (top.is_synced()) {
       new_top.set_sync();
       elements_[index].clear_sync();
     }
     elements_[top_index] = new_top;
   } else {
     // The stored-to slot holds the same value as the top but
     // unsynced.  (We do not have copies of constants yet.)
     ASSERT(top.is_constant());
     elements_[index].clear_sync();
   }
 }
 
 
 void VirtualFrame::PushTryHandler(HandlerType type) {
-  ASSERT(cgen_->HasValidEntryRegisters());
+  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);
 }
 
 
 Result VirtualFrame::RawCallStub(CodeStub* stub) {
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ CallStub(stub);
-  Result result = cgen_->allocator()->Allocate(eax);
+  Result result = cgen()->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub, Result* arg) {
   PrepareForCall(0, 0);
   arg->ToRegister(eax);
   arg->Unuse();
   return RawCallStub(stub);
@@ skipping 20 matching lines @@
   }
 
   arg0->Unuse();
   arg1->Unuse();
   return RawCallStub(stub);
 }
 
 
 Result VirtualFrame::CallRuntime(Runtime::Function* f, int arg_count) {
   PrepareForCall(arg_count, arg_count);
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ CallRuntime(f, arg_count);
-  Result result = cgen_->allocator()->Allocate(eax);
+  Result result = cgen()->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallRuntime(Runtime::FunctionId id, int arg_count) {
   PrepareForCall(arg_count, arg_count);
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ CallRuntime(id, arg_count);
-  Result result = cgen_->allocator()->Allocate(eax);
+  Result result = cgen()->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
                                    InvokeFlag flag,
                                    int arg_count) {
   PrepareForCall(arg_count, arg_count);
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ InvokeBuiltin(id, flag);
-  Result result = cgen_->allocator()->Allocate(eax);
+  Result result = cgen()->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::RawCallCodeObject(Handle<Code> code,
                                        RelocInfo::Mode rmode) {
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ call(code, rmode);
-  Result result = cgen_->allocator()->Allocate(eax);
+  Result result = cgen()->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallLoadIC(RelocInfo::Mode mode) {
   // Name and receiver are on the top of the frame.  The IC expects
   // name in ecx and receiver on the stack.  It does not drop the
   // receiver.
   Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
@@ skipping 59 matching lines @@
 }
 
 
 Result VirtualFrame::CallCallIC(RelocInfo::Mode mode,
                                 int arg_count,
                                 int loop_nesting) {
   // Arguments, receiver, and function name are on top of the frame.
   // The IC expects them on the stack.  It does not drop the function
   // name slot (but it does drop the rest).
   Handle<Code> ic = (loop_nesting > 0)
-                    ? cgen_->ComputeCallInitializeInLoop(arg_count)
-                    : cgen_->ComputeCallInitialize(arg_count);
+      ? cgen()->ComputeCallInitializeInLoop(arg_count)
+      : cgen()->ComputeCallInitialize(arg_count);
   // Spill args, receiver, and function.  The call will drop args and
   // receiver.
   PrepareForCall(arg_count + 2, arg_count + 1);
   return RawCallCodeObject(ic, mode);
 }
 
 
 Result VirtualFrame::CallConstructor(int arg_count) {
   // Arguments, receiver, and function are on top of the frame.  The
   // IC expects arg count in eax, function in edi, and the arguments
   // and receiver on the stack.
   Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
   // Duplicate the function before preparing the frame.
   PushElementAt(arg_count + 1);
   Result function = Pop();
   PrepareForCall(arg_count + 1, arg_count + 1);  // Spill args and receiver.
   function.ToRegister(edi);
 
   // Constructors are called with the number of arguments in register
   // eax for now. Another option would be to have separate construct
   // call trampolines per different arguments counts encountered.
-  Result num_args = cgen_->allocator()->Allocate(eax);
+  Result num_args = cgen()->allocator()->Allocate(eax);
   ASSERT(num_args.is_valid());
   __ Set(num_args.reg(), Immediate(arg_count));
 
   function.Unuse();
   num_args.Unuse();
   return RawCallCodeObject(ic, RelocInfo::CONSTRUCT_CALL);
 }
 
 
 void VirtualFrame::Drop(int count) {
@@ skipping 19 matching lines @@
 
 Result VirtualFrame::Pop() {
   FrameElement element = elements_.RemoveLast();
   int index = elements_.length();
   ASSERT(element.is_valid());
 
   bool pop_needed = (stack_pointer_ == index);
   if (pop_needed) {
     stack_pointer_--;
     if (element.is_memory()) {
-      Result temp = cgen_->allocator()->Allocate();
+      Result temp = cgen()->allocator()->Allocate();
       ASSERT(temp.is_valid());
       temp.set_static_type(element.static_type());
       __ pop(temp.reg());
       return temp;
     }
 
     __ add(Operand(esp), Immediate(kPointerSize));
   }
   ASSERT(!element.is_memory());
 
   // The top element is a register, constant, or a copy.  Unuse
   // registers and follow copies to their backing store.
   if (element.is_register()) {
     Unuse(element.reg());
   } else if (element.is_copy()) {
     ASSERT(element.index() < index);
     index = element.index();
     element = elements_[index];
   }
   ASSERT(!element.is_copy());
 
   // The element is memory, a register, or a constant.
   if (element.is_memory()) {
     // Memory elements could only be the backing store of a copy.
     // Allocate the original to a register.
     ASSERT(index <= stack_pointer_);
-    Result temp = cgen_->allocator()->Allocate();
+    Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     Use(temp.reg(), index);
     FrameElement new_element =
         FrameElement::RegisterElement(temp.reg(), FrameElement::SYNCED);
     // Preserve the copy flag on the element.
     if (element.is_copied()) new_element.set_copied();
     new_element.set_static_type(element.static_type());
     elements_[index] = new_element;
     __ mov(temp.reg(), Operand(ebp, fp_relative(index)));
     return Result(temp.reg(), element.static_type());
@@ skipping 42 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal