Reimplement stack manipulations for LiveEdit

src/scopeinfo.h

 // Copyright 2006-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 28 matching lines @@
 // and the allocation of the scope's variables. Scope information
 // is stored in a compressed form with Code objects and is used
 // at runtime (stack dumps, deoptimization, etc.).
 //
 // Historical note: In other VMs built by this team, ScopeInfo was
 // usually called DebugInfo since the information was used (among
 // other things) for on-demand debugging (Self, Smalltalk). However,
 // DebugInfo seems misleading, since this information is primarily used
 // in debugging-unrelated contexts.
 
+// Define state of the function execution. It reflects whether locals are
+// available or not.
+enum FunctionScopeState {
+  // Function is in a normal state.
+  FUNCTION_SCOPE_NORMAL,
+
+  // LiveEdit stack manipulation has reset the function execution:
+  // all below frame pointer (arguments, 'this' and outer context) is
+  // available, but locals are not.
+  FUNCTION_SCOPE_NOT_ENTERED
+};
+
 // Forward defined as
 // template <class Allocator = FreeStoreAllocationPolicy> class ScopeInfo;
 template<class Allocator>
 class ScopeInfo BASE_EMBEDDED {
  public:
   // Create a ScopeInfo instance from a scope.
   explicit ScopeInfo(Scope* scope);
 
   // Create a ScopeInfo instance from a Code object.
-  explicit ScopeInfo(Code* code);
+  explicit ScopeInfo(Code* code, FunctionScopeState scope_state);
 
   // Write the ScopeInfo data into a Code object, and returns the
   // amount of space that was needed. If no Code object is provided
   // (NULL handle), Serialize() only returns the amount of space needed.
   //
   // This operations requires that the Code object has the correct amount
   // of space for the ScopeInfo data; otherwise the operation fails (fatal
   // error). Any existing scope info in the Code object is simply overwritten.
   int Serialize(Code* code);
 
@@ skipping 86 matching lines @@
   List<Variable::Mode, Allocator > context_modes_;
 };
 
 class ZoneScopeInfo: public ScopeInfo<ZoneListAllocationPolicy> {
  public:
   // Create a ZoneScopeInfo instance from a scope.
   explicit ZoneScopeInfo(Scope* scope)
       : ScopeInfo<ZoneListAllocationPolicy>(scope) {}
 
   // Create a ZoneScopeInfo instance from a Code object.
-  explicit ZoneScopeInfo(Code* code)
-      :  ScopeInfo<ZoneListAllocationPolicy>(code) {}
+  explicit ZoneScopeInfo(Code* code, FunctionScopeState scope_state)
+      :  ScopeInfo<ZoneListAllocationPolicy>(code, scope_state) {}
 };
 
 
 // Cache for mapping (code, property name) into context slot index.
 // The cache contains both positive and negative results.
 // Slot index equals -1 means the property is absent.
 // Cleared at startup and prior to mark sweep collection.
 class ContextSlotCache {
  public:
   // Lookup context slot index for (code, name).
@@ skipping 54 matching lines @@
   };
 
   static Key keys_[kLength];
   static uint32_t values_[kLength];
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPEINFO_H_