Use source position table for unoptimized code.

src/debug/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/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 78 matching lines @@
            debug_info_->shared()->start_position() - 1;
   } else {
     return 0;
   }
 }
 
 BreakLocation::CodeIterator::CodeIterator(Handle<DebugInfo> debug_info,
                                           BreakLocatorType type)
     : Iterator(debug_info),
       reloc_iterator_(debug_info->abstract_code()->GetCode(),
-                      GetModeMask(type)) {
+                      GetModeMask(type)),
+      source_position_iterator_(
+          debug_info->abstract_code()->GetCode()->source_position_table()),
+      start_position_(debug_info_->shared()->start_position()) {
   // There is at least one break location.
   DCHECK(!Done());
   Next();
 }
 
 int BreakLocation::CodeIterator::GetModeMask(BreakLocatorType type) {
   int mask = 0;
-  mask |= RelocInfo::ModeMask(RelocInfo::POSITION);
-  mask |= RelocInfo::ModeMask(RelocInfo::STATEMENT_POSITION);
   mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_RETURN);
   mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_CALL);
   if (isolate()->is_tail_call_elimination_enabled()) {
     mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_TAIL_CALL);
   }
   if (type == ALL_BREAK_LOCATIONS) {
     mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_POSITION);
     mask |= RelocInfo::ModeMask(RelocInfo::DEBUGGER_STATEMENT);
   }
   return mask;
 }
 
 void BreakLocation::CodeIterator::Next() {
   DisallowHeapAllocation no_gc;
   DCHECK(!Done());
 
   // Iterate through reloc info stopping at each breakable code target.
   bool first = break_index_ == -1;
   while (!Done()) {
     if (!first) reloc_iterator_.next();
     first = false;
     if (Done()) 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());
+    int offset = code_offset();
+    while (!source_position_iterator_.done() &&
+           source_position_iterator_.code_offset() <= offset) {
+      position_ = source_position_iterator_.source_position() - start_position_;
+      if (source_position_iterator_.is_statement()) {
+        statement_position_ = 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);
-      continue;
+      source_position_iterator_.Advance();
     }
 
     DCHECK(RelocInfo::IsDebugBreakSlot(rmode()) ||
            RelocInfo::IsDebuggerStatement(rmode()));
 
-    if (RelocInfo::IsDebugBreakSlotAtReturn(rmode())) {

[jgruber, 2016/06/27 09:32:42]

Just for my understanding, why is this not needed anymore?

[Yang, 2016/06/27 10:30:22]

We already have the correct source position attached to returns, so we don't
actually need this. I added an assert in the BreakLocation constructor to guard
this assumption.

-      // Set the positions to the end of the function.
-      statement_position_ = position_ = ReturnPosition();
-    }
-
     break;
   }
   break_index_++;
 }
 
 BreakLocation BreakLocation::CodeIterator::GetBreakLocation() {
   DebugBreakType type;
   if (RelocInfo::IsDebugBreakSlotAtReturn(rmode())) {
     type = DEBUG_BREAK_SLOT_AT_RETURN;
   } else if (RelocInfo::IsDebugBreakSlotAtCall(rmode())) {
@@ skipping 2430 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8