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