Restore behavior of PrepareForBreakpoints which was broken by r21145

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 "v8.h"
 
 #include "api.h"
 #include "arguments.h"
 #include "bootstrapper.h"
 #include "code-stubs.h"
@@ skipping 2019 matching lines @@
   }
 
  private:
   Isolate *isolate_;
   bool old_state_;
 
   DISALLOW_COPY_AND_ASSIGN(ForceDebuggerActive);
 };
 
 
-void Debug::MaybeRecompileFunctionForDebugging(Handle<JSFunction> function) {
-  ASSERT_EQ(Code::FUNCTION, function->code()->kind());
-  ASSERT_EQ(function->code(), function->shared()->code());
-
-  if (function->code()->has_debug_break_slots()) return;
+void Debug::EnsureFunctionHasDebugBreakSlots(Handle<JSFunction> function) {
+  if (function->code()->kind() != Code::FUNCTION ||

[Yang, 2014/05/08 14:28:09]

Like I said in the reland CL, this is incorrect. In this function we want to
make sure that the function code is unoptimized with debug break slots. If the
code type is optimized code or builtin, we want to replace that by recompiling
it.
We can only skip this if the code is already unoptimized with debug break slots.
So it should be

if (function->code()->kind() == Code::FUNCTION &&
function->code()->has_debug_break_slots())

[rmcilroy, 2014/05/08 14:53:59]

Sorry I missed that comment.  This doesn't work - I get the following ASSERT
failure with that change:

# Fatal error in ../src/compiler.cc, line 717
# CHECK(!old_code->has_debug_break_slots()) failed

==== C stack trace ===============================
v8::internal::Compiler::GetCodeForDebugging(v8::internal::Handle<v8::internal::JSFunction>)
 3:
v8::internal::Debug::MaybeRecompileFunctionForDebugging(v8::internal::Handle<v8::internal::JSFunction>)

Should it be:
if (function->shared()->code()->kind() == Code::FUNCTION && 
    function->shared()->code()->has_debug_break_slots()) return;

instead? That seems to work.

+      function->code()->has_debug_break_slots()) {
+    return;
+  }
 
   ForceDebuggerActive force_debugger_active(isolate_);
   MaybeHandle<Code> code = Compiler::GetCodeForDebugging(function);
   // Recompilation can fail.  In that case leave the code as it was.
   if (!code.is_null())
     function->ReplaceCode(*code.ToHandleChecked());
   ASSERT_EQ(function->code(), function->shared()->code());
 }
 
 
 void Debug::RecompileAndRelocateSuspendedGenerators(
     const List<Handle<JSGeneratorObject> > &generators) {
   for (int i = 0; i < generators.length(); i++) {
     Handle<JSFunction> fun(generators[i]->function());
 
-    MaybeRecompileFunctionForDebugging(fun);
+    EnsureFunctionHasDebugBreakSlots(fun);
 
     int code_offset = generators[i]->continuation();
     int pc_offset = ComputePcOffsetFromCodeOffset(fun->code(), code_offset);
     generators[i]->set_continuation(pc_offset);
   }
 }
 
 
 void Debug::PrepareForBreakPoints() {
   // If preparing for the first break point make sure to deoptimize all
@@ skipping 139 matching lines @@
     // activations could also have active activations.  That's fine.
     for (int i = 0; i < active_functions.length(); i++) {
       Handle<JSFunction> function = active_functions[i];
       Handle<SharedFunctionInfo> shared(function->shared());
 
       // If recompilation is not possible just skip it.
       if (shared->is_toplevel()) continue;
       if (!shared->allows_lazy_compilation()) continue;
       if (shared->code()->kind() == Code::BUILTIN) continue;
 
-      MaybeRecompileFunctionForDebugging(function);
+      EnsureFunctionHasDebugBreakSlots(function);
     }
 
     RedirectActivationsToRecompiledCodeOnThread(isolate_,
                                                 isolate_->thread_local_top());
 
     ActiveFunctionsRedirector active_functions_redirector;
     isolate_->thread_manager()->IterateArchivedThreads(
           &active_functions_redirector);
   }
 }
@@ skipping 1616 matching lines @@
       already_signalled_ = false;
     }
     {
       Locker locker(reinterpret_cast<v8::Isolate*>(isolate_));
       isolate_->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 } }  // namespace v8::internal