GDB (xrefs)
/tmp/gdb-7.10/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-2015 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 "gdbthread.h"
27 
28 /* The last program space number assigned. */
30 
31 /* The head of the program spaces list. */
33 
34 /* Pointer to the current program space. */
36 
37 /* The last address space number assigned. */
39 
40 
41 
42 /* Keep a registry of per-program_space data-pointers required by other GDB
43  modules. */
44 
46 
47 /* An address space. It is used for comparing if pspaces/inferior/threads
48  see the same address space and for associating caches to each address
49  space. */
50 
52 {
53  int num;
54 
55  /* Per aspace data-pointers required by other GDB modules. */
57 };
58 
59 /* Keep a registry of per-address_space data-pointers required by other GDB
60  modules. */
61 
63 
64 
65 
66 /* Create a new address space object, and add it to the list. */
67 
68 struct address_space *
70 {
71  struct address_space *aspace;
72 
73  aspace = XCNEW (struct address_space);
74  aspace->num = ++highest_address_space_num;
75  address_space_alloc_data (aspace);
76 
77  return aspace;
78 }
79 
80 /* Maybe create a new address space object, and add it to the list, or
81  return a pointer to an existing address space, in case inferiors
82  share an address space on this target system. */
83 
84 struct address_space *
86 {
87  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
88 
89  if (shared_aspace)
90  {
91  /* Just return the first in the list. */
92  return program_spaces->aspace;
93  }
94 
95  return new_address_space ();
96 }
97 
98 static void
100 {
101  address_space_free_data (aspace);
102  xfree (aspace);
103 }
104 
105 int
107 {
108  return aspace->num;
109 }
110 
111 /* Start counting over from scratch. */
112 
113 static void
115 {
117 }
118 
119 
120 
121 /* Adds a new empty program space to the program space list, and binds
122  it to ASPACE. Returns the pointer to the new object. */
123 
124 struct program_space *
126 {
127  struct program_space *pspace;
128 
129  pspace = XCNEW (struct program_space);
130 
131  pspace->num = ++last_program_space_num;
132  pspace->aspace = aspace;
133 
134  program_space_alloc_data (pspace);
135 
136  pspace->next = program_spaces;
137  program_spaces = pspace;
138 
139  return pspace;
140 }
141 
142 /* Releases program space PSPACE, and all its contents (shared
143  libraries, objfiles, and any other references to the PSPACE in
144  other modules). It is an internal error to call this when PSPACE
145  is the current program space, since there should always be a
146  program space. */
147 
148 static void
150 {
151  struct cleanup *old_chain = save_current_program_space ();
152 
153  gdb_assert (pspace != current_program_space);
154 
155  set_current_program_space (pspace);
156 
158  no_shared_libraries (NULL, 0);
159  exec_close ();
162  free_address_space (pspace->aspace);
165  /* Discard any data modules have associated with the PSPACE. */
166  program_space_free_data (pspace);
167  xfree (pspace);
168 
169  do_cleanups (old_chain);
170 }
171 
172 /* Copies program space SRC to DEST. Copies the main executable file,
173  and the main symbol file. Returns DEST. */
174 
175 struct program_space *
177 {
178  struct cleanup *old_chain;
179 
180  old_chain = save_current_program_space ();
181 
183 
184  if (src->pspace_exec_filename != NULL)
186 
187  if (src->symfile_object_file != NULL)
189 
190  do_cleanups (old_chain);
191  return dest;
192 }
193 
194 /* Sets PSPACE as the current program space. It is the caller's
195  responsibility to make sure that the currently selected
196  inferior/thread matches the selected program space. */
197 
198 void
200 {
201  if (current_program_space == pspace)
202  return;
203 
204  gdb_assert (pspace != NULL);
205 
206  current_program_space = pspace;
207 
208  /* Different symbols change our view of the frame chain. */
210 }
211 
212 /* A cleanups callback, helper for save_current_program_space
213  below. */
214 
215 static void
217 {
218  struct program_space *saved_pspace = arg;
219 
220  set_current_program_space (saved_pspace);
221 }
222 
223 /* Save the current program space so that it may be restored by a later
224  call to do_cleanups. Returns the struct cleanup pointer needed for
225  later doing the cleanup. */
226 
227 struct cleanup *
229 {
230  struct cleanup *old_chain = make_cleanup (restore_program_space,
231  current_program_space);
232 
233  return old_chain;
234 }
235 
236 /* Returns true iff there's no inferior bound to PSPACE. */
237 
238 static int
240 {
241  if (find_inferior_for_program_space (pspace) != NULL)
242  return 0;
243 
244  return 1;
245 }
246 
247 /* Prune away automatically added program spaces that aren't required
248  anymore. */
249 
250 void
252 {
253  struct program_space *ss, **ss_link;
254  struct program_space *current = current_program_space;
255 
256  ss = program_spaces;
257  ss_link = &program_spaces;
258  while (ss)
259  {
260  if (ss == current || !pspace_empty_p (ss))
261  {
262  ss_link = &ss->next;
263  ss = *ss_link;
264  continue;
265  }
266 
267  *ss_link = ss->next;
269  ss = *ss_link;
270  }
271 }
272 
273 /* Prints the list of program spaces and their details on UIOUT. If
274  REQUESTED is not -1, it's the ID of the pspace that should be
275  printed. Otherwise, all spaces are printed. */
276 
277 static void
278 print_program_space (struct ui_out *uiout, int requested)
279 {
280  struct program_space *pspace;
281  int count = 0;
282  struct cleanup *old_chain;
283 
284  /* Compute number of pspaces we will print. */
285  ALL_PSPACES (pspace)
286  {
287  if (requested != -1 && pspace->num != requested)
288  continue;
289 
290  ++count;
291  }
292 
293  /* There should always be at least one. */
294  gdb_assert (count > 0);
295 
296  old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
297  ui_out_table_header (uiout, 1, ui_left, "current", "");
298  ui_out_table_header (uiout, 4, ui_left, "id", "Id");
299  ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
300  ui_out_table_body (uiout);
301 
302  ALL_PSPACES (pspace)
303  {
304  struct cleanup *chain2;
305  struct inferior *inf;
306  int printed_header;
307 
308  if (requested != -1 && requested != pspace->num)
309  continue;
310 
311  chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
312 
313  if (pspace == current_program_space)
314  ui_out_field_string (uiout, "current", "*");
315  else
316  ui_out_field_skip (uiout, "current");
317 
318  ui_out_field_int (uiout, "id", pspace->num);
319 
320  if (pspace->pspace_exec_filename)
321  ui_out_field_string (uiout, "exec", pspace->pspace_exec_filename);
322  else
323  ui_out_field_skip (uiout, "exec");
324 
325  /* Print extra info that doesn't really fit in tabular form.
326  Currently, we print the list of inferiors bound to a pspace.
327  There can be more than one inferior bound to the same pspace,
328  e.g., both parent/child inferiors in a vfork, or, on targets
329  that share pspaces between inferiors. */
330  printed_header = 0;
331  for (inf = inferior_list; inf; inf = inf->next)
332  if (inf->pspace == pspace)
333  {
334  if (!printed_header)
335  {
336  printed_header = 1;
337  printf_filtered ("\n\tBound inferiors: ID %d (%s)",
338  inf->num,
340  }
341  else
342  printf_filtered (", ID %d (%s)",
343  inf->num,
345  }
346 
347  ui_out_text (uiout, "\n");
348  do_cleanups (chain2);
349  }
350 
351  do_cleanups (old_chain);
352 }
353 
354 /* Boolean test for an already-known program space id. */
355 
356 static int
358 {
359  struct program_space *pspace;
360 
361  ALL_PSPACES (pspace)
362  if (pspace->num == num)
363  return 1;
364 
365  return 0;
366 }
367 
368 /* If ARGS is NULL or empty, print information about all program
369  spaces. Otherwise, ARGS is a text representation of a LONG
370  indicating which the program space to print information about. */
371 
372 static void
373 maintenance_info_program_spaces_command (char *args, int from_tty)
374 {
375  int requested = -1;
376 
377  if (args && *args)
378  {
379  requested = parse_and_eval_long (args);
380  if (!valid_program_space_id (requested))
381  error (_("program space ID %d not known."), requested);
382  }
383 
384  print_program_space (current_uiout, requested);
385 }
386 
387 /* Simply returns the count of program spaces. */
388 
389 int
391 {
392  struct program_space *pspace;
393  int count = 0;
394 
395  ALL_PSPACES (pspace)
396  count++;
397 
398  return count;
399 }
400 
401 /* Update all program spaces matching to address spaces. The user may
402  have created several program spaces, and loaded executables into
403  them before connecting to the target interface that will create the
404  inferiors. All that happens before GDB has a chance to know if the
405  inferiors will share an address space or not. Call this after
406  having connected to the target interface and having fetched the
407  target description, to fixup the program/address spaces mappings.
408 
409  It is assumed that there are no bound inferiors yet, otherwise,
410  they'd be left with stale referenced to released aspaces. */
411 
412 void
414 {
415  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
416  struct program_space *pspace;
417  struct inferior *inf;
418 
420 
421  if (shared_aspace)
422  {
423  struct address_space *aspace = new_address_space ();
424 
425  free_address_space (current_program_space->aspace);
426  ALL_PSPACES (pspace)
427  pspace->aspace = aspace;
428  }
429  else
430  ALL_PSPACES (pspace)
431  {
432  free_address_space (pspace->aspace);
433  pspace->aspace = new_address_space ();
434  }
435 
436  for (inf = inferior_list; inf; inf = inf->next)
439  else
440  inf->aspace = inf->pspace->aspace;
441 }
442 
443 /* Save the current program space so that it may be restored by a later
444  call to do_cleanups. Returns the struct cleanup pointer needed for
445  later doing the cleanup. */
446 
447 struct cleanup *
449 {
450  struct cleanup *old_chain;
451 
452  /* If restoring to null thread, we need to restore the pspace as
453  well, hence, we need to save the current program space first. */
454  old_chain = save_current_program_space ();
455  /* There's no need to save the current inferior here.
456  That is handled by make_cleanup_restore_current_thread. */
458 
459  return old_chain;
460 }
461 
462 /* See progspace.h */
463 
464 void
466 {
467  struct inferior *inf;
468 
469  inf = find_inferior_for_program_space (pspace);
470  if (inf != NULL && inf->pid != 0)
471  {
472  struct thread_info *tp;
473 
474  tp = any_live_thread_of_process (inf->pid);
475  if (tp != NULL)
476  {
477  switch_to_thread (tp->ptid);
478  /* Switching thread switches pspace implicitly. We're
479  done. */
480  return;
481  }
482  }
483 
485  set_current_program_space (pspace);
486 }
487 
488 
489 
490 /* See progspace.h. */
491 
492 void
494 {
495  VEC_free (so_list_ptr, pspace->added_solibs);
496 
497  free_char_ptr_vec (pspace->deleted_solibs);
498  pspace->deleted_solibs = NULL;
499 }
500 
501 
502 
503 void
505 {
506  add_cmd ("program-spaces", class_maintenance,
508  _("Info about currently known program spaces."),
510 
511  /* There's always one program space. Note that this function isn't
512  an automatic _initialize_foo function, since other
513  _initialize_foo routines may need to install their per-pspace
514  data keys. We can only allocate a progspace when all those
515  modules have done that. Do this before
516  initialize_current_architecture, because that accesses exec_bfd,
517  which in turn dereferences current_program_space. */
518  current_program_space = add_program_space (new_address_space ());
519 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
int number_of_program_spaces(void)
Definition: progspace.c:390
struct address_space * maybe_new_address_space(void)
Definition: progspace.c:85
void free_char_ptr_vec(VEC(char_ptr)*char_ptr_vec)
Definition: gdb_vecs.c:32
#define DEFINE_REGISTRY(TAG, ACCESS)
Definition: registry.h:154
void ui_out_field_int(struct ui_out *uiout, const char *fldname, int value)
Definition: ui-out.c:467
static int pspace_empty_p(struct program_space *pspace)
Definition: progspace.c:239
struct address_space * aspace
Definition: progspace.h:166
void xfree(void *)
Definition: common-utils.c:97
void free_all_objfiles(void)
Definition: objfiles.c:675
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition: gdbarch.c:4346
void no_shared_libraries(char *ignored, int from_tty)
Definition: solib.c:1302
struct objfile * symfile_object_file
Definition: progspace.h:184
tuple inf
Definition: arm-linux.py:13
struct cleanup * make_cleanup_ui_out_table_begin_end(struct ui_out *ui_out, int nr_cols, int nr_rows, const char *tblid)
Definition: ui-out.c:369
struct cmd_list_element * maintenanceinfolist
Definition: cli-cmds.c:163
int pid
Definition: inferior.h:299
int num
Definition: inferior.h:295
#define REGISTRY_ACCESS_FIELD(CONTAINER)
Definition: registry.h:85
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
Definition: solist.h:30
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
#define _(String)
Definition: gdb_locale.h:40
Definition: ui-out.h:40
void breakpoint_program_space_exit(struct program_space *pspace)
Definition: breakpoint.c:2941
Definition: ui-out.c:99
void ui_out_text(struct ui_out *uiout, const char *string)
Definition: ui-out.c:582
void printf_filtered(const char *format,...)
Definition: utils.c:2388
struct program_space * add_program_space(struct address_space *aspace)
Definition: progspace.c:125
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:199
static void print_program_space(struct ui_out *uiout, int requested)
Definition: progspace.c:278
static int valid_program_space_id(int num)
Definition: progspace.c:357
void initialize_progspace(void)
Definition: progspace.c:504
struct address_space * aspace
Definition: inferior.h:314
void ui_out_field_skip(struct ui_out *uiout, const char *fldname)
Definition: ui-out.c:528
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
struct program_space * pspace
Definition: inferior.h:317
struct target_section_table target_sections
Definition: progspace.h:192
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:528
static int highest_address_space_num
Definition: progspace.c:38
void update_address_spaces(void)
Definition: progspace.c:413
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int last_program_space_num
Definition: progspace.c:29
void clear_program_space_solib_cache(struct program_space *pspace)
Definition: progspace.c:493
struct inferior * inferior_list
Definition: inferior.c:46
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int gdbarch_has_shared_address_space(struct gdbarch *gdbarch)
Definition: gdbarch.c:4380
static void init_address_spaces(void)
Definition: progspace.c:114
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
void symbol_file_add_main(const char *args, int from_tty)
Definition: symfile.c:1309
struct program_space * clone_program_space(struct program_space *dest, struct program_space *src)
Definition: progspace.c:176
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:195
struct inferior * next
Definition: inferior.h:291
ptid_t null_ptid
Definition: ptid.c:25
static void restore_program_space(void *arg)
Definition: progspace.c:216
#define ALL_PSPACES(pspace)
Definition: progspace.h:232
ptid_t ptid
Definition: gdbthread.h:169
static void release_program_space(struct program_space *pspace)
Definition: progspace.c:149
struct cleanup * make_cleanup_restore_current_thread(void)
Definition: thread.c:1354
char * pspace_exec_filename
Definition: progspace.h:155
#define VEC_free(T, V)
Definition: vec.h:180
int address_space_num(struct address_space *aspace)
Definition: progspace.c:106
struct address_space * new_address_space(void)
Definition: progspace.c:69
void ui_out_table_header(struct ui_out *uiout, int width, enum ui_align alignment, const char *col_name, const char *colhdr)
Definition: ui-out.c:346
struct program_space * current_program_space
Definition: progspace.c:35
void exec_close(void)
Definition: exec.c:88
static void free_address_space(struct address_space *aspace)
Definition: progspace.c:99
struct cleanup * save_current_program_space(void)
Definition: progspace.c:228
struct cleanup * save_current_space_and_thread(void)
Definition: progspace.c:448
struct inferior * find_inferior_for_program_space(struct program_space *pspace)
Definition: inferior.c:381
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
static void maintenance_info_program_spaces_command(char *args, int from_tty)
Definition: progspace.c:373
void ui_out_table_body(struct ui_out *uiout)
Definition: ui-out.c:309
void switch_to_program_space_and_thread(struct program_space *pspace)
Definition: progspace.c:465
void * arg
Definition: cleanups.c:43
void reinit_frame_cache(void)
Definition: frame.c:1687
void prune_program_spaces(void)
Definition: progspace.c:251
struct ui_out * current_uiout
Definition: ui-out.c:233
void clear_section_table(struct target_section_table *table)
Definition: exec.c:433
void error(const char *fmt,...)
Definition: errors.c:38
struct program_space * next
Definition: progspace.h:140
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct program_space * program_spaces
Definition: progspace.c:32
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111