gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009-2014 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
  28 /* The last program space number assigned.  */
  29 int last_program_space_num = 0;
  30
  31 /* The head of the program spaces list.  */
  32 struct program_space *program_spaces;
  33
  34 /* Pointer to the current program space.  */
  35 struct program_space *current_program_space;
  36
  37 /* The last address space number assigned.  */
  38 static int highest_address_space_num;
  39
  40 \f
  41
  42 /* Keep a registry of per-program_space data-pointers required by other GDB
  43    modules.  */
  44
  45 DEFINE_REGISTRY (program_space, REGISTRY_ACCESS_FIELD)
  46
  47 /* An address space.  It is used for comparing if pspaces/inferior/threads
  48    see the same address space and for associating caches to each address
  49    space.  */
  50
  51 struct address_space
  52 {
  53   int num;
  54
  55   /* Per aspace data-pointers required by other GDB modules.  */
  56   REGISTRY_FIELDS;
  57 };
  58
  59 /* Keep a registry of per-address_space data-pointers required by other GDB
  60    modules.  */
  61
  62 DEFINE_REGISTRY (address_space, REGISTRY_ACCESS_FIELD)
  63
  64 \f
  65
  66 /* Create a new address space object, and add it to the list.  */
  67
  68 struct address_space *
  69 new_address_space (void)
  70 {
  71   struct address_space *aspace;
  72
  73   aspace = XCNEW (struct address_space);
  74   aspace->num = ++highest_address_space_num;
  75   address_space_alloc_data (aspace);
  76
  77   return aspace;
  78 }
  79
  80 /* Maybe create a new address space object, and add it to the list, or
  81    return a pointer to an existing address space, in case inferiors
  82    share an address space on this target system.  */
  83
  84 struct address_space *
  85 maybe_new_address_space (void)
  86 {
  87   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
  88
  89   if (shared_aspace)
  90     {
  91       /* Just return the first in the list.  */
  92       return program_spaces->aspace;
  93     }
  94
  95   return new_address_space ();
  96 }
  97
  98 static void
  99 free_address_space (struct address_space *aspace)
 100 {
 101   address_space_free_data (aspace);
 102   xfree (aspace);
 103 }
 104
 105 int
 106 address_space_num (struct address_space *aspace)
 107 {
 108   return aspace->num;
 109 }
 110
 111 /* Start counting over from scratch.  */
 112
 113 static void
 114 init_address_spaces (void)
 115 {
 116   highest_address_space_num = 0;
 117 }
 118
 119 \f
 120
 121 /* Adds a new empty program space to the program space list, and binds
 122    it to ASPACE.  Returns the pointer to the new object.  */
 123
 124 struct program_space *
 125 add_program_space (struct address_space *aspace)
 126 {
 127   struct program_space *pspace;
 128
 129   pspace = XCNEW (struct program_space);
 130
 131   pspace->num = ++last_program_space_num;
 132   pspace->aspace = aspace;
 133
 134   program_space_alloc_data (pspace);
 135
 136   pspace->next = program_spaces;
 137   program_spaces = pspace;
 138
 139   return pspace;
 140 }
 141
 142 /* Releases program space PSPACE, and all its contents (shared
 143    libraries, objfiles, and any other references to the PSPACE in
 144    other modules).  It is an internal error to call this when PSPACE
 145    is the current program space, since there should always be a
 146    program space.  */
 147
 148 static void
 149 release_program_space (struct program_space *pspace)
 150 {
 151   struct cleanup *old_chain = save_current_program_space ();
 152
 153   gdb_assert (pspace != current_program_space);
 154
 155   set_current_program_space (pspace);
 156
 157   breakpoint_program_space_exit (pspace);
 158   no_shared_libraries (NULL, 0);
 159   exec_close ();
 160   free_all_objfiles ();
 161   if (!gdbarch_has_shared_address_space (target_gdbarch ()))
 162     free_address_space (pspace->aspace);
 163   resize_section_table (&pspace->target_sections,
 164                         -resize_section_table (&pspace->target_sections, 0));
 165   clear_program_space_solib_cache (pspace);
 166     /* Discard any data modules have associated with the PSPACE.  */
 167   program_space_free_data (pspace);
 168   xfree (pspace);
 169
 170   do_cleanups (old_chain);
 171 }
 172
 173 /* Copies program space SRC to DEST.  Copies the main executable file,
 174    and the main symbol file.  Returns DEST.  */
 175
 176 struct program_space *
 177 clone_program_space (struct program_space *dest, struct program_space *src)
 178 {
 179   struct cleanup *old_chain;
 180
 181   old_chain = save_current_program_space ();
 182
 183   set_current_program_space (dest);
 184
 185   if (src->pspace_exec_filename != NULL)
 186     exec_file_attach (src->pspace_exec_filename, 0);
 187
 188   if (src->symfile_object_file != NULL)
 189     symbol_file_add_main (objfile_name (src->symfile_object_file), 0);
 190
 191   do_cleanups (old_chain);
 192   return dest;
 193 }
 194
 195 /* Sets PSPACE as the current program space.  It is the caller's
 196    responsibility to make sure that the currently selected
 197    inferior/thread matches the selected program space.  */
 198
 199 void
 200 set_current_program_space (struct program_space *pspace)
 201 {
 202   if (current_program_space == pspace)
 203     return;
 204
 205   gdb_assert (pspace != NULL);
 206
 207   current_program_space = pspace;
 208
 209   /* Different symbols change our view of the frame chain.  */
 210   reinit_frame_cache ();
 211 }
 212
 213 /* A cleanups callback, helper for save_current_program_space
 214    below.  */
 215
 216 static void
 217 restore_program_space (void *arg)
 218 {
 219   struct program_space *saved_pspace = arg;
 220
 221   set_current_program_space (saved_pspace);
 222 }
 223
 224 /* Save the current program space so that it may be restored by a later
 225    call to do_cleanups.  Returns the struct cleanup pointer needed for
 226    later doing the cleanup.  */
 227
 228 struct cleanup *
 229 save_current_program_space (void)
 230 {
 231   struct cleanup *old_chain = make_cleanup (restore_program_space,
 232                                             current_program_space);
 233
 234   return old_chain;
 235 }
 236
 237 /* Returns true iff there's no inferior bound to PSPACE.  */
 238
 239 static int
 240 pspace_empty_p (struct program_space *pspace)
 241 {
 242   if (find_inferior_for_program_space (pspace) != NULL)
 243       return 0;
 244
 245   return 1;
 246 }
 247
 248 /* Prune away automatically added program spaces that aren't required
 249    anymore.  */
 250
 251 void
 252 prune_program_spaces (void)
 253 {
 254   struct program_space *ss, **ss_link;
 255   struct program_space *current = current_program_space;
 256
 257   ss = program_spaces;
 258   ss_link = &program_spaces;
 259   while (ss)
 260     {
 261       if (ss == current || !pspace_empty_p (ss))
 262         {
 263           ss_link = &ss->next;
 264           ss = *ss_link;
 265           continue;
 266         }
 267
 268       *ss_link = ss->next;
 269       release_program_space (ss);
 270       ss = *ss_link;
 271     }
 272 }
 273
 274 /* Prints the list of program spaces and their details on UIOUT.  If
 275    REQUESTED is not -1, it's the ID of the pspace that should be
 276    printed.  Otherwise, all spaces are printed.  */
 277
 278 static void
 279 print_program_space (struct ui_out *uiout, int requested)
 280 {
 281   struct program_space *pspace;
 282   int count = 0;
 283   struct cleanup *old_chain;
 284
 285   /* Might as well prune away unneeded ones, so the user doesn't even
 286      seem them.  */
 287   prune_program_spaces ();
 288
 289   /* Compute number of pspaces we will print.  */
 290   ALL_PSPACES (pspace)
 291     {
 292       if (requested != -1 && pspace->num != requested)
 293         continue;
 294
 295       ++count;
 296     }
 297
 298   /* There should always be at least one.  */
 299   gdb_assert (count > 0);
 300
 301   old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
 302   ui_out_table_header (uiout, 1, ui_left, "current", "");
 303   ui_out_table_header (uiout, 4, ui_left, "id", "Id");
 304   ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
 305   ui_out_table_body (uiout);
 306
 307   ALL_PSPACES (pspace)
 308     {
 309       struct cleanup *chain2;
 310       struct inferior *inf;
 311       int printed_header;
 312
 313       if (requested != -1 && requested != pspace->num)
 314         continue;
 315
 316       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 317
 318       if (pspace == current_program_space)
 319         ui_out_field_string (uiout, "current", "*");
 320       else
 321         ui_out_field_skip (uiout, "current");
 322
 323       ui_out_field_int (uiout, "id", pspace->num);
 324
 325       if (pspace->pspace_exec_filename)
 326         ui_out_field_string (uiout, "exec", pspace->pspace_exec_filename);
 327       else
 328         ui_out_field_skip (uiout, "exec");
 329
 330       /* Print extra info that doesn't really fit in tabular form.
 331          Currently, we print the list of inferiors bound to a pspace.
 332          There can be more than one inferior bound to the same pspace,
 333          e.g., both parent/child inferiors in a vfork, or, on targets
 334          that share pspaces between inferiors.  */
 335       printed_header = 0;
 336       for (inf = inferior_list; inf; inf = inf->next)
 337         if (inf->pspace == pspace)
 338           {
 339             if (!printed_header)
 340               {
 341                 printed_header = 1;
 342                 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
 343                                  inf->num,
 344                                  target_pid_to_str (pid_to_ptid (inf->pid)));
 345               }
 346             else
 347               printf_filtered (", ID %d (%s)",
 348                                inf->num,
 349                                target_pid_to_str (pid_to_ptid (inf->pid)));
 350           }
 351
 352       ui_out_text (uiout, "\n");
 353       do_cleanups (chain2);
 354     }
 355
 356   do_cleanups (old_chain);
 357 }
 358
 359 /* Boolean test for an already-known program space id.  */
 360
 361 static int
 362 valid_program_space_id (int num)
 363 {
 364   struct program_space *pspace;
 365
 366   ALL_PSPACES (pspace)
 367     if (pspace->num == num)
 368       return 1;
 369
 370   return 0;
 371 }
 372
 373 /* If ARGS is NULL or empty, print information about all program
 374    spaces.  Otherwise, ARGS is a text representation of a LONG
 375    indicating which the program space to print information about.  */
 376
 377 static void
 378 maintenance_info_program_spaces_command (char *args, int from_tty)
 379 {
 380   int requested = -1;
 381
 382   if (args && *args)
 383     {
 384       requested = parse_and_eval_long (args);
 385       if (!valid_program_space_id (requested))
 386         error (_("program space ID %d not known."), requested);
 387     }
 388
 389   print_program_space (current_uiout, requested);
 390 }
 391
 392 /* Simply returns the count of program spaces.  */
 393
 394 int
 395 number_of_program_spaces (void)
 396 {
 397   struct program_space *pspace;
 398   int count = 0;
 399
 400   ALL_PSPACES (pspace)
 401     count++;
 402
 403   return count;
 404 }
 405
 406 /* Update all program spaces matching to address spaces.  The user may
 407    have created several program spaces, and loaded executables into
 408    them before connecting to the target interface that will create the
 409    inferiors.  All that happens before GDB has a chance to know if the
 410    inferiors will share an address space or not.  Call this after
 411    having connected to the target interface and having fetched the
 412    target description, to fixup the program/address spaces mappings.
 413
 414    It is assumed that there are no bound inferiors yet, otherwise,
 415    they'd be left with stale referenced to released aspaces.  */
 416
 417 void
 418 update_address_spaces (void)
 419 {
 420   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
 421   struct program_space *pspace;
 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       ALL_PSPACES (pspace)
 432         pspace->aspace = aspace;
 433     }
 434   else
 435     ALL_PSPACES (pspace)
 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 /* Save the current program space so that it may be restored by a later
 449    call to do_cleanups.  Returns the struct cleanup pointer needed for
 450    later doing the cleanup.  */
 451
 452 struct cleanup *
 453 save_current_space_and_thread (void)
 454 {
 455   struct cleanup *old_chain;
 456
 457   /* If restoring to null thread, we need to restore the pspace as
 458      well, hence, we need to save the current program space first.  */
 459   old_chain = save_current_program_space ();
 460   /* There's no need to save the current inferior here.
 461      That is handled by make_cleanup_restore_current_thread.  */
 462   make_cleanup_restore_current_thread ();
 463
 464   return old_chain;
 465 }
 466
 467 /* Switches full context to program space PSPACE.  Switches to the
 468    first thread found bound to PSPACE.  */
 469
 470 void
 471 switch_to_program_space_and_thread (struct program_space *pspace)
 472 {
 473   struct inferior *inf;
 474
 475   inf = find_inferior_for_program_space (pspace);
 476   if (inf != NULL)
 477     {
 478       struct thread_info *tp;
 479
 480       tp = any_live_thread_of_process (inf->pid);
 481       if (tp != NULL)
 482         {
 483           switch_to_thread (tp->ptid);
 484           /* Switching thread switches pspace implicitly.  We're
 485              done.  */
 486           return;
 487         }
 488     }
 489
 490   switch_to_thread (null_ptid);
 491   set_current_program_space (pspace);
 492 }
 493
 494 \f
 495
 496 /* See progspace.h.  */
 497
 498 void
 499 clear_program_space_solib_cache (struct program_space *pspace)
 500 {
 501   VEC_free (so_list_ptr, pspace->added_solibs);
 502
 503   free_char_ptr_vec (pspace->deleted_solibs);
 504   pspace->deleted_solibs = NULL;
 505 }
 506
 507 \f
 508
 509 void
 510 initialize_progspace (void)
 511 {
 512   add_cmd ("program-spaces", class_maintenance,
 513            maintenance_info_program_spaces_command,
 514            _("Info about currently known program spaces."),
 515            &maintenanceinfolist);
 516
 517   /* There's always one program space.  Note that this function isn't
 518      an automatic _initialize_foo function, since other
 519      _initialize_foo routines may need to install their per-pspace
 520      data keys.  We can only allocate a progspace when all those
 521      modules have done that.  Do this before
 522      initialize_current_architecture, because that accesses exec_bfd,
 523      which in turn dereferences current_program_space.  */
 524   current_program_space = add_program_space (new_address_space ());
 525 }