gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009-2013 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 \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->pspace_exec_filename != NULL)
 200     exec_file_attach (src->pspace_exec_filename, 0);
 201
 202   if (src->symfile_object_file != NULL)
 203     symbol_file_add_main (objfile_name (src->symfile_object_file), 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->pspace_exec_filename)
 340         ui_out_field_string (uiout, "exec", pspace->pspace_exec_filename);
 341       else
 342         ui_out_field_skip (uiout, "exec");
 343
 344       /* Print extra info that doesn't really fit in tabular form.
 345          Currently, we print the list of inferiors bound to a pspace.
 346          There can be more than one inferior bound to the same pspace,
 347          e.g., both parent/child inferiors in a vfork, or, on targets
 348          that share pspaces between inferiors.  */
 349       printed_header = 0;
 350       for (inf = inferior_list; inf; inf = inf->next)
 351         if (inf->pspace == pspace)
 352           {
 353             if (!printed_header)
 354               {
 355                 printed_header = 1;
 356                 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
 357                                  inf->num,
 358                                  target_pid_to_str (pid_to_ptid (inf->pid)));
 359               }
 360             else
 361               printf_filtered (", ID %d (%s)",
 362                                inf->num,
 363                                target_pid_to_str (pid_to_ptid (inf->pid)));
 364           }
 365
 366       ui_out_text (uiout, "\n");
 367       do_cleanups (chain2);
 368     }
 369
 370   do_cleanups (old_chain);
 371 }
 372
 373 /* Boolean test for an already-known program space id.  */
 374
 375 static int
 376 valid_program_space_id (int num)
 377 {
 378   struct program_space *pspace;
 379
 380   ALL_PSPACES (pspace)
 381     if (pspace->num == num)
 382       return 1;
 383
 384   return 0;
 385 }
 386
 387 /* If ARGS is NULL or empty, print information about all program
 388    spaces.  Otherwise, ARGS is a text representation of a LONG
 389    indicating which the program space to print information about.  */
 390
 391 static void
 392 maintenance_info_program_spaces_command (char *args, int from_tty)
 393 {
 394   int requested = -1;
 395
 396   if (args && *args)
 397     {
 398       requested = parse_and_eval_long (args);
 399       if (!valid_program_space_id (requested))
 400         error (_("program space ID %d not known."), requested);
 401     }
 402
 403   print_program_space (current_uiout, requested);
 404 }
 405
 406 /* Simply returns the count of program spaces.  */
 407
 408 int
 409 number_of_program_spaces (void)
 410 {
 411   struct program_space *pspace;
 412   int count = 0;
 413
 414   ALL_PSPACES (pspace)
 415     count++;
 416
 417   return count;
 418 }
 419
 420 /* Update all program spaces matching to address spaces.  The user may
 421    have created several program spaces, and loaded executables into
 422    them before connecting to the target interface that will create the
 423    inferiors.  All that happens before GDB has a chance to know if the
 424    inferiors will share an address space or not.  Call this after
 425    having connected to the target interface and having fetched the
 426    target description, to fixup the program/address spaces mappings.
 427
 428    It is assumed that there are no bound inferiors yet, otherwise,
 429    they'd be left with stale referenced to released aspaces.  */
 430
 431 void
 432 update_address_spaces (void)
 433 {
 434   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
 435   struct program_space *pspace;
 436   struct inferior *inf;
 437
 438   init_address_spaces ();
 439
 440   if (shared_aspace)
 441     {
 442       struct address_space *aspace = new_address_space ();
 443
 444       free_address_space (current_program_space->aspace);
 445       ALL_PSPACES (pspace)
 446         pspace->aspace = aspace;
 447     }
 448   else
 449     ALL_PSPACES (pspace)
 450       {
 451         free_address_space (pspace->aspace);
 452         pspace->aspace = new_address_space ();
 453       }
 454
 455   for (inf = inferior_list; inf; inf = inf->next)
 456     if (gdbarch_has_global_solist (target_gdbarch ()))
 457       inf->aspace = maybe_new_address_space ();
 458     else
 459       inf->aspace = inf->pspace->aspace;
 460 }
 461
 462 /* Save the current program space so that it may be restored by a later
 463    call to do_cleanups.  Returns the struct cleanup pointer needed for
 464    later doing the cleanup.  */
 465
 466 struct cleanup *
 467 save_current_space_and_thread (void)
 468 {
 469   struct cleanup *old_chain;
 470
 471   /* If restoring to null thread, we need to restore the pspace as
 472      well, hence, we need to save the current program space first.  */
 473   old_chain = save_current_program_space ();
 474   /* There's no need to save the current inferior here.
 475      That is handled by make_cleanup_restore_current_thread.  */
 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 }