gdb/progspace.c

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