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 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 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 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 (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->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 save_current_inferior (); 475 make_cleanup_restore_current_thread (); 476 477 return old_chain; 478 } 479 480 /* Switches full context to program space PSPACE. Switches to the 481 first thread found bound to PSPACE. */ 482 483 void 484 switch_to_program_space_and_thread (struct program_space *pspace) 485 { 486 struct inferior *inf; 487 488 inf = find_inferior_for_program_space (pspace); 489 if (inf != NULL) 490 { 491 struct thread_info *tp; 492 493 tp = any_live_thread_of_process (inf->pid); 494 if (tp != NULL) 495 { 496 switch_to_thread (tp->ptid); 497 /* Switching thread switches pspace implicitly. We're 498 done. */ 499 return; 500 } 501 } 502 503 switch_to_thread (null_ptid); 504 set_current_program_space (pspace); 505 } 506 507 508 509 /* See progspace.h. */ 510 511 void 512 clear_program_space_solib_cache (struct program_space *pspace) 513 { 514 VEC_free (so_list_ptr, pspace->added_solibs); 515 516 free_char_ptr_vec (pspace->deleted_solibs); 517 pspace->deleted_solibs = NULL; 518 } 519 520 521 522 void 523 initialize_progspace (void) 524 { 525 add_cmd ("program-spaces", class_maintenance, 526 maintenance_info_program_spaces_command, 527 _("Info about currently known program spaces."), 528 &maintenanceinfolist); 529 530 /* There's always one program space. Note that this function isn't 531 an automatic _initialize_foo function, since other 532 _initialize_foo routines may need to install their per-pspace 533 data keys. We can only allocate a progspace when all those 534 modules have done that. Do this before 535 initialize_current_architecture, because that accesses exec_bfd, 536 which in turn dereferences current_program_space. */ 537 current_program_space = add_program_space (new_address_space ()); 538 } 539