Fix handling of recompiling code for optimized and inlined functions

src/debug.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1762 matching lines @@
 
     {
       // We are going to iterate heap to find all functions without
       // debug break slots.
       isolate_->heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask);
 
       // Ensure no GC in this scope as we are comparing raw pointer
       // values and performing a heap iteration.
       AssertNoAllocation no_allocation;
 
-      // Find all non-optimized code functions with activation frames on
-      // the stack.
+      // Find all non-optimized code functions with activation frames
+      // on the stack. This includes functions which have optimized
+      // activations (including inlined functions) on the stack as the
+      // non-optimized code is needed for the lazy deoptimization.
       for (JavaScriptFrameIterator it(isolate_); !it.done(); it.Advance()) {
         JavaScriptFrame* frame = it.frame();
-        if (frame->function()->IsJSFunction()) {
+        if (frame->is_optimized()) {
+          List<JSFunction*> functions(Compiler::kMaxInliningLevels + 1);
+          frame->GetFunctions(&functions);
+          for (int i = 0; i < functions.length(); i++) {
+            if (!functions[i]->shared()->code()->has_debug_break_slots()) {
+              active_functions.Add(Handle<JSFunction>(functions[i]));
+            }
+          }
+        } else if (frame->function()->IsJSFunction()) {
           JSFunction* function = JSFunction::cast(frame->function());
           if (function->code()->kind() == Code::FUNCTION &&
-              !function->code()->has_debug_break_slots())
+              !function->code()->has_debug_break_slots()) {
             active_functions.Add(Handle<JSFunction>(function));
+          }
         }
       }
+
       // Sort the functions on the object pointer value to prepare for
       // the binary search below.
       active_functions.Sort(HandleObjectPointerCompare<JSFunction>);
 
       // Scan the heap for all non-optimized functions which has no
       // debug break slots.
       HeapIterator iterator;
       HeapObject* obj = NULL;
       while (((obj = iterator.next()) != NULL)) {
         if (obj->IsJSFunction()) {
@@ skipping 27 matching lines @@
       Handle<SharedFunctionInfo> shared(function->shared());
       // If recompilation is not possible just skip it.
       if (shared->is_toplevel() ||
           !shared->allows_lazy_compilation() ||
           shared->code()->kind() == Code::BUILTIN) {
         continue;
       }
 
       // Make sure that the shared full code is compiled with debug
       // break slots.
+      if (function->code() == *lazy_compile) {
+        function->set_code(shared->code());
+      }
       Handle<Code> current_code(function->code());
       if (shared->code()->has_debug_break_slots()) {
         // if the code is already recompiled to have break slots skip
         // recompilation.
         ASSERT(!function->code()->has_debug_break_slots());
       } else {
         // Try to compile the full code with debug break slots. If it
         // fails just keep the current code.
         ASSERT(shared->code() == *current_code);
         ZoneScope zone_scope(isolate_, DELETE_ON_EXIT);
         shared->set_code(*lazy_compile);
         bool prev_force_debugger_active =
             isolate_->debugger()->force_debugger_active();
         isolate_->debugger()->set_force_debugger_active(true);
         CompileFullCodeForDebugging(shared, current_code);
         isolate_->debugger()->set_force_debugger_active(
             prev_force_debugger_active);
         if (!shared->is_compiled()) {
           shared->set_code(*current_code);
           continue;
         }
       }
       Handle<Code> new_code(shared->code());
 
-      // Find the function and patch return address.
+      // Find the function and patch the return address.
       for (JavaScriptFrameIterator it(isolate_); !it.done(); it.Advance()) {
         JavaScriptFrame* frame = it.frame();
         // If the current frame is for this function in its
         // non-optimized form rewrite the return address to continue
         // in the newly compiled full code with debug break slots.
         if (frame->function()->IsJSFunction() &&
             frame->function() == *function &&
             frame->LookupCode()->kind() == Code::FUNCTION) {
           intptr_t delta = frame->pc() - current_code->instruction_start();
           int debug_break_slot_count = 0;
@@ skipping 1599 matching lines @@
     {
       Locker locker;
       Isolate::Current()->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal