Simplify virtual frame by removing the virtual stack pointer, which...

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 23 matching lines @@
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 #define __ masm_->
 
 VirtualFrame::VirtualFrame(CodeGenerator* cgen)
     : masm_(cgen->masm()),
       elements_(0),
-      virtual_stack_pointer_(-1),
-      virtual_frame_pointer_(-1),
       parameter_count_(cgen->scope()->num_parameters()),
-      local_count_(0) {
+      local_count_(0),
+      frame_pointer_(-1) {

[iposva, 2008/11/17 17:11:53]

Ideally you could define an illegal index and use that wherever the VirtualFrame
has not yet been setup and in other similar situations.

   // The virtual frame contains a receiver and the parameters (all in
   // memory) when it is created.
   Adjust(parameter_count_ + 1);
 }
 
 
 VirtualFrame::VirtualFrame(VirtualFrame* original)
     : masm_(original->masm_),
       elements_(original->elements_.length()),
-      virtual_stack_pointer_(original->virtual_stack_pointer_),
-      virtual_frame_pointer_(original->virtual_frame_pointer_),
       parameter_count_(original->parameter_count_),
-      local_count_(original->local_count_) {
+      local_count_(original->local_count_),
+      frame_pointer_(original->frame_pointer_) {
   // Copy all the elements.
-  for (int i = 0; i <= virtual_stack_pointer_; i++) {
+  for (int i = 0; i < original->elements_.length(); i++) {
     elements_.Add(original->elements_[i]);
   }
 }
 
 
 void VirtualFrame::Adjust(int count) {
   ASSERT(count >= 0);
   for (int i = 0; i < count; i++) {
-    AddElement(Element());
+    elements_.Add(Element());
   }
 }
 
 
 void VirtualFrame::Forget(int count) {
   ASSERT(count >= 0);
-  ASSERT(virtual_stack_pointer_ >= count);
+  ASSERT(elements_.length() >= count);
   for (int i = 0; i < count; i++) {
-    RemoveElement();
+    elements_.RemoveLast();
   }
 }
 
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
   ASSERT(masm_ == expected->masm_);
   ASSERT(elements_.length() == expected->elements_.length());
-  ASSERT(virtual_frame_pointer_ == expected->virtual_frame_pointer_);
-  ASSERT(virtual_stack_pointer_ == expected->virtual_stack_pointer_);
   ASSERT(parameter_count_ == expected->parameter_count_);
   ASSERT(local_count_ == expected->local_count_);
-  for (int i = 0; i <= virtual_stack_pointer_; i++) {
+  ASSERT(frame_pointer_ == expected->frame_pointer_);
+  for (int i = 0; i < elements_.length(); i++) {
     ASSERT(elements_[i].matches(expected->elements_[i]));
   }
 }
 
 
 void VirtualFrame::Enter() {
   Comment cmnt(masm_, "[ Enter JS frame");
 #ifdef DEBUG
   { Label done, fail;
     __ tst(r1, Operand(kSmiTagMask));
     __ b(eq, &fail);
     __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
     __ ldrb(r2, FieldMemOperand(r2, Map::kInstanceTypeOffset));
     __ cmp(r2, Operand(JS_FUNCTION_TYPE));
     __ b(eq, &done);
     __ bind(&fail);
     __ stop("CodeGenerator::EnterJSFrame - r1 not a function");
     __ bind(&done);
   }
 #endif  // DEBUG
 
   Adjust(4);

[iposva, 2008/11/17 17:11:53]

Can you please document the magic numbers in this file? I assume 4 is the size
of the arm native stack frame. A simple comment referring to the line below
would do.

   __ stm(db_w, sp, r1.bit() | cp.bit() | fp.bit() | lr.bit());
   // Adjust FP to point to saved FP.
-  virtual_frame_pointer_ = virtual_stack_pointer_ - 1;
+  frame_pointer_ = elements_.length() - 2;
   __ add(fp, sp, Operand(2 * kPointerSize));
 }
 
 
 void VirtualFrame::Exit() {
   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());
@@ skipping 82 matching lines @@
 
 void VirtualFrame::Push(Register reg) {
   Adjust(1);
   __ push(reg);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal