1 /* Program and address space management, for GDB, the GNU debugger.
3 Copyright (C) 2009, 2010 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)
93 address_space_num (struct address_space *aspace)
98 /* Start counting over from scratch. */
101 init_address_spaces (void)
103 highest_address_space_num = 0;
108 /* Adds a new empty program space to the program space list, and binds
109 it to ASPACE. Returns the pointer to the new object. */
111 struct program_space *
112 add_program_space (struct address_space *aspace)
114 struct program_space *pspace;
116 pspace = XZALLOC (struct program_space);
118 pspace->num = ++last_program_space_num;
119 pspace->aspace = aspace;
121 program_space_alloc_data (pspace);
123 pspace->next = program_spaces;
124 program_spaces = pspace;
129 /* Releases program space PSPACE, and all its contents (shared
130 libraries, objfiles, and any other references to the PSPACE in
131 other modules). It is an internal error to call this when PSPACE
132 is the current program space, since there should always be a
136 release_program_space (struct program_space *pspace)
138 struct cleanup *old_chain = save_current_program_space ();
140 gdb_assert (pspace != current_program_space);
142 set_current_program_space (pspace);
144 breakpoint_program_space_exit (pspace);
145 no_shared_libraries (NULL, 0);
147 free_all_objfiles ();
148 if (!gdbarch_has_shared_address_space (target_gdbarch))
149 free_address_space (pspace->aspace);
150 resize_section_table (&pspace->target_sections,
151 -resize_section_table (&pspace->target_sections, 0));
152 /* Discard any data modules have associated with the PSPACE. */
153 program_space_free_data (pspace);
156 do_cleanups (old_chain);
159 /* Unlinks PSPACE from the pspace list, and releases it. */
162 remove_program_space (struct program_space *pspace)
164 struct program_space *ss, **ss_link;
167 ss_link = &program_spaces;
178 release_program_space (ss);
183 /* Copies program space SRC to DEST. Copies the main executable file,
184 and the main symbol file. Returns DEST. */
186 struct program_space *
187 clone_program_space (struct program_space *dest, struct program_space *src)
189 struct cleanup *old_chain;
191 old_chain = save_current_program_space ();
193 set_current_program_space (dest);
195 if (src->ebfd != NULL)
196 exec_file_attach (bfd_get_filename (src->ebfd), 0);
198 if (src->symfile_object_file != NULL)
199 symbol_file_add_main (src->symfile_object_file->name, 0);
201 do_cleanups (old_chain);
205 /* Sets PSPACE as the current program space. It is the caller's
206 responsibility to make sure that the currently selected
207 inferior/thread matches the selected program space. */
210 set_current_program_space (struct program_space *pspace)
212 if (current_program_space == pspace)
215 gdb_assert (pspace != NULL);
217 current_program_space = pspace;
219 /* Different symbols change our view of the frame chain. */
220 reinit_frame_cache ();
223 /* A cleanups callback, helper for save_current_program_space
227 restore_program_space (void *arg)
229 struct program_space *saved_pspace = arg;
230 set_current_program_space (saved_pspace);
233 /* Save the current program space so that it may be restored by a later
234 call to do_cleanups. Returns the struct cleanup pointer needed for
235 later doing the cleanup. */
238 save_current_program_space (void)
240 struct cleanup *old_chain = make_cleanup (restore_program_space,
241 current_program_space);
245 /* Returns true iff there's no inferior bound to PSPACE. */
248 pspace_empty_p (struct program_space *pspace)
250 if (find_inferior_for_program_space (pspace) != NULL)
256 /* Prune away automatically added program spaces that aren't required
260 prune_program_spaces (void)
262 struct program_space *ss, **ss_link;
263 struct program_space *current = current_program_space;
266 ss_link = &program_spaces;
269 if (ss == current || !pspace_empty_p (ss))
277 release_program_space (ss);
282 /* Prints the list of program spaces and their details on UIOUT. If
283 REQUESTED is not -1, it's the ID of the pspace that should be
284 printed. Otherwise, all spaces are printed. */
287 print_program_space (struct ui_out *uiout, int requested)
289 struct program_space *pspace;
291 struct cleanup *old_chain;
293 /* Might as well prune away unneeded ones, so the user doesn't even
295 prune_program_spaces ();
297 /* Compute number of pspaces we will print. */
300 if (requested != -1 && pspace->num != requested)
306 /* There should always be at least one. */
307 gdb_assert (count > 0);
309 old_chain = make_cleanup_ui_out_table_begin_end (uiout, 3, count, "pspaces");
310 ui_out_table_header (uiout, 1, ui_left, "current", "");
311 ui_out_table_header (uiout, 4, ui_left, "id", "Id");
312 ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
313 ui_out_table_body (uiout);
317 struct cleanup *chain2;
318 struct inferior *inf;
321 if (requested != -1 && requested != pspace->num)
324 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
326 if (pspace == current_program_space)
327 ui_out_field_string (uiout, "current", "*");
329 ui_out_field_skip (uiout, "current");
331 ui_out_field_int (uiout, "id", pspace->num);
334 ui_out_field_string (uiout, "exec",
335 bfd_get_filename (pspace->ebfd));
337 ui_out_field_skip (uiout, "exec");
339 /* Print extra info that doesn't really fit in tabular form.
340 Currently, we print the list of inferiors bound to a pspace.
341 There can be more than one inferior bound to the same pspace,
342 e.g., both parent/child inferiors in a vfork, or, on targets
343 that share pspaces between inferiors. */
345 for (inf = inferior_list; inf; inf = inf->next)
346 if (inf->pspace == pspace)
351 printf_filtered ("\n\tBound inferiors: ID %d (%s)",
353 target_pid_to_str (pid_to_ptid (inf->pid)));
356 printf_filtered (", ID %d (%s)",
358 target_pid_to_str (pid_to_ptid (inf->pid)));
361 ui_out_text (uiout, "\n");
362 do_cleanups (chain2);
365 do_cleanups (old_chain);
368 /* Boolean test for an already-known program space id. */
371 valid_program_space_id (int num)
373 struct program_space *pspace;
376 if (pspace->num == num)
382 /* If ARGS is NULL or empty, print information about all program
383 spaces. Otherwise, ARGS is a text representation of a LONG
384 indicating which the program space to print information about. */
387 maintenance_info_program_spaces_command (char *args, int from_tty)
393 requested = parse_and_eval_long (args);
394 if (!valid_program_space_id (requested))
395 error (_("program space ID %d not known."), requested);
398 print_program_space (uiout, requested);
401 /* Simply returns the count of program spaces. */
404 number_of_program_spaces (void)
406 struct program_space *pspace;
415 /* Update all program spaces matching to address spaces. The user may
416 have created several program spaces, and loaded executables into
417 them before connecting to the target interface that will create the
418 inferiors. All that happens before GDB has a chance to know if the
419 inferiors will share an address space or not. Call this after
420 having connected to the target interface and having fetched the
421 target description, to fixup the program/address spaces mappings.
423 It is assumed that there are no bound inferiors yet, otherwise,
424 they'd be left with stale referenced to released aspaces. */
427 update_address_spaces (void)
429 int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
430 struct program_space *pspace;
431 struct inferior *inf;
433 init_address_spaces ();
437 struct address_space *aspace = new_address_space ();
438 free_address_space (current_program_space->aspace);
440 pspace->aspace = aspace;
445 free_address_space (pspace->aspace);
446 pspace->aspace = new_address_space ();
449 for (inf = inferior_list; inf; inf = inf->next)
450 if (gdbarch_has_global_solist (target_gdbarch))
451 inf->aspace = maybe_new_address_space ();
453 inf->aspace = inf->pspace->aspace;
456 /* Save the current program space so that it may be restored by a later
457 call to do_cleanups. Returns the struct cleanup pointer needed for
458 later doing the cleanup. */
461 save_current_space_and_thread (void)
463 struct cleanup *old_chain;
465 /* If restoring to null thread, we need to restore the pspace as
466 well, hence, we need to save the current program space first. */
467 old_chain = save_current_program_space ();
468 save_current_inferior ();
469 make_cleanup_restore_current_thread ();
474 /* Switches full context to program space PSPACE. Switches to the
475 first thread found bound to PSPACE. */
478 switch_to_program_space_and_thread (struct program_space *pspace)
480 struct inferior *inf;
482 inf = find_inferior_for_program_space (pspace);
485 struct thread_info *tp;
487 tp = any_live_thread_of_process (inf->pid);
490 switch_to_thread (tp->ptid);
491 /* Switching thread switches pspace implicitly. We're
497 switch_to_thread (null_ptid);
498 set_current_program_space (pspace);
503 /* Keep a registry of per-program_space data-pointers required by other GDB
506 struct program_space_data
509 void (*cleanup) (struct program_space *, void *);
512 struct program_space_data_registration
514 struct program_space_data *data;
515 struct program_space_data_registration *next;
518 struct program_space_data_registry
520 struct program_space_data_registration *registrations;
521 unsigned num_registrations;
524 static struct program_space_data_registry program_space_data_registry
527 const struct program_space_data *
528 register_program_space_data_with_cleanup
529 (void (*cleanup) (struct program_space *, void *))
531 struct program_space_data_registration **curr;
533 /* Append new registration. */
534 for (curr = &program_space_data_registry.registrations;
535 *curr != NULL; curr = &(*curr)->next);
537 *curr = XMALLOC (struct program_space_data_registration);
538 (*curr)->next = NULL;
539 (*curr)->data = XMALLOC (struct program_space_data);
540 (*curr)->data->index = program_space_data_registry.num_registrations++;
541 (*curr)->data->cleanup = cleanup;
543 return (*curr)->data;
546 const struct program_space_data *
547 register_program_space_data (void)
549 return register_program_space_data_with_cleanup (NULL);
553 program_space_alloc_data (struct program_space *pspace)
555 gdb_assert (pspace->data == NULL);
556 pspace->num_data = program_space_data_registry.num_registrations;
557 pspace->data = XCALLOC (pspace->num_data, void *);
561 program_space_free_data (struct program_space *pspace)
563 gdb_assert (pspace->data != NULL);
564 clear_program_space_data (pspace);
565 xfree (pspace->data);
570 clear_program_space_data (struct program_space *pspace)
572 struct program_space_data_registration *registration;
575 gdb_assert (pspace->data != NULL);
577 for (registration = program_space_data_registry.registrations, i = 0;
578 i < pspace->num_data;
579 registration = registration->next, i++)
580 if (pspace->data[i] != NULL && registration->data->cleanup)
581 registration->data->cleanup (pspace, pspace->data[i]);
583 memset (pspace->data, 0, pspace->num_data * sizeof (void *));
587 set_program_space_data (struct program_space *pspace,
588 const struct program_space_data *data,
591 gdb_assert (data->index < pspace->num_data);
592 pspace->data[data->index] = value;
596 program_space_data (struct program_space *pspace, const struct program_space_data *data)
598 gdb_assert (data->index < pspace->num_data);
599 return pspace->data[data->index];
605 initialize_progspace (void)
607 add_cmd ("program-spaces", class_maintenance,
608 maintenance_info_program_spaces_command, _("\
609 Info about currently known program spaces."),
610 &maintenanceinfolist);
612 /* There's always one program space. Note that this function isn't
613 an automatic _initialize_foo function, since other
614 _initialize_foo routines may need to install their per-pspace
615 data keys. We can only allocate a progspace when all those
616 modules have done that. Do this before
617 initialize_current_architecture, because that accesses exec_bfd,
618 which in turn dereferences current_program_space. */
619 current_program_space = add_program_space (new_address_space ());