[binutils-gdb] gdb: remove one user of the executable changed observer

[Andrew Burgess]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=a0a031bce0527b1521788b5dad640e7883b3a252

commit a0a031bce0527b1521788b5dad640e7883b3a252
Author: Andrew Burgess <aburgess@redhat.com>
Date:   Fri Sep 8 15:44:40 2023 +0100

    gdb: remove one user of the executable changed observer
    
    My goal for the next few commits is to expose the executable_changed
    observable from the Python API.
    
    However, there is call to the executable_changed observable in the
    reread_symbols function (in symfile.c), and this doesn't actually
    correspond to the executable changing.  My idea then, is to remove
    this use of the executable_changed observable, but, before I can do
    that, I need to check that nothing is going to break, and that
    requires my to think about the current users of this observable.
    
    One current user of executable_changed is in symtab.c.  We add an
    executable_changed observer that calls:
    
      set_main_name (nullptr, language_unknown);
    
    to discard all information about the main function when the executable
    changes.
    
    However, changing the executable doesn't actually change the debug
    information.  The debug information changes when the symbol-file
    changes, so I think this observer is in slightly the wrong place.
    
    The new_objfile observable is (unfortunately) overloaded, it is called
    when a new objfile is loaded, and also (when its argument is nullptr),
    when all debug information should be discarded.
    
    It turns out that there is already a new_objfile observer in
    symtab.c.  I propose that, when the argument is nullptr (indicating
    all debug info should be discarded), that we should call set_main_name
    to discard the information about the main function.  We can then
    remove the executable_changed observer from symtab.c.
    
    All tests still pass, and, in my local world, I added some debug
    printf calls, and I think we are still discarded the main information
    everywhere we need to.
    
    Approved-By: Tom Tromey <tom@tromey.com>

Diff:
---
 gdb/symtab.c | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 66d073e3b7b..e399dd81d81 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -100,6 +100,8 @@ static struct block_symbol
 			    enum block_enum block_index,
 			    const char *name, const domain_enum domain);
 
+static void set_main_name (const char *name, enum language lang);
+
 /* Type of the data stored on the program space.  */
 
 struct main_info
@@ -1694,6 +1696,11 @@ symtab_new_objfile_observer (struct objfile *objfile)
 {
   /* Ideally we'd use OBJFILE->pspace, but OBJFILE may be NULL.  */
   symbol_cache_flush (current_program_space);
+
+  /* When all objfiles have been removed (OBJFILE is nullptr), then forget
+     everything we know about the main function.  */
+  if (objfile == nullptr)
+    set_main_name (nullptr, language_unknown);
 }
 
 /* This module's 'free_objfile' observer.  */
@@ -6329,15 +6336,6 @@ main_language (void)
   return info->language_of_main;
 }
 
-/* Handle ``executable_changed'' events for the symtab module.  */
-
-static void
-symtab_observer_executable_changed (void)
-{
-  /* NAME_OF_MAIN may no longer be the same, so reset it for now.  */
-  set_main_name (NULL, language_unknown);
-}
-
 /* Return 1 if the supplied producer string matches the ARM RealView
    compiler (armcc).  */
 
@@ -7020,8 +7018,6 @@ the use of prologue scanners."),
 		     class_maintenance, 0, &maintenancelist);
   deprecate_cmd (c, "maintenancelist flush symbol-cache");
 
-  gdb::observers::executable_changed.attach (symtab_observer_executable_changed,
-					     "symtab");
   gdb::observers::new_objfile.attach (symtab_new_objfile_observer, "symtab");
   gdb::observers::free_objfile.attach (symtab_free_objfile_observer, "symtab");
 }