1 /* Program and address space management, for GDB, the GNU debugger. 2 3 Copyright (C) 2009-2019 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 #include "inferior.h" 28 29 /* The last program space number assigned. */ 30 int last_program_space_num = 0; 31 32 /* The head of the program spaces list. */ 33 struct program_space *program_spaces; 34 35 /* Pointer to the current program space. */ 36 struct program_space *current_program_space; 37 38 /* The last address space number assigned. */ 39 static int highest_address_space_num; 40 41 42 43 /* Keep a registry of per-program_space data-pointers required by other GDB 44 modules. */ 45 46 DEFINE_REGISTRY (program_space, REGISTRY_ACCESS_FIELD) 47 48 /* Keep a registry of per-address_space data-pointers required by other GDB 49 modules. */ 50 51 DEFINE_REGISTRY (address_space, REGISTRY_ACCESS_FIELD) 52 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 = XCNEW (struct address_space); 63 aspace->num = ++highest_address_space_num; 64 address_space_alloc_data (aspace); 65 66 return aspace; 67 } 68 69 /* Maybe create a new address space object, and add it to the list, or 70 return a pointer to an existing address space, in case inferiors 71 share an address space on this target system. */ 72 73 struct address_space * 74 maybe_new_address_space (void) 75 { 76 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ()); 77 78 if (shared_aspace) 79 { 80 /* Just return the first in the list. */ 81 return program_spaces->aspace; 82 } 83 84 return new_address_space (); 85 } 86 87 static void 88 free_address_space (struct address_space *aspace) 89 { 90 address_space_free_data (aspace); 91 xfree (aspace); 92 } 93 94 int 95 address_space_num (struct address_space *aspace) 96 { 97 return aspace->num; 98 } 99 100 /* Start counting over from scratch. */ 101 102 static void 103 init_address_spaces (void) 104 { 105 highest_address_space_num = 0; 106 } 107 108 109 110 /* Adds a new empty program space to the program space list, and binds 111 it to ASPACE. Returns the pointer to the new object. */ 112 113 program_space::program_space (address_space *aspace_) 114 : num (++last_program_space_num), aspace (aspace_) 115 { 116 program_space_alloc_data (this); 117 118 if (program_spaces == NULL) 119 program_spaces = this; 120 else 121 { 122 struct program_space *last; 123 124 for (last = program_spaces; last->next != NULL; last = last->next) 125 ; 126 last->next = this; 127 } 128 } 129 130 /* Releases program space PSPACE, and all its contents (shared 131 libraries, objfiles, and any other references to the PSPACE in 132 other modules). It is an internal error to call this when PSPACE 133 is the current program space, since there should always be a 134 program space. */ 135 136 program_space::~program_space () 137 { 138 gdb_assert (this != current_program_space); 139 140 scoped_restore_current_program_space restore_pspace; 141 142 set_current_program_space (this); 143 144 breakpoint_program_space_exit (this); 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 (this->aspace); 150 clear_section_table (&this->target_sections); 151 clear_program_space_solib_cache (this); 152 /* Discard any data modules have associated with the PSPACE. */ 153 program_space_free_data (this); 154 } 155 156 /* Copies program space SRC to DEST. Copies the main executable file, 157 and the main symbol file. Returns DEST. */ 158 159 struct program_space * 160 clone_program_space (struct program_space *dest, struct program_space *src) 161 { 162 scoped_restore_current_program_space restore_pspace; 163 164 set_current_program_space (dest); 165 166 if (src->pspace_exec_filename != NULL) 167 exec_file_attach (src->pspace_exec_filename, 0); 168 169 if (src->symfile_object_file != NULL) 170 symbol_file_add_main (objfile_name (src->symfile_object_file), 171 SYMFILE_DEFER_BP_RESET); 172 173 return dest; 174 } 175 176 /* Sets PSPACE as the current program space. It is the caller's 177 responsibility to make sure that the currently selected 178 inferior/thread matches the selected program space. */ 179 180 void 181 set_current_program_space (struct program_space *pspace) 182 { 183 if (current_program_space == pspace) 184 return; 185 186 gdb_assert (pspace != NULL); 187 188 current_program_space = pspace; 189 190 /* Different symbols change our view of the frame chain. */ 191 reinit_frame_cache (); 192 } 193 194 /* Returns true iff there's no inferior bound to PSPACE. */ 195 196 int 197 program_space_empty_p (struct program_space *pspace) 198 { 199 if (find_inferior_for_program_space (pspace) != NULL) 200 return 0; 201 202 return 1; 203 } 204 205 /* Remove a program space from the program spaces list and release it. It is 206 an error to call this function while PSPACE is the current program space. */ 207 208 void 209 delete_program_space (struct program_space *pspace) 210 { 211 struct program_space *ss, **ss_link; 212 gdb_assert (pspace != NULL); 213 gdb_assert (pspace != current_program_space); 214 215 ss = program_spaces; 216 ss_link = &program_spaces; 217 while (ss != NULL) 218 { 219 if (ss == pspace) 220 { 221 *ss_link = ss->next; 222 break; 223 } 224 225 ss_link = &ss->next; 226 ss = *ss_link; 227 } 228 229 delete pspace; 230 } 231 232 /* Prints the list of program spaces and their details on UIOUT. If 233 REQUESTED is not -1, it's the ID of the pspace that should be 234 printed. Otherwise, all spaces are printed. */ 235 236 static void 237 print_program_space (struct ui_out *uiout, int requested) 238 { 239 struct program_space *pspace; 240 int count = 0; 241 242 /* Compute number of pspaces we will print. */ 243 ALL_PSPACES (pspace) 244 { 245 if (requested != -1 && pspace->num != requested) 246 continue; 247 248 ++count; 249 } 250 251 /* There should always be at least one. */ 252 gdb_assert (count > 0); 253 254 ui_out_emit_table table_emitter (uiout, 3, count, "pspaces"); 255 uiout->table_header (1, ui_left, "current", ""); 256 uiout->table_header (4, ui_left, "id", "Id"); 257 uiout->table_header (17, ui_left, "exec", "Executable"); 258 uiout->table_body (); 259 260 ALL_PSPACES (pspace) 261 { 262 struct inferior *inf; 263 int printed_header; 264 265 if (requested != -1 && requested != pspace->num) 266 continue; 267 268 ui_out_emit_tuple tuple_emitter (uiout, NULL); 269 270 if (pspace == current_program_space) 271 uiout->field_string ("current", "*"); 272 else 273 uiout->field_skip ("current"); 274 275 uiout->field_int ("id", pspace->num); 276 277 if (pspace->pspace_exec_filename) 278 uiout->field_string ("exec", pspace->pspace_exec_filename); 279 else 280 uiout->field_skip ("exec"); 281 282 /* Print extra info that doesn't really fit in tabular form. 283 Currently, we print the list of inferiors bound to a pspace. 284 There can be more than one inferior bound to the same pspace, 285 e.g., both parent/child inferiors in a vfork, or, on targets 286 that share pspaces between inferiors. */ 287 printed_header = 0; 288 for (inf = inferior_list; inf; inf = inf->next) 289 if (inf->pspace == pspace) 290 { 291 if (!printed_header) 292 { 293 printed_header = 1; 294 printf_filtered ("\n\tBound inferiors: ID %d (%s)", 295 inf->num, 296 target_pid_to_str (ptid_t (inf->pid))); 297 } 298 else 299 printf_filtered (", ID %d (%s)", 300 inf->num, 301 target_pid_to_str (ptid_t (inf->pid))); 302 } 303 304 uiout->text ("\n"); 305 } 306 } 307 308 /* Boolean test for an already-known program space id. */ 309 310 static int 311 valid_program_space_id (int num) 312 { 313 struct program_space *pspace; 314 315 ALL_PSPACES (pspace) 316 if (pspace->num == num) 317 return 1; 318 319 return 0; 320 } 321 322 /* If ARGS is NULL or empty, print information about all program 323 spaces. Otherwise, ARGS is a text representation of a LONG 324 indicating which the program space to print information about. */ 325 326 static void 327 maintenance_info_program_spaces_command (const char *args, int from_tty) 328 { 329 int requested = -1; 330 331 if (args && *args) 332 { 333 requested = parse_and_eval_long (args); 334 if (!valid_program_space_id (requested)) 335 error (_("program space ID %d not known."), requested); 336 } 337 338 print_program_space (current_uiout, requested); 339 } 340 341 /* Simply returns the count of program spaces. */ 342 343 int 344 number_of_program_spaces (void) 345 { 346 struct program_space *pspace; 347 int count = 0; 348 349 ALL_PSPACES (pspace) 350 count++; 351 352 return count; 353 } 354 355 /* Update all program spaces matching to address spaces. The user may 356 have created several program spaces, and loaded executables into 357 them before connecting to the target interface that will create the 358 inferiors. All that happens before GDB has a chance to know if the 359 inferiors will share an address space or not. Call this after 360 having connected to the target interface and having fetched the 361 target description, to fixup the program/address spaces mappings. 362 363 It is assumed that there are no bound inferiors yet, otherwise, 364 they'd be left with stale referenced to released aspaces. */ 365 366 void 367 update_address_spaces (void) 368 { 369 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ()); 370 struct program_space *pspace; 371 struct inferior *inf; 372 373 init_address_spaces (); 374 375 if (shared_aspace) 376 { 377 struct address_space *aspace = new_address_space (); 378 379 free_address_space (current_program_space->aspace); 380 ALL_PSPACES (pspace) 381 pspace->aspace = aspace; 382 } 383 else 384 ALL_PSPACES (pspace) 385 { 386 free_address_space (pspace->aspace); 387 pspace->aspace = new_address_space (); 388 } 389 390 for (inf = inferior_list; inf; inf = inf->next) 391 if (gdbarch_has_global_solist (target_gdbarch ())) 392 inf->aspace = maybe_new_address_space (); 393 else 394 inf->aspace = inf->pspace->aspace; 395 } 396 397 398 399 /* See progspace.h. */ 400 401 void 402 clear_program_space_solib_cache (struct program_space *pspace) 403 { 404 pspace->added_solibs.clear (); 405 pspace->deleted_solibs.clear (); 406 } 407 408 409 410 void 411 initialize_progspace (void) 412 { 413 add_cmd ("program-spaces", class_maintenance, 414 maintenance_info_program_spaces_command, 415 _("Info about currently known program spaces."), 416 &maintenanceinfolist); 417 418 /* There's always one program space. Note that this function isn't 419 an automatic _initialize_foo function, since other 420 _initialize_foo routines may need to install their per-pspace 421 data keys. We can only allocate a progspace when all those 422 modules have done that. Do this before 423 initialize_current_architecture, because that accesses exec_bfd, 424 which in turn dereferences current_program_space. */ 425 current_program_space = new program_space (new_address_space ()); 426 } 427