1 /* Program and address space management, for GDB, the GNU debugger.
3 Copyright (C) 2009 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"
28 /* The last program space number assigned. */
29 int last_program_space_num = 0;
31 /* The head of the program spaces list. */
32 struct program_space *program_spaces;
34 /* Pointer to the current program space. */
35 struct program_space *current_program_space;
37 /* The last address space number assigned. */
38 static int highest_address_space_num;
40 /* Prototypes for local functions */
42 static void program_space_alloc_data (struct program_space *);
43 static void program_space_free_data (struct program_space *);
46 /* An address space. Currently this is not used for much other than
47 for comparing if pspaces/inferior/threads see the same address
55 /* Create a new address space object, and add it to the list. */
57 struct address_space *
58 new_address_space (void)
60 struct address_space *aspace;
62 aspace = XZALLOC (struct address_space);
63 aspace->num = ++highest_address_space_num;
68 /* Maybe create a new address space object, and add it to the list, or
69 return a pointer to an existing address space, in case inferiors
70 share an address space on this target system. */
72 struct address_space *
73 maybe_new_address_space (void)
75 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
79 /* Just return the first in the list. */
80 return program_spaces->aspace;
83 return new_address_space ();
87 free_address_space (struct address_space *aspace)
92 /* Start counting over from scratch. */
95 init_address_spaces (void)
97 highest_address_space_num = 0;
102 /* Adds a new empty program space to the program space list, and binds
103 it to ASPACE. Returns the pointer to the new object. */
105 struct program_space *
106 add_program_space (struct address_space *aspace)
108 struct program_space *pspace;
110 pspace = XZALLOC (struct program_space);
112 pspace->num = ++last_program_space_num;
113 pspace->aspace = aspace;
115 program_space_alloc_data (pspace);
117 pspace->next = program_spaces;
118 program_spaces = pspace;
123 /* Releases program space PSPACE, and all its contents (shared
124 libraries, objfiles, and any other references to the PSPACE in
125 other modules). It is an internal error to call this when PSPACE
126 is the current program space, since there should always be a
130 release_program_space (struct program_space *pspace)
132 struct cleanup *old_chain = save_current_program_space ();
134 gdb_assert (pspace != current_program_space);
136 set_current_program_space (pspace);
138 breakpoint_program_space_exit (pspace);
139 no_shared_libraries (NULL, 0);
141 free_all_objfiles ();
142 if (!gdbarch_has_shared_address_space (target_gdbarch))
143 free_address_space (pspace->aspace);
144 resize_section_table (&pspace->target_sections,
145 -resize_section_table (&pspace->target_sections, 0));
146 /* Discard any data modules have associated with the PSPACE. */
147 program_space_free_data (pspace);
150 do_cleanups (old_chain);
153 /* Unlinks PSPACE from the pspace list, and releases it. */
156 remove_program_space (struct program_space *pspace)
158 struct program_space *ss, **ss_link;
161 ss_link = &program_spaces;
172 release_program_space (ss);
177 /* Copies program space SRC to DEST. Copies the main executable file,
178 and the main symbol file. Returns DEST. */
180 struct program_space *
181 clone_program_space (struct program_space *dest, struct program_space *src)
183 struct program_space *new_pspace;
184 struct cleanup *old_chain;
186 old_chain = save_current_program_space ();
188 set_current_program_space (dest);
190 if (src->ebfd != NULL)
191 exec_file_attach (bfd_get_filename (src->ebfd), 0);
193 if (src->symfile_object_file != NULL)
194 symbol_file_add_main (src->symfile_object_file->name, 0);
196 do_cleanups (old_chain);
200 /* Sets PSPACE as the current program space. It is the caller's
201 responsibility to make sure that the currently selected
202 inferior/thread matches the selected program space. */
205 set_current_program_space (struct program_space *pspace)
207 if (current_program_space == pspace)
210 gdb_assert (pspace != NULL);
212 current_program_space = pspace;
214 /* Different symbols change our view of the frame chain. */
215 reinit_frame_cache ();
218 /* A cleanups callback, helper for save_current_program_space
222 restore_program_space (void *arg)
224 struct program_space *saved_pspace = arg;
225 set_current_program_space (saved_pspace);
228 /* Save the current program space so that it may be restored by a later
229 call to do_cleanups. Returns the struct cleanup pointer needed for
230 later doing the cleanup. */
233 save_current_program_space (void)
235 struct cleanup *old_chain = make_cleanup (restore_program_space,
236 current_program_space);
240 /* Find program space number NUM; returns NULL if not found. */
242 static struct program_space *
243 find_program_space_by_num (int num)
245 struct program_space *pspace;
248 if (pspace->num == num)
254 /* Returns true iff there's no inferior bound to PSPACE. */
257 pspace_empty_p (struct program_space *pspace)
259 struct inferior *inf;
261 if (find_inferior_for_program_space (pspace) != NULL)
267 /* Prune away automatically added program spaces that aren't required
271 prune_program_spaces (void)
273 struct program_space *ss, **ss_link;
274 struct program_space *current = current_program_space;
277 ss_link = &program_spaces;
280 if (ss == current || !pspace_empty_p (ss))
288 release_program_space (ss);
293 /* Prints the list of program spaces and their details on UIOUT. If
294 REQUESTED is not -1, it's the ID of the pspace that should be
295 printed. Otherwise, all spaces are printed. */
298 print_program_space (struct ui_out *uiout, int requested)
300 struct program_space *pspace;
302 struct cleanup *old_chain;
304 /* Might as well prune away unneeded ones, so the user doesn't even
306 prune_program_spaces ();
308 /* Compute number of pspaces we will print. */
311 if (requested != -1 && pspace->num != requested)
317 /* There should always be at least one. */
318 gdb_assert (count > 0);
320 old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
321 ui_out_table_header (uiout, 1, ui_left, "current", "");
322 ui_out_table_header (uiout, 4, ui_left, "id", "Id");
323 ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
324 ui_out_table_body (uiout);
328 struct cleanup *chain2;
329 struct inferior *inf;
332 if (requested != -1 && requested != pspace->num)
335 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
337 if (pspace == current_program_space)
338 ui_out_field_string (uiout, "current", "*");
340 ui_out_field_skip (uiout, "current");
342 ui_out_field_int (uiout, "id", pspace->num);
345 ui_out_field_string (uiout, "exec",
346 bfd_get_filename (pspace->ebfd));
348 ui_out_field_skip (uiout, "exec");
350 /* Print extra info that doesn't really fit in tabular form.
351 Currently, we print the list of inferiors bound to a pspace.
352 There can be more than one inferior bound to the same pspace,
353 e.g., both parent/child inferiors in a vfork, or, on targets
354 that share pspaces between inferiors. */
356 for (inf = inferior_list; inf; inf = inf->next)
357 if (inf->pspace == pspace)
362 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
364 target_pid_to_str (pid_to_ptid (inf->pid)));
367 printf_filtered (", ID %d (%s)",
369 target_pid_to_str (pid_to_ptid (inf->pid)));
372 ui_out_text (uiout, "\n");
373 do_cleanups (chain2);
376 do_cleanups (old_chain);
379 /* Boolean test for an already-known program space id. */
382 valid_program_space_id (int num)
384 struct program_space *pspace;
387 if (pspace->num == num)
393 /* If ARGS is NULL or empty, print information about all program
394 spaces. Otherwise, ARGS is a text representation of a LONG
395 indicating which the program space to print information about. */
398 maintenance_info_program_spaces_command (char *args, int from_tty)
404 requested = parse_and_eval_long (args);
405 if (!valid_program_space_id (requested))
406 error (_("program space ID %d not known."), requested);
409 print_program_space (uiout, requested);
412 /* Simply returns the count of program spaces. */
415 number_of_program_spaces (void)
417 struct program_space *pspace;
426 /* Update all program spaces matching to address spaces. The user may
427 have created several program spaces, and loaded executables into
428 them before connecting to the target interface that will create the
429 inferiors. All that happens before GDB has a chance to know if the
430 inferiors will share an address space or not. Call this after
431 having connected to the target interface and having fetched the
432 target description, to fixup the program/address spaces mappings.
434 It is assumed that there are no bound inferiors yet, otherwise,
435 they'd be left with stale referenced to released aspaces. */
438 update_address_spaces (void)
440 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
441 struct address_space *aspace = NULL;
442 struct program_space *pspace;
444 init_address_spaces ();
448 free_address_space (pspace->aspace);
453 aspace = new_address_space ();
454 pspace->aspace = aspace;
457 pspace->aspace = new_address_space ();
461 /* Save the current program space so that it may be restored by a later
462 call to do_cleanups. Returns the struct cleanup pointer needed for
463 later doing the cleanup. */
466 save_current_space_and_thread (void)
468 struct cleanup *old_chain;
470 /* If restoring to null thread, we need to restore the pspace as
471 well, hence, we need to save the current program space first. */
472 old_chain = save_current_program_space ();
473 save_current_inferior ();
474 make_cleanup_restore_current_thread ();
479 /* Switches full context to program space PSPACE. Switches to the
480 first thread found bound to PSPACE. */
483 switch_to_program_space_and_thread (struct program_space *pspace)
485 struct inferior *inf;
487 inf = find_inferior_for_program_space (pspace);
490 struct thread_info *tp;
492 tp = any_live_thread_of_process (inf->pid);
495 switch_to_thread (tp->ptid);
496 /* Switching thread switches pspace implicitly. We're
502 switch_to_thread (null_ptid);
503 set_current_program_space (pspace);
508 /* Keep a registry of per-program_space data-pointers required by other GDB
511 struct program_space_data
514 void (*cleanup) (struct program_space *, void *);
517 struct program_space_data_registration
519 struct program_space_data *data;
520 struct program_space_data_registration *next;
523 struct program_space_data_registry
525 struct program_space_data_registration *registrations;
526 unsigned num_registrations;
529 static struct program_space_data_registry program_space_data_registry
532 const struct program_space_data *
533 register_program_space_data_with_cleanup
534 (void (*cleanup) (struct program_space *, void *))
536 struct program_space_data_registration **curr;
538 /* Append new registration. */
539 for (curr = &program_space_data_registry.registrations;
540 *curr != NULL; curr = &(*curr)->next);
542 *curr = XMALLOC (struct program_space_data_registration);
543 (*curr)->next = NULL;
544 (*curr)->data = XMALLOC (struct program_space_data);
545 (*curr)->data->index = program_space_data_registry.num_registrations++;
546 (*curr)->data->cleanup = cleanup;
548 return (*curr)->data;
551 const struct program_space_data *
552 register_program_space_data (void)
554 return register_program_space_data_with_cleanup (NULL);
558 program_space_alloc_data (struct program_space *pspace)
560 gdb_assert (pspace->data == NULL);
561 pspace->num_data = program_space_data_registry.num_registrations;
562 pspace->data = XCALLOC (pspace->num_data, void *);
566 program_space_free_data (struct program_space *pspace)
568 gdb_assert (pspace->data != NULL);
569 clear_program_space_data (pspace);
570 xfree (pspace->data);
575 clear_program_space_data (struct program_space *pspace)
577 struct program_space_data_registration *registration;
580 gdb_assert (pspace->data != NULL);
582 for (registration = program_space_data_registry.registrations, i = 0;
583 i < pspace->num_data;
584 registration = registration->next, i++)
585 if (pspace->data[i] != NULL && registration->data->cleanup)
586 registration->data->cleanup (pspace, pspace->data[i]);
588 memset (pspace->data, 0, pspace->num_data * sizeof (void *));
592 set_program_space_data (struct program_space *pspace,
593 const struct program_space_data *data,
596 gdb_assert (data->index < pspace->num_data);
597 pspace->data[data->index] = value;
601 program_space_data (struct program_space *pspace, const struct program_space_data *data)
603 gdb_assert (data->index < pspace->num_data);
604 return pspace->data[data->index];
610 initialize_progspace (void)
612 add_cmd ("program-spaces", class_maintenance,
613 maintenance_info_program_spaces_command, _("\
614 Info about currently known program spaces."),
615 &maintenanceinfolist);
617 /* There's always one program space. Note that this function isn't
618 an automatic _initialize_foo function, since other
619 _initialize_foo routines may need to install their per-pspace
620 data keys. We can only allocate a progspace when all those
621 modules have done that. Do this before
622 initialize_current_architecture, because that accesses exec_bfd,
623 which in turn dereferences current_program_space. */
624 current_program_space = add_program_space (new_address_space ());