Debugger: load debugger builtins as normal native JS.

src/debug/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 412 matching lines @@
 }
 
 
 DebugInfoListNode::~DebugInfoListNode() {
   if (debug_info_ == nullptr) return;
   GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_info_));
   debug_info_ = nullptr;
 }
 
 
-bool Debug::CompileDebuggerScript(Isolate* isolate, int index) {
-  Factory* factory = isolate->factory();
-  HandleScope scope(isolate);
-
-  // Bail out if the index is invalid.
-  if (index == -1) return false;
-
-  // Find source and name for the requested script.
-  Handle<String> source_code =
-      isolate->bootstrapper()->SourceLookup<Natives>(index);
-  Vector<const char> name = Natives::GetScriptName(index);
-  Handle<String> script_name =
-      factory->NewStringFromAscii(name).ToHandleChecked();
-  Handle<Context> context = isolate->native_context();
-
-  // Compile the script.
-  Handle<SharedFunctionInfo> function_info;
-  function_info = Compiler::CompileScript(
-      source_code, script_name, 0, 0, ScriptOriginOptions(), Handle<Object>(),
-      context, NULL, NULL, ScriptCompiler::kNoCompileOptions, NATIVES_CODE,
-      false);
-  if (function_info.is_null()) return false;
-
-  // Execute the shared function in the debugger context.
-  Handle<JSFunction> function =
-      factory->NewFunctionFromSharedFunctionInfo(function_info, context);
-
-  MaybeHandle<Object> maybe_exception;
-  MaybeHandle<Object> result = Execution::TryCall(
-      function, handle(context->global_proxy()), 0, NULL, &maybe_exception);
-
-  // Check for caught exceptions.
-  if (result.is_null()) {
-    DCHECK(!isolate->has_pending_exception());
-    MessageLocation computed_location;
-    isolate->ComputeLocation(&computed_location);
-    Handle<JSMessageObject> message = MessageHandler::MakeMessageObject(
-        isolate, MessageTemplate::kDebuggerLoading, &computed_location,
-        isolate->factory()->undefined_value(), Handle<JSArray>());
-    DCHECK(!isolate->has_pending_exception());
-    Handle<Object> exception;
-    if (maybe_exception.ToHandle(&exception)) {
-      isolate->set_pending_exception(*exception);
-      MessageHandler::ReportMessage(isolate, NULL, message);
-    }
-    DCHECK(!maybe_exception.is_null());
-    return false;
-  }
-
-  // Mark this script as native and return successfully.
-  Handle<Script> script(Script::cast(function->shared()->script()));
-  script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
-  return true;
-}
-
-
 bool Debug::Load() {
   // Return if debugger is already loaded.
   if (is_loaded()) return true;
 
   // Bail out if we're already in the process of compiling the native
   // JavaScript source code for the debugger.
   if (is_suppressed_) return false;
   SuppressDebug while_loading(this);
 
   // Disable breakpoints and interrupts while compiling and running the
   // debugger scripts including the context creation code.
   DisableBreak disable(this, true);
   PostponeInterruptsScope postpone(isolate_);
 
   // Create the debugger context.
   HandleScope scope(isolate_);
   ExtensionConfiguration no_extensions;
   Handle<Context> context = isolate_->bootstrapper()->CreateEnvironment(
-      MaybeHandle<JSGlobalProxy>(), v8::Local<ObjectTemplate>(),
-      &no_extensions);
+      MaybeHandle<JSGlobalProxy>(), v8::Local<ObjectTemplate>(), &no_extensions,
+      DEBUG_CONTEXT);
 
   // Fail if no context could be created.
   if (context.is_null()) return false;
 
