gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009-2020 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
  31 /* The last program space number assigned.  */
  32 int last_program_space_num = 0;
  33
  34 /* The head of the program spaces list.  */
  35 struct program_space *program_spaces;
  36
  37 /* Pointer to the current program space.  */
  38 struct program_space *current_program_space;
  39
  40 /* The last address space number assigned.  */
  41 static int highest_address_space_num;
  42
  43 \f
  44
  45 /* Keep a registry of per-program_space data-pointers required by other GDB
  46    modules.  */
  47
  48 DEFINE_REGISTRY (program_space, REGISTRY_ACCESS_FIELD)
  49
  50 /* Keep a registry of per-address_space data-pointers required by other GDB
  51    modules.  */
  52
  53 DEFINE_REGISTRY (address_space, REGISTRY_ACCESS_FIELD)
  54
  55 \f
  56
  57 /* Create a new address space object, and add it to the list.  */
  58
  59 struct address_space *
  60 new_address_space (void)
  61 {
  62   struct address_space *aspace;
  63
  64   aspace = XCNEW (struct address_space);
  65   aspace->num = ++highest_address_space_num;
  66   address_space_alloc_data (aspace);
  67
  68   return aspace;
  69 }
  70
  71 /* Maybe create a new address space object, and add it to the list, or
  72    return a pointer to an existing address space, in case inferiors
  73    share an address space on this target system.  */
  74
  75 struct address_space *
  76 maybe_new_address_space (void)
  77 {
  78   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
  79
  80   if (shared_aspace)
  81     {
  82       /* Just return the first in the list.  */
  83       return program_spaces->aspace;
  84     }
  85
  86   return new_address_space ();
  87 }
  88
  89 static void
  90 free_address_space (struct address_space *aspace)
  91 {
  92   address_space_free_data (aspace);
  93   xfree (aspace);
  94 }
  95
  96 int
  97 address_space_num (struct address_space *aspace)
  98 {
  99   return aspace->num;
 100 }
 101
 102 /* Start counting over from scratch.  */
 103
 104 static void
 105 init_address_spaces (void)
 106 {
 107   highest_address_space_num = 0;
 108 }
 109
 110 \f
 111
 112 /* Adds a new empty program space to the program space list, and binds
 113    it to ASPACE.  Returns the pointer to the new object.  */
 114
 115 program_space::program_space (address_space *aspace_)
 116 : num (++last_program_space_num), aspace (aspace_)
 117 {
 118   program_space_alloc_data (this);
 119
 120   if (program_spaces == NULL)
 121     program_spaces = this;
 122   else
 123     {
 124       struct program_space *last;
 125
 126       for (last = program_spaces; last->next != NULL; last = last->next)
 127         ;
 128       last->next = this;
 129     }
 130 }
 131
 132 /* Releases program space PSPACE, and all its contents (shared
 133    libraries, objfiles, and any other references to the PSPACE in
 134    other modules).  It is an internal error to call this when PSPACE
 135    is the current program space, since there should always be a
 136    program space.  */
 137
 138 program_space::~program_space ()
 139 {
 140   gdb_assert (this != current_program_space);
 141
 142   scoped_restore_current_program_space restore_pspace;
 143
 144   set_current_program_space (this);
 145
 146   breakpoint_program_space_exit (this);
 147   no_shared_libraries (NULL, 0);
 148   exec_close ();
 149   free_all_objfiles ();
 150   /* Defer breakpoint re-set because we don't want to create new
 151      locations for this pspace which we're tearing down.  */
 152   clear_symtab_users (SYMFILE_DEFER_BP_RESET);
 153   if (!gdbarch_has_shared_address_space (target_gdbarch ()))
 154     free_address_space (this->aspace);
 155   clear_section_table (&this->target_sections);
 156   clear_program_space_solib_cache (this);
 157     /* Discard any data modules have associated with the PSPACE.  */
 158   program_space_free_data (this);
 159 }
 160
 161 /* See progspace.h.  */
 162
 163 void
 164 program_space::free_all_objfiles ()
 165 {
 166   struct so_list *so;
 167
 168   /* Any objfile reference would become stale.  */
 169   for (so = master_so_list (); so; so = so->next)
 170     gdb_assert (so->objfile == NULL);
 171
 172   while (!objfiles_list.empty ())
 173     objfiles_list.front ()->unlink ();
 174 }
 175
 176 /* See progspace.h.  */
 177
 178 void
 179 program_space::add_objfile (std::shared_ptr<objfile> &&objfile,
 180                             struct objfile *before)
 181 {
 182   if (before == nullptr)
 183     objfiles_list.push_back (std::move (objfile));
 184   else
 185     {
 186       auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 187                                 [=] (const std::shared_ptr<::objfile> &objf)
 188                                 {
 189                                   return objf.get () == before;
 190                                 });
 191       gdb_assert (iter != objfiles_list.end ());
 192       objfiles_list.insert (iter, std::move (objfile));
 193     }
 194 }
 195
 196 /* See progspace.h.  */
 197
 198 void
 199 program_space::remove_objfile (struct objfile *objfile)
 200 {
 201   auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (),
 202                             [=] (const std::shared_ptr<::objfile> &objf)
 203                             {
 204                               return objf.get () == objfile;
 205                             });
 206   gdb_assert (iter != objfiles_list.end ());
 207   objfiles_list.erase (iter);
 208
 209   if (objfile == symfile_object_file)
 210     symfile_object_file = NULL;
 211 }
 212
 213 /* Copies program space SRC to DEST.  Copies the main executable file,
 214    and the main symbol file.  Returns DEST.  */
 215
 216 struct program_space *
 217 clone_program_space (struct program_space *dest, struct program_space *src)
 218 {
 219   scoped_restore_current_program_space restore_pspace;
 220
 221   set_current_program_space (dest);
 222
 223   if (src->pspace_exec_filename != NULL)
 224     exec_file_attach (src->pspace_exec_filename, 0);
 225
 226   if (src->symfile_object_file != NULL)
 227     symbol_file_add_main (objfile_name (src->symfile_object_file),
 228                           SYMFILE_DEFER_BP_RESET);
 229
 230   return dest;
 231 }
 232
 233 /* Sets PSPACE as the current program space.  It is the caller's
 234    responsibility to make sure that the currently selected
 235    inferior/thread matches the selected program space.  */
 236
 237 void
 238 set_current_program_space (struct program_space *pspace)
 239 {
 240   if (current_program_space == pspace)
 241     return;
 242
 243   gdb_assert (pspace != NULL);
 244
 245   current_program_space = pspace;
 246
 247   /* Different symbols change our view of the frame chain.  */
 248   reinit_frame_cache ();
 249 }
 250
 251 /* Returns true iff there's no inferior bound to PSPACE.  */
 252
 253 int
 254 program_space_empty_p (struct program_space *pspace)
 255 {
 256   if (find_inferior_for_program_space (pspace) != NULL)
 257       return 0;
 258
 259   return 1;
 260 }
 261
 262 /* Remove a program space from the program spaces list and release it.  It is
 263    an error to call this function while PSPACE is the current program space. */
 264
 265 void
 266 delete_program_space (struct program_space *pspace)
 267 {
 268   struct program_space *ss, **ss_link;
 269   gdb_assert (pspace != NULL);
 270   gdb_assert (pspace != current_program_space);
 271
 272   ss = program_spaces;
 273   ss_link = &program_spaces;
 274   while (ss != NULL)
 275     {
 276       if (ss == pspace)
 277         {
 278           *ss_link = ss->next;
 279           break;
 280         }
 281
 282       ss_link = &ss->next;
 283       ss = *ss_link;
 284     }
 285
 286   delete pspace;
 287 }
 288
 289 /* Prints the list of program spaces and their details on UIOUT.  If
 290    REQUESTED is not -1, it's the ID of the pspace that should be
 291    printed.  Otherwise, all spaces are printed.  */
 292
 293 static void
 294 print_program_space (struct ui_out *uiout, int requested)
 295 {
 296   struct program_space *pspace;
 297   int count = 0;
 298
 299   /* Compute number of pspaces we will print.  */
 300   ALL_PSPACES (pspace)
 301     {
 302       if (requested != -1 && pspace->num != requested)
 303         continue;
 304
 305       ++count;
 306     }
 307
 308   /* There should always be at least one.  */
 309   gdb_assert (count > 0);
 310
 311   ui_out_emit_table table_emitter (uiout, 3, count, "pspaces");
 312   uiout->table_header (1, ui_left, "current", "");
 313   uiout->table_header (4, ui_left, "id", "Id");
 314   uiout->table_header (17, ui_left, "exec", "Executable");
 315   uiout->table_body ();
 316
 317   ALL_PSPACES (pspace)
 318     {
 319       struct inferior *inf;
 320       int printed_header;
 321
 322       if (requested != -1 && requested != pspace->num)
 323         continue;
 324
 325       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 326
 327       if (pspace == current_program_space)
 328         uiout->field_string ("current", "*");
 329       else
 330         uiout->field_skip ("current");
 331
 332       uiout->field_signed ("id", pspace->num);
 333
 334       if (pspace->pspace_exec_filename)
 335         uiout->field_string ("exec", pspace->pspace_exec_filename);
 336       else
 337         uiout->field_skip ("exec");
 338
 339       /* Print extra info that doesn't really fit in tabular form.
 340          Currently, we print the list of inferiors bound to a pspace.
 341          There can be more than one inferior bound to the same pspace,
 342          e.g., both parent/child inferiors in a vfork, or, on targets
 343          that share pspaces between inferiors.  */
 344       printed_header = 0;
 345       for (inf = inferior_list; inf; inf = inf->next)
 346         if (inf->pspace == pspace)
 347           {
 348             if (!printed_header)
 349               {
 350                 printed_header = 1;
 351                 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
 352                                  inf->num,
 353                                  target_pid_to_str (ptid_t (inf->pid)).c_str ());
 354               }
 355             else
 356               printf_filtered (", ID %d (%s)",
 357                                inf->num,
 358                                target_pid_to_str (ptid_t (inf->pid)).c_str ());
 359           }
 360
 361       uiout->text ("\n");
 362     }
 363 }
 364
 365 /* Boolean test for an already-known program space id.  */
 366
 367 static int
 368 valid_program_space_id (int num)
 369 {
 370   struct program_space *pspace;
 371
 372   ALL_PSPACES (pspace)
 373     if (pspace->num == num)
 374       return 1;
 375
 376   return 0;
 377 }
 378
 379 /* If ARGS is NULL or empty, print information about all program
 380    spaces.  Otherwise, ARGS is a text representation of a LONG
 381    indicating which the program space to print information about.  */
 382
 383 static void
 384 maintenance_info_program_spaces_command (const char *args, int from_tty)
 385 {
 386   int requested = -1;
 387
 388   if (args && *args)
 389     {
 390       requested = parse_and_eval_long (args);
 391       if (!valid_program_space_id (requested))
 392         error (_("program space ID %d not known."), requested);
 393     }
 394
 395   print_program_space (current_uiout, requested);
 396 }
 397
 398 /* Simply returns the count of program spaces.  */
 399
 400 int
 401 number_of_program_spaces (void)
 402 {
 403   struct program_space *pspace;
 404   int count = 0;
 405
 406   ALL_PSPACES (pspace)
 407     count++;
 408
 409   return count;
 410 }
 411
 412 /* Update all program spaces matching to address spaces.  The user may
 413    have created several program spaces, and loaded executables into
 414    them before connecting to the target interface that will create the
 415    inferiors.  All that happens before GDB has a chance to know if the
 416    inferiors will share an address space or not.  Call this after
 417    having connected to the target interface and having fetched the
 418    target description, to fixup the program/address spaces mappings.
 419
 420    It is assumed that there are no bound inferiors yet, otherwise,
 421    they'd be left with stale referenced to released aspaces.  */
 422
 423 void
 424 update_address_spaces (void)
 425 {
 426   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
 427   struct program_space *pspace;
 428   struct inferior *inf;
 429
 430   init_address_spaces ();
 431
 432   if (shared_aspace)
 433     {
 434       struct address_space *aspace = new_address_space ();
 435
 436       free_address_space (current_program_space->aspace);
 437       ALL_PSPACES (pspace)
 438         pspace->aspace = aspace;
 439     }
 440   else
 441     ALL_PSPACES (pspace)
 442       {
 443         free_address_space (pspace->aspace);
 444         pspace->aspace = new_address_space ();
 445       }
 446
 447   for (inf = inferior_list; inf; inf = inf->next)
 448     if (gdbarch_has_global_solist (target_gdbarch ()))
 449       inf->aspace = maybe_new_address_space ();
 450     else
 451       inf->aspace = inf->pspace->aspace;
 452 }
 453
 454 \f
 455
 456 /* See progspace.h.  */
 457
 458 void
 459 clear_program_space_solib_cache (struct program_space *pspace)
 460 {
 461   pspace->added_solibs.clear ();
 462   pspace->deleted_solibs.clear ();
 463 }
 464
 465 \f
 466
 467 void
 468 initialize_progspace (void)
 469 {
 470   add_cmd ("program-spaces", class_maintenance,
 471            maintenance_info_program_spaces_command,
 472            _("Info about currently known program spaces."),
 473            &maintenanceinfolist);
 474
 475   /* There's always one program space.  Note that this function isn't
 476      an automatic _initialize_foo function, since other
 477      _initialize_foo routines may need to install their per-pspace
 478      data keys.  We can only allocate a progspace when all those
 479      modules have done that.  Do this before
 480      initialize_current_architecture, because that accesses exec_bfd,
 481      which in turn dereferences current_program_space.  */
 482   current_program_space = new program_space (new_address_space ());
 483 }