Reimplement stack manipulations for LiveEdit

src/frames.cc

 // 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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "frames-inl.h"
 #include "mark-compact.h"
 #include "scopeinfo.h"
 #include "string-stream.h"
 #include "top.h"
+#include "liveedit.h"
 
 namespace v8 {
 namespace internal {
 
 // Iterator that supports traversing the stack handlers of a
 // particular frame. Needs to know the top of the handler chain.
 class StackHandlerIterator BASE_EMBEDDED {
  public:
   StackHandlerIterator(const StackFrame* frame, StackHandler* handler)
       : limit_(frame->fp()), handler_(handler) {
@@ skipping 506 matching lines @@
         int line = GetScriptLineNumberSafe(script, function_start_pos) + 1;
         accumulator->Add(":~%d", line);
       }
 
       accumulator->Add("] ");
     }
   }
 
   accumulator->Add("(this=%o", receiver);
 
+  FunctionScopeState scope_state;
+  if (LiveEdit::IsAtFrameResetPatch(this)) {
+    scope_state = FUNCTION_SCOPE_NOT_ENTERED;
+    accumulator->Add(",<no locals -- function is at restarter patch>");
+  } else {
+    scope_state = FUNCTION_SCOPE_NORMAL;
+  }
+
   // Get scope information for nicer output, if possible. If code is
   // NULL, or doesn't contain scope info, info will return 0 for the
   // number of parameters, stack slots, or context slots.
-  ScopeInfo<PreallocatedStorage> info(code);
+  ScopeInfo<PreallocatedStorage> info(code, scope_state);
 
   // Print the parameters.
   int parameters_count = ComputeParametersCount();
   for (int i = 0; i < parameters_count; i++) {
     accumulator->Add(",");
     // If we have a name for the parameter we print it. Nameless
     // parameters are either because we have more actual parameters
     // than formal parameters or because we have no scope information.
     if (i < info.number_of_parameters()) {
       accumulator->PrintName(*info.parameter_name(i));
@@ skipping 138 matching lines @@
     const Address address = handler->address();
     v->VisitPointers(base, reinterpret_cast<Object**>(address));
     base = reinterpret_cast<Object**>(address + StackHandlerConstants::kSize);
     // Traverse the pointers in the handler itself.
     handler->Iterate(v);
   }
   v->VisitPointers(base, limit);
 }
 
 
+void StandardFrame::SetContext(Context* context) {
+  const int offset = StandardFrameConstants::kContextOffset;
+  Memory::Object_at(fp() + offset) = context;
+}
+
+
 void JavaScriptFrame::Iterate(ObjectVisitor* v) const {
   IterateExpressions(v);
 
   // Traverse callee-saved registers, receiver, and parameters.
   const int kBaseOffset = JavaScriptFrameConstants::kSavedRegistersOffset;
   const int kLimitOffset = JavaScriptFrameConstants::kReceiverOffset;
   Object** base = &Memory::Object_at(fp() + kBaseOffset);
   Object** limit = &Memory::Object_at(caller_sp() + kLimitOffset) + 1;
   v->VisitPointers(base, limit);
 }
@@ skipping 79 matching lines @@
 
 Vector<StackFrame*> CreateStackMap() {
   ZoneList<StackFrame*> list(10);
   for (StackFrameIterator it; !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame());
     list.Add(frame);
   }
   return list.ToVector();
 }
 
+int GetStackFrameObjectSize(StackFrame* frame) {
+#define FRAME_TYPE_CASE(type, field) \
+  case StackFrame::type: return sizeof(field);
+
+  switch (frame->type()) {
+    STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
+    default: UNREACHABLE();
+  }
+#undef FRAME_TYPE_CASE
+  return 0;
+}
+
 
 } }  // namespace v8::internal