gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009-2023 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcmd.h"
  22 #include "objfiles.h"
  23 #include "arch-utils.h"
  24 #include "gdbcore.h"
  25 #include "solib.h"
  26 #include "solist.h"
  27 #include "gdbthread.h"
  28 #include "inferior.h"
  29 #include <algorithm>
  30 #include "cli/cli-style.h"
  31 #include "observable.h"
  32
  33 /* The last program space number assigned.  */
  34 static int last_program_space_num = 0;
  35
  36 /* The head of the program spaces list.  */
  37 std::vector<struct program_space *> program_spaces;
  38
  39 /* Pointer to the current program space.  */
  40 struct program_space *current_program_space;
  41
  42 /* The last address space number assigned.  */
  43 static int highest_address_space_num;
  44
  45 \f
  46
  47 /* Create a new address space object, and add it to the list.  */
  48
  49 address_space::address_space ()
  50   : m_num (++highest_address_space_num)
  51 {
  52 }
  53
  54 /* Maybe create a new address space object, and add it to the list, or
  55    return a pointer to an existing address space, in case inferiors
  56    share an address space on this target system.  */
  57
  58 address_space_ref_ptr
  59 maybe_new_address_space ()
  60 {
  61   int shared_aspace
  62     = gdbarch_has_shared_address_space (current_inferior ()->arch ());
  63
  64   if (shared_aspace)
  65     {
  66       /* Just return the first in the list.  */
  67       return program_spaces[0]->aspace;
  68     }
  69
  70   return new_address_space ();
  71 }
  72
  73 /* Start counting over from scratch.  */
  74
  75 static void
  76 init_address_spaces (void)
  77 {
  78   highest_address_space_num = 0;
  79 }
  80
  81 \f
  82
  83 /* Remove a program space from the program spaces list.  */
  84
  85 static void
  86 remove_program_space (program_space *pspace)
  87 {
  88   gdb_assert (pspace != NULL);
  89
  90   auto iter = std::find (program_spaces.begin (), program_spaces.end (),
  91                          pspace);
  92   gdb_assert (iter != program_spaces.end ());
  93   program_spaces.erase (iter);
  94 }
  95
  96 /* See progspace.h.  */
  97
  98 program_space::program_space (address_space_ref_ptr aspace_)
  99   : num (++last_program_space_num),
 100     aspace (std::move (aspace_))
 101 {
 102   program_spaces.push_back (this);
 103   gdb::observers::new_program_space.notify (this);
 104 }
 105
 106 /* See progspace.h.  */
 107
 108 program_space::~program_space ()
 109 {
 110   gdb_assert (this != current_program_space);
 111
 112   gdb::observers::free_program_space.notify (this);
 113   remove_program_space (this);
 114
 115   scoped_restore_current_program_space restore_pspace;
 116
 117   set_current_program_space (this);
 118
 119   breakpoint_program_space_exit (this);
 120   no_shared_libraries (NULL, 0);
 121   free_all_objfiles ();
 122   /* Defer breakpoint re-set because we don't want to create new
 123      locations for this pspace which we're tearing down.  */
 124   clear_symtab_users (SYMFILE_DEFER_BP_RESET);
 125 }
 126
 127 /* See progspace.h.  */
 128
 129 void
 130 program_space::free_all_objfiles ()
 131 {
 132   /* Any objfile reference would become stale.  */
 133   for (const shobj &so : current_program_space->solibs ())
 134     gdb_assert (so.objfile == NULL);
 135
 136   while (!objfiles_list.empty ())
 137     objfiles_list.front ()->unlink ();
 138 }
 139
 140 /* See progspace.h.  */
 141
 142 void
 143 program_space::add_objfile (std::unique_ptr<objfile> &&objfile,
 144                             struct objfile *before)
 145 {
 146   if (before == nullptr)
 147     objfiles_list.push_back (std::move (objfile));
 148   else
 149     {
 150       auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 151                                 [=] (const std::unique_ptr<::objfile> &objf)
 152                                 {
 153                                   return objf.get () == before;
 154                                 });
 155       gdb_assert (iter != objfiles_list.end ());
 156       objfiles_list.insert (iter, std::move (objfile));
 157     }
 158 }
 159
 160 /* See progspace.h.  */
 161
 162 void
 163 program_space::remove_objfile (struct objfile *objfile)
 164 {
 165   /* Removing an objfile from the objfile list invalidates any frame
 166      that was built using frame info found in the objfile.  Reinit the
 167      frame cache to get rid of any frame that might otherwise
 168      reference stale info.  */
 169   reinit_frame_cache ();
 170
 171   auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 172                             [=] (const std::unique_ptr<::objfile> &objf)
 173                             {
 174                               return objf.get () == objfile;
 175                             });
 176   gdb_assert (iter != objfiles_list.end ());
 177   objfiles_list.erase (iter);
 178
 179   if (objfile == symfile_object_file)
 180     symfile_object_file = NULL;
 181 }
 182
 183 /* See progspace.h.  */
 184
 185 struct objfile *
 186 program_space::objfile_for_address (CORE_ADDR address)
 187 {
 188   for (auto iter : objfiles ())
 189     {
 190       /* Don't check separate debug objfiles.  */
 191       if (iter->separate_debug_objfile_backlink != nullptr)
 192         continue;
 193       if (is_addr_in_objfile (address, iter))
 194         return iter;
 195     }
 196   return nullptr;
 197 }
 198
 199 /* See progspace.h.  */
 200
 201 void
 202 program_space::exec_close ()
 203 {
 204   if (ebfd != nullptr)
 205     {
 206       /* Removing target sections may close the exec_ops target.
 207          Clear ebfd before doing so to prevent recursion.  */
 208       bfd *saved_ebfd = ebfd.get ();
 209       ebfd.reset (nullptr);
 210       ebfd_mtime = 0;
 211
 212       remove_target_sections (saved_ebfd);
 213
 214       exec_filename.reset (nullptr);
 215     }
 216 }
 217
 218 /* Copies program space SRC to DEST.  Copies the main executable file,
 219    and the main symbol file.  Returns DEST.  */
 220
 221 struct program_space *
 222 clone_program_space (struct program_space *dest, struct program_space *src)
 223 {
 224   scoped_restore_current_program_space restore_pspace;
 225
 226   set_current_program_space (dest);
 227
 228   if (src->exec_filename != NULL)
 229     exec_file_attach (src->exec_filename.get (), 0);
 230
 231   if (src->symfile_object_file != NULL)
 232     symbol_file_add_main (objfile_name (src->symfile_object_file),
 233                           SYMFILE_DEFER_BP_RESET);
 234
 235   return dest;
 236 }
 237
 238 /* Sets PSPACE as the current program space.  It is the caller's
 239    responsibility to make sure that the currently selected
 240    inferior/thread matches the selected program space.  */
 241
 242 void
 243 set_current_program_space (struct program_space *pspace)
 244 {
 245   if (current_program_space == pspace)
 246     return;
 247
 248   gdb_assert (pspace != NULL);
 249
 250   current_program_space = pspace;
 251
 252   /* Different symbols change our view of the frame chain.  */
 253   reinit_frame_cache ();
 254 }
 255
 256 /* Returns true iff there's no inferior bound to PSPACE.  */
 257
 258 bool
 259 program_space::empty ()
 260 {
 261   return find_inferior_for_program_space (this) == nullptr;
 262 }
 263
 264 /* Prints the list of program spaces and their details on UIOUT.  If
 265    REQUESTED is not -1, it's the ID of the pspace that should be
 266    printed.  Otherwise, all spaces are printed.  */
 267
 268 static void
 269 print_program_space (struct ui_out *uiout, int requested)
 270 {
 271   int count = 0;
 272
 273   /* Start with a minimum width of 17 for the executable name column.  */
 274   size_t longest_exec_name = 17;
 275
 276   /* Compute number of pspaces we will print.  */
 277   for (struct program_space *pspace : program_spaces)
 278     {
 279       if (requested != -1 && pspace->num != requested)
 280         continue;
 281
 282       if (pspace->exec_filename != nullptr)
 283         longest_exec_name = std::max (strlen (pspace->exec_filename.get ()),
 284                                       longest_exec_name);
 285
 286       ++count;
 287     }
 288
 289   /* There should always be at least one.  */
 290   gdb_assert (count > 0);
 291
 292   ui_out_emit_table table_emitter (uiout, 4, count, "pspaces");
 293   uiout->table_header (1, ui_left, "current", "");
 294   uiout->table_header (4, ui_left, "id", "Id");
 295   uiout->table_header (longest_exec_name, ui_left, "exec", "Executable");
 296   uiout->table_header (17, ui_left, "core", "Core File");
 297   uiout->table_body ();
 298
 299   for (struct program_space *pspace : program_spaces)
 300     {
 301       int printed_header;
 302
 303       if (requested != -1 && requested != pspace->num)
 304         continue;
 305
 306       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 307
 308       if (pspace == current_program_space)
 309         uiout->field_string ("current", "*");
 310       else
 311         uiout->field_skip ("current");
 312
 313       uiout->field_signed ("id", pspace->num);
 314
 315       if (pspace->exec_filename != nullptr)
 316         uiout->field_string ("exec", pspace->exec_filename.get (),
 317                              file_name_style.style ());
 318       else
 319         uiout->field_skip ("exec");
 320
 321       if (pspace->cbfd != nullptr)
 322         uiout->field_string ("core", bfd_get_filename (pspace->cbfd.get ()),
 323                              file_name_style.style ());
 324       else
 325         uiout->field_skip ("core");
 326
 327       /* Print extra info that doesn't really fit in tabular form.
 328          Currently, we print the list of inferiors bound to a pspace.
 329          There can be more than one inferior bound to the same pspace,
 330          e.g., both parent/child inferiors in a vfork, or, on targets
 331          that share pspaces between inferiors.  */
 332       printed_header = 0;
 333
 334       /* We're going to switch inferiors.  */
 335       scoped_restore_current_thread restore_thread;
 336
 337       for (inferior *inf : all_inferiors ())
 338         if (inf->pspace == pspace)
 339           {
 340             /* Switch to inferior in order to call target methods.  */
 341             switch_to_inferior_no_thread (inf);
 342
 343             if (!printed_header)
 344               {
 345                 printed_header = 1;
 346                 gdb_printf ("\n\tBound inferiors: ID %d (%s)",
 347                             inf->num,
 348                             target_pid_to_str (ptid_t (inf->pid)).c_str ());
 349               }
 350             else
 351               gdb_printf (", ID %d (%s)",
 352                           inf->num,
 353                           target_pid_to_str (ptid_t (inf->pid)).c_str ());
 354           }
 355
 356       uiout->text ("\n");
 357     }
 358 }
 359
 360 /* Boolean test for an already-known program space id.  */
 361
 362 static int
 363 valid_program_space_id (int num)
 364 {
 365   for (struct program_space *pspace : program_spaces)
 366     if (pspace->num == num)
 367       return 1;
 368
 369   return 0;
 370 }
 371
 372 /* If ARGS is NULL or empty, print information about all program
 373    spaces.  Otherwise, ARGS is a text representation of a LONG
 374    indicating which the program space to print information about.  */
 375
 376 static void
 377 maintenance_info_program_spaces_command (const char *args, int from_tty)
 378 {
 379   int requested = -1;
 380
 381   if (args && *args)
 382     {
 383       requested = parse_and_eval_long (args);
 384       if (!valid_program_space_id (requested))
 385         error (_("program space ID %d not known."), requested);
 386     }
 387
 388   print_program_space (current_uiout, requested);
 389 }
 390
 391 /* Update all program spaces matching to address spaces.  The user may
 392    have created several program spaces, and loaded executables into
 393    them before connecting to the target interface that will create the
 394    inferiors.  All that happens before GDB has a chance to know if the
 395    inferiors will share an address space or not.  Call this after
 396    having connected to the target interface and having fetched the
 397    target description, to fixup the program/address spaces mappings.
 398
 399    It is assumed that there are no bound inferiors yet, otherwise,
 400    they'd be left with stale referenced to released aspaces.  */
 401
 402 void
 403 update_address_spaces (void)
 404 {
 405   int shared_aspace
 406     = gdbarch_has_shared_address_space (current_inferior ()->arch ());
 407
 408   init_address_spaces ();
 409
 410   if (shared_aspace)
 411     {
 412       address_space_ref_ptr aspace = new_address_space ();
 413
 414       for (struct program_space *pspace : program_spaces)
 415         pspace->aspace = aspace;
 416     }
 417   else
 418     for (struct program_space *pspace : program_spaces)
 419       pspace->aspace = new_address_space ();
 420
 421   for (inferior *inf : all_inferiors ())
 422     if (gdbarch_has_global_solist (current_inferior ()->arch ()))
 423       inf->aspace = maybe_new_address_space ();
 424     else
 425       inf->aspace = inf->pspace->aspace;
 426 }
 427
 428 \f
 429
 430 /* See progspace.h.  */
 431
 432 void
 433 program_space::clear_solib_cache ()
 434 {
 435   added_solibs.clear ();
 436   deleted_solibs.clear ();
 437 }
 438
 439 \f
 440
 441 void
 442 initialize_progspace (void)
 443 {
 444   add_cmd ("program-spaces", class_maintenance,
 445            maintenance_info_program_spaces_command,
 446            _("Info about currently known program spaces."),
 447            &maintenanceinfolist);
 448
 449   /* There's always one program space.  Note that this function isn't
 450      an automatic _initialize_foo function, since other
 451      _initialize_foo routines may need to install their per-pspace
 452      data keys.  We can only allocate a progspace when all those
 453      modules have done that.  Do this before
 454      initialize_current_architecture, because that accesses the ebfd
 455      of current_program_space.  */
 456   current_program_space = new program_space (new_address_space ());
 457 }