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