gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009-2012 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)
  46
  47 \f
  48
  49 /* An address space.  Currently this is not used for much other than
  50    for comparing if pspaces/inferior/threads see the same address
  51    space.  */
  52
  53 struct address_space
  54 {
  55   int num;
  56 };
  57
  58 /* Create a new address space object, and add it to the list.  */
  59
  60 struct address_space *
  61 new_address_space (void)
  62 {
  63   struct address_space *aspace;
  64
  65   aspace = XZALLOC (struct address_space);
  66   aspace->num = ++highest_address_space_num;
  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   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 struct program_space *
 115 add_program_space (struct address_space *aspace)
 116 {
 117   struct program_space *pspace;
 118
 119   pspace = XZALLOC (struct program_space);
 120
 121   pspace->num = ++last_program_space_num;
 122   pspace->aspace = aspace;
 123
 124   program_space_alloc_data (pspace);
 125
 126   pspace->next = program_spaces;
 127   program_spaces = pspace;
 128
 129   return pspace;
 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 static void
 139 release_program_space (struct program_space *pspace)
 140 {
 141   struct cleanup *old_chain = save_current_program_space ();
 142
 143   gdb_assert (pspace != current_program_space);
 144
 145   set_current_program_space (pspace);
 146
 147   breakpoint_program_space_exit (pspace);
 148   no_shared_libraries (NULL, 0);
 149   exec_close ();
 150   free_all_objfiles ();
 151   if (!gdbarch_has_shared_address_space (target_gdbarch))
 152     free_address_space (pspace->aspace);
 153   resize_section_table (&pspace->target_sections,
 154                         -resize_section_table (&pspace->target_sections, 0));
 155   clear_program_space_solib_cache (pspace);
 156     /* Discard any data modules have associated with the PSPACE.  */
 157   program_space_free_data (pspace);
 158   xfree (pspace);
 159
 160   do_cleanups (old_chain);
 161 }
 162
 163 /* Unlinks PSPACE from the pspace list, and releases it.  */
 164
 165 void
 166 remove_program_space (struct program_space *pspace)
 167 {
 168   struct program_space *ss, **ss_link;
 169
 170   ss = program_spaces;
 171   ss_link = &program_spaces;
 172   while (ss)
 173     {
 174       if (ss != pspace)
 175         {
 176           ss_link = &ss->next;
 177           ss = *ss_link;
 178           continue;
 179         }
 180
 181       *ss_link = ss->next;
 182       release_program_space (ss);
 183       ss = *ss_link;
 184     }
 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   struct cleanup *old_chain;
 194
 195   old_chain = save_current_program_space ();
 196
 197   set_current_program_space (dest);
 198
 199   if (src->ebfd != NULL)
 200     exec_file_attach (bfd_get_filename (src->ebfd), 0);
 201
 202   if (src->symfile_object_file != NULL)
 203     symbol_file_add_main (src->symfile_object_file->name, 0);
 204
 205   do_cleanups (old_chain);
 206   return dest;
 207 }
 208
 209 /* Sets PSPACE as the current program space.  It is the caller's
 210    responsibility to make sure that the currently selected
 211    inferior/thread matches the selected program space.  */
 212
 213 void
 214 set_current_program_space (struct program_space *pspace)
 215 {
 216   if (current_program_space == pspace)
 217     return;
 218
 219   gdb_assert (pspace != NULL);
 220
 221   current_program_space = pspace;
 222
 223   /* Different symbols change our view of the frame chain.  */
 224   reinit_frame_cache ();
 225 }
 226
 227 /* A cleanups callback, helper for save_current_program_space
 228    below.  */
 229
 230 static void
 231 restore_program_space (void *arg)
 232 {
 233   struct program_space *saved_pspace = arg;
 234
 235   set_current_program_space (saved_pspace);
 236 }
 237
 238 /* Save the current program space so that it may be restored by a later
 239    call to do_cleanups.  Returns the struct cleanup pointer needed for
 240    later doing the cleanup.  */
 241
 242 struct cleanup *
 243 save_current_program_space (void)
 244 {
 245   struct cleanup *old_chain = make_cleanup (restore_program_space,
 246                                             current_program_space);
 247
 248   return old_chain;
 249 }
 250
 251 /* Returns true iff there's no inferior bound to PSPACE.  */
 252
 253 static int
 254 pspace_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 /* Prune away automatically added program spaces that aren't required
 263    anymore.  */
 264
 265 void
 266 prune_program_spaces (void)
 267 {
 268   struct program_space *ss, **ss_link;
 269   struct program_space *current = current_program_space;
 270
 271   ss = program_spaces;
 272   ss_link = &program_spaces;
 273   while (ss)
 274     {
 275       if (ss == current || !pspace_empty_p (ss))
 276         {
 277           ss_link = &ss->next;
 278           ss = *ss_link;
 279           continue;
 280         }
 281
 282       *ss_link = ss->next;
 283       release_program_space (ss);
 284       ss = *ss_link;
 285     }
 286 }
 287
 288 /* Prints the list of program spaces and their details on UIOUT.  If
 289    REQUESTED is not -1, it's the ID of the pspace that should be
 290    printed.  Otherwise, all spaces are printed.  */
 291
 292 static void
 293 print_program_space (struct ui_out *uiout, int requested)
 294 {
 295   struct program_space *pspace;
 296   int count = 0;
 297   struct cleanup *old_chain;
 298
 299   /* Might as well prune away unneeded ones, so the user doesn't even
 300      seem them.  */
 301   prune_program_spaces ();
 302
 303   /* Compute number of pspaces we will print.  */
 304   ALL_PSPACES (pspace)
 305     {
 306       if (requested != -1 && pspace->num != requested)
 307         continue;
 308
 309       ++count;
 310     }
 311
 312   /* There should always be at least one.  */
 313   gdb_assert (count > 0);
 314
 315   old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
 316   ui_out_table_header (uiout, 1, ui_left, "current", "");
 317   ui_out_table_header (uiout, 4, ui_left, "id", "Id");
 318   ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
 319   ui_out_table_body (uiout);
 320
 321   ALL_PSPACES (pspace)
 322     {
 323       struct cleanup *chain2;
 324       struct inferior *inf;
 325       int printed_header;
 326
 327       if (requested != -1 && requested != pspace->num)
 328         continue;
 329
 330       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 331
 332       if (pspace == current_program_space)
 333         ui_out_field_string (uiout, "current", "*");
 334       else
 335         ui_out_field_skip (uiout, "current");
 336
 337       ui_out_field_int (uiout, "id", pspace->num);
 338
 339       if (pspace->ebfd)
 340         ui_out_field_string (uiout, "exec",
 341                              bfd_get_filename (pspace->ebfd));
 342       else
 343         ui_out_field_skip (uiout, "exec");
 344
 345       /* Print extra info that doesn't really fit in tabular form.
 346          Currently, we print the list of inferiors bound to a pspace.
 347          There can be more than one inferior bound to the same pspace,
 348          e.g., both parent/child inferiors in a vfork, or, on targets
 349          that share pspaces between inferiors.  */
 350       printed_header = 0;
 351       for (inf = inferior_list; inf; inf = inf->next)
 352         if (inf->pspace == pspace)
 353           {
 354             if (!printed_header)
 355               {
 356                 printed_header = 1;
 357                 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
 358                                  inf->num,
 359                                  target_pid_to_str (pid_to_ptid (inf->pid)));
 360               }
 361             else
 362               printf_filtered (", ID %d (%s)",
 363                                inf->num,
 364                                target_pid_to_str (pid_to_ptid (inf->pid)));
 365           }
 366
 367       ui_out_text (uiout, "\n");
 368       do_cleanups (chain2);
 369     }
 370
 371   do_cleanups (old_chain);
 372 }
 373
 374 /* Boolean test for an already-known program space id.  */
 375
 376 static int
 377 valid_program_space_id (int num)
 378 {
 379   struct program_space *pspace;
 380
 381   ALL_PSPACES (pspace)
 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 (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 /* Simply returns the count of program spaces.  */
 408
 409 int
 410 number_of_program_spaces (void)
 411 {
 412   struct program_space *pspace;
 413   int count = 0;
 414
 415   ALL_PSPACES (pspace)
 416     count++;
 417
 418   return count;
 419 }
 420
 421 /* Update all program spaces matching to address spaces.  The user may
 422    have created several program spaces, and loaded executables into
 423    them before connecting to the target interface that will create the
 424    inferiors.  All that happens before GDB has a chance to know if the
 425    inferiors will share an address space or not.  Call this after
 426    having connected to the target interface and having fetched the
 427    target description, to fixup the program/address spaces mappings.
 428
 429    It is assumed that there are no bound inferiors yet, otherwise,
 430    they'd be left with stale referenced to released aspaces.  */
 431
 432 void
 433 update_address_spaces (void)
 434 {
 435   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
 436   struct program_space *pspace;
 437   struct inferior *inf;
 438
 439   init_address_spaces ();
 440
 441   if (shared_aspace)
 442     {
 443       struct address_space *aspace = new_address_space ();
 444
 445       free_address_space (current_program_space->aspace);
 446       ALL_PSPACES (pspace)
 447         pspace->aspace = aspace;
 448     }
 449   else
 450     ALL_PSPACES (pspace)
 451       {
 452         free_address_space (pspace->aspace);
 453         pspace->aspace = new_address_space ();
 454       }
 455
 456   for (inf = inferior_list; inf; inf = inf->next)
 457     if (gdbarch_has_global_solist (target_gdbarch))
 458       inf->aspace = maybe_new_address_space ();
 459     else
 460       inf->aspace = inf->pspace->aspace;
 461 }
 462
 463 /* Save the current program space so that it may be restored by a later
 464    call to do_cleanups.  Returns the struct cleanup pointer needed for
 465    later doing the cleanup.  */
 466
 467 struct cleanup *
 468 save_current_space_and_thread (void)
 469 {
 470   struct cleanup *old_chain;
 471
 472   /* If restoring to null thread, we need to restore the pspace as
 473      well, hence, we need to save the current program space first.  */
 474   old_chain = save_current_program_space ();
 475   save_current_inferior ();
 476   make_cleanup_restore_current_thread ();
 477
 478   return old_chain;
 479 }
 480
 481 /* Switches full context to program space PSPACE.  Switches to the
 482    first thread found bound to PSPACE.  */
 483
 484 void
 485 switch_to_program_space_and_thread (struct program_space *pspace)
 486 {
 487   struct inferior *inf;
 488
 489   inf = find_inferior_for_program_space (pspace);
 490   if (inf != NULL)
 491     {
 492       struct thread_info *tp;
 493
 494       tp = any_live_thread_of_process (inf->pid);
 495       if (tp != NULL)
 496         {
 497           switch_to_thread (tp->ptid);
 498           /* Switching thread switches pspace implicitly.  We're
 499              done.  */
 500           return;
 501         }
 502     }
 503
 504   switch_to_thread (null_ptid);
 505   set_current_program_space (pspace);
 506 }
 507
 508 \f
 509
 510 /* See progspace.h.  */
 511
 512 void
 513 clear_program_space_solib_cache (struct program_space *pspace)
 514 {
 515   VEC_free (so_list_ptr, pspace->added_solibs);
 516
 517   free_char_ptr_vec (pspace->deleted_solibs);
 518   pspace->deleted_solibs = NULL;
 519 }
 520
 521 \f
 522
 523 void
 524 initialize_progspace (void)
 525 {
 526   add_cmd ("program-spaces", class_maintenance,
 527            maintenance_info_program_spaces_command,
 528            _("Info about currently known program spaces."),
 529            &maintenanceinfolist);
 530
 531   /* There's always one program space.  Note that this function isn't
 532      an automatic _initialize_foo function, since other
 533      _initialize_foo routines may need to install their per-pspace
 534      data keys.  We can only allocate a progspace when all those
 535      modules have done that.  Do this before
 536      initialize_current_architecture, because that accesses exec_bfd,
 537      which in turn dereferences current_program_space.  */
 538   current_program_space = add_program_space (new_address_space ());
 539 }