First step toward allowing constants to appear in the virtual frame...

src/virtual-frame-ia32.h

 // 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 21 matching lines @@
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // Virtual frame elements
 //
 // The internal elements of the virtual frames.  Elements are (currently) of
 // only one kind, in-memory.  Their actual location is given by their
 // position in the virtual frame.
 
-class Element BASE_EMBEDDED {
+class FrameElement BASE_EMBEDDED {
  public:
-  Element() {}
+  enum Type { MEMORY = 0, CONSTANT = 2};
 
-  bool matches(const Element& other) { return true; }
+  FrameElement() : type_(MEMORY) {}
+
+  explicit FrameElement(Handle<Object> value) : type_(CONSTANT | 0x1) {
+    data_.handle_ = value.location();
+  }
+
+  Type type() const { return static_cast<Type>(type_ & ~0x1); }

[William Hesse, 2008/11/18 16:37:34]

Name the dirty flag mask.  Unless you are also storing SMIs in this word, I
would use a higher bit for the flag, and store the types in the low bits, rather
than using only even type IDs.

[Kevin Millikin (Chromium), 2008/11/18 19:12:06]

OK.

+
+  bool is_dirty() const { return type_ & 0x1; }
+
+  void set_dirty() {
+    ASSERT(type_ != MEMORY);
+    type_ = type_ | 0x1;
+  }
+
+  void clear_dirty() {
+    ASSERT(type_ != MEMORY);
+    type_ = type_ & 0x1;
+  }
+
+  Handle<Object> handle() const { return Handle<Object>(data_.handle_); }

[William Hesse, 2008/11/18 16:37:34]

Put asserts here to assert it is a type that has handle data?

[Kevin Millikin (Chromium), 2008/11/18 19:12:06]

OK.

+
+ private:
+  // The element's type and a dirty bit in the low-order bit.  The dirty bit
+  // can be cleared for non-memory elements to indicate that the element
+  // agrees with the value in memory in the actual frame.
+  int type_;
+
+  union {
+    Object** handle_;
+  } data_;

[William Hesse, 2008/11/18 16:37:34]

ASSERT( sizeof data_  == sizeof what? )

 };
 
 
 // -------------------------------------------------------------------------
 // Virtual frames
 //
 // The virtual frame is an abstraction of the physical stack frame.  It
 // encapsulates the parameters, frame-allocated locals, and the expression
 // stack.  It supports push/pop operations on the expression stack, as well
 // as random access to the expression stack elements, locals, and
 // parameters.
 
 class VirtualFrame : public Malloced {
  public:
-  // Construct a virtual frame with the given code generator used to
-  // generate code.
+  // Construct an initial virtual frame on entry to a JS function.
   explicit VirtualFrame(CodeGenerator* cgen);
 
-  // Construct a virtual frame that is a clone of an existing one, initially
-  // with an identical state.
+  // Construct a virtual frame as a clone of an existing one.
   explicit VirtualFrame(VirtualFrame* original);
 
   // The height of the virtual expression stack.
   int height() const {
     return elements_.length() - expression_base_index();
   }
 
-  // Add extra in-memory elements to the top of the frame without generating
-  // code.
+  // Add extra in-memory elements to the top of the frame to match an actual
+  // frame (eg, the frame after an exception handler is pushed).  No code is
+  // emitted.
   void Adjust(int count);
 
-  // Forget frame elements without generating code.
+  // Forget elements from the top of the frame to match an actual frame (eg,
+  // the frame after a runtime call).  No code is emitted.
   void Forget(int count);
 
+  // Spill all values from the frame to memory.
+  void SpillAll();
+
+  // Ensure that this frame is in a state where an arbitrary frame of the
+  // right size could be merged to it.  May emit code.
+  void EnsureMergable();
+
   // Make this virtual frame have a state identical to an expected virtual
   // frame.  As a side effect, code may be emitted to make this frame match
   // the expected one.
   void MergeTo(VirtualFrame* expected);
 
   // Emit code for the physical JS entry and exit frame sequences.  After
   // calling Enter, the virtual frame is ready for use; and after calling
   // Exit it should not be used.  Note that Enter does not allocate space in
   // the physical frame for storing frame-allocated locals.
   void Enter();
@@ skipping 60 matching lines @@
                       int frame_arg_count);
 
   // Drop a number of elements from the top of the expression stack.  May
   // emit code to affect the physical frame.  Does not clobber any registers
   // excepting possibly the stack pointer.
   void Drop(int count);
 
   // Drop one element.
   void Drop();
 
-  // Pop and save an element from the top of the expression stack.  May emit
-  // code.
-  void Pop(Register reg);
-  void Pop(Operand operand);
+  // Pop and save an element from the top of the expression stack and emit a
+  // corresponding pop instruction.
+  void EmitPop(Register reg);
+  void EmitPop(Operand operand);
 
   // Push an element on top of the expression stack and emit a corresponding
   // push instruction.
   void EmitPush(Register reg);
   void EmitPush(Operand operand);
   void EmitPush(Immediate immediate);
 
  private:
+  // An illegal index into the virtual frame.
+  static const int kIllegalIndex = -1;
+
   static const int kLocal0Offset = JavaScriptFrameConstants::kLocal0Offset;
   static const int kFunctionOffset = JavaScriptFrameConstants::kFunctionOffset;
   static const int kContextOffset = StandardFrameConstants::kContextOffset;
 
   static const int kHandlerSize = StackHandlerConstants::kSize / kPointerSize;
 
   MacroAssembler* masm_;
 
-  List<Element> elements_;
+  List<FrameElement> elements_;
 
   int parameter_count_;
   int local_count_;
 
+  // The index of the element that is at the processor's stack pointer
+  // (the esp register).
+  int stack_pointer_;
+
+  // The index of the element that is at the processor's frame pointer
+  // (the ebp register).
   int frame_pointer_;
 
   // The index of the first parameter.  The receiver lies below the first
   // parameter.
   int param0_index() const { return 1; }
 
   // The index of the first local.  Between the parameters and the locals
   // lie the return address, the saved frame pointer, the context, and the
   // function.
   int local0_index() const { return param0_index() + parameter_count_ + 4; }
 
   // The index of the base of the expression stack.
   int expression_base_index() const { return local0_index() + local_count_; }
+
+  // Convert a frame index into a frame pointer relative offset into the
+  // actual stack.
+  int fp_relative(int index) const {
+    return (frame_pointer_ - index) * kPointerSize;
+  }
+
+  // Spill the topmost elements of the frame to memory (eg, they are the
+  // arguments to a call) and all registers.
+  void PrepareCall(int count);

[William Hesse, 2008/11/18 16:37:34]

PrepareForCall?

[Kevin Millikin (Chromium), 2008/11/18 19:12:06]

OK.

 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_