Debugger: use debug break slot to break on call.

src/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_H_
 #define V8_DEBUG_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/assembler.h"
@@ skipping 33 matching lines @@
 
 
 // Type of exception break. NOTE: These values are in macros.py as well.
 enum ExceptionBreakType {
   BreakException = 0,
   BreakUncaughtException = 1
 };
 
 
 // Type of exception break.
-enum BreakLocatorType {
-  ALL_BREAK_LOCATIONS = 0,
-  SOURCE_BREAK_LOCATIONS = 1,
-  CALLS_AND_RETURNS = 2
-};
+enum BreakLocatorType { ALL_BREAK_LOCATIONS, CALLS_AND_RETURNS };
 
 
 // The different types of breakpoint position alignments.
 // Must match Debug.BreakPositionAlignment in debug-debugger.js
 enum BreakPositionAlignment {
   STATEMENT_ALIGNED = 0,
   BREAK_POSITION_ALIGNED = 1
 };
 
 
 class BreakLocation {
  public:
   // Find the break point at the supplied address, or the closest one before
   // the address.
   static BreakLocation FromAddress(Handle<DebugInfo> debug_info,
                                    BreakLocatorType type, Address pc);
 
   static void FromAddressSameStatement(Handle<DebugInfo> debug_info,
                                        BreakLocatorType type, Address pc,
                                        List<BreakLocation>* result_out);
 
   static BreakLocation FromPosition(Handle<DebugInfo> debug_info,
                                     BreakLocatorType type, int position,
                                     BreakPositionAlignment alignment);
 
   bool IsDebugBreak() const;
   inline bool IsExit() const { return RelocInfo::IsJSReturn(rmode_); }
+  inline bool IsCall() const {
+    return IsDebugBreakSlot() && RelocInfo::DebugBreakIsCall(data_);
+  }
   inline bool IsConstructCall() const {
-    return RelocInfo::IsConstructCall(rmode_);
+    return IsDebugBreakSlot() && RelocInfo::DebugBreakIsConstructCall(data_);
   }
-  inline bool IsCodeTarget() const { return RelocInfo::IsCodeTarget(rmode_); }
-
-  Handle<Code> CodeTarget() const;
-  Handle<Code> OriginalCodeTarget() const;
+  inline int CallArgc() const {

[ulan, 2015/07/08 11:53:33]

Please use CallArgCount() or CallArgumentsCount()

[Yang, 2015/07/09 09:38:48]

Done.

+    DCHECK(IsCall());
+    return RelocInfo::DebugBreakCallArgumentsCount(data_);
+  }
 
   bool IsStepInLocation() const;
   inline bool HasBreakPoint() const {
     return debug_info_->HasBreakPoint(pc_offset_);
   }
 
   Handle<Object> BreakPointObjects() const;
 
   void SetBreakPoint(Handle<Object> break_point_object);
   void ClearBreakPoint(Handle<Object> break_point_object);
 
   void SetOneShot();
   void ClearOneShot();
 
+
   inline RelocInfo rinfo() const {
     return RelocInfo(pc(), rmode(), data_, code());
   }
 
-  inline RelocInfo original_rinfo() const {
-    return RelocInfo(original_pc(), original_rmode(), original_data_,
-                     original_code());
-  }
-
   inline int position() const { return position_; }
   inline int statement_position() const { return statement_position_; }
 
   inline Address pc() const { return code()->entry() + pc_offset_; }
   inline Address original_pc() const {
-    return original_code()->entry() + original_pc_offset_;
+    return debug_info_->original_code()->entry() + original_pc_offset_;
   }
 
   inline RelocInfo::Mode rmode() const { return rmode_; }
-  inline RelocInfo::Mode original_rmode() const { return original_rmode_; }
 
   inline Code* code() const { return debug_info_->code(); }
-  inline Code* original_code() const { return debug_info_->original_code(); }
 
  private:
   BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo,
                 RelocInfo* original_rinfo, int position,
                 int statement_position);
 
