Classes: Add support for stepping through default constructors

src/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/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 1207 matching lines @@
 
 
 void Debug::FloodBoundFunctionWithOneShot(Handle<JSFunction> function) {
   Handle<FixedArray> new_bindings(function->function_bindings());
   Handle<Object> bindee(new_bindings->get(JSFunction::kBoundFunctionIndex),
                         isolate_);
 
   if (!bindee.is_null() && bindee->IsJSFunction() &&
       !JSFunction::cast(*bindee)->IsFromNativeScript()) {
     Handle<JSFunction> bindee_function(JSFunction::cast(*bindee));
-    FloodWithOneShot(bindee_function);
+    if (bindee_function->shared()->is_default_constructor()) {
+      FloodDefaultConstructorWithOneShot(bindee_function);
+    } else {
+      FloodWithOneShot(bindee_function);
+    }
   }
 }
 
+
+void Debug::FloodDefaultConstructorWithOneShot(Handle<JSFunction> function) {
+  DCHECK(function->shared()->is_default_constructor());
+  // Instead of stepping into the function we directly step into the super class
+  // constructor.
+  Isolate* isolate = function->GetIsolate();
+  PrototypeIterator iter(isolate, function);
+  Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
+  if (!proto->IsJSFunction()) return;  // Object.prototype
+  Handle<JSFunction> function_proto = Handle<JSFunction>::cast(proto);
+
+  if (function_proto->shared()->bound()) {

[aandrey, 2014/11/14 19:27:13]

this if-else block is repeated several times below. maybe extract into a
function?

[arv (Not doing code reviews), 2014/11/14 22:02:22]

Done.

+    FloodBoundFunctionWithOneShot(function_proto);
+  } else if (function_proto->shared()->is_default_constructor()) {
+    FloodDefaultConstructorWithOneShot(function_proto);
+  } else if (!function_proto->IsFromNativeScript()) {
+    FloodWithOneShot(function_proto);
+  }
+}
+
 
 void Debug::FloodHandlerWithOneShot() {
   // Iterate through the JavaScript stack looking for handlers.
   StackFrame::Id id = break_frame_id();
   if (id == StackFrame::NO_ID) {
     // If there is no JavaScript stack don't do anything.
     return;
   }
   for (JavaScriptFrameIterator it(isolate_, id); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
@@ skipping 215 matching lines @@
         while (fun->IsJSFunction()) {
           Code* code = JSFunction::cast(fun)->shared()->code();
           if (code != apply && code != call) break;
           fun = frame->GetExpression(
               expressions_count - 1 - call_function_arg_count);
         }
       }
 
       if (fun->IsJSFunction()) {
         Handle<JSFunction> js_function(JSFunction::cast(fun));
         if (js_function->shared()->bound()) {

[aandrey, 2014/11/14 19:27:13]

repeated again

[arv (Not doing code reviews), 2014/11/14 22:02:22]

Done.

           FloodBoundFunctionWithOneShot(js_function);
+        } else if (js_function->shared()->is_default_constructor()) {
+          FloodDefaultConstructorWithOneShot(js_function);
         } else if (!js_function->IsFromNativeScript()) {
           // Don't step into builtins.
           // It will also compile target function if it's not compiled yet.
           FloodWithOneShot(js_function);
         }
       }
     }
 
     // Fill the current function with one-shot break points even for step in on
     // a call target as the function called might be a native function for
@@ skipping 126 matching lines @@
     if (is_constructor) {
       DCHECK(it.frame()->is_construct());
       it.Advance();
     }
     fp = it.frame()->fp();
   }
 
   // Flood the function with one-shot break points if it is called from where
   // step into was requested, or when stepping into a new frame.
   if (fp == thread_local_.step_into_fp_ || step_frame) {
     if (function->shared()->bound()) {

[aandrey, 2014/11/14 19:27:13]

repeated once more.

[arv (Not doing code reviews), 2014/11/14 22:02:22]

Done.

       // Handle Function.prototype.bind
       FloodBoundFunctionWithOneShot(function);
+    } else if (function->shared()->is_default_constructor()) {
+      FloodDefaultConstructorWithOneShot(function);
     } else if (!function->IsFromNativeScript()) {
       // Don't allow step into functions in the native context.
       if (function->shared()->code() ==

[aandrey, 2014/11/14 19:27:13]

maybe the following apply & call checks should be there in the other places
also?

[arv (Not doing code reviews), 2014/11/14 22:02:22]

This is the only place where we have the holder.

           isolate->builtins()->builtin(Builtins::kFunctionApply) ||
           function->shared()->code() ==
           isolate->builtins()->builtin(Builtins::kFunctionCall)) {
         // Handle function.apply and function.call separately to flood the
         // function to be called and not the code for Builtins::FunctionApply or
         // Builtins::FunctionCall. The receiver of call/apply is the target
         // function.
         if (!holder.is_null() && holder->IsJSFunction()) {
           Handle<JSFunction> js_function = Handle<JSFunction>::cast(holder);
           if (!js_function->IsFromNativeScript()) {

[aandrey, 2014/11/14 19:27:13]

BTW, is this in the correct order?

[arv (Not doing code reviews), 2014/11/14 19:36:57]

Yeah. This looks wrong.

[arv (Not doing code reviews), 2014/11/14 22:02:22]

Done.

             FloodWithOneShot(js_function);
           } else if (js_function->shared()->bound()) {
             // Handle Function.prototype.bind
             FloodBoundFunctionWithOneShot(js_function);
+          } else if (js_function->shared()->is_default_constructor()) {
+            FloodDefaultConstructorWithOneShot(js_function);
           }
         }
       } else {
         FloodWithOneShot(function);
       }
     }
   }
 }
 
 
@@ skipping 1781 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal