Fix bogus assertion in Debug::PrepareStep.

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 1337 matching lines @@
   {
     // Find the break location where execution has stopped.
     DisallowHeapAllocation no_gc;
     BreakLocationIterator it(debug_info, ALL_BREAK_LOCATIONS);
 
     // pc points to the instruction after the current one, possibly a break
     // location as well. So the "- 1" to exclude it from the search.
     it.FindBreakLocationFromAddress(frame->pc() - 1);
 
     is_exit = it.IsExit();
+    is_construct_call = RelocInfo::IsConstructCall(it.rmode());
 
     if (thread_local_.restarter_frame_function_pointer_ == NULL) {
       if (RelocInfo::IsCodeTarget(it.rinfo()->rmode())) {
         bool is_call_target = false;
         Address target = it.rinfo()->target_address();
         Code* code = Code::GetCodeFromTargetAddress(target);
 
         is_call_target = code->is_call_stub();
-        is_construct_call = RelocInfo::IsConstructCall(it.rmode());
         is_inline_cache_stub = code->is_inline_cache_stub();
         is_load_or_store = is_inline_cache_stub && !is_call_target;
 
         // Check if target code is CallFunction stub.
         Code* maybe_call_function_stub = code;
         // If there is a breakpoint at this line look at the original code to
         // check if it is a CallFunction stub.
         if (it.IsDebugBreak()) {
           Address original_target = it.original_rinfo()->target_address();
           maybe_call_function_stub =
@@ skipping 128 matching lines @@
 
     // Step in or Step in min
     // Step in through construct call requires no changes to the running code.
     // Step in through getters/setters should already be prepared as well
     // because caller of this function (Debug::PrepareStep) is expected to
     // flood the top frame's function with one shot breakpoints.
     // Step in through CallFunction stub should also be prepared by caller of
     // this function (Debug::PrepareStep) which should flood target function
     // with breakpoints.
     DCHECK(is_construct_call || is_inline_cache_stub ||
-           !call_function_stub.is_null());
+           !call_function_stub.is_null() || is_at_restarted_function);
     ActivateStepIn(frame);
   }
 }
 
 
 // Check whether the current debug break should be reported to the debugger. It
 // is used to have step next and step in only report break back to the debugger
 // if on a different frame or in a different statement. In some situations
 // there will be several break points in the same statement when the code is
 // flooded with one-shot break points. This function helps to perform several
@@ skipping 1946 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal