Debugger: skip function prologue when computing redirect PC.

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 1293 matching lines @@
 }
 
 
 void Debug::ClearStepNext() {
   thread_local_.last_step_action_ = StepNone;
   thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
   thread_local_.last_fp_ = 0;
 }
 
 
+// We start counting call sites from the stack check because the declaration
+// code at the start of the function may have changed on recompile.
+static void SkipToStackCheck(Isolate* isolate, RelocIterator* it) {
+  while (Code::GetCodeFromTargetAddress(it->rinfo()->target_address()) !=
+         *isolate->builtins()->StackCheck()) {
+    it->next();
+  }
+}
+
+
 // Count the number of calls before the current frame PC to find the
 // corresponding PC in the newly recompiled code.
 static Address ComputeNewPcForRedirect(Code* new_code, Code* old_code,
                                        Address old_pc) {
   DCHECK_EQ(old_code->kind(), Code::FUNCTION);
   DCHECK_EQ(new_code->kind(), Code::FUNCTION);
   DCHECK(new_code->has_debug_break_slots());
   int mask = RelocInfo::kCodeTargetMask;
   int index = 0;
   intptr_t delta = 0;
-  for (RelocIterator it(old_code, mask); !it.done(); it.next()) {
-    RelocInfo* rinfo = it.rinfo();
+  Isolate* isolate = new_code->GetIsolate();
+  RelocIterator old_it(old_code, mask);
+  for (SkipToStackCheck(isolate, &old_it); !old_it.done(); old_it.next()) {
+    RelocInfo* rinfo = old_it.rinfo();
     Address current_pc = rinfo->pc();
     // The frame PC is behind the call instruction by the call instruction size.
     if (current_pc > old_pc) break;
     index++;
     delta = old_pc - current_pc;
   }
 
-  RelocIterator it(new_code, mask);
-  for (int i = 1; i < index; i++) it.next();
-  return it.rinfo()->pc() + delta;
+  RelocIterator new_it(new_code, mask);
+  SkipToStackCheck(isolate, &new_it);
+  for (int i = 1; i < index; i++) new_it.next();
+  return new_it.rinfo()->pc() + delta;
 }
 
 
 // Count the number of continuations at which the current pc offset is at.
 static int ComputeContinuationIndexFromPcOffset(Code* code, int pc_offset) {
   DCHECK_EQ(code->kind(), Code::FUNCTION);
   Address pc = code->instruction_start() + pc_offset;
   int mask = RelocInfo::ModeMask(RelocInfo::GENERATOR_CONTINUATION);
   int index = 0;
   for (RelocIterator it(code, mask); !it.done(); it.next()) {
@@ skipping 1428 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8