+  static const int kNonCallArgc = -2;

[ulan, 2015/07/08 11:53:33]

Please use the same constants here and in assembler.h

[Yang, 2015/07/09 09:38:48]

Removed. They are not actually necessary anymore.

+  static const int kConstructCallArgc = -1;
+
   class Iterator {
    public:
     Iterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
 
     BreakLocation GetBreakLocation() {
       return BreakLocation(debug_info_, rinfo(), original_rinfo(), position(),
                            statement_position());
     }
 
     inline bool Done() const { return RinfoDone(); }
     void Next();
 
     void SkipTo(int count) {
       while (count-- > 0) Next();
     }
 
     inline RelocInfo::Mode rmode() { return reloc_iterator_.rinfo()->rmode(); }
-    inline RelocInfo::Mode original_rmode() {
-      return reloc_iterator_.rinfo()->rmode();
-    }
-
     inline RelocInfo* rinfo() { return reloc_iterator_.rinfo(); }
     inline RelocInfo* original_rinfo() {
       return reloc_iterator_original_.rinfo();
     }
 
     inline Address pc() { return rinfo()->pc(); }
-    inline Address original_pc() { return original_rinfo()->pc(); }
-
     int break_index() const { return break_index_; }
-
     inline int position() const { return position_; }
     inline int statement_position() const { return statement_position_; }
 
    private:
     bool RinfoDone() const;
     void RinfoNext();
 
     Handle<DebugInfo> debug_info_;
     BreakLocatorType type_;
     RelocIterator reloc_iterator_;
@@ skipping 11 matching lines @@
 
   static int BreakIndexFromAddress(Handle<DebugInfo> debug_info,
                                    BreakLocatorType type, Address pc);
 
   void ClearDebugBreak();
   void RestoreFromOriginal(int length_in_bytes);
 
   void SetDebugBreak();
   void SetDebugBreakAtReturn();
   void SetDebugBreakAtSlot();
-  void SetDebugBreakAtIC();
 
   inline bool IsDebuggerStatement() const {
     return RelocInfo::IsDebuggerStatement(rmode_);
   }
   inline bool IsDebugBreakSlot() const {
     return RelocInfo::IsDebugBreakSlot(rmode_);
   }
 
   Handle<DebugInfo> debug_info_;
   int pc_offset_;
@@ skipping 593 matching lines @@
   Debug* debug_;
   bool old_state_;
   DISALLOW_COPY_AND_ASSIGN(SuppressDebug);
 };
 
 
 // Code generator routines.
 class DebugCodegen : public AllStatic {
  public:
   static void GenerateSlot(MacroAssembler* masm);
-  static void GenerateCallICStubDebugBreak(MacroAssembler* masm);
-  static void GenerateLoadICDebugBreak(MacroAssembler* masm);
-  static void GenerateStoreICDebugBreak(MacroAssembler* masm);
-  static void GenerateKeyedLoadICDebugBreak(MacroAssembler* masm);
-  static void GenerateKeyedStoreICDebugBreak(MacroAssembler* masm);
-  static void GenerateCompareNilICDebugBreak(MacroAssembler* masm);
   static void GenerateReturnDebugBreak(MacroAssembler* masm);
-  static void GenerateCallFunctionStubDebugBreak(MacroAssembler* masm);
-  static void GenerateCallConstructStubDebugBreak(MacroAssembler* masm);
-  static void GenerateCallConstructStubRecordDebugBreak(MacroAssembler* masm);
   static void GenerateSlotDebugBreak(MacroAssembler* masm);
   static void GeneratePlainReturnLiveEdit(MacroAssembler* masm);
 
   // FrameDropper is a code replacement for a JavaScript frame with possibly
   // several frames above.
   // There is no calling conventions here, because it never actually gets
   // called, it only gets returned to.
   static void GenerateFrameDropperLiveEdit(MacroAssembler* masm);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_