GDB (xrefs)
Loading...
Searching...
No Matches
progspace.c
Go to the documentation of this file.
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. */
34
35/* The head of the program spaces list. */
36std::vector<struct program_space *> program_spaces;
37
38/* Pointer to the current program space. */
40
41/* The last address space number assigned. */
43
44
45
46/* Create a new address space object, and add it to the list. */
47
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
57struct address_space *
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
73static void
75{
77}
78
79
80
81/* Remove a program space from the program spaces list. */
82
83static void
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
98 aspace (aspace_)
99{
100 program_spaces.push_back (this);
101}
102
103/* See progspace.h. */
104
106{
107 gdb_assert (this != current_program_space);
108
110
112
114
116 no_shared_libraries (NULL, 0);
118 /* Defer breakpoint re-set because we don't want to create new
119 locations for this pspace which we're tearing down. */
122 delete this->aspace;
123}
124
125/* See progspace.h. */
126
127void
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
140void
141program_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
160void
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. */
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
178 symfile_object_file = NULL;
179}
180
181/* See progspace.h. */
182
183void
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
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
202struct program_space *
204{
206
208
209 if (src->exec_filename != NULL)
210 exec_file_attach (src->exec_filename.get (), 0);
211
212 if (src->symfile_object_file != NULL)
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
223void
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. */
235}
236
237/* Returns true iff there's no inferior bound to PSPACE. */
238
239bool
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
249static void
250print_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 (),
299 else
300 uiout->field_skip ("exec");
301
302 if (pspace->cbfd != nullptr)
303 uiout->field_string ("core", bfd_get_filename (pspace->cbfd.get ()),
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. */
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
343static int
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
357static void
358maintenance_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
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
383void
385{
386 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
387
389
390 if (shared_aspace)
391 {
392 struct address_space *aspace = new address_space ();
393
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 ())
407 inf->aspace = maybe_new_address_space ();
408 else
409 inf->aspace = inf->pspace->aspace;
410}
411
412
413
414/* See progspace.h. */
415
416void
418{
419 added_solibs.clear ();
420 deleted_solibs.clear ();
421}
422
423
424
425void
427{
428 add_cmd ("program-spaces", class_maintenance,
430 _("Info about currently known program spaces."),
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. */
441}
struct gdbarch * target_gdbarch(void)
void breakpoint_program_space_exit(struct program_space *pspace)
ui_file_style style() const
Definition cli-style.c:169
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void field_signed(const char *fldname, LONGEST value)
Definition ui-out.c:437
void field_skip(const char *fldname)
Definition ui-out.c:499
void text(const char *string)
Definition ui-out.c:566
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition ui-out.c:363
void table_body()
Definition ui-out.c:376
struct cmd_list_element * maintenanceinfolist
Definition cli-cmds.c:145
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
cli_style_option file_name_style
@ class_maintenance
Definition command.h:65
LONGEST parse_and_eval_long(const char *exp)
Definition eval.c:62
void exec_file_attach(const char *filename, int from_tty)
Definition exec.c:365
void reinit_frame_cache(void)
Definition frame.c:2006
int gdbarch_has_shared_address_space(struct gdbarch *gdbarch)
Definition gdbarch.c:4788
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition gdbarch.c:4754
struct inferior * find_inferior_for_program_space(struct program_space *pspace)
Definition inferior.c:373
void switch_to_inferior_no_thread(inferior *inf)
Definition inferior.c:671
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:758
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
struct program_space * current_program_space
Definition progspace.c:39
static void init_address_spaces(void)
Definition progspace.c:74
void set_current_program_space(struct program_space *pspace)
Definition progspace.c:224
static void maintenance_info_program_spaces_command(const char *args, int from_tty)
Definition progspace.c:358
struct program_space * clone_program_space(struct program_space *dest, struct program_space *src)
Definition progspace.c:203
static void remove_program_space(program_space *pspace)
Definition progspace.c:84
static int highest_address_space_num
Definition progspace.c:42
void initialize_progspace(void)
Definition progspace.c:426
struct address_space * maybe_new_address_space(void)
Definition progspace.c:58
static void print_program_space(struct ui_out *uiout, int requested)
Definition progspace.c:250
void update_address_spaces(void)
Definition progspace.c:384
static int last_program_space_num
Definition progspace.c:33
static int valid_program_space_id(int num)
Definition progspace.c:344
std::vector< struct program_space * > program_spaces
Definition progspace.c:36
struct program_space * current_program_space
Definition progspace.c:39
void set_current_program_space(struct program_space *pspace)
Definition progspace.c:224
std::vector< struct program_space * > program_spaces
Definition progspace.c:36
void no_shared_libraries(const char *ignored, int from_tty)
Definition solib.c:1277
int num() const
Definition progspace.h:392
Definition gnu-nat.c:154
pid_t pid
Definition gnu-nat.c:166
void remove_target_sections(void *owner)
Definition exec.c:647
void remove_objfile(struct objfile *objfile)
Definition progspace.c:161
gdb_bfd_ref_ptr ebfd
Definition progspace.h:315
std::vector< std::string > deleted_solibs
Definition progspace.h:371
void exec_close()
Definition progspace.c:184
std::vector< struct so_list * > added_solibs
Definition progspace.h:367
void add_objfile(std::unique_ptr< objfile > &&objfile, struct objfile *before)
Definition progspace.c:141
struct address_space * aspace
Definition progspace.h:335
program_space(address_space *aspace)
Definition progspace.c:96
gdb::unique_xmalloc_ptr< char > exec_filename
Definition progspace.h:321
struct objfile * symfile_object_file
Definition progspace.h:353
std::list< std::unique_ptr< objfile > > objfiles_list
Definition progspace.h:356
void free_all_objfiles()
Definition progspace.c:128
void clear_solib_cache()
Definition progspace.c:417
so_list_range solibs() const
Definition progspace.h:256
@ SYMFILE_DEFER_BP_RESET
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
Definition symfile.c:1194
void clear_symtab_users(symfile_add_flags add_flags)
Definition symfile.c:2862
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2602
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865