1 /* Program and address space management, for GDB, the GNU debugger.
3 Copyright (C) 2009-2019 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"
26 #include "gdbthread.h"
30 /* The last program space number assigned. */
31 int last_program_space_num
= 0;
33 /* The head of the program spaces list. */
34 struct program_space
*program_spaces
;
36 /* Pointer to the current program space. */
37 struct program_space
*current_program_space
;
39 /* The last address space number assigned. */
40 static int highest_address_space_num
;
44 /* Keep a registry of per-program_space data-pointers required by other GDB
47 DEFINE_REGISTRY (program_space
, REGISTRY_ACCESS_FIELD
)
49 /* Keep a registry of per-address_space data-pointers required by other GDB
52 DEFINE_REGISTRY (address_space
, REGISTRY_ACCESS_FIELD
)
56 /* Create a new address space object, and add it to the list. */
58 struct address_space
*
59 new_address_space (void)
61 struct address_space
*aspace
;
63 aspace
= XCNEW (struct address_space
);
64 aspace
->num
= ++highest_address_space_num
;
65 address_space_alloc_data (aspace
);
70 /* Maybe create a new address space object, and add it to the list, or
71 return a pointer to an existing address space, in case inferiors
72 share an address space on this target system. */
74 struct address_space
*
75 maybe_new_address_space (void)
77 int shared_aspace
= gdbarch_has_shared_address_space (target_gdbarch ());
81 /* Just return the first in the list. */
82 return program_spaces
->aspace
;
85 return new_address_space ();
89 free_address_space (struct address_space
*aspace
)
91 address_space_free_data (aspace
);
96 address_space_num (struct address_space
*aspace
)
101 /* Start counting over from scratch. */
104 init_address_spaces (void)
106 highest_address_space_num
= 0;
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. */
114 program_space::program_space (address_space
*aspace_
)
115 : num (++last_program_space_num
), aspace (aspace_
)
117 program_space_alloc_data (this);
119 if (program_spaces
== NULL
)
120 program_spaces
= this;
123 struct program_space
*last
;
125 for (last
= program_spaces
; last
->next
!= NULL
; last
= last
->next
)
131 /* Releases program space PSPACE, and all its contents (shared
132 libraries, objfiles, and any other references to the PSPACE in
133 other modules). It is an internal error to call this when PSPACE
134 is the current program space, since there should always be a
137 program_space::~program_space ()
139 gdb_assert (this != current_program_space
);
141 scoped_restore_current_program_space restore_pspace
;
143 set_current_program_space (this);
145 breakpoint_program_space_exit (this);
146 no_shared_libraries (NULL
, 0);
148 free_all_objfiles ();
149 if (!gdbarch_has_shared_address_space (target_gdbarch ()))
150 free_address_space (this->aspace
);
151 clear_section_table (&this->target_sections
);
152 clear_program_space_solib_cache (this);
153 /* Discard any data modules have associated with the PSPACE. */
154 program_space_free_data (this);
157 /* See progspace.h. */
160 program_space::add_objfile (struct objfile
*objfile
, struct objfile
*before
)
162 if (before
== nullptr)
163 objfiles_list
.push_back (objfile
);
166 auto iter
= std::find (objfiles_list
.begin (), objfiles_list
.end (),
168 gdb_assert (iter
!= objfiles_list
.end ());
169 objfiles_list
.insert (iter
, objfile
);
173 /* See progspace.h. */
176 program_space::remove_objfile (struct objfile
*objfile
)
178 auto iter
= std::find (objfiles_list
.begin (), objfiles_list
.end (),
180 gdb_assert (iter
!= objfiles_list
.end ());
181 objfiles_list
.erase (iter
);
183 if (objfile
== symfile_object_file
)
184 symfile_object_file
= NULL
;
187 /* Copies program space SRC to DEST. Copies the main executable file,
188 and the main symbol file. Returns DEST. */
190 struct program_space
*
191 clone_program_space (struct program_space
*dest
, struct program_space
*src
)
193 scoped_restore_current_program_space restore_pspace
;
195 set_current_program_space (dest
);
197 if (src
->pspace_exec_filename
!= NULL
)
198 exec_file_attach (src
->pspace_exec_filename
, 0);
200 if (src
->symfile_object_file
!= NULL
)
201 symbol_file_add_main (objfile_name (src
->symfile_object_file
),
202 SYMFILE_DEFER_BP_RESET
);
207 /* Sets PSPACE as the current program space. It is the caller's
208 responsibility to make sure that the currently selected
209 inferior/thread matches the selected program space. */
212 set_current_program_space (struct program_space
*pspace
)
214 if (current_program_space
== pspace
)
217 gdb_assert (pspace
!= NULL
);
219 current_program_space
= pspace
;
221 /* Different symbols change our view of the frame chain. */
222 reinit_frame_cache ();
225 /* Returns true iff there's no inferior bound to PSPACE. */
228 program_space_empty_p (struct program_space
*pspace
)
230 if (find_inferior_for_program_space (pspace
) != NULL
)
236 /* Remove a program space from the program spaces list and release it. It is
237 an error to call this function while PSPACE is the current program space. */
240 delete_program_space (struct program_space
*pspace
)
242 struct program_space
*ss
, **ss_link
;
243 gdb_assert (pspace
!= NULL
);
244 gdb_assert (pspace
!= current_program_space
);
247 ss_link
= &program_spaces
;
263 /* Prints the list of program spaces and their details on UIOUT. If
264 REQUESTED is not -1, it's the ID of the pspace that should be
265 printed. Otherwise, all spaces are printed. */
268 print_program_space (struct ui_out
*uiout
, int requested
)
270 struct program_space
*pspace
;
273 /* Compute number of pspaces we will print. */
276 if (requested
!= -1 && pspace
->num
!= requested
)
282 /* There should always be at least one. */
283 gdb_assert (count
> 0);
285 ui_out_emit_table
table_emitter (uiout
, 3, count
, "pspaces");
286 uiout
->table_header (1, ui_left
, "current", "");
287 uiout
->table_header (4, ui_left
, "id", "Id");
288 uiout
->table_header (17, ui_left
, "exec", "Executable");
289 uiout
->table_body ();
293 struct inferior
*inf
;
296 if (requested
!= -1 && requested
!= pspace
->num
)
299 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
301 if (pspace
== current_program_space
)
302 uiout
->field_string ("current", "*");
304 uiout
->field_skip ("current");
306 uiout
->field_signed ("id", pspace
->num
);
308 if (pspace
->pspace_exec_filename
)
309 uiout
->field_string ("exec", pspace
->pspace_exec_filename
);
311 uiout
->field_skip ("exec");
313 /* Print extra info that doesn't really fit in tabular form.
314 Currently, we print the list of inferiors bound to a pspace.
315 There can be more than one inferior bound to the same pspace,
316 e.g., both parent/child inferiors in a vfork, or, on targets
317 that share pspaces between inferiors. */
319 for (inf
= inferior_list
; inf
; inf
= inf
->next
)
320 if (inf
->pspace
== pspace
)
325 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
327 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
330 printf_filtered (", ID %d (%s)",
332 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
339 /* Boolean test for an already-known program space id. */
342 valid_program_space_id (int num
)
344 struct program_space
*pspace
;
347 if (pspace
->num
== num
)
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. */
358 maintenance_info_program_spaces_command (const char *args
, int from_tty
)
364 requested
= parse_and_eval_long (args
);
365 if (!valid_program_space_id (requested
))
366 error (_("program space ID %d not known."), requested
);
369 print_program_space (current_uiout
, requested
);
372 /* Simply returns the count of program spaces. */
375 number_of_program_spaces (void)
377 struct program_space
*pspace
;
386 /* Update all program spaces matching to address spaces. The user may
387 have created several program spaces, and loaded executables into
388 them before connecting to the target interface that will create the
389 inferiors. All that happens before GDB has a chance to know if the
390 inferiors will share an address space or not. Call this after
391 having connected to the target interface and having fetched the
392 target description, to fixup the program/address spaces mappings.
394 It is assumed that there are no bound inferiors yet, otherwise,
395 they'd be left with stale referenced to released aspaces. */
398 update_address_spaces (void)
400 int shared_aspace
= gdbarch_has_shared_address_space (target_gdbarch ());
401 struct program_space
*pspace
;
402 struct inferior
*inf
;
404 init_address_spaces ();
408 struct address_space
*aspace
= new_address_space ();
410 free_address_space (current_program_space
->aspace
);
412 pspace
->aspace
= aspace
;
417 free_address_space (pspace
->aspace
);
418 pspace
->aspace
= new_address_space ();
421 for (inf
= inferior_list
; inf
; inf
= inf
->next
)
422 if (gdbarch_has_global_solist (target_gdbarch ()))
423 inf
->aspace
= maybe_new_address_space ();
425 inf
->aspace
= inf
->pspace
->aspace
;
430 /* See progspace.h. */
433 clear_program_space_solib_cache (struct program_space
*pspace
)
435 pspace
->added_solibs
.clear ();
436 pspace
->deleted_solibs
.clear ();
442 initialize_progspace (void)
444 add_cmd ("program-spaces", class_maintenance
,
445 maintenance_info_program_spaces_command
,
446 _("Info about currently known program spaces."),
447 &maintenanceinfolist
);
449 /* There's always one program space. Note that this function isn't
450 an automatic _initialize_foo function, since other
451 _initialize_foo routines may need to install their per-pspace
452 data keys. We can only allocate a progspace when all those
453 modules have done that. Do this before
454 initialize_current_architecture, because that accesses exec_bfd,
455 which in turn dereferences current_program_space. */
456 current_program_space
= new program_space (new_address_space ());