gdb: remove disable_breakpoints_in_shlibs function

I think there is a problem with the disable_breakpoints_in_shlibs
function: it can disable breakpoint locations without calling
notify_breakpoint_modified.  This means that the Python API's
breakpoint_modified event will not trigger, nor will the MI send a
breakpoint modified event.

I started looking at disable_breakpoints_in_shlibs because of an
earlier commit:

  commit 8c48ec7a6160aed0d1126c623443935e4435cd41
  Date:   Thu Aug 29 12:34:15 2024 +0100

      gdb: handle dprintf breakpoints when unloading a shared library

Currently disable_breakpoints_in_shlibs is only called from one
location, clear_solib in solib.c.  clear_solib also calls
notify_solib_unloaded for every solib in the program_space of
interest, and notify_solib_unloaded will call
disable_breakpoints_in_unloaded_shlib via the solib_unloaded
observer.  These two function, disable_breakpoints_in_shlibs and
disable_breakpoints_in_unloaded_shlib are very similar in what they
do.

I think that we can remove the disable_breakpoints_in_shlibs call, and
instead, tweak how we call disable_breakpoints_in_unloaded_shlib in
order to get the same end result, except that, after this change, we
will call notify_breakpoint_modified, which means the Python API event
will trigger, and the MI events will be emitted.

All that disable_breakpoints_in_shlibs does is disable some
breakpoints.

Meanwhile, disable_breakpoints_in_unloaded_shlib, will disable the
same set of breakpoints, call notify_breakpoint_modified, and
then (for some breakpoint types) print a message telling the user that
the breakpoint has been disabled.  However, this function will ignore
any breakpoints that are already disabled.

As disable_breakpoints_in_shlibs disables the same set of breakpoints,
the result of the current code is that disable_breakpoints_in_shlibs
serves only to prevent the notify_breakpoint_modified call, which I
think is wrong, and to prevent the user message being printed, which I
think is reasonable.

If we remove the disable_breakpoints_in_shlibs call without making any
additional changes, then we start to see some message printed in cases
like this:

  (gdb) start
  The program being debugged has been started already.
  Start it from the beginning? (y or n) y
  warning: Temporarily disabling breakpoints for unloaded shared library "/tmp/shared-lib-test/libfoo.so"
  Temporary breakpoint 3 at 0x40113e: file test.c, line 9.
  Starting program: /tmp/shared-lib-test/test.x

Notice the 'warning:' line, which is new.  I think this is confusing
because, in most cases the breakpoint will be enabled again by the
time the inferior reaches `main` and stops.

In the future I'm interested in exploring if GDB could be smarter
about when to print these 'Temporarily disabling breakpoints ...'
messages so that if the 'start' command does mean a breakpoint is left
disabled, then the user would be informed.  However, I don't propose
doing that work immediately, and certainly not in this commit.  For
now, my intention is to leave things as they are right now, GDB
doesn't warn about disabling breakpoints during an inferior re-start.

To achieve this I think we need to pass a new argument to
disable_breakpoints_in_unloaded_shlib which controls whether we should
print a message about the breakpoint being disabled or not.  With this
added we can now silence the warning when the inferior is
restarted (i.e. when disable_breakpoints_in_unloaded_shlib is called
from clear_solib), but keep the warning for cases like stepping over a
dlclose() call in the inferior.

After this commit, GDB now emits breakpoint modified events (in Python
and/or MI) when a breakpoint is disabled as a result of all shared
libraries being unloaded.  This will be visible in two places that I
can thing of, the 'nosharedlibrary' command, and when an inferior is
restarted.

1 files changed, 1 insertions, 1 deletions

diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index 67db0ca..129e7a6 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -295,7 +295,7 @@ bsd_uthread_solib_loaded (solib &so)
 
 static void
 bsd_uthread_solib_unloaded (program_space *pspace, const solib &so,
-			    bool still_in_use)
+			    bool still_in_use, bool /* silent */)
 {
   if (bsd_uthread_solib_name.empty () || still_in_use)
     return;