Experimental: allow the virtual frame to explicitly indicate sharing...

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 89 matching lines @@
 
   void clear_sync() {
     ASSERT(type() != MEMORY);
     type_ = (type_ & ~SyncField::mask()) | SyncField::encode(NOT_SYNCED);
   }
 
   bool is_valid() const { return type() != INVALID; }
   bool is_memory() const { return type() == MEMORY; }
   bool is_register() const { return type() == REGISTER; }
   bool is_constant() const { return type() == CONSTANT; }
+  bool is_copy() const { return type() == COPY; }
 
   Register reg() const {
-    ASSERT(type() == REGISTER);
+    ASSERT(is_register());
     return data_.reg_;
   }
 
   Handle<Object> handle() const {
-    ASSERT(type() == CONSTANT);
+    ASSERT(is_constant());
     return Handle<Object>(data_.handle_);
   }
 
+  int index() const {
+    ASSERT(is_copy());
+    return data_.index_;
+  }
+
  private:
   enum Type {
     INVALID,
     MEMORY,
     REGISTER,
-    CONSTANT
+    CONSTANT,
+    COPY
   };
 
   // BitField is <type, shift, size>.
   class SyncField : public BitField<SyncFlag, 0, 1> {};
   class TypeField : public BitField<Type, 1, 32 - 1> {};
 
   Type type() const { return TypeField::decode(type_); }
 
   // The element's type and a dirty 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 {
     Register reg_;
     Object** handle_;
+    int index_;
   } data_;
+
+  friend class VirtualFrame;
 };
 
 
 // -------------------------------------------------------------------------
 // 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
@@ skipping 16 matching lines @@
     CodeGenerator* cgen_;
     bool previous_state_;
   };
 
   // Construct an initial virtual frame on entry to a JS function.
   explicit VirtualFrame(CodeGenerator* cgen);
 
   // Construct a virtual frame as a clone of an existing one.
   explicit VirtualFrame(VirtualFrame* original);
 
+  // Create a duplicate of an existing valid frame element.
+  FrameElement CopyElementAt(int index);
+
   // The height of the virtual expression stack.
   int height() const {
     return elements_.length() - expression_base_index();
   }
 
   int register_count(Register reg) {
     return frame_registers_.count(reg);
   }
 
   // Add extra in-memory elements to the top of the frame to match an actual
@@ skipping 301 matching lines @@
 
   // Record that a register reference has been dropped from the frame.  This
   // decrements both the register's internal and external reference counts.
   void Unuse(Register reg);
 
   // Spill the element at a particular index---write it to memory if
   // necessary, free any associated register, and forget its value if
   // constant.
   void SpillElementAt(int index);
 
-  // Spill the element at an index without modifying its reference count (if
-  // it was in a register).
-  void RawSpillElementAt(int index);
-
   // Sync the element at a particular index.  If it is a register or
   // constant that disagrees with the value on the stack, write it to memory.
   // Keep the element type as register or constant, and clear the dirty bit.
   void SyncElementAt(int index);
 
   // Sync the range of elements in [begin, end).
   void SyncRange(int begin, int end);
 
   // Sync a single element, assuming that its index is less than
   // or equal to stack pointer + 1.
@@ skipping 30 matching lines @@
   // Used in the implementation of MergeTo().
   void MergeMoveRegistersToRegisters(VirtualFrame* expected);
 
   // Make the memory-to-register and constant-to-register moves
   // needed to make this frame equal the expected frame.
   // Called after all register-to-memory and register-to-register
   // moves have been made.  After this function returns, the frames
   // should be equal.
   void MergeMoveMemoryToRegisters(VirtualFrame* expected);
 
-  // Calls a code object which takes spilled_args frame arguments
-  // and which drops dropped_args of them.
-  Result RawCallCodeObject(Handle<Code> code,
-                           RelocInfo::Mode rmode,
-                           int spilled_args,
-                           int dropped_args);
+  // Helper function to implement the copy-on-write semantics of an
+  // element's copies just before writing to the element.  The copies
+  // are updated, but the element is not changed.  A copy of the new
+  // backing store of all the copies is returned if there were any
+  // copies and in invalid frame element is returned if there were no
+  // copies.
+  FrameElement AdjustCopies(int index);
+
+  // Call a code stub that has already been prepared for calling (via
+  // PrepareForCall).
+  Result RawCallStub(CodeStub* stub, int frame_arg_count);
+
+  // Calls a code object which has already been prepared for calling
+  // (via PrepareForCall).
+  Result RawCallCodeObject(Handle<Code> code, RelocInfo::Mode rmode);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_