GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/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)
Definition: arch-utils.c:1453
void breakpoint_program_space_exit(struct program_space *pspace)
Definition: breakpoint.c:3009
ui_file_style style() const
Definition: cli-style.c:169
Definition: ui-out.h:160
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
bool empty()
Definition: progspace.c:240
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
long ebfd_mtime
Definition: progspace.h:317
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
Definition: solist.h:35
@ 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