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

src/arm/virtual-frame-arm.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 18 matching lines @@
 
 #include "codegen-inl.h"
 #include "register-allocator-inl.h"
 #include "scopes.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
-#define __ ACCESS_MASM(masm_)
+#define __ ACCESS_MASM(masm())
 
 
 // On entry to a function, the virtual frame already contains the
 // receiver and the parameters.  All initial 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_),  // 0-based index of TOS.
-      frame_pointer_(kIllegalIndex) {
-  for (int i = 0; i < parameter_count_ + 1; i++) {
+VirtualFrame::VirtualFrame()
+    : elements_(parameter_count() + local_count() + kPreallocatedElements),
+      stack_pointer_(parameter_count()) {  // 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) {
   UNREACHABLE();
 }
 
 
 void VirtualFrame::SyncElementByPushing(int index) {
   UNREACHABLE();
 }
 
 
 void VirtualFrame::SyncRange(int begin, int end) {
   // All elements are in memory on ARM (ie, synced).
 #ifdef DEBUG
   for (int i = begin; i <= end; i++) {
     ASSERT(elements_[i].is_synced());
   }
 #endif
 }
 
 
 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(sp, sp, Operand(difference * kPointerSize));
   }
 
   MergeMoveRegistersToMemory(expected);
@@ skipping 46 matching lines @@
 
 void VirtualFrame::MergeMoveRegistersToRegisters(VirtualFrame* expected) {
 }
 
 
 void VirtualFrame::MergeMoveMemoryToRegisters(VirtualFrame* expected) {
 }
 
 
 void VirtualFrame::Enter() {
-  Comment cmnt(masm_, "[ Enter JS frame");
+  Comment cmnt(masm(), "[ Enter JS frame");
 
 #ifdef DEBUG
   // Verify that r1 contains a JS function.  The following code relies
   // on r2 being available for use.
   { Label map_check, done;
     __ tst(r1, Operand(kSmiTagMask));
     __ b(ne, &map_check);
     __ stop("VirtualFrame::Enter - r1 is not a function (smi check).");
     __ bind(&map_check);
     __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
     __ ldrb(r2, FieldMemOperand(r2, Map::kInstanceTypeOffset));
     __ cmp(r2, Operand(JS_FUNCTION_TYPE));
     __ b(eq, &done);
     __ stop("VirtualFrame::Enter - r1 is not a function (map check).");
     __ bind(&done);
   }
 #endif  // DEBUG
 
   // We are about to push four values to the frame.
   Adjust(4);
   __ stm(db_w, sp, r1.bit() | cp.bit() | fp.bit() | lr.bit());
   // Adjust FP to point to saved FP.
-  frame_pointer_ = elements_.length() - 2;
   __ add(fp, sp, Operand(2 * kPointerSize));
-  cgen_->allocator()->Unuse(r1);
-  cgen_->allocator()->Unuse(lr);
+  cgen()->allocator()->Unuse(r1);
+  cgen()->allocator()->Unuse(lr);
 }
 
 
 void VirtualFrame::Exit() {
-  Comment cmnt(masm_, "[ Exit JS frame");
+  Comment cmnt(masm(), "[ Exit JS frame");
   // Drop the execution stack down to the frame pointer and restore the caller
   // frame pointer and return address.
   __ mov(sp, fp);
   __ ldm(ia_w, sp, fp.bit() | lr.bit());
 }
 
 
-void VirtualFrame::AllocateStackSlots(int count) {
+void VirtualFrame::AllocateStackSlots() {
   ASSERT(height() == 0);
-  local_count_ = count;
-  Adjust(count);
+  int count = local_count();
   if (count > 0) {
-    Comment cmnt(masm_, "[ Allocate space for locals");
+    Comment cmnt(masm(), "[ Allocate space for locals");
+    Adjust(count);
       // Initialize stack slots with 'undefined' value.
     __ mov(ip, Operand(Factory::undefined_value()));
     for (int i = 0; i < count; i++) {
       __ push(ip);
     }
   }
 }
 
 
 void VirtualFrame::SaveContextRegister() {
@@ skipping 29 matching lines @@
 
 void VirtualFrame::PushTryHandler(HandlerType type) {
   // Grow the expression stack by handler size less one (the return address
   // is already pushed by a call instruction).
   Adjust(kHandlerSize - 1);
   __ PushTryHandler(IN_JAVASCRIPT, type);
 }
 
 
 Result VirtualFrame::RawCallStub(CodeStub* stub) {
-  ASSERT(cgen_->HasValidEntryRegisters());
+  ASSERT(cgen()->HasValidEntryRegisters());
   __ CallStub(stub);
-  Result result = cgen_->allocator()->Allocate(r0);
+  Result result = cgen()->allocator()->Allocate(r0);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub, Result* arg) {
   PrepareForCall(0, 0);
   arg->Unuse();
   return RawCallStub(stub);
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub, Result* arg0, Result* arg1) {
   PrepareForCall(0, 0);
   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(r0);
+  Result result = cgen()->allocator()->Allocate(r0);
   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(r0);
+  Result result = cgen()->allocator()->Allocate(r0);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
                                    InvokeJSFlags flags,
                                    Result* arg_count_register,
                                    int arg_count) {
   ASSERT(arg_count_register->reg().is(r0));
   PrepareForCall(arg_count, arg_count);
   arg_count_register->Unuse();
   __ InvokeBuiltin(id, flags);
-  Result result = cgen_->allocator()->Allocate(r0);
+  Result result = cgen()->allocator()->Allocate(r0);
   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(r0);
+  Result result = cgen()->allocator()->Allocate(r0);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallCodeObject(Handle<Code> code,
                                     RelocInfo::Mode rmode,
                                     int dropped_args) {
   int spilled_args = 0;
   switch (code->kind()) {
@@ skipping 118 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(reg);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal