Reimplement stack manipulations for LiveEdit

src/runtime.cc

 // Copyright 2006-2009 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 8472 matching lines @@
   Handle<Object> frame_id(WrapFrameId(it.frame()->id()));
 
   // Find source position.
   int position = it.frame()->code()->SourcePosition(it.frame()->pc());
 
   // Check for constructor frame.
   bool constructor = it.frame()->IsConstructor();
 
   // Get code and read scope info from it for local variable information.
   Handle<Code> code(it.frame()->code());
-  ScopeInfo<> info(*code);
+  FunctionScopeState scope_state = LiveEdit::IsAtFrameResetPatch(it.frame())
+      ? FUNCTION_SCOPE_NOT_ENTERED : FUNCTION_SCOPE_NORMAL;
+  ScopeInfo<> info(*code, scope_state);
 
   // Get the context.
   Handle<Context> context(Context::cast(it.frame()->context()));
 
   // Get the locals names and values into a temporary array.
   //
   // TODO(1240907): Hide compiler-introduced stack variables
   // (e.g. .result)?  For users of the debugger, they will probably be
   // confusing.
   Handle<FixedArray> locals = Factory::NewFixedArray(info.NumberOfLocals() * 2);
@@ skipping 176 matching lines @@
     }
   }
 }
 
 
 // Create a plain JSObject which materializes the local scope for the specified
 // frame.
 static Handle<JSObject> MaterializeLocalScope(JavaScriptFrame* frame) {
   Handle<JSFunction> function(JSFunction::cast(frame->function()));
   Handle<Code> code(function->code());
-  ScopeInfo<> scope_info(*code);
+
+  FunctionScopeState scope_state = LiveEdit::IsAtFrameResetPatch(frame)
+      ? FUNCTION_SCOPE_NOT_ENTERED : FUNCTION_SCOPE_NORMAL;
+  ScopeInfo<> scope_info(*code, scope_state);
 
   // Allocate and initialize a JSObject with all the arguments, stack locals
   // heap locals and extension properties of the debugged function.
   Handle<JSObject> local_scope = Factory::NewJSObject(Top::object_function());
 
   // First fill all parameters.
   for (int i = 0; i < scope_info.number_of_parameters(); ++i) {
     SetProperty(local_scope,
                 scope_info.parameter_name(i),
                 Handle<Object>(frame->GetParameter(i)), NONE);
@@ skipping 30 matching lines @@
   return local_scope;
 }
 
 
 // Create a plain JSObject which materializes the closure content for the
 // context.
 static Handle<JSObject> MaterializeClosure(Handle<Context> context) {
   ASSERT(context->is_function_context());
 
   Handle<Code> code(context->closure()->code());
-  ScopeInfo<> scope_info(*code);
+  ScopeInfo<> scope_info(*code, FUNCTION_SCOPE_NORMAL);
 
   // Allocate and initialize a JSObject with all the content of theis function
   // closure.
   Handle<JSObject> closure_scope = Factory::NewJSObject(Top::object_function());
 
   // Check whether the arguments shadow object exists.
   int arguments_shadow_index =
       ScopeInfo<>::ContextSlotIndex(*code,
                                     Heap::arguments_shadow_symbol(),
                                     NULL);
@@ skipping 168 matching lines @@
   void DebugPrint() {
     switch (Type()) {
       case ScopeIterator::ScopeTypeGlobal:
         PrintF("Global:\n");
         CurrentContext()->Print();
         break;
 
       case ScopeIterator::ScopeTypeLocal: {
         PrintF("Local:\n");
         Handle<Code> code(function_->code());
-        ScopeInfo<> scope_info(*code);
+        ScopeInfo<> scope_info(*code, FUNCTION_SCOPE_NORMAL);
         scope_info.Print();
         if (!CurrentContext().is_null()) {
           CurrentContext()->Print();
           if (CurrentContext()->has_extension()) {
             Handle<JSObject> extension =
                 Handle<JSObject>(CurrentContext()->extension());
             if (extension->IsJSContextExtensionObject()) {
               extension->Print();
             }
           }
@@ skipping 571 matching lines @@
 
   // Handle the processing of break.
   DisableBreak disable_break_save(disable_break);
 
   // Get the frame where the debugging is performed.
   StackFrame::Id id = UnwrapFrameId(wrapped_id);
   JavaScriptFrameIterator it(id);
   JavaScriptFrame* frame = it.frame();
   Handle<JSFunction> function(JSFunction::cast(frame->function()));
   Handle<Code> code(function->code());
-  ScopeInfo<> sinfo(*code);
+  FunctionScopeState scope_state = LiveEdit::IsAtFrameResetPatch(frame)
+      ? FUNCTION_SCOPE_NOT_ENTERED : FUNCTION_SCOPE_NORMAL;
+  ScopeInfo<> sinfo(*code, scope_state);
 
   // Traverse the saved contexts chain to find the active context for the
   // selected frame.
   SaveContext* save = Top::save_context();
   while (save != NULL && !save->below(frame)) {
     save = save->prev();
   }
   ASSERT(save != NULL);
   SaveContext savex;
   Top::set_context(*(save->context()));
 
   // Create the (empty) function replacing the function on the stack frame for
   // the purpose of evaluating in the context created below. It is important
   // that this function does not describe any parameters and local variables
   // in the context. If it does then this will cause problems with the lookup
   // in Context::Lookup, where context slots for parameters and local variables
   // are looked at before the extension object.
   Handle<JSFunction> go_between =
       Factory::NewFunction(Factory::empty_string(), Factory::undefined_value());
   go_between->set_context(function->context());
 #ifdef DEBUG
-  ScopeInfo<> go_between_sinfo(go_between->shared()->code());
+  ScopeInfo<> go_between_sinfo(go_between->shared()->code(),
+                               FUNCTION_SCOPE_NORMAL);
   ASSERT(go_between_sinfo.number_of_parameters() == 0);
   ASSERT(go_between_sinfo.number_of_context_slots() == 0);
 #endif
 
   // Materialize the content of the local scope into a JSObject.
   Handle<JSObject> local_scope = MaterializeLocalScope(frame);
 
   // Allocate a new context for the debug evaluation and set the extension
   // object build.
   Handle<Context> context =
@@ skipping 469 matching lines @@
   if (old_script->IsScript()) {
     Handle<Script> script_handle(Script::cast(old_script));
     return *(GetScriptWrapper(script_handle));
   } else {
     return Heap::null_value();
   }
 }
 
 // Replaces code of SharedFunctionInfo with a new one.
 static Object* Runtime_LiveEditReplaceFunctionCode(Arguments args) {
-  ASSERT(args.length() == 2);
+  ASSERT(args.length() == 3);
   HandleScope scope;
   CONVERT_ARG_CHECKED(JSArray, new_compile_info, 0);
   CONVERT_ARG_CHECKED(JSArray, shared_info, 1);
+  ByteArray* stack_drop_data;
+  if (args[2]->IsUndefined()) {
+    stack_drop_data = NULL;
+  } else {
+    CONVERT_CHECKED(JSValue, stack_drop_data_wrapped, args[2]);
+    CONVERT_CHECKED(ByteArray, stack_drop_data_temp,
+                    stack_drop_data_wrapped->value());
+    stack_drop_data = stack_drop_data_temp;
+  }
+  Handle<ByteArray> stack_drop_data_handle;
+  if (stack_drop_data != NULL) {
+    stack_drop_data_handle = Handle<ByteArray>(stack_drop_data);
+  }
 
-  return LiveEdit::ReplaceFunctionCode(new_compile_info, shared_info);
+  return LiveEdit::ReplaceFunctionCode(new_compile_info, shared_info,
+                                       stack_drop_data_handle);
 }
 
 // Connects SharedFunctionInfo to another script.
 static Object* Runtime_LiveEditFunctionSetScript(Arguments args) {
   ASSERT(args.length() == 2);
   HandleScope scope;
   Handle<Object> function_object(args[0]);
   Handle<Object> script_object(args[1]);
 
   if (function_object->IsJSValue()) {
@@ skipping 42 matching lines @@
   CONVERT_ARG_CHECKED(JSArray, position_change_array, 1);
 
   return LiveEdit::PatchFunctionPositions(shared_array, position_change_array);
 }
 
 
 // For array of SharedFunctionInfo's (each wrapped in JSValue)
 // checks that none of them have activations on stacks (of any thread).
 // Returns array of the same length with corresponding results of
 // LiveEdit::FunctionPatchabilityStatus type.
-static Object* Runtime_LiveEditCheckAndDropActivations(Arguments args) {
-  ASSERT(args.length() == 2);
+static Object* Runtime_LiveEditCheckActivations(Arguments args) {
+  ASSERT(args.length() == 1);
   HandleScope scope;
   CONVERT_ARG_CHECKED(JSArray, shared_array, 0);
-  CONVERT_BOOLEAN_CHECKED(do_drop, args[1]);
 
-  return *LiveEdit::CheckAndDropActivations(shared_array, do_drop);
+  return *LiveEdit::CheckActivations(shared_array);
 }
 
 // Compares 2 strings line-by-line and returns diff in form of JSArray of
 // triplets (pos1, pos1_end, pos2_end) describing list of diff chunks.
 static Object* Runtime_LiveEditCompareStringsLinewise(Arguments args) {
   ASSERT(args.length() == 2);
   HandleScope scope;
   CONVERT_ARG_CHECKED(String, s1, 0);
   CONVERT_ARG_CHECKED(String, s2, 1);
 
@@ skipping 425 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal