Begin using the virtual frame for variable proxies and slots. Loading...

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 247 matching lines @@
     return Operand(esp, index * kPointerSize);
   }
 
   // A frame-allocated local as an assembly operand.
   Operand LocalAt(int index) const {
     ASSERT(0 <= index);
     ASSERT(index < local_count_);
     return Operand(ebp, kLocal0Offset - index * kPointerSize);
   }
 
+  // Push a copy of the value of a local frame slot on top of the frame.
+  void LoadLocalAt(int index) {
+    LoadFrameSlotAt(local0_index() + index);
+  }
+
   // Store the top value on the virtual frame into a local frame slot.  The
   // value is left in place on top of the frame.
   void StoreToLocalAt(int index) {
     StoreToFrameSlotAt(local0_index() + index);
   }
 
   // The function frame slot.
   Operand Function() const { return Operand(ebp, kFunctionOffset); }
 
   // The context frame slot.
   Operand Context() const { return Operand(ebp, kContextOffset); }
 
   // A parameter as an assembly operand.
   Operand ParameterAt(int index) const {
     ASSERT(-1 <= index);  // -1 is the receiver.
     ASSERT(index < parameter_count_);
     return Operand(ebp, (1 + parameter_count_ - index) * kPointerSize);
   }
 
+  // Push a copy of the value of a parameter frame slot on top of the frame.
+  void LoadParameterAt(int index) {
+    LoadFrameSlotAt(param0_index() + index);
+  }
+
   // Store the top value on the virtual frame into a parameter frame slot.
   // The value is left in place on top of the frame.
   void StoreToParameterAt(int index) {
     StoreToFrameSlotAt(param0_index() + index);
   }
 
   // The receiver frame slot.
   Operand Receiver() const { return ParameterAt(-1); }
 
   // Push a try-catch or try-finally handler on top of the virtual frame.
@@ skipping 125 matching lines @@
   void Unuse(Register reg);
 
   // Sync the element at a particular index---write it to memory if
   // necessary, but do not free any associated register or forget its value
   // if constant.  Space should have already been allocated in the actual
   // frame for all the elements below this one (at least).
   void SyncElementAt(int index);
 
   // Spill the element at a particular index---write it to memory if
   // necessary, free any associated register, and forget its value if
-  // constant.  Space should have already been allocated in the actual frame
-  // for all the elements below this one (at least).
+  // 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 range of elements in [begin, end).
   void SyncRange(int begin, int end);
 
+  // Push a copy of a frame slot (typically a local or parameter) on top of
+  // the frame.
+  void LoadFrameSlotAt(int index);
+
   // Store the value on top of the frame to a frame slot (typically a local
   // or parameter).
   void StoreToFrameSlotAt(int index);
 
   // Spill the topmost elements of the frame to memory (eg, they are the
   // arguments to a call) and all registers.
   void PrepareForCall(int count);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_