Debugger: PreservePositionScope should clear positions inside the scope.

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 51 matching lines @@
                                   BreakLocatorType type)
     : debug_info_(debug_info),
       type_(type),
       reloc_iterator_(debug_info->code(),
                       ~RelocInfo::ModeMask(RelocInfo::CODE_AGE_SEQUENCE)),
       reloc_iterator_original_(
           debug_info->original_code(),
           ~RelocInfo::ModeMask(RelocInfo::CODE_AGE_SEQUENCE)),
       break_index_(-1),
       position_(1),
-      statement_position_(1) {
+      statement_position_(1),
+      has_immediate_position_(false) {
   Next();
 }
 
 
 void BreakLocation::Iterator::Next() {
   DisallowHeapAllocation no_gc;
   DCHECK(!RinfoDone());
 
   // Iterate through reloc info for code and original code stopping at each
   // breakable code target.
   bool first = break_index_ == -1;
   while (!RinfoDone()) {
     if (!first) RinfoNext();
     first = false;
     if (RinfoDone()) return;
 
     // Whenever a statement position or (plain) position is passed update the
     // current value of these.
     if (RelocInfo::IsPosition(rmode())) {
       if (RelocInfo::IsStatementPosition(rmode())) {
         statement_position_ = static_cast<int>(
             rinfo()->data() - debug_info_->shared()->start_position());
       }
       // Always update the position as we don't want that to be before the
       // statement position.
       position_ = static_cast<int>(rinfo()->data() -
                                    debug_info_->shared()->start_position());
       DCHECK(position_ >= 0);
       DCHECK(statement_position_ >= 0);
+      has_immediate_position_ = true;
+      continue;
     }
 
     // Check for break at return.
     if (RelocInfo::IsJSReturn(rmode())) {
       // Set the positions to the end of the function.
       if (debug_info_->shared()->HasSourceCode()) {
         position_ = debug_info_->shared()->end_position() -
                     debug_info_->shared()->start_position() - 1;
       } else {
         position_ = 0;
       }
       statement_position_ = position_;
       break_index_++;
-      return;
+      break;
     }
 
     if (RelocInfo::IsCodeTarget(rmode())) {
       // Check for breakable code target. Look in the original code as setting
       // break points can cause the code targets in the running (debugged) code
       // to be of a different kind than in the original code.
       Address target = original_rinfo()->target_address();
       Code* code = Code::GetCodeFromTargetAddress(target);
 
       if (RelocInfo::IsConstructCall(rmode()) || code->is_call_stub()) {
         break_index_++;
-        return;
+        break;
       }
 
       // Skip below if we only want locations for calls and returns.
       if (type_ == CALLS_AND_RETURNS) continue;
 
-      if ((code->is_inline_cache_stub() && !code->is_binary_op_stub() &&
+      // Only break at an inline cache if it has an immediate position attached.
+      if (has_immediate_position_ &&
+          (code->is_inline_cache_stub() && !code->is_binary_op_stub() &&
            !code->is_compare_ic_stub() && !code->is_to_boolean_ic_stub())) {
         break_index_++;
-        return;
+        break;
       }
       if (code->kind() == Code::STUB) {
         if (RelocInfo::IsDebuggerStatement(rmode())) {
           break_index_++;
-          return;
+          break;
         } else if (CodeStub::GetMajorKey(code) == CodeStub::CallFunction) {
           break_index_++;
-          return;
+          break;
         }
       }
     }
 
     if (RelocInfo::IsDebugBreakSlot(rmode()) && type_ != CALLS_AND_RETURNS) {
       // There is always a possible break point at a debug break slot.
       break_index_++;
-      return;
+      break;
     }
   }
+  has_immediate_position_ = false;
 }
 
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
 BreakLocation BreakLocation::FromAddress(Handle<DebugInfo> debug_info,
                                          BreakLocatorType type, Address pc) {
   Iterator it(debug_info, type);
   it.SkipTo(BreakIndexFromAddress(debug_info, type, pc));
   return it.GetBreakLocation();
@@ skipping 3197 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal