1 /* Program and address space management, for GDB, the GNU debugger. 2 3 Copyright (C) 2009-2024 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 "cli/cli-cmds.h" 21 #include "objfiles.h" 22 #include "gdbcore.h" 23 #include "solib.h" 24 #include "solist.h" 25 #include "gdbthread.h" 26 #include "inferior.h" 27 #include <algorithm> 28 #include "cli/cli-style.h" 29 #include "observable.h" 30 31 /* The last program space number assigned. */ 32 static int last_program_space_num = 0; 33 34 /* The head of the program spaces list. */ 35 std::vector<struct program_space *> program_spaces; 36 37 /* Pointer to the current program space. */ 38 struct program_space *current_program_space; 39 40 /* The last address space number assigned. */ 41 static int highest_address_space_num; 42 43 44 45 /* Create a new address space object, and add it to the list. */ 46 47 address_space::address_space () 48 : m_num (++highest_address_space_num) 49 { 50 } 51 52 /* Maybe create a new address space object, and add it to the list, or 53 return a pointer to an existing address space, in case inferiors 54 share an address space on this target system. */ 55 56 address_space_ref_ptr 57 maybe_new_address_space () 58 { 59 int shared_aspace 60 = gdbarch_has_shared_address_space (current_inferior ()->arch ()); 61 62 if (shared_aspace) 63 { 64 /* Just return the first in the list. */ 65 return program_spaces[0]->aspace; 66 } 67 68 return new_address_space (); 69 } 70 71 /* Start counting over from scratch. */ 72 73 static void 74 init_address_spaces (void) 75 { 76 highest_address_space_num = 0; 77 } 78 79 80 81 /* Remove a program space from the program spaces list. */ 82 83 static void 84 remove_program_space (program_space *pspace) 85 { 86 gdb_assert (pspace != NULL); 87 88 auto iter = std::find (program_spaces.begin (), program_spaces.end (), 89 pspace); 90 gdb_assert (iter != program_spaces.end ()); 91 program_spaces.erase (iter); 92 } 93 94 /* See progspace.h. */ 95 96 program_space::program_space (address_space_ref_ptr aspace_) 97 : num (++last_program_space_num), 98 aspace (std::move (aspace_)) 99 { 100 program_spaces.push_back (this); 101 gdb::observers::new_program_space.notify (this); 102 } 103 104 /* See progspace.h. */ 105 106 program_space::~program_space () 107 { 108 gdb_assert (this != current_program_space); 109 110 gdb::observers::free_program_space.notify (this); 111 remove_program_space (this); 112 113 scoped_restore_current_program_space restore_pspace; 114 115 set_current_program_space (this); 116 117 breakpoint_program_space_exit (this); 118 no_shared_libraries (NULL, 0); 119 free_all_objfiles (); 120 /* Defer breakpoint re-set because we don't want to create new 121 locations for this pspace which we're tearing down. */ 122 clear_symtab_users (SYMFILE_DEFER_BP_RESET); 123 } 124 125 /* See progspace.h. */ 126 127 void 128 program_space::free_all_objfiles () 129 { 130 /* Any objfile reference would become stale. */ 131 for (const solib &so : current_program_space->solibs ()) 132 gdb_assert (so.objfile == NULL); 133 134 while (!objfiles_list.empty ()) 135 objfiles_list.front ()->unlink (); 136 } 137 138 /* See progspace.h. */ 139 140 void 141 program_space::add_objfile (std::unique_ptr<objfile> &&objfile, 142 struct objfile *before) 143 { 144 if (before == nullptr) 145 objfiles_list.push_back (std::move (objfile)); 146 else 147 { 148 auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (), 149 [=] (const std::unique_ptr<::objfile> &objf) 150 { 151 return objf.get () == before; 152 }); 153 gdb_assert (iter != objfiles_list.end ()); 154 objfiles_list.insert (iter, std::move (objfile)); 155 } 156 } 157 158 /* See progspace.h. */ 159 160 void 161 program_space::remove_objfile (struct objfile *objfile) 162 { 163 /* Removing an objfile from the objfile list invalidates any frame 164 that was built using frame info found in the objfile. Reinit the 165 frame cache to get rid of any frame that might otherwise 166 reference stale info. */ 167 reinit_frame_cache (); 168 169 auto iter = std::find_if (objfiles_list.begin (), objfiles_list.end (), 170 [=] (const std::unique_ptr<::objfile> &objf) 171 { 172 return objf.get () == objfile; 173 }); 174 gdb_assert (iter != objfiles_list.end ()); 175 objfiles_list.erase (iter); 176 177 if (objfile == symfile_object_file) 178 symfile_object_file = NULL; 179 } 180 181 /* See progspace.h. */ 182 183 struct objfile * 184 program_space::objfile_for_address (CORE_ADDR address) 185 { 186 for (auto iter : objfiles ()) 187 { 188 /* Don't check separate debug objfiles. */ 189 if (iter->separate_debug_objfile_backlink != nullptr) 190 continue; 191 if (is_addr_in_objfile (address, iter)) 192 return iter; 193 } 194 return nullptr; 195 } 196 197 /* See progspace.h. */ 198 199 void 200 program_space::exec_close () 201 { 202 if (ebfd != nullptr) 203 { 204 /* Removing target sections may close the exec_ops target. 205 Clear ebfd before doing so to prevent recursion. */ 206 bfd *saved_ebfd = ebfd.get (); 207 ebfd.reset (nullptr); 208 ebfd_mtime = 0; 209 210 remove_target_sections (saved_ebfd); 211 212 exec_filename.reset (nullptr); 213 } 214 } 215 216 /* Copies program space SRC to DEST. Copies the main executable file, 217 and the main symbol file. Returns DEST. */ 218 219 struct program_space * 220 clone_program_space (struct program_space *dest, struct program_space *src) 221 { 222 scoped_restore_current_program_space restore_pspace; 223 224 set_current_program_space (dest); 225 226 if (src->exec_filename != NULL) 227 exec_file_attach (src->exec_filename.get (), 0); 228 229 if (src->symfile_object_file != NULL) 230 symbol_file_add_main (objfile_name (src->symfile_object_file), 231 SYMFILE_DEFER_BP_RESET); 232 233 return dest; 234 } 235 236 /* Sets PSPACE as the current program space. It is the caller's 237 responsibility to make sure that the currently selected 238 inferior/thread matches the selected program space. */ 239 240 void 241 set_current_program_space (struct program_space *pspace) 242 { 243 if (current_program_space == pspace) 244 return; 245 246 gdb_assert (pspace != NULL); 247 248 current_program_space = pspace; 249 250 /* Different symbols change our view of the frame chain. */ 251 reinit_frame_cache (); 252 } 253 254 /* Returns true iff there's no inferior bound to PSPACE. */ 255 256 bool 257 program_space::empty () 258 { 259 return find_inferior_for_program_space (this) == nullptr; 260 } 261 262 /* Prints the list of program spaces and their details on UIOUT. If 263 REQUESTED is not -1, it's the ID of the pspace that should be 264 printed. Otherwise, all spaces are printed. */ 265 266 static void 267 print_program_space (struct ui_out *uiout, int requested) 268 { 269 int count = 0; 270 271 /* Start with a minimum width of 17 for the executable name column. */ 272 size_t longest_exec_name = 17; 273 274 /* Compute number of pspaces we will print. */ 275 for (struct program_space *pspace : program_spaces) 276 { 277 if (requested != -1 && pspace->num != requested) 278 continue; 279 280 if (pspace->exec_filename != nullptr) 281 longest_exec_name = std::max (strlen (pspace->exec_filename.get ()), 282 longest_exec_name); 283 284 ++count; 285 } 286 287 /* There should always be at least one. */ 288 gdb_assert (count > 0); 289 290 ui_out_emit_table table_emitter (uiout, 4, count, "pspaces"); 291 uiout->table_header (1, ui_left, "current", ""); 292 uiout->table_header (4, ui_left, "id", "Id"); 293 uiout->table_header (longest_exec_name, ui_left, "exec", "Executable"); 294 uiout->table_header (17, ui_left, "core", "Core File"); 295 uiout->table_body (); 296 297 for (struct program_space *pspace : program_spaces) 298 { 299 int printed_header; 300 301 if (requested != -1 && requested != pspace->num) 302 continue; 303 304 ui_out_emit_tuple tuple_emitter (uiout, NULL); 305 306 if (pspace == current_program_space) 307 uiout->field_string ("current", "*"); 308 else 309 uiout->field_skip ("current"); 310 311 uiout->field_signed ("id", pspace->num); 312 313 if (pspace->exec_filename != nullptr) 314 uiout->field_string ("exec", pspace->exec_filename.get (), 315 file_name_style.style ()); 316 else 317 uiout->field_skip ("exec"); 318 319 if (pspace->cbfd != nullptr) 320 uiout->field_string ("core", bfd_get_filename (pspace->cbfd.get ()), 321 file_name_style.style ()); 322 else 323 uiout->field_skip ("core"); 324 325 /* Print extra info that doesn't really fit in tabular form. 326 Currently, we print the list of inferiors bound to a pspace. 327 There can be more than one inferior bound to the same pspace, 328 e.g., both parent/child inferiors in a vfork, or, on targets 329 that share pspaces between inferiors. */ 330 printed_header = 0; 331 332 /* We're going to switch inferiors. */ 333 scoped_restore_current_thread restore_thread; 334 335 for (inferior *inf : all_inferiors ()) 336 if (inf->pspace == pspace) 337 { 338 /* Switch to inferior in order to call target methods. */ 339 switch_to_inferior_no_thread (inf); 340 341 if (!printed_header) 342 { 343 printed_header = 1; 344 gdb_printf ("\n\tBound inferiors: ID %d (%s)", 345 inf->num, 346 target_pid_to_str (ptid_t (inf->pid)).c_str ()); 347 } 348 else 349 gdb_printf (", ID %d (%s)", 350 inf->num, 351 target_pid_to_str (ptid_t (inf->pid)).c_str ()); 352 } 353 354 uiout->text ("\n"); 355 } 356 } 357 358 /* Boolean test for an already-known program space id. */ 359 360 static int 361 valid_program_space_id (int num) 362 { 363 for (struct program_space *pspace : program_spaces) 364 if (pspace->num == num) 365 return 1; 366 367 return 0; 368 } 369 370 /* If ARGS is NULL or empty, print information about all program 371 spaces. Otherwise, ARGS is a text representation of a LONG 372 indicating which the program space to print information about. */ 373 374 static void 375 maintenance_info_program_spaces_command (const char *args, int from_tty) 376 { 377 int requested = -1; 378 379 if (args && *args) 380 { 381 requested = parse_and_eval_long (args); 382 if (!valid_program_space_id (requested)) 383 error (_("program space ID %d not known."), requested); 384 } 385 386 print_program_space (current_uiout, requested); 387 } 388 389 /* Update all program spaces matching to address spaces. The user may 390 have created several program spaces, and loaded executables into 391 them before connecting to the target interface that will create the 392 inferiors. All that happens before GDB has a chance to know if the 393 inferiors will share an address space or not. Call this after 394 having connected to the target interface and having fetched the 395 target description, to fixup the program/address spaces mappings. 396 397 It is assumed that there are no bound inferiors yet, otherwise, 398 they'd be left with stale referenced to released aspaces. */ 399 400 void 401 update_address_spaces (void) 402 { 403 int shared_aspace 404 = gdbarch_has_shared_address_space (current_inferior ()->arch ()); 405 406 init_address_spaces (); 407 408 if (shared_aspace) 409 { 410 address_space_ref_ptr aspace = new_address_space (); 411 412 for (struct program_space *pspace : program_spaces) 413 pspace->aspace = aspace; 414 } 415 else 416 for (struct program_space *pspace : program_spaces) 417 pspace->aspace = new_address_space (); 418 419 for (inferior *inf : all_inferiors ()) 420 if (gdbarch_has_global_solist (current_inferior ()->arch ())) 421 inf->aspace = maybe_new_address_space (); 422 else 423 inf->aspace = inf->pspace->aspace; 424 } 425 426 427 428 /* See progspace.h. */ 429 430 void 431 program_space::clear_solib_cache () 432 { 433 added_solibs.clear (); 434 deleted_solibs.clear (); 435 } 436 437 /* See progspace.h. */ 438 439 void 440 initialize_progspace () 441 { 442 add_cmd ("program-spaces", class_maintenance, 443 maintenance_info_program_spaces_command, 444 _("Info about currently known program spaces."), 445 &maintenanceinfolist); 446 447 /* There's always one program space. Note that this function isn't 448 an automatic _initialize_foo function, since other 449 _initialize_foo routines may need to install their per-pspace 450 data keys. We can only allocate a progspace when all those 451 modules have done that. Do this before 452 initialize_current_architecture, because that accesses the ebfd 453 of current_program_space. */ 454 current_program_space = new program_space (new_address_space ()); 455 } 456