Added mutation of locals to debugger

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 6144 matching lines @@
         ASSERT(keys->get(i)->IsString());
         Handle<String> key(String::cast(keys->get(i)));
         SetProperty(local_scope, key, GetProperty(ext, key), NONE);
       }
     }
   }
   return local_scope;
 }
 
 
+// Write back the to the local scope from a materialized local scope.
+static void DematerializeLocalScope(JavaScriptFrame* frame,
+                                    Handle<JSObject> local_scope,
+                                    Handle<JSObject> arguments) {
+  Handle<JSFunction> function(JSFunction::cast(frame->function()));
+  Handle<Code> code(function->code());
+  ScopeInfo<> scope_info(*code);
+  Handle<Context> frame_context(Context::cast(frame->context()));
+  Handle<Context> function_context(frame_context->fcontext());
+
+  // Locate the arguments shadow (.arguments) variable if it exists either as a
+  // context allocated or stack allocated variable.
+  Handle<JSObject> arguments_shadow;
+
+  // First write back to the function context extension. This will be variables
+  // introduced by eval.
+  if (function_context->has_extension() &&
+      !function_context->IsGlobalContext()) {
+    Handle<JSObject> ext(JSObject::cast(function_context->extension()));
+    Handle<FixedArray> keys = GetKeysInFixedArrayFor(ext);
+    for (int i = 0; i < keys->length(); i++) {
+      // Names of variables introduced by eval are strings.
+      ASSERT(keys->get(i)->IsString());
+      Handle<String> key(String::cast(keys->get(i)));
+      SetProperty(ext, key, GetProperty(local_scope, key), NONE);
+    }
+  }
+
+  // Second  write back all context locals.
+  for (int i = Context::MIN_CONTEXT_SLOTS;
+       i < scope_info.number_of_context_slots();
+       i++) {
+    Handle<String> name = scope_info.context_slot_name(i);
+    // Don't write to the arguments shadow (.arguments).
+    if (*name != Heap::arguments_shadow_symbol()) {
+      function_context->set(i, *GetProperty(local_scope, name));
+    } else {
+      arguments_shadow =
+          Handle<JSObject>(JSObject::cast(function_context->get(i)));
+    }
+  }
+
+  // Third write back all stack locals.
+  for (int i = 0; i < scope_info.number_of_stack_slots(); i++) {
+    Handle<String> name = scope_info.stack_slot_name(i);
+    // Don't write to the arguments shadow (.arguments).
+    if (*name != Heap::arguments_shadow_symbol()) {
+      frame->SetExpression(i, *GetProperty(local_scope, name));
+    } else {
+      arguments_shadow =
+          Handle<JSObject>(JSObject::cast(frame->GetExpression(i)));
+    }
+  }
+
+  // Finally write back all parameters. Parameters are written to the stack and
+  // to the arguments shadow (.arguments) variable if it exists.
+  for (int i = 0; i < scope_info.number_of_parameters(); ++i) {
+    Handle<Object> obj =
+        GetProperty(local_scope, scope_info.parameter_name(i));
+    frame->SetParameter(i, *obj);
+
+    // Write to arguments shadow if it exists.
+    if (!arguments_shadow.is_null()) {
+      SetElement(arguments_shadow, i, obj);
+    }
+  }
+
+  // If the frame has an adaptor frame then the parameters needs to be written
+  // back to this frame as well.
+  if (frame->has_adapted_arguments()) {
+    StackFrameIterator it(false, frame->fp(), frame->sp());
+    ASSERT(it.frame()->is_java_script());
+    it.Advance();
+    ASSERT(!it.done());
+    ASSERT(it.frame()->is_arguments_adaptor());
+    JavaScriptFrame* adaptor_frame =
+        reinterpret_cast<JavaScriptFrame*>(it.frame());
+    for (int i = 0; i < adaptor_frame->GetProvidedParametersCount(); i++) {
+      if (i < scope_info.number_of_parameters()) {
+        Handle<Object> obj =
+            GetProperty(local_scope, scope_info.parameter_name(i));
+        adaptor_frame->SetParameter(i, *obj);
+      } else {
+        adaptor_frame->SetParameter(i, arguments->GetElement(i));
+      }
+    }
+  }
+}
+
+
 // 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);
 
   // Allocate and initialize a JSObject with all the content of theis function
   // closure.
@@ skipping 164 matching lines @@
       case ScopeIterator::ScopeTypeGlobal:
         PrintF("Global:\n");
         CurrentContext()->Print();
         break;
 
       case ScopeIterator::ScopeTypeLocal: {
         PrintF("Local:\n");
         Handle<Code> code(function_->code());
         ScopeInfo<> scope_info(*code);
         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 488 matching lines @@
   Handle<JSObject> extension(JSObject::cast(context_chain->extension()));
   return Factory::NewWithContext(
       CopyWithContextChain(function_context, previous),
       extension,
       context_chain->IsCatchContext());
 }
 
 
 // Helper function to find or create the arguments object for
 // Runtime_DebugEvaluate.
