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