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 struct address_space *
  59 maybe_new_address_space (void)
  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 *aspace_)
  99   : num (++last_program_space_num),
 100     aspace (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   if (!gdbarch_has_shared_address_space (current_inferior ()->arch ()))
 126     delete this->aspace;
 127 }
 128
 129 /* See progspace.h.  */
 130
 131 void
 132 program_space::free_all_objfiles ()
 133 {
 134   /* Any objfile reference would become stale.  */
 135   for (const shobj &so : current_program_space->solibs ())
 136     gdb_assert (so.objfile == NULL);
 137
 138   while (!objfiles_list.empty ())
 139     objfiles_list.front ()->unlink ();
 140 }
 141
 142 /* See progspace.h.  */
 143
 144 void
 145 program_space::add_objfile (std::unique_ptr<objfile> &&objfile,
 146                             struct objfile *before)
 147 {
 148   if (before == nullptr)
 149     objfiles_list.push_back (std::move (objfile));
 150   else
 151     {
 152       auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 153                                 [=] (const std::unique_ptr<::objfile> &objf)
 154                                 {
 155                                   return objf.get () == before;
 156                                 });
 157       gdb_assert (iter != objfiles_list.end ());
 158       objfiles_list.insert (iter, std::move (objfile));
 159     }
 160 }
 161
 162 /* See progspace.h.  */
 163
 164 void
 165 program_space::remove_objfile (struct objfile *objfile)
 166 {
 167   /* Removing an objfile from the objfile list invalidates any frame
 168      that was built using frame info found in the objfile.  Reinit the
 169      frame cache to get rid of any frame that might otherwise
 170      reference stale info.  */
 171   reinit_frame_cache ();
 172
 173   auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 174                             [=] (const std::unique_ptr<::objfile> &objf)
 175                             {
 176                               return objf.get () == objfile;
 177                             });
 178   gdb_assert (iter != objfiles_list.end ());
 179   objfiles_list.erase (iter);
 180
 181   if (objfile == symfile_object_file)
 182     symfile_object_file = NULL;
 183 }
 184
 185 /* See progspace.h.  */
 186
 187 struct objfile *
 188 program_space::objfile_for_address (CORE_ADDR address)
 189 {
 190   for (auto iter : objfiles ())
 191     {
 192       /* Don't check separate debug objfiles.  */
 193       if (iter->separate_debug_objfile_backlink != nullptr)
 194         continue;
 195       if (is_addr_in_objfile (address, iter))
 196         return iter;
 197     }
 198   return nullptr;
 199 }
 200
 201 /* See progspace.h.  */
 202
 203 void
 204 program_space::exec_close ()
 205 {
 206   if (ebfd != nullptr)
 207     {
 208       /* Removing target sections may close the exec_ops target.
 209          Clear ebfd before doing so to prevent recursion.  */
 210       bfd *saved_ebfd = ebfd.get ();
 211       ebfd.reset (nullptr);
 212       ebfd_mtime = 0;
 213
 214       remove_target_sections (saved_ebfd);
 215
 216       exec_filename.reset (nullptr);
 217     }
 218 }
 219
 220 /* Copies program space SRC to DEST.  Copies the main executable file,
 221    and the main symbol file.  Returns DEST.  */
 222
 223 struct program_space *
 224 clone_program_space (struct program_space *dest, struct program_space *src)
 225 {
 226   scoped_restore_current_program_space restore_pspace;
 227
 228   set_current_program_space (dest);
 229
 230   if (src->exec_filename != NULL)
 231     exec_file_attach (src->exec_filename.get (), 0);
 232
 233   if (src->symfile_object_file != NULL)
 234     symbol_file_add_main (objfile_name (src->symfile_object_file),
 235                           SYMFILE_DEFER_BP_RESET);
 236
 237   return dest;
 238 }
 239
 240 /* Sets PSPACE as the current program space.  It is the caller's
 241    responsibility to make sure that the currently selected
 242    inferior/thread matches the selected program space.  */
 243
 244 void
 245 set_current_program_space (struct program_space *pspace)
 246 {
 247   if (current_program_space == pspace)
 248     return;
 249
 250   gdb_assert (pspace != NULL);
 251
 252   current_program_space = pspace;
 253
 254   /* Different symbols change our view of the frame chain.  */
 255   reinit_frame_cache ();
 256 }
 257
 258 /* Returns true iff there's no inferior bound to PSPACE.  */
 259
 260 bool
 261 program_space::empty ()
 262 {
 263   return find_inferior_for_program_space (this) == nullptr;
 264 }
 265
 266 /* Prints the list of program spaces and their details on UIOUT.  If
 267    REQUESTED is not -1, it's the ID of the pspace that should be
 268    printed.  Otherwise, all spaces are printed.  */
 269
 270 static void
 271 print_program_space (struct ui_out *uiout, int requested)
 272 {
 273   int count = 0;
 274
 275   /* Start with a minimum width of 17 for the executable name column.  */
 276   size_t longest_exec_name = 17;
 277
 278   /* Compute number of pspaces we will print.  */
 279   for (struct program_space *pspace : program_spaces)
 280     {
 281       if (requested != -1 && pspace->num != requested)
 282         continue;
 283
 284       if (pspace->exec_filename != nullptr)
 285         longest_exec_name = std::max (strlen (pspace->exec_filename.get ()),
 286                                       longest_exec_name);
 287
 288       ++count;
 289     }
 290
 291   /* There should always be at least one.  */
 292   gdb_assert (count > 0);
 293
 294   ui_out_emit_table table_emitter (uiout, 4, count, "pspaces");
 295   uiout->table_header (1, ui_left, "current", "");
 296   uiout->table_header (4, ui_left, "id", "Id");
 297   uiout->table_header (longest_exec_name, ui_left, "exec", "Executable");
 298   uiout->table_header (17, ui_left, "core", "Core File");
 299   uiout->table_body ();
 300
 301   for (struct program_space *pspace : program_spaces)
 302     {
 303       int printed_header;
 304
 305       if (requested != -1 && requested != pspace->num)
 306         continue;
 307
 308       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 309
 310       if (pspace == current_program_space)
 311         uiout->field_string ("current", "*");
 312       else
 313         uiout->field_skip ("current");
 314
 315       uiout->field_signed ("id", pspace->num);
 316
 317       if (pspace->exec_filename != nullptr)
 318         uiout->field_string ("exec", pspace->exec_filename.get (),
 319                              file_name_style.style ());
 320       else
 321         uiout->field_skip ("exec");
 322
 323       if (pspace->cbfd != nullptr)
 324         uiout->field_string ("core", bfd_get_filename (pspace->cbfd.get ()),
 325                              file_name_style.style ());
 326       else
 327         uiout->field_skip ("core");
 328
 329       /* Print extra info that doesn't really fit in tabular form.
 330          Currently, we print the list of inferiors bound to a pspace.
 331          There can be more than one inferior bound to the same pspace,
 332          e.g., both parent/child inferiors in a vfork, or, on targets
 333          that share pspaces between inferiors.  */
 334       printed_header = 0;
 335
 336       /* We're going to switch inferiors.  */
 337       scoped_restore_current_thread restore_thread;
 338
 339       for (inferior *inf : all_inferiors ())
 340         if (inf->pspace == pspace)
 341           {
 342             /* Switch to inferior in order to call target methods.  */
 343             switch_to_inferior_no_thread (inf);
 344
 345             if (!printed_header)
 346               {
 347                 printed_header = 1;
 348                 gdb_printf ("\n\tBound inferiors: ID %d (%s)",
 349                             inf->num,
 350                             target_pid_to_str (ptid_t (inf->pid)).c_str ());
 351               }
 352             else
 353               gdb_printf (", ID %d (%s)",
 354                           inf->num,
 355                           target_pid_to_str (ptid_t (inf->pid)).c_str ());
 356           }
 357
 358       uiout->text ("\n");
 359     }
 360 }
 361
 362 /* Boolean test for an already-known program space id.  */
 363
 364 static int
 365 valid_program_space_id (int num)
 366 {
 367   for (struct program_space *pspace : program_spaces)
 368     if (pspace->num == num)
 369       return 1;
 370
 371   return 0;
 372 }
 373
 374 /* If ARGS is NULL or empty, print information about all program
 375    spaces.  Otherwise, ARGS is a text representation of a LONG
 376    indicating which the program space to print information about.  */
 377
 378 static void
 379 maintenance_info_program_spaces_command (const char *args, int from_tty)
 380 {
 381   int requested = -1;
 382
 383   if (args && *args)
 384     {
 385       requested = parse_and_eval_long (args);
 386       if (!valid_program_space_id (requested))
 387         error (_("program space ID %d not known."), requested);
 388     }
 389
 390   print_program_space (current_uiout, requested);
 391 }
 392
 393 /* Update all program spaces matching to address spaces.  The user may
 394    have created several program spaces, and loaded executables into
 395    them before connecting to the target interface that will create the
 396    inferiors.  All that happens before GDB has a chance to know if the
 397    inferiors will share an address space or not.  Call this after
 398    having connected to the target interface and having fetched the
 399    target description, to fixup the program/address spaces mappings.
 400
 401    It is assumed that there are no bound inferiors yet, otherwise,
 402    they'd be left with stale referenced to released aspaces.  */
 403
 404 void
 405 update_address_spaces (void)
 406 {
 407   int shared_aspace
 408     = gdbarch_has_shared_address_space (current_inferior ()->arch ());
 409
 410   init_address_spaces ();
 411
 412   if (shared_aspace)
 413     {
 414       struct address_space *aspace = new address_space ();
 415
 416       delete current_program_space->aspace;
 417       for (struct program_space *pspace : program_spaces)
 418         pspace->aspace = aspace;
 419     }
 420   else
 421     for (struct program_space *pspace : program_spaces)
 422       {
 423         delete pspace->aspace;
 424         pspace->aspace = new address_space ();
 425       }
 426
 427   for (inferior *inf : all_inferiors ())
 428     if (gdbarch_has_global_solist (current_inferior ()->arch ()))
 429       inf->aspace = maybe_new_address_space ();
 430     else
 431       inf->aspace = inf->pspace->aspace;
 432 }
 433
 434 \f
 435
 436 /* See progspace.h.  */
 437
 438 void
 439 program_space::clear_solib_cache ()
 440 {
 441   added_solibs.clear ();
 442   deleted_solibs.clear ();
 443 }
 444
 445 \f
 446
 447 void
 448 initialize_progspace (void)
 449 {
 450   add_cmd ("program-spaces", class_maintenance,
 451            maintenance_info_program_spaces_command,
 452            _("Info about currently known program spaces."),
 453            &maintenanceinfolist);
 454
 455   /* There's always one program space.  Note that this function isn't
 456      an automatic _initialize_foo function, since other
 457      _initialize_foo routines may need to install their per-pspace
 458      data keys.  We can only allocate a progspace when all those
 459      modules have done that.  Do this before
 460      initialize_current_architecture, because that accesses the ebfd
 461      of current_program_space.  */
 462   current_program_space = new program_space (new address_space ());
 463 }