-static Handle<Object> GetArgumentsObject(JavaScriptFrame* frame,
-                                         Handle<JSFunction> function,
-                                         Handle<Code> code,
-                                         const ScopeInfo<>* sinfo,
-                                         Handle<Context> function_context) {
+static Handle<JSObject> GetArgumentsObject(JavaScriptFrame* frame,
+                                           Handle<JSFunction> function,
+                                           Handle<Code> code,
+                                           const ScopeInfo<>* sinfo,
+                                           Handle<Context> function_context) {
   // Try to find the value of 'arguments' to pass as parameter. If it is not
   // found (that is the debugged function does not reference 'arguments' and
   // does not support eval) then create an 'arguments' object.
   int index;
   if (sinfo->number_of_stack_slots() > 0) {
     index = ScopeInfo<>::StackSlotIndex(*code, Heap::arguments_symbol());
     if (index != -1) {
-      return Handle<Object>(frame->GetExpression(index));
+      return Handle<JSObject>(JSObject::cast(frame->GetExpression(index)));
     }
   }
 
   if (sinfo->number_of_context_slots() > Context::MIN_CONTEXT_SLOTS) {
     index = ScopeInfo<>::ContextSlotIndex(*code, Heap::arguments_symbol(),
                                           NULL);
     if (index != -1) {
-      return Handle<Object>(function_context->get(index));
+      return Handle<JSObject>(JSObject::cast(function_context->get(index)));
     }
   }
 
-  const int length = frame->GetProvidedParametersCount();
+  // Locate the actual frame which holds all the passed arguments. Either the
+  // current JavaScript frame or the adaptor frame just below it.
+  JavaScriptFrame* actual_frame = frame;
+  StackFrameIterator it(false, frame->fp(), frame->sp());
+  if (frame->has_adapted_arguments()) {
+    ASSERT(it.frame()->is_java_script());
+    it.Advance();
+    ASSERT(!it.done());
+    ASSERT(it.frame()->is_arguments_adaptor());
+    actual_frame = reinterpret_cast<JavaScriptFrame*>(it.frame());
+  }
+
+  // Fill an array with all the passed arguments.
+  const int length = actual_frame->GetProvidedParametersCount();
   Handle<JSObject> arguments = Factory::NewArgumentsObject(function, length);
   Handle<FixedArray> array = Factory::NewFixedArray(length);
   WriteBarrierMode mode = array->GetWriteBarrierMode();
   for (int i = 0; i < length; i++) {
-    array->set(i, frame->GetParameter(i), mode);
+    array->set(i, actual_frame->GetParameter(i), mode);
   }
   arguments->set_elements(*array);
   return arguments;
 }
 
 
 // Evaluate a piece of JavaScript in the context of a stack frame for
 // debugging. This is accomplished by creating a new context which in its
 // extension part has all the parameters and locals of the function on the
 // stack frame. A function which calls eval with the code to evaluate is then
@@ skipping 86 matching lines @@
       Factory::NewFunctionFromBoilerplate(boilerplate, context);
 
   // Invoke the result of the compilation to get the evaluation function.
   bool has_pending_exception;
   Handle<Object> receiver(frame->receiver());
   Handle<Object> evaluation_function =
       Execution::Call(compiled_function, receiver, 0, NULL,
                       &has_pending_exception);
   if (has_pending_exception) return Failure::Exception();
 
-  Handle<Object> arguments = GetArgumentsObject(frame, function, code, &sinfo,
-                                                function_context);
+  Handle<JSObject> arguments = GetArgumentsObject(frame, function, code, &sinfo,
+                                                  function_context);
 
   // Invoke the evaluation function and return the result.
   const int argc = 2;
-  Object** argv[argc] = { arguments.location(),
+  Object** argv[argc] = { reinterpret_cast<Object**>(arguments.location()),
                           Handle<Object>::cast(source).location() };
   Handle<Object> result =
       Execution::Call(Handle<JSFunction>::cast(evaluation_function), receiver,
                       argc, argv, &has_pending_exception);
+  // Write back the content of the materialized scope to where it came from to
+  // reflect changes from the evaluation.This must be done before returning any
+  // exceptions.
+  DematerializeLocalScope(frame, local_scope, arguments);
   if (has_pending_exception) return Failure::Exception();
 
   // Skip the global proxy as it has no properties and always delegates to the
   // real global object.
   if (result->IsJSGlobalProxy()) {
     result = Handle<JSObject>(JSObject::cast(result->GetPrototype()));
   }
 
   return *result;
 }
@@ skipping 442 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();
   }
 }
 
 
 } }  // namespace v8::internal