gdb/progspace.c

   1 /* Program and address space management, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2009 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 program_space *new_pspace;
 190   struct cleanup *old_chain;
 191
 192   old_chain = save_current_program_space ();
 193
 194   set_current_program_space (dest);
 195
 196   if (src->ebfd != NULL)
 197     exec_file_attach (bfd_get_filename (src->ebfd), 0);
 198
 199   if (src->symfile_object_file != NULL)
 200     symbol_file_add_main (src->symfile_object_file->name, 0);
 201
 202   do_cleanups (old_chain);
 203   return dest;
 204 }
 205
 206 /* Sets PSPACE as the current program space.  It is the caller's
 207    responsibility to make sure that the currently selected
 208    inferior/thread matches the selected program space.  */
 209
 210 void
 211 set_current_program_space (struct program_space *pspace)
 212 {
 213   if (current_program_space == pspace)
 214     return;
 215
 216   gdb_assert (pspace != NULL);
 217
 218   current_program_space = pspace;
 219
 220   /* Different symbols change our view of the frame chain.  */
 221   reinit_frame_cache ();
 222 }
 223
 224 /* A cleanups callback, helper for save_current_program_space
 225    below.  */
 226
 227 static void
 228 restore_program_space (void *arg)
 229 {
 230   struct program_space *saved_pspace = arg;
 231   set_current_program_space (saved_pspace);
 232 }
 233
 234 /* Save the current program space so that it may be restored by a later
 235    call to do_cleanups.  Returns the struct cleanup pointer needed for
 236    later doing the cleanup.  */
 237
 238 struct cleanup *
 239 save_current_program_space (void)
 240 {
 241   struct cleanup *old_chain = make_cleanup (restore_program_space,
 242                                             current_program_space);
 243   return old_chain;
 244 }
 245
 246 /* Find program space number NUM; returns NULL if not found.  */
 247
 248 static struct program_space *
 249 find_program_space_by_num (int num)
 250 {
 251   struct program_space *pspace;
 252
 253   ALL_PSPACES (pspace)
 254     if (pspace->num == num)
 255       return pspace;
 256
 257   return NULL;
 258 }
 259
 260 /* Returns true iff there's no inferior bound to PSPACE.  */
 261
 262 static int
 263 pspace_empty_p (struct program_space *pspace)
 264 {
 265   struct inferior *inf;
 266
 267   if (find_inferior_for_program_space (pspace) != NULL)
 268       return 0;
 269
 270   return 1;
 271 }
 272
 273 /* Prune away automatically added program spaces that aren't required
 274    anymore.  */
 275
 276 void
 277 prune_program_spaces (void)
 278 {
 279   struct program_space *ss, **ss_link;
 280   struct program_space *current = current_program_space;
 281
 282   ss = program_spaces;
 283   ss_link = &program_spaces;
 284   while (ss)
 285     {
 286       if (ss == current || !pspace_empty_p (ss))
 287         {
 288           ss_link = &ss->next;
 289           ss = *ss_link;
 290           continue;
 291         }
 292
 293       *ss_link = ss->next;
 294       release_program_space (ss);
 295       ss = *ss_link;
 296     }
 297 }
 298
 299 /* Prints the list of program spaces and their details on UIOUT.  If
 300    REQUESTED is not -1, it's the ID of the pspace that should be
 301    printed.  Otherwise, all spaces are printed.  */
 302
 303 static void
 304 print_program_space (struct ui_out *uiout, int requested)
 305 {
 306   struct program_space *pspace;
 307   int count = 0;
 308   struct cleanup *old_chain;
 309
 310   /* Might as well prune away unneeded ones, so the user doesn't even
 311      seem them.  */
 312   prune_program_spaces ();
 313
 314   /* Compute number of pspaces we will print.  */
 315   ALL_PSPACES (pspace)
 316     {
 317       if (requested != -1 && pspace->num != requested)
 318         continue;
 319
 320       ++count;
 321     }
 322
 323   /* There should always be at least one.  */
 324   gdb_assert (count > 0);
 325
 326   old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
 327   ui_out_table_header (uiout, 1, ui_left, "current", "");
 328   ui_out_table_header (uiout, 4, ui_left, "id", "Id");
 329   ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
 330   ui_out_table_body (uiout);
 331
 332   ALL_PSPACES (pspace)
 333     {
 334       struct cleanup *chain2;
 335       struct inferior *inf;
 336       int printed_header;
 337
 338       if (requested != -1 && requested != pspace->num)
 339         continue;
 340
 341       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 342
 343       if (pspace == current_program_space)
 344         ui_out_field_string (uiout, "current", "*");
 345       else
 346         ui_out_field_skip (uiout, "current");
 347
 348       ui_out_field_int (uiout, "id", pspace->num);
 349
 350       if (pspace->ebfd)
 351         ui_out_field_string (uiout, "exec",
 352                              bfd_get_filename (pspace->ebfd));
 353       else
 354         ui_out_field_skip (uiout, "exec");
 355
 356       /* Print extra info that doesn't really fit in tabular form.
 357          Currently, we print the list of inferiors bound to a pspace.
 358          There can be more than one inferior bound to the same pspace,
 359          e.g., both parent/child inferiors in a vfork, or, on targets
 360          that share pspaces between inferiors.  */
 361       printed_header = 0;
 362       for (inf = inferior_list; inf; inf = inf->next)
 363         if (inf->pspace == pspace)
 364           {
 365             if (!printed_header)
 366               {
 367                 printed_header = 1;
 368                 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
 369                                  inf->num,
 370                                  target_pid_to_str (pid_to_ptid (inf->pid)));
 371               }
 372             else
 373               printf_filtered (", ID %d (%s)",
 374                                inf->num,
 375                                target_pid_to_str (pid_to_ptid (inf->pid)));
 376           }
 377
 378       ui_out_text (uiout, "\n");
 379       do_cleanups (chain2);
 380     }
 381
 382   do_cleanups (old_chain);
 383 }
 384
 385 /* Boolean test for an already-known program space id.  */
 386
 387 static int
 388 valid_program_space_id (int num)
 389 {
 390   struct program_space *pspace;
 391
 392   ALL_PSPACES (pspace)
 393     if (pspace->num == num)
 394       return 1;
 395
 396   return 0;
 397 }
 398
 399 /* If ARGS is NULL or empty, print information about all program
 400    spaces.  Otherwise, ARGS is a text representation of a LONG
 401    indicating which the program space to print information about.  */
 402
 403 static void
 404 maintenance_info_program_spaces_command (char *args, int from_tty)
 405 {
 406   int requested = -1;
 407
 408   if (args && *args)
 409     {
 410       requested = parse_and_eval_long (args);
 411       if (!valid_program_space_id (requested))
 412         error (_("program space ID %d not known."), requested);
 413     }
 414
 415   print_program_space (uiout, requested);
 416 }
 417
 418 /* Simply returns the count of program spaces.  */
 419
 420 int
 421 number_of_program_spaces (void)
 422 {
 423   struct program_space *pspace;
 424   int count = 0;
 425
 426   ALL_PSPACES (pspace)
 427     count++;
 428
 429   return count;
 430 }
 431
 432 /* Update all program spaces matching to address spaces.  The user may
 433    have created several program spaces, and loaded executables into
 434    them before connecting to the target interface that will create the
 435    inferiors.  All that happens before GDB has a chance to know if the
 436    inferiors will share an address space or not.  Call this after
 437    having connected to the target interface and having fetched the
 438    target description, to fixup the program/address spaces mappings.
 439
 440    It is assumed that there are no bound inferiors yet, otherwise,
 441    they'd be left with stale referenced to released aspaces.  */
 442
 443 void
 444 update_address_spaces (void)
 445 {
 446   int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
 447   struct address_space *aspace = NULL;
 448   struct program_space *pspace;
 449
 450   init_address_spaces ();
 451
 452   ALL_PSPACES (pspace)
 453     {
 454       free_address_space (pspace->aspace);
 455
 456       if (shared_aspace)
 457         {
 458           if (aspace == NULL)
 459             aspace = new_address_space ();
 460           pspace->aspace = aspace;
 461         }
 462       else
 463         pspace->aspace = new_address_space ();
 464     }
 465 }
 466
 467 /* Save the current program space so that it may be restored by a later
 468    call to do_cleanups.  Returns the struct cleanup pointer needed for
 469    later doing the cleanup.  */
 470
 471 struct cleanup *
 472 save_current_space_and_thread (void)
 473 {
 474   struct cleanup *old_chain;
 475
 476   /* If restoring to null thread, we need to restore the pspace as
 477      well, hence, we need to save the current program space first.  */
 478   old_chain = save_current_program_space ();
 479   save_current_inferior ();
 480   make_cleanup_restore_current_thread ();
 481
 482   return old_chain;
 483 }
 484
 485 /* Switches full context to program space PSPACE.  Switches to the
 486    first thread found bound to PSPACE.  */
 487
 488 void
 489 switch_to_program_space_and_thread (struct program_space *pspace)
 490 {
 491   struct inferior *inf;
 492
 493   inf = find_inferior_for_program_space (pspace);
 494   if (inf != NULL)
 495     {
 496       struct thread_info *tp;
 497
 498       tp = any_live_thread_of_process (inf->pid);
 499       if (tp != NULL)
 500         {
 501           switch_to_thread (tp->ptid);
 502           /* Switching thread switches pspace implicitly.  We're
 503              done.  */
 504           return;
 505         }
 506     }
 507
 508   switch_to_thread (null_ptid);
 509   set_current_program_space (pspace);
 510 }
 511
 512 \f
 513
 514 /* Keep a registry of per-program_space data-pointers required by other GDB
 515    modules.  */
 516
 517 struct program_space_data
 518 {
 519   unsigned index;
 520   void (*cleanup) (struct program_space *, void *);
 521 };
 522
 523 struct program_space_data_registration
 524 {
 525   struct program_space_data *data;
 526   struct program_space_data_registration *next;
 527 };
 528
 529 struct program_space_data_registry
 530 {
 531   struct program_space_data_registration *registrations;
 532   unsigned num_registrations;
 533 };
 534
 535 static struct program_space_data_registry program_space_data_registry
 536   = { NULL, 0 };
 537
 538 const struct program_space_data *
 539 register_program_space_data_with_cleanup
 540   (void (*cleanup) (struct program_space *, void *))
 541 {
 542   struct program_space_data_registration **curr;
 543
 544   /* Append new registration.  */
 545   for (curr = &program_space_data_registry.registrations;
 546        *curr != NULL; curr = &(*curr)->next);
 547
 548   *curr = XMALLOC (struct program_space_data_registration);
 549   (*curr)->next = NULL;
 550   (*curr)->data = XMALLOC (struct program_space_data);
 551   (*curr)->data->index = program_space_data_registry.num_registrations++;
 552   (*curr)->data->cleanup = cleanup;
 553
 554   return (*curr)->data;
 555 }
 556
 557 const struct program_space_data *
 558 register_program_space_data (void)
 559 {
 560   return register_program_space_data_with_cleanup (NULL);
 561 }
 562
 563 static void
 564 program_space_alloc_data (struct program_space *pspace)
 565 {
 566   gdb_assert (pspace->data == NULL);
 567   pspace->num_data = program_space_data_registry.num_registrations;
 568   pspace->data = XCALLOC (pspace->num_data, void *);
 569 }
 570
 571 static void
 572 program_space_free_data (struct program_space *pspace)
 573 {
 574   gdb_assert (pspace->data != NULL);
 575   clear_program_space_data (pspace);
 576   xfree (pspace->data);
 577   pspace->data = NULL;
 578 }
 579
 580 void
 581 clear_program_space_data (struct program_space *pspace)
 582 {
 583   struct program_space_data_registration *registration;
 584   int i;
 585
 586   gdb_assert (pspace->data != NULL);
 587
 588   for (registration = program_space_data_registry.registrations, i = 0;
 589        i < pspace->num_data;
 590        registration = registration->next, i++)
 591     if (pspace->data[i] != NULL && registration->data->cleanup)
 592       registration->data->cleanup (pspace, pspace->data[i]);
 593
 594   memset (pspace->data, 0, pspace->num_data * sizeof (void *));
 595 }
 596
 597 void
 598 set_program_space_data (struct program_space *pspace,
 599                        const struct program_space_data *data,
 600                        void *value)
 601 {
 602   gdb_assert (data->index < pspace->num_data);
 603   pspace->data[data->index] = value;
 604 }
 605
 606 void *
 607 program_space_data (struct program_space *pspace, const struct program_space_data *data)
 608 {
 609   gdb_assert (data->index < pspace->num_data);
 610   return pspace->data[data->index];
 611 }
 612
 613 \f
 614
 615 void
 616 initialize_progspace (void)
 617 {
 618   add_cmd ("program-spaces", class_maintenance,
 619            maintenance_info_program_spaces_command, _("\
 620 Info about currently known program spaces."),
 621            &maintenanceinfolist);
 622
 623   /* There's always one program space.  Note that this function isn't
 624      an automatic _initialize_foo function, since other
 625      _initialize_foo routines may need to install their per-pspace
 626      data keys.  We can only allocate a progspace when all those
 627      modules have done that.  Do this before
 628      initialize_current_architecture, because that accesses exec_bfd,
 629      which in turn dereferences current_program_space.  */
 630   current_program_space = add_program_space (new_address_space ());
 631 }