gdb/progspace.c

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