1 /* Program and address space management, for GDB, the GNU debugger.
3 Copyright (C) 2009-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "arch-utils.h"
27 #include "gdbthread.h"
31 /* The last program space number assigned. */
32 static int last_program_space_num
= 0;
34 /* The head of the program spaces list. */
35 std::vector
<struct program_space
*> program_spaces
;
37 /* Pointer to the current program space. */
38 struct program_space
*current_program_space
;
40 /* The last address space number assigned. */
41 static int highest_address_space_num
;
45 /* Keep a registry of per-program_space data-pointers required by other GDB
48 DEFINE_REGISTRY (program_space
, REGISTRY_ACCESS_FIELD
)
50 /* Keep a registry of per-address_space data-pointers required by other GDB
53 DEFINE_REGISTRY (address_space
, REGISTRY_ACCESS_FIELD
)
57 /* Create a new address space object, and add it to the list. */
59 struct address_space
*
60 new_address_space (void)
62 struct address_space
*aspace
;
64 aspace
= XCNEW (struct address_space
);
65 aspace
->num
= ++highest_address_space_num
;
66 address_space_alloc_data (aspace
);
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. */
75 struct address_space
*
76 maybe_new_address_space (void)
78 int shared_aspace
= gdbarch_has_shared_address_space (target_gdbarch ());
82 /* Just return the first in the list. */
83 return program_spaces
[0]->aspace
;
86 return new_address_space ();
90 free_address_space (struct address_space
*aspace
)
92 address_space_free_data (aspace
);
97 address_space_num (struct address_space
*aspace
)
102 /* Start counting over from scratch. */
105 init_address_spaces (void)
107 highest_address_space_num
= 0;
112 /* Remove a program space from the program spaces list. */
115 remove_program_space (program_space
*pspace
)
117 gdb_assert (pspace
!= NULL
);
119 auto iter
= std::find (program_spaces
.begin (), program_spaces
.end (),
121 gdb_assert (iter
!= program_spaces
.end ());
122 program_spaces
.erase (iter
);
125 /* See progspace.h. */
127 program_space::program_space (address_space
*aspace_
)
128 : num (++last_program_space_num
),
131 program_space_alloc_data (this);
133 program_spaces
.push_back (this);
136 /* See progspace.h. */
138 program_space::~program_space ()
140 gdb_assert (this != current_program_space
);
142 remove_program_space (this);
144 scoped_restore_current_program_space restore_pspace
;
146 set_current_program_space (this);
148 breakpoint_program_space_exit (this);
149 no_shared_libraries (NULL
, 0);
150 free_all_objfiles ();
151 /* Defer breakpoint re-set because we don't want to create new
152 locations for this pspace which we're tearing down. */
153 clear_symtab_users (SYMFILE_DEFER_BP_RESET
);
154 if (!gdbarch_has_shared_address_space (target_gdbarch ()))
155 free_address_space (this->aspace
);
156 /* Discard any data modules have associated with the PSPACE. */
157 program_space_free_data (this);
160 /* See progspace.h. */
163 program_space::free_all_objfiles ()
165 /* Any objfile reference would become stale. */
166 for (struct so_list
*so
: current_program_space
->solibs ())
167 gdb_assert (so
->objfile
== NULL
);
169 while (!objfiles_list
.empty ())
170 objfiles_list
.front ()->unlink ();
173 /* See progspace.h. */
176 program_space::add_objfile (std::shared_ptr
<objfile
> &&objfile
,
177 struct objfile
*before
)
179 if (before
== nullptr)
180 objfiles_list
.push_back (std::move (objfile
));
183 auto iter
= std::find_if (objfiles_list
.begin (), objfiles_list
.end (),
184 [=] (const std::shared_ptr
<::objfile
> &objf
)
186 return objf
.get () == before
;
188 gdb_assert (iter
!= objfiles_list
.end ());
189 objfiles_list
.insert (iter
, std::move (objfile
));
193 /* See progspace.h. */
196 program_space::remove_objfile (struct objfile
*objfile
)
198 /* Removing an objfile from the objfile list invalidates any frame
199 that was built using frame info found in the objfile. Reinit the
200 frame cache to get rid of any frame that might otherwise
201 reference stale info. */
202 reinit_frame_cache ();
204 auto iter
= std::find_if (objfiles_list
.begin (), objfiles_list
.end (),
205 [=] (const std::shared_ptr
<::objfile
> &objf
)
207 return objf
.get () == objfile
;
209 gdb_assert (iter
!= objfiles_list
.end ());
210 objfiles_list
.erase (iter
);
212 if (objfile
== symfile_object_file
)
213 symfile_object_file
= NULL
;
216 /* See progspace.h. */
219 program_space::exec_close ()
223 /* Removing target sections may close the exec_ops target.
224 Clear ebfd before doing so to prevent recursion. */
225 ebfd
.reset (nullptr);
228 remove_target_sections (&ebfd
);
230 exec_filename
.reset (nullptr);
234 /* Copies program space SRC to DEST. Copies the main executable file,
235 and the main symbol file. Returns DEST. */
237 struct program_space
*
238 clone_program_space (struct program_space
*dest
, struct program_space
*src
)
240 scoped_restore_current_program_space restore_pspace
;
242 set_current_program_space (dest
);
244 if (src
->exec_filename
!= NULL
)
245 exec_file_attach (src
->exec_filename
.get (), 0);
247 if (src
->symfile_object_file
!= NULL
)
248 symbol_file_add_main (objfile_name (src
->symfile_object_file
),
249 SYMFILE_DEFER_BP_RESET
);
254 /* Sets PSPACE as the current program space. It is the caller's
255 responsibility to make sure that the currently selected
256 inferior/thread matches the selected program space. */
259 set_current_program_space (struct program_space
*pspace
)
261 if (current_program_space
== pspace
)
264 gdb_assert (pspace
!= NULL
);
266 current_program_space
= pspace
;
268 /* Different symbols change our view of the frame chain. */
269 reinit_frame_cache ();
272 /* Returns true iff there's no inferior bound to PSPACE. */
275 program_space::empty ()
277 return find_inferior_for_program_space (this) == nullptr;
280 /* Prints the list of program spaces and their details on UIOUT. If
281 REQUESTED is not -1, it's the ID of the pspace that should be
282 printed. Otherwise, all spaces are printed. */
285 print_program_space (struct ui_out
*uiout
, int requested
)
289 /* Compute number of pspaces we will print. */
290 for (struct program_space
*pspace
: program_spaces
)
292 if (requested
!= -1 && pspace
->num
!= requested
)
298 /* There should always be at least one. */
299 gdb_assert (count
> 0);
301 ui_out_emit_table
table_emitter (uiout
, 3, count
, "pspaces");
302 uiout
->table_header (1, ui_left
, "current", "");
303 uiout
->table_header (4, ui_left
, "id", "Id");
304 uiout
->table_header (17, ui_left
, "exec", "Executable");
305 uiout
->table_body ();
307 for (struct program_space
*pspace
: program_spaces
)
311 if (requested
!= -1 && requested
!= pspace
->num
)
314 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
316 if (pspace
== current_program_space
)
317 uiout
->field_string ("current", "*");
319 uiout
->field_skip ("current");
321 uiout
->field_signed ("id", pspace
->num
);
323 if (pspace
->exec_filename
!= nullptr)
324 uiout
->field_string ("exec", pspace
->exec_filename
.get ());
326 uiout
->field_skip ("exec");
328 /* Print extra info that doesn't really fit in tabular form.
329 Currently, we print the list of inferiors bound to a pspace.
330 There can be more than one inferior bound to the same pspace,
331 e.g., both parent/child inferiors in a vfork, or, on targets
332 that share pspaces between inferiors. */
335 /* We're going to switch inferiors. */
336 scoped_restore_current_thread restore_thread
;
338 for (inferior
*inf
: all_inferiors ())
339 if (inf
->pspace
== pspace
)
341 /* Switch to inferior in order to call target methods. */
342 switch_to_inferior_no_thread (inf
);
347 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
349 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
352 printf_filtered (", ID %d (%s)",
354 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
361 /* Boolean test for an already-known program space id. */
364 valid_program_space_id (int num
)
366 for (struct program_space
*pspace
: program_spaces
)
367 if (pspace
->num
== num
)
373 /* If ARGS is NULL or empty, print information about all program
374 spaces. Otherwise, ARGS is a text representation of a LONG
375 indicating which the program space to print information about. */
378 maintenance_info_program_spaces_command (const char *args
, int from_tty
)
384 requested
= parse_and_eval_long (args
);
385 if (!valid_program_space_id (requested
))
386 error (_("program space ID %d not known."), requested
);
389 print_program_space (current_uiout
, requested
);
392 /* Update all program spaces matching to address spaces. The user may
393 have created several program spaces, and loaded executables into
394 them before connecting to the target interface that will create the
395 inferiors. All that happens before GDB has a chance to know if the
396 inferiors will share an address space or not. Call this after
397 having connected to the target interface and having fetched the
398 target description, to fixup the program/address spaces mappings.
400 It is assumed that there are no bound inferiors yet, otherwise,
401 they'd be left with stale referenced to released aspaces. */
404 update_address_spaces (void)
406 int shared_aspace
= gdbarch_has_shared_address_space (target_gdbarch ());
408 init_address_spaces ();
412 struct address_space
*aspace
= new_address_space ();
414 free_address_space (current_program_space
->aspace
);
415 for (struct program_space
*pspace
: program_spaces
)
416 pspace
->aspace
= aspace
;
419 for (struct program_space
*pspace
: program_spaces
)
421 free_address_space (pspace
->aspace
);
422 pspace
->aspace
= new_address_space ();
425 for (inferior
*inf
: all_inferiors ())
426 if (gdbarch_has_global_solist (target_gdbarch ()))
427 inf
->aspace
= maybe_new_address_space ();
429 inf
->aspace
= inf
->pspace
->aspace
;
434 /* See progspace.h. */
437 program_space::clear_solib_cache ()
439 added_solibs
.clear ();
440 deleted_solibs
.clear ();
446 initialize_progspace (void)
448 add_cmd ("program-spaces", class_maintenance
,
449 maintenance_info_program_spaces_command
,
450 _("Info about currently known program spaces."),
451 &maintenanceinfolist
);
453 /* There's always one program space. Note that this function isn't
454 an automatic _initialize_foo function, since other
455 _initialize_foo routines may need to install their per-pspace
456 data keys. We can only allocate a progspace when all those
457 modules have done that. Do this before
458 initialize_current_architecture, because that accesses the ebfd
459 of current_program_space. */
460 current_program_space
= new program_space (new_address_space ());