Reinstate call breakpoints

Author: rocky

trepan/lib/breakpoint.py

@@ -200,27 +200,15 @@ class BreakpointManager:
 
     Breakpoints are indexed by number in the `bpbynumber' list, and
     through a (file,line) tuple which is a key in the `bplist'
-    dictionary. If the breakpoint is a function it is in `code_list' as
+    dictionary. If the breakpoint is a function it is in `code2position_brkpts' as
     well.  Note there may be more than one breakpoint per line which
     may have different conditions associated with them.
     """
 
     def __init__(self):
 
-        # self.reset()
+        self.reset()
 
-        # The below duplicates self.reset(). However we include it here,
-        # to assist linters which as of 2014 largely do not grok attributes of
-        # class unless it is put inside __init__
-
-        self.bpbynumber: list = [None]
-        self.bplist = defaultdict(list)
-
-        # Keep a mapping from code object to breakpoints that are currently
-        # active in that code. By keeping this mapping, we avoid
-        # tracing frames that do not have breakpoints in their
-        # corresponding code objects.
-        self.code_list: DefaultDict[CodeType, list] = defaultdict(list)
         return
 
     def bpnumbers(self):
@@ -264,6 +252,8 @@ def add_breakpoint(
         ``temporary`` specifies whether the breakpoint will be removed once it is hit.
         `condition`` specifies that a string Python expression to be evaluated to determine
         whether the breakpoint is hit or not.
+
+        The parameter ``position`` is -1 when we want a breakpoint on a call event.
         """
         bpnum = len(self.bpbynumber)
         if filename:
@@ -320,8 +310,14 @@ def add_breakpoint(
         # Build the internal lists of breakpoints
         self.bpbynumber.append(brkpt)
         self.bplist[filename, line_number].append(brkpt)
-        if func_or_code and position != -1:
-            self.code_list[code].append(brkpt)
+        if func_or_code:
+            if position == -1:
+                # Add breakpoint to list of call event breakpoints,
+                # indexed by code object.
+                self.codecall_brkpts[code].append(brkpt)
+            else:
+                # Add breakpoint to list of breakpoints indexed by code object.
+                self.code2position_brkpts[code].append(brkpt)
         return brkpt
 
     def delete_all_breakpoints(self) -> str:
@@ -347,7 +343,12 @@ def delete_breakpoint(self, bp: Breakpoint) -> bool:
         if index not in self.bplist:
             return False
 
-        brkpts = self.code_list[bp.code]
+        # FIXME: should mark breakpoint as being a call breakpoint or not instead of doing
+        # this logic.
+        brkpts = self.codecall_brkpts[bp.code] if bp.offset is None else self.code2position_brkpts[bp.code]
+        if not brkpts:
+            brkpts = self.code2position_brkpts[bp.code]
+
         assert brkpts, f"Should have a list of breakpoints set in {bp.code}"
         if bp in brkpts:
             brkpts.remove(bp)
@@ -472,11 +473,21 @@ def reset(self):
         """A list of breakpoints by breakpoint number.  Each entry is
         None or an instance of Breakpoint.  Index 0 is unused, except
         for marking an effective break .... see effective()."""
-        self.bpbynumber = [None]
+        self.bpbynumber: list = [None]
+
+        # Keep a mapping from code object to breakpoints that are currently
+        # active in that code. By keeping this mapping, we avoid
+        # tracing frames that do not have breakpoints in their
+        # corresponding code objects.
+        self.code2position_brkpts: DefaultDict[CodeType, list] = defaultdict(list)
 
-        # A list of breakpoints indexed by (file, line_number) tuple
-        self.bplist = {}
-        self.code_list = {}
+        # Keep a mapping from code object for call events only to breakpoints that are currently
+        # active in that code. By keeping this mapping, we avoid
+        # tracing frames that do not have breakpoints in their
+        # corresponding code objects.
+        self.codecall_brkpts: DefaultDict[CodeType, list] = defaultdict(list)
+
+        self.bplist = defaultdict(list)
 
         return
 

trepan/lib/core.py

@@ -56,8 +56,9 @@
     "ignore_filter": None,  # But see debugger.py
 }
 
