Debugger: do not compile IC for accessors when debugging.

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 1333 matching lines @@
           i -= 1;
         }
       }
 
       if (fun->IsJSFunction()) {
         Handle<JSFunction> js_function(JSFunction::cast(fun));
         FloodWithOneShotGeneric(js_function);
       }
     }
 
-    ActivateStepIn(function, frame);
+    ActivateStepIn(frame);
   }
 
   // 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
   // which step in will not stop. It also prepares for stepping in
   // getters/setters.
   // If we are stepping into another frame, only fill calls and returns.
   FloodWithOneShot(function, step_action == StepFrame ? CALLS_AND_RETURNS
                                                       : ALL_BREAK_LOCATIONS);
 
@@ skipping 137 matching lines @@
   for (DebugInfoListNode* node = debug_info_list_; node != NULL;
        node = node->next()) {
     for (BreakLocation::Iterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
          !it.Done(); it.Next()) {
       it.GetBreakLocation().ClearOneShot();
     }
   }
 }
 
 
-void Debug::ActivateStepIn(Handle<JSFunction> function, StackFrame* frame) {
+void Debug::ActivateStepIn(StackFrame* frame) {
   DCHECK(!StepOutActive());
-  // Make sure IC state is clean. This is so that we correct flood
-  // accessor pairs when stepping in.
-  function->code()->ClearInlineCaches();
-  function->shared()->feedback_vector()->ClearICSlots(function->shared());
   thread_local_.step_into_fp_ = frame->UnpaddedFP();
 }
 
 
 void Debug::ClearStepIn() {
   thread_local_.step_into_fp_ = 0;
 }
 
 
 void Debug::ActivateStepOut(StackFrame* frame) {
@@ skipping 535 matching lines @@
 
   // There will be at least one break point when we are done.
   has_break_points_ = true;
 
   // Ensure function is compiled. Return false if this failed.
   if (!function.is_null() &&
       !Compiler::EnsureCompiled(function, CLEAR_EXCEPTION)) {
     return false;
   }
 
+  // Make sure IC state is clean. This is so that we correctly flood
+  // accessor pairs when stepping in.
+  shared->code()->ClearInlineCaches();
+  shared->feedback_vector()->ClearICSlots(*shared);
+
   // Create the debug info object.
   Handle<DebugInfo> debug_info = isolate->factory()->NewDebugInfo(shared);
 
   // Add debug info to the list.
   DebugInfoListNode* node = new DebugInfoListNode(*debug_info);
   node->set_next(debug_info_list_);
   debug_info_list_ = node;
 
   return true;
 }
@@ skipping 1243 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8