1 /* Program and address space management, for GDB, the GNU debugger. 2 3 Copyright (C) 2009-2023 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 "solist.h" 27 #include "gdbthread.h" 28 #include "inferior.h" 29 #include <algorithm> 30 #include "cli/cli-style.h" 31 32 /* The last program space number assigned. */ 33 static int last_program_space_num = 0; 34 35 /* The head of the program spaces list. */ 36 std::vector<struct program_space *> program_spaces; 37 38 /* Pointer to the current program space. */ 39 struct program_space *current_program_space; 40 41 /* The last address space number assigned. */ 42 static int highest_address_space_num; 43 44 45 46 /* Create a new address space object, and add it to the list. */ 47 48 address_space::address_space () 49 : m_num (++highest_address_space_num) 50 { 51 } 52 53 /* Maybe create a new address space object, and add it to the list, or 54 return a pointer to an existing address space, in case inferiors 55 share an address space on this target system. */ 56 57 struct address_space * 58 maybe_new_address_space (void) 59 { 60 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ()); 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 *aspace_) 97 : num (++last_program_space_num), 98 aspace (aspace_) 99 { 100 program_spaces.push_back (this); 101 } 102 103 /* See progspace.h. */ 104 105 program_space::~program_space () 106 { 107 gdb_assert (this != current_program_space); 108 109 remove_program_space (this); 110 111 scoped_restore_current_program_space restore_pspace; 112 113 set_current_program_space (this); 114 115 breakpoint_program_space_exit (this); 116 no_shared_libraries (NULL, 0); 117 free_all_objfiles (); 118 /* Defer breakpoint re-set because we don't want to create new 119 locations for this pspace which we're tearing down. */ 120 clear_symtab_users (SYMFILE_DEFER_BP_RESET); 121 if (!gdbarch_has_shared_address_space (target_gdbarch ())) 122 delete this->aspace; 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 (struct so_list *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 void 184 program_space::exec_close () 185 { 186 if (ebfd != nullptr) 187 { 188 /* Removing target sections may close the exec_ops target. 189 Clear ebfd before doing so to prevent recursion. */ 190 ebfd.reset (nullptr); 191 ebfd_mtime = 0; 192 193 remove_target_sections (&ebfd); 194 195 exec_filename.reset (nullptr); 196 } 197 } 198 199 /* Copies program space SRC to DEST. Copies the main executable file, 200 and the main symbol file. Returns DEST. */ 201 202 struct program_space * 203 clone_program_space (struct program_space *dest, struct program_space *src) 204 { 205 scoped_restore_current_program_space restore_pspace; 206 207 set_current_program_space (dest); 208 209 if (src->exec_filename != NULL) 210 exec_file_attach (src->exec_filename.get (), 0); 211 212 if (src->symfile_object_file != NULL) 213 symbol_file_add_main (objfile_name (src->symfile_object_file), 214 SYMFILE_DEFER_BP_RESET); 215 216 return dest; 217 } 218 219 /* Sets PSPACE as the current program space. It is the caller's 220 responsibility to make sure that the currently selected 221 inferior/thread matches the selected program space. */ 222 223 void 224 set_current_program_space (struct program_space *pspace) 225 { 226 if (current_program_space == pspace) 227 return; 228 229 gdb_assert (pspace != NULL); 230 231 current_program_space = pspace; 232 233 /* Different symbols change our view of the frame chain. */ 234 reinit_frame_cache (); 235 } 236 237 /* Returns true iff there's no inferior bound to PSPACE. */ 238 239 bool 240 program_space::empty () 241 { 242 return find_inferior_for_program_space (this) == nullptr; 243 } 244 245 /* Prints the list of program spaces and their details on UIOUT. If 246 REQUESTED is not -1, it's the ID of the pspace that should be 247 printed. Otherwise, all spaces are printed. */ 248 249 static void 250 print_program_space (struct ui_out *uiout, int requested) 251 { 252 int count = 0; 253 254 /* Start with a minimum width of 17 for the executable name column. */ 255 size_t longest_exec_name = 17; 256 257 /* Compute number of pspaces we will print. */ 258 for (struct program_space *pspace : program_spaces) 259 { 260 if (requested != -1 && pspace->num != requested) 261 continue; 262 263 if (pspace->exec_filename != nullptr) 264 longest_exec_name = std::max (strlen (pspace->exec_filename.get ()), 265 longest_exec_name); 266 267 ++count; 268 } 269 270 /* There should always be at least one. */ 271 gdb_assert (count > 0); 272 273 ui_out_emit_table table_emitter (uiout, 4, count, "pspaces"); 274 uiout->table_header (1, ui_left, "current", ""); 275 uiout->table_header (4, ui_left, "id", "Id"); 276 uiout->table_header (longest_exec_name, ui_left, "exec", "Executable"); 277 uiout->table_header (17, ui_left, "core", "Core File"); 278 uiout->table_body (); 279 280 for (struct program_space *pspace : program_spaces) 281 { 282 int printed_header; 283 284 if (requested != -1 && requested != pspace->num) 285 continue; 286 287 ui_out_emit_tuple tuple_emitter (uiout, NULL); 288 289 if (pspace == current_program_space) 290 uiout->field_string ("current", "*"); 291 else 292 uiout->field_skip ("current"); 293 294 uiout->field_signed ("id", pspace->num); 295 296 if (pspace->exec_filename != nullptr) 297 uiout->field_string ("exec", pspace->exec_filename.get (), 298 file_name_style.style ()); 299 else 300 uiout->field_skip ("exec"); 301 302 if (pspace->cbfd != nullptr) 303 uiout->field_string ("core", bfd_get_filename (pspace->cbfd.get ()), 304 file_name_style.style ()); 305 else 306 uiout->field_skip ("core"); 307 308 /* Print extra info that doesn't really fit in tabular form. 309 Currently, we print the list of inferiors bound to a pspace. 310 There can be more than one inferior bound to the same pspace, 311 e.g., both parent/child inferiors in a vfork, or, on targets 312 that share pspaces between inferiors. */ 313 printed_header = 0; 314 315 /* We're going to switch inferiors. */ 316 scoped_restore_current_thread restore_thread; 317 318 for (inferior *inf : all_inferiors ()) 319 if (inf->pspace == pspace) 320 { 321 /* Switch to inferior in order to call target methods. */ 322 switch_to_inferior_no_thread (inf); 323 324 if (!printed_header) 325 { 326 printed_header = 1; 327 gdb_printf ("\n\tBound inferiors: ID %d (%s)", 328 inf->num, 329 target_pid_to_str (ptid_t (inf->pid)).c_str ()); 330 } 331 else 332 gdb_printf (", ID %d (%s)", 333 inf->num, 334 target_pid_to_str (ptid_t (inf->pid)).c_str ()); 335 } 336 337 uiout->text ("\n"); 338 } 339 } 340 341 /* Boolean test for an already-known program space id. */ 342 343 static int 344 valid_program_space_id (int num) 345 { 346 for (struct program_space *pspace : program_spaces) 347 if (pspace->num == num) 348 return 1; 349 350 return 0; 351 } 352 353 /* If ARGS is NULL or empty, print information about all program 354 spaces. Otherwise, ARGS is a text representation of a LONG 355 indicating which the program space to print information about. */ 356 357 static void 358 maintenance_info_program_spaces_command (const char *args, int from_tty) 359 { 360 int requested = -1; 361 362 if (args && *args) 363 { 364 requested = parse_and_eval_long (args); 365 if (!valid_program_space_id (requested)) 366 error (_("program space ID %d not known."), requested); 367 } 368 369 print_program_space (current_uiout, requested); 370 } 371 372 /* Update all program spaces matching to address spaces. The user may 373 have created several program spaces, and loaded executables into 374 them before connecting to the target interface that will create the 375 inferiors. All that happens before GDB has a chance to know if the 376 inferiors will share an address space or not. Call this after 377 having connected to the target interface and having fetched the 378 target description, to fixup the program/address spaces mappings. 379 380 It is assumed that there are no bound inferiors yet, otherwise, 381 they'd be left with stale referenced to released aspaces. */ 382 383 void 384 update_address_spaces (void) 385 { 386 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ()); 387 388 init_address_spaces (); 389 390 if (shared_aspace) 391 { 392 struct address_space *aspace = new address_space (); 393 394 delete current_program_space->aspace; 395 for (struct program_space *pspace : program_spaces) 396 pspace->aspace = aspace; 397 } 398 else 399 for (struct program_space *pspace : program_spaces) 400 { 401 delete pspace->aspace; 402 pspace->aspace = new address_space (); 403 } 404 405 for (inferior *inf : all_inferiors ()) 406 if (gdbarch_has_global_solist (target_gdbarch ())) 407 inf->aspace = maybe_new_address_space (); 408 else 409 inf->aspace = inf->pspace->aspace; 410 } 411 412 413 414 /* See progspace.h. */ 415 416 void 417 program_space::clear_solib_cache () 418 { 419 added_solibs.clear (); 420 deleted_solibs.clear (); 421 } 422 423 424 425 void 426 initialize_progspace (void) 427 { 428 add_cmd ("program-spaces", class_maintenance, 429 maintenance_info_program_spaces_command, 430 _("Info about currently known program spaces."), 431 &maintenanceinfolist); 432 433 /* There's always one program space. Note that this function isn't 434 an automatic _initialize_foo function, since other 435 _initialize_foo routines may need to install their per-pspace 436 data keys. We can only allocate a progspace when all those 437 modules have done that. Do this before 438 initialize_current_architecture, because that accesses the ebfd 439 of current_program_space. */ 440 current_program_space = new program_space (new address_space ()); 441 } 442