+
 class TrepanCore:
-    def __init__(self, debugger, opts: InitOptions=DEFAULT_INIT_OPTS):
+    def __init__(self, debugger, opts: InitOptions = DEFAULT_INIT_OPTS):
         """Create a debugger object. But depending on the value of
         key 'start' inside hash `opts', we may or may not initially
         start tracing events (i.e. enter the debugger).
@@ -197,7 +198,7 @@ def canonic_filename(self, frame: Optional[FrameType]) -> str:
 
         filename = frame.f_code.co_filename
         if "<string>" == filename:
-            if (new_filename := pyficache.main.code2tempfile.get(frame.f_code)):
+            if new_filename := pyficache.main.code2tempfile.get(frame.f_code):
                 filename = new_filename
         return self.canonic(filename)
 
@@ -231,7 +232,7 @@ def remove_ignore(self, frame_or_fn):
         be debugged"""
         return self.ignore_filter.remove(frame_or_fn)
 
-    def start(self, opts: InitOptions=DEFAULT_INIT_OPTS):
+    def start(self, opts: InitOptions = DEFAULT_INIT_OPTS):
         """We've already created a debugger object, but here we start
         debugging in earnest. We can also turn off debugging (but have
         the hooks suspended or not) using 'stop'.
@@ -292,32 +293,12 @@ def get_option(key: str) -> Any:
 
     def is_break_here(self, frame):
         filename = self.canonic(frame.f_code.co_filename)
-        if "call" == self.event:
-            find_name = frame.f_code
-            # Could check code object or decide not to
-            # The below could be done as a list comprehension, but
-            # I'm feeling in Fortran mood right now.
-            for fn in self.bpmgr.code_list:
-                if fn == find_name:
-                    bp_fn = self.bpmgr.code_list.get(fn)
-                    if not bp_fn:
-                        return False
-                    bp = bp_fn[0]
-                    if bp.offset is not None and bp.offset != frame.f_lasti:
-                        # print(f"XXXX core: have breakpoint, but offsets mismatch {bp.offset} vs {frame.f_lasti}")
-                        return False
-                    self.current_bp = bp
-                    if bp.temporary:
-                        msg = "temporary "
-                        self.bpmgr.delete_breakpoint(bp)
-                    else:
-                        msg = ""
-                        pass
-                    self.stop_reason = f"at {msg}call breakpoint {bp.number}"
-                    self.event = "brkpt"
-                    return True
-                pass
-            pass
+        code_object = frame.f_code
+        brkpts_in_code = self.bpmgr.code2position_brkpts.get(code_object)
+
+        if brkpts_in_code is None:
+            return False
+
         if (filename, frame.f_lineno) in list(self.bpmgr.bplist.keys()):
             (bp, clear_bp) = self.bpmgr.find_bp(filename, frame.f_lineno, frame)
             if bp:
@@ -339,6 +320,25 @@ def is_break_here(self, frame):
                 return False
         return False
 
+    def is_call_break_here(self, frame):
+        code_object = frame.f_code
+        brkpts_in_code = self.bpmgr.codecall_brkpts.get(code_object)
+
+        if brkpts_in_code is None:
+            return False
+        for bp in brkpts_in_code:
+            self.current_bp = bp
+            if bp.temporary:
+                msg = "temporary "
+                self.bpmgr.delete_breakpoint(bp)
+            else:
+                msg = ""
+                pass
+            self.stop_reason = f"at {msg}call breakpoint {bp.number}"
+            self.event = "brkpt"
+            return True
+        return False
+
     def matches_condition(self, frame):
         # Conditional bp.
         # Ignore count applies only to those bpt hits where the
@@ -450,19 +450,25 @@ def trace_dispatch(self, frame, event: str, arg):
         # for breakpoints in a kind of slow way of checking all events.
 
         remove_frame_on_return = False
+        is_call_breakpoint = False
         # FIXME:
         # instead of self.bpmgr.bplist == 0, we should be counting on
         # per breakpoints in code object.
         if event == "call":
-            if (self.last_frame != frame
+            if (
+                self.last_frame != frame
                 and len(self.bpmgr.bplist) == 0
                 and self.stop_level is not None
                 and self.stop_level < count_frames(frame)
                 and self.current_thread == threading.current_thread()
-                ):
+            ):
                 # We are "finish"ing or "next"ing and should not be tracing into this call
                 # or any other calls from this. Return None to not trace further.
-                # print("""XXX+  trace_dispatch: "finish"ing or "next"ing from call event""")
+
+                # print(
+                #     """XXX+  trace_dispatch: "finish"ing or "next"ing from call event"""
+                # )
+
                 frame.f_trace = None
                 return None
 
@@ -474,7 +480,11 @@ def trace_dispatch(self, frame, event: str, arg):
                 # this function. In this case we need to ignore this stop, but
                 # make sure we don't turn off breakpoints inside this function which
                 # we do by returning "self".
-                return self
+                if self.is_call_break_here(frame):
+                    is_call_breakpoint = True
+                else:
+                    # print("XXX+ trace_dispatch: is_stop_here() return")
+                    return self
 
         elif event == "return" and frame in FrameInfo:
             remove_frame_on_return = True
@@ -535,7 +545,11 @@ def trace_dispatch(self, frame, event: str, arg):
             # user's standpoint to test for breaks before steps. In
             # this case we will need to factor out the counting
             # updates.
-            if self.is_stop_here(frame, event) or self.is_break_here(frame):
+            if (
+                self.is_stop_here(frame, event)
+                or self.is_break_here(frame)
+                or is_call_breakpoint
+            ):
                 # Run the event processor
                 return self.processor.event_processor(frame, self.event, arg)
             # else:
@@ -549,6 +563,7 @@ def trace_dispatch(self, frame, event: str, arg):
             pass
             if remove_frame_on_return:
                 del FrameInfo[frame]
+
     pass
 
 

trepan/processor/cmdproc.py

@@ -590,14 +590,17 @@ def process_commands(self):
                 pass
             pass
         run_hooks(self, self.postcmd_hooks)
-        if self.fast_continue and len(self.core.bpmgr.bplist) == 0:
-            # Remove tracing on frames and remove trace hook.
-            frame = self.curframe
-            while frame:
-                del frame.f_trace
-                frame = frame.f_back
-            self.debugger.intf[-1].msg("Fast continue...")
-            remove_hook(self.core.trace_dispatch, True)
+        if self.fast_continue:
+            if len(self.core.bpmgr.bplist) == 0:
+                # Remove tracing on frames and remove trace hook.
+                frame = self.curframe
+                while frame:
+                    del frame.f_trace
+                    frame = frame.f_back
+                self.debugger.intf[-1].msg("Fast continue...")
+                remove_hook(self.core.trace_dispatch, True)
+            else:
+                self.debugger.intf[-1].msg("Continue with breakpoint checking...")
 
         return
 

trepan/processor/location.py

@@ -198,16 +198,18 @@ def resolve_location(proc, location) -> Optional[Location]:
                         proc.msg("Offset %d not found for line %d; using offset %d instead." %
                                  (location.offset, location.line_number, offset))
 
-                    mod_or_func_or_code_name = lineinfo[0].name
-                    if mod_or_func_or_code.co_name != mod_or_func_or_code_name:
-                        # Breakpoint is in a nested function/method.
-                        # Get new code object
-                        mod_or_func_or_code = code_info.get(
-                            mod_or_func_or_code_name, mod_or_func_or_code
-                        )
+                    pass
                 pass
             else:
                 return INVALID_LOCATION
+            mod_or_func_or_code_name = lineinfo[0].name
+            if mod_or_func_or_code.co_name != mod_or_func_or_code_name:
+                # Breakpoint is in a nested function/method.
+                # Get new code object
+                mod_or_func_or_code = code_info.get(
+                    mod_or_func_or_code_name, mod_or_func_or_code
+                )
+            pass
     elif location.offset is not None:
         filename = frame2file(proc.core, curframe, canonic=False)
         is_address = True