[debugger] fix step-next for tail calls.

src/debug/debug.h

 // 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.
 
 #ifndef V8_DEBUG_DEBUG_H_
 #define V8_DEBUG_DEBUG_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/assembler.h"
@@ skipping 63 matching lines @@
                                       int statement_position,
                                       List<BreakLocation>* result_out);
 
   static BreakLocation FromPosition(Handle<DebugInfo> debug_info, int position,
                                     BreakPositionAlignment alignment);
 
   bool IsDebugBreak() const;
 
   inline bool IsReturn() const { return type_ == DEBUG_BREAK_SLOT_AT_RETURN; }
   inline bool IsCall() const { return type_ == DEBUG_BREAK_SLOT_AT_CALL; }
+  inline bool IsTailCall() const {
+    return type_ == DEBUG_BREAK_SLOT_AT_TAIL_CALL;
+  }
   inline bool IsDebugBreakSlot() const { return type_ >= DEBUG_BREAK_SLOT; }
   inline bool IsDebuggerStatement() const {
     return type_ == DEBUGGER_STATEMENT;
   }
   inline bool HasBreakPoint() const {
     return debug_info_->HasBreakPoint(code_offset_);
   }
 
   Handle<Object> BreakPointObjects() const;
 
@@ skipping 12 matching lines @@
   inline AbstractCode* abstract_code() const {
     return debug_info_->abstract_code();
   }
 
  protected:
   enum DebugBreakType {
     NOT_DEBUG_BREAK,
     DEBUGGER_STATEMENT,
     DEBUG_BREAK_SLOT,
     DEBUG_BREAK_SLOT_AT_CALL,
-    DEBUG_BREAK_SLOT_AT_RETURN
+    DEBUG_BREAK_SLOT_AT_RETURN,
+    DEBUG_BREAK_SLOT_AT_TAIL_CALL,
   };
 
   BreakLocation(Handle<DebugInfo> debug_info, DebugBreakType type,
                 int code_offset, int position, int statement_position);
 
   class Iterator {
    public:
     virtual ~Iterator() {}
 
     virtual BreakLocation GetBreakLocation() = 0;
     virtual bool Done() const = 0;
     virtual void Next() = 0;
 
     void SkipTo(int count) {
       while (count-- > 0) Next();
     }
 
     virtual int code_offset() = 0;
     int break_index() const { return break_index_; }
     inline int position() const { return position_; }
     inline int statement_position() const { return statement_position_; }
 
    protected:
     explicit Iterator(Handle<DebugInfo> debug_info);
     int ReturnPosition();
 
+    Isolate* isolate() { return debug_info_->GetIsolate(); }
+
     Handle<DebugInfo> debug_info_;
     int break_index_;
     int position_;
     int statement_position_;
 
    private:
     DisallowHeapAllocation no_gc_;
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
   class CodeIterator : public Iterator {
    public:
     CodeIterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
     ~CodeIterator() override {}
 
     BreakLocation GetBreakLocation() override;
     bool Done() const override { return reloc_iterator_.done(); }
     void Next() override;
 
     int code_offset() override {
       return static_cast<int>(
           rinfo()->pc() -
           debug_info_->abstract_code()->GetCode()->instruction_start());
     }
 
    private:
-    static int GetModeMask(BreakLocatorType type);
+    int GetModeMask(BreakLocatorType type);
     RelocInfo::Mode rmode() { return reloc_iterator_.rinfo()->rmode(); }
     RelocInfo* rinfo() { return reloc_iterator_.rinfo(); }
 
     RelocIterator reloc_iterator_;
     DISALLOW_COPY_AND_ASSIGN(CodeIterator);
   };
 
   class BytecodeArrayIterator : public Iterator {
    public:
     BytecodeArrayIterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
@@ skipping 617 matching lines @@
                                   Handle<Code> code);
   static bool DebugBreakSlotIsPatched(Address pc);
   static void ClearDebugBreakSlot(Isolate* isolate, Address pc);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_H_