-  // Use the debugger context.
-  SaveContext save(isolate_);
-  isolate_->set_context(*context);
-
-  // Expose the builtins object in the debugger context.
-  Handle<String> key = isolate_->factory()->InternalizeOneByteString(
-      STATIC_CHAR_VECTOR("builtins"));
-  Handle<GlobalObject> global =
-      Handle<GlobalObject>(context->global_object(), isolate_);
-  Handle<JSBuiltinsObject> builtin =
-      Handle<JSBuiltinsObject>(global->builtins(), isolate_);
-  RETURN_ON_EXCEPTION_VALUE(
-      isolate_, Object::SetProperty(global, key, builtin, SLOPPY), false);
-
-  // Compile the JavaScript for the debugger in the debugger context.
-  bool caught_exception =
-      !CompileDebuggerScript(isolate_, Natives::GetIndex("mirrors")) ||
-      !CompileDebuggerScript(isolate_, Natives::GetIndex("debug"));
-
-  if (FLAG_enable_liveedit) {
-    caught_exception = caught_exception ||
-        !CompileDebuggerScript(isolate_, Natives::GetIndex("liveedit"));
-  }
-  // Check for caught exceptions.
-  if (caught_exception) return false;
-
   debug_context_ = Handle<Context>::cast(
       isolate_->global_handles()->Create(*context));
   return true;
 }
 
 
 void Debug::Unload() {
   ClearAllBreakPoints();
   ClearStepping();
 
@@ skipping 168 matching lines @@
   HandleScope scope(isolate_);
 
   // Ignore check if break point object is not a JSObject.
   if (!break_point_object->IsJSObject()) return true;
 
   // Get the function IsBreakPointTriggered (defined in debug.js).
   Handle<String> is_break_point_triggered_string =
       factory->InternalizeOneByteString(
           STATIC_CHAR_VECTOR("IsBreakPointTriggered"));
   Handle<GlobalObject> debug_global(debug_context()->global_object());
-  Handle<JSFunction> check_break_point =
-    Handle<JSFunction>::cast(Object::GetProperty(
-        debug_global, is_break_point_triggered_string).ToHandleChecked());
+  Handle<JSFunction> check_break_point = Handle<JSFunction>::cast(
+      Object::GetProperty(debug_utils(), is_break_point_triggered_string)
+          .ToHandleChecked());
 
   // Get the break id as an object.
   Handle<Object> break_id = factory->NewNumberFromInt(Debug::break_id());
 
   // Call HandleBreakPointx.
   Handle<Object> argv[] = { break_id, break_point_object };
   Handle<Object> result;
   if (!Execution::TryCall(check_break_point,
                           isolate_->js_builtins_object(),
                           arraysize(argv),
@@ skipping 1000 matching lines @@
 
 bool Debug::IsDebugGlobal(GlobalObject* global) {
   return is_loaded() && global == debug_context()->global_object();
 }
 
 
 void Debug::ClearMirrorCache() {
   PostponeInterruptsScope postpone(isolate_);
   HandleScope scope(isolate_);
   AssertDebugContext();
-  Factory* factory = isolate_->factory();
-  Handle<GlobalObject> global(isolate_->global_object());
-  JSObject::SetProperty(global,
-                        factory->NewStringFromAsciiChecked("next_handle_"),
-                        handle(Smi::FromInt(0), isolate_), SLOPPY).Check();
-  JSObject::SetProperty(global,
-                        factory->NewStringFromAsciiChecked("mirror_cache_"),
-                        factory->NewJSArray(0, FAST_ELEMENTS), SLOPPY).Check();
+
+  Handle<Object> fun =
+      Object::GetProperty(isolate_, debug_utils(), "ClearMirrorCache")
+          .ToHandleChecked();
+  Handle<Object> undefined = isolate_->factory()->undefined_value();
+  Execution::TryCall(Handle<JSFunction>::cast(fun), undefined, 0, NULL);
 }
 
 
 Handle<FixedArray> Debug::GetLoadedScripts() {
   // Create and fill the script cache when the loaded scripts is requested for
   // the first time.
   if (script_cache_ == NULL) script_cache_ = new ScriptCache(isolate_);
 
   // Perform GC to get unreferenced scripts evicted from the cache before
   // returning the content.
@@ skipping 56 matching lines @@
     script->set_eval_from_instructions_offset(Smi::FromInt(offset));
   }
 }
 
 
 MaybeHandle<Object> Debug::MakeJSObject(const char* constructor_name,
                                         int argc,
                                         Handle<Object> argv[]) {
   AssertDebugContext();
   // Create the execution state object.
-  Handle<GlobalObject> global(isolate_->global_object());
-  Handle<Object> constructor = Object::GetProperty(
-      isolate_, global, constructor_name).ToHandleChecked();
+  Handle<Object> constructor =
+      Object::GetProperty(isolate_, debug_utils(), constructor_name)
+          .ToHandleChecked();
   DCHECK(constructor->IsJSFunction());
   if (!constructor->IsJSFunction()) return MaybeHandle<Object>();
   // We do not handle interrupts here.  In particular, termination interrupts.
   PostponeInterruptsScope no_interrupts(isolate_);
   return Execution::TryCall(Handle<JSFunction>::cast(constructor),
                             handle(debug_context()->global_proxy()),
                             argc,
                             argv);
 }
 
@@ skipping 207 matching lines @@
   }
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // If debugging there might be script break points registered for this
   // script. Make sure that these break points are set.
 
   // Get the function UpdateScriptBreakPoints (defined in debug.js).
-  Handle<String> update_script_break_points_string =
-      isolate_->factory()->InternalizeOneByteString(
-          STATIC_CHAR_VECTOR("UpdateScriptBreakPoints"));
-  Handle<GlobalObject> debug_global(debug_context()->global_object());
   Handle<Object> update_script_break_points =
-      Object::GetProperty(
-          debug_global, update_script_break_points_string).ToHandleChecked();
+      Object::GetProperty(isolate_, debug_utils(), "UpdateScriptBreakPoints")
+          .ToHandleChecked();
   if (!update_script_break_points->IsJSFunction()) {
     return;
   }
   DCHECK(update_script_break_points->IsJSFunction());
 
   // Wrap the script object in a proper JS object before passing it
   // to JavaScript.
   Handle<Object> wrapper = Script::GetWrapper(script);
 
   // Call UpdateScriptBreakPoints expect no exceptions.
@@ skipping 722 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8