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());
+void Debug::EnsureFunctionHasDebugBreakSlots(Handle<JSFunction> function) {
+  if (function->code()->kind() == Code::FUNCTION &&
+      function->code()->has_debug_break_slots()) {
+    // Nothing to do. Function code already had debug break slots.
+    return;
+  }
 
-  if (function->code()->has_debug_break_slots()) return;
+  // Make sure that the shared full code is compiled with debug
+  // break slots.
+  if (!function->shared()->code()->has_debug_break_slots()) {
+    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());
+  }
 
-  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());
+  // Keep function code in sync with shared function info.
+  function->set_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);

[rmcilroy, 2014/05/08 17:00:45]

Should there also be checks here to just continue if function->shared() is
toplevel or !allow_lazy_compilation like lines 2223-2224 below, or is this not
possible for generators (I assume they can't be builtins)?  

[Yang, 2014/05/08 17:03:49]

Not sure about lazy compilation. I'll do some research tomorrow.

[rmcilroy, 2014/05/08 17:45:37]

OK, I'll land as-is now, and leave investigation of whether generators and
lazy_compilation interact to you.

[wingo, 2014/05/12 08:02:50]

Some test cases would have been nice here.  I don't think the condition
corresponding to this problem is exercised in the test suite.

Regarding generators -- it isn't possible to have a toplevel generator.  I think
however it is possible to have a generator that doesn't allow lazy compilation,
if I understand scopes.cc:AllowLazyCompilation() correctly.

 
     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