Debugger: use debug break slots to break at function exit.

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 60 matching lines @@
 
   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 IsReturn() const {
+    return RelocInfo::IsDebugBreakSlotAtReturn(rmode_);
+  }
   inline bool IsCall() const {
     return RelocInfo::IsDebugBreakSlotAtCall(rmode_);
   }
   inline bool IsConstructCall() const {
     return RelocInfo::IsDebugBreakSlotAtConstructCall(rmode_);
   }
   inline int CallArgumentsCount() const {
     DCHECK(IsCall());
     return RelocInfo::DebugBreakCallArgumentsCount(data_);
   }
@@ skipping 13 matching lines @@
 
 
   inline RelocInfo rinfo() const {
     return RelocInfo(pc(), rmode(), data_, 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 debug_info_->original_code()->entry() + original_pc_offset_;
-  }
 
   inline RelocInfo::Mode rmode() const { return rmode_; }
 
   inline Code* code() const { return debug_info_->code(); }
 
  private:
-  BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo,
-                RelocInfo* original_rinfo, int position,
+  BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo, int position,
                 int statement_position);
 
   class Iterator {
    public:
     Iterator(Handle<DebugInfo> debug_info, BreakLocatorType type);
 
     BreakLocation GetBreakLocation() {
-      return BreakLocation(debug_info_, rinfo(), original_rinfo(), position(),
+      return BreakLocation(debug_info_, rinfo(), position(),
                            statement_position());
     }
 
-    inline bool Done() const { return RinfoDone(); }
+    inline bool Done() const { return reloc_iterator_.done(); }
     void Next();
 
     void SkipTo(int count) {
       while (count-- > 0) Next();
     }
 
     inline RelocInfo::Mode 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(); }
     int break_index() const { return break_index_; }
     inline int position() const { return position_; }
     inline int statement_position() const { return statement_position_; }
 
    private:
     static int GetModeMask(BreakLocatorType type);
 
-    bool RinfoDone() const;
-    void RinfoNext();
-
     Handle<DebugInfo> debug_info_;
     RelocIterator reloc_iterator_;
-    RelocIterator reloc_iterator_original_;
     int break_index_;
     int position_;
     int statement_position_;
 
     DisallowHeapAllocation no_gc_;
 
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
   friend class Debug;
 
   static int BreakIndexFromAddress(Handle<DebugInfo> debug_info,
                                    BreakLocatorType type, Address pc);
 
+  void SetDebugBreak();
   void ClearDebugBreak();
-  void RestoreFromOriginal(int length_in_bytes);
-
-  void SetDebugBreak();
-  void SetDebugBreakAtReturn();
-  void SetDebugBreakAtSlot();
 
   inline bool IsDebuggerStatement() const {
     return RelocInfo::IsDebuggerStatement(rmode_);
   }
   inline bool IsDebugBreakSlot() const {
     return RelocInfo::IsDebugBreakSlot(rmode_);
   }
 
   Handle<DebugInfo> debug_info_;
   int pc_offset_;
-  int original_pc_offset_;
   RelocInfo::Mode rmode_;
-  RelocInfo::Mode original_rmode_;
   intptr_t data_;
-  intptr_t original_data_;
   int position_;
   int statement_position_;
 };
 
 
 // Cache of all script objects in the heap. When a script is added a weak handle
 // to it is created and that weak handle is stored in the cache. The weak handle
 // callback takes care of removing the script from the cache. The key used in
 // the cache is the script id.
 class ScriptCache {
@@ skipping 576 matching lines @@
  private:
   Debug* debug_;
   bool old_state_;
   DISALLOW_COPY_AND_ASSIGN(SuppressDebug);
 };
 
 
 // Code generator routines.
 class DebugCodegen : public AllStatic {
  public:
-  enum SlotLocation {
-    PLAIN_DEBUG_BREAK,
-    DEBUG_BREAK_AT_CALL,
-    DEBUG_BREAK_AT_CONSTRUCT_CALL
+  enum DebugBreakCallHelperMode {
+    SAVE_RESULT_REGISTER,
+    IGNORE_RESULT_REGISTER
   };
 
-  static void GenerateSlot(MacroAssembler* masm, SlotLocation location,
-                           int call_argc = -1);
-  static void GenerateReturnDebugBreak(MacroAssembler* masm);
-  static void GenerateSlotDebugBreak(MacroAssembler* masm);
+  static void GenerateDebugBreakStub(MacroAssembler* masm,
+                                     DebugBreakCallHelperMode mode);
+
   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);
 
- private:
-  static void RecordRelocInfo(MacroAssembler* masm, SlotLocation location,
-                              int call_argc);
+
+  static void GenerateSlot(MacroAssembler* masm, RelocInfo::Mode mode,
+                           int call_argc = -1);
+
+  static void PatchDebugBreakSlot(Address pc, Handle<Code> code);
+  static void ClearDebugBreakSlot(Address pc);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_