GDB (xrefs)
/tmp/gdb-7.10/gdb/objfiles.c
Go to the documentation of this file.
1 /* GDB routines for manipulating objfiles.
2 
3  Copyright (C) 1992-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Support, using pieces from other GDB modules.
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 /* This file contains support routines for creating, manipulating, and
23  destroying objfile structures. */
24 
25 #include "defs.h"
26 #include "bfd.h" /* Binary File Description */
27 #include "symtab.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "gdb-stabs.h"
31 #include "target.h"
32 #include "bcache.h"
33 #include "expression.h"
34 #include "parser-defs.h"
35 
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <fcntl.h>
39 #include "gdb_obstack.h"
40 #include "hashtab.h"
41 
42 #include "breakpoint.h"
43 #include "block.h"
44 #include "dictionary.h"
45 #include "source.h"
46 #include "addrmap.h"
47 #include "arch-utils.h"
48 #include "exec.h"
49 #include "observer.h"
50 #include "complaints.h"
51 #include "psymtab.h"
52 #include "solist.h"
53 #include "gdb_bfd.h"
54 #include "btrace.h"
55 
56 /* Keep a registry of per-objfile data-pointers required by other GDB
57  modules. */
58 
60 
61 /* Externally visible variables that are owned by this module.
62  See declarations in objfile.h for more info. */
63 
65 {
68 
69  /* Nonzero if object files have been added since the section map
70  was last updated. */
72 
73  /* Nonzero if the section map MUST be updated before use. */
75 
76  /* Nonzero if section map updates should be inhibited if possible. */
78 };
79 
80 /* Per-program-space data key. */
81 static const struct program_space_data *objfiles_pspace_data;
82 
83 static void
84 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
85 {
86  struct objfile_pspace_info *info = arg;
87 
88  xfree (info->sections);
89  xfree (info);
90 }
91 
92 /* Get the current svr4 data. If none is found yet, add it now. This
93  function always returns a valid object. */
94 
95 static struct objfile_pspace_info *
97 {
98  struct objfile_pspace_info *info;
99 
100  info = program_space_data (pspace, objfiles_pspace_data);
101  if (info == NULL)
102  {
103  info = XCNEW (struct objfile_pspace_info);
104  set_program_space_data (pspace, objfiles_pspace_data, info);
105  }
106 
107  return info;
108 }
109 
110 
111 
112 /* Per-BFD data key. */
113 
114 static const struct bfd_data *objfiles_bfd_data;
115 
116 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
117  NULL, and it already has a per-BFD storage object, use that.
118  Otherwise, allocate a new per-BFD storage object. If ABFD is not
119  NULL, the object is allocated on the BFD; otherwise it is allocated
120  on OBJFILE's obstack. Note that it is not safe to call this
121  multiple times for a given OBJFILE -- it can only be called when
122  allocating or re-initializing OBJFILE. */
123 
124 static struct objfile_per_bfd_storage *
125 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
126 {
127  struct objfile_per_bfd_storage *storage = NULL;
128 
129  if (abfd != NULL)
130  storage = bfd_data (abfd, objfiles_bfd_data);
131 
132  if (storage == NULL)
133  {
134  /* If the object requires gdb to do relocations, we simply fall
135  back to not sharing data across users. These cases are rare
136  enough that this seems reasonable. */
137  if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
138  {
139  storage = bfd_zalloc (abfd, sizeof (struct objfile_per_bfd_storage));
140  set_bfd_data (abfd, objfiles_bfd_data, storage);
141  }
142  else
143  storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
144  struct objfile_per_bfd_storage);
145 
146  /* Look up the gdbarch associated with the BFD. */
147  if (abfd != NULL)
148  storage->gdbarch = gdbarch_from_bfd (abfd);
149 
150  obstack_init (&storage->storage_obstack);
151  storage->filename_cache = bcache_xmalloc (NULL, NULL);
152  storage->macro_cache = bcache_xmalloc (NULL, NULL);
154  }
155 
156  return storage;
157 }
158 
159 /* Free STORAGE. */
160 
161 static void
163 {
164  bcache_xfree (storage->filename_cache);
165  bcache_xfree (storage->macro_cache);
166  if (storage->demangled_names_hash)
167  htab_delete (storage->demangled_names_hash);
168  obstack_free (&storage->storage_obstack, 0);
169 }
170 
171 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
172  cleanup function to the BFD registry. */
173 
174 static void
175 objfile_bfd_data_free (struct bfd *unused, void *d)
176 {
178 }
179 
180 /* See objfiles.h. */
181 
182 void
184 {
185  objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
186 }
187 
188 /* Set the objfile's per-BFD notion of the "main" name and
189  language. */
190 
191 void
193  const char *name, enum language lang)
194 {
195  if (objfile->per_bfd->name_of_main == NULL
196  || strcmp (objfile->per_bfd->name_of_main, name) != 0)
197  objfile->per_bfd->name_of_main
198  = obstack_copy0 (&objfile->per_bfd->storage_obstack, name, strlen (name));
199  objfile->per_bfd->language_of_main = lang;
200 }
201 
202 
203 
204 /* Called via bfd_map_over_sections to build up the section table that
205  the objfile references. The objfile contains pointers to the start
206  of the table (objfile->sections) and to the first location after
207  the end of the table (objfile->sections_end). */
208 
209 static void
210 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
211  struct objfile *objfile, int force)
212 {
213  struct obj_section *section;
214 
215  if (!force)
216  {
217  flagword aflag;
218 
219  aflag = bfd_get_section_flags (abfd, asect);
220  if (!(aflag & SEC_ALLOC))
221  return;
222  }
223 
224  section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
225  section->objfile = objfile;
226  section->the_bfd_section = asect;
227  section->ovly_mapped = 0;
228 }
229 
230 static void
231 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
232  void *objfilep)
233 {
234  add_to_objfile_sections_full (abfd, asect, objfilep, 0);
235 }
236 
237 /* Builds a section table for OBJFILE.
238 
239  Note that the OFFSET and OVLY_MAPPED in each table entry are
240  initialized to zero. */
241 
242 void
244 {
245  int count = gdb_bfd_count_sections (objfile->obfd);
246 
247  objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
248  count,
249  struct obj_section);
250  objfile->sections_end = (objfile->sections + count);
251  bfd_map_over_sections (objfile->obfd,
252  add_to_objfile_sections, (void *) objfile);
253 
254  /* See gdb_bfd_section_index. */
255  add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
256  add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
257  add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
258  add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
259 }
260 
261 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
262  allocate a new objfile struct, fill it in as best we can, link it
263  into the list of all known objfiles, and return a pointer to the
264  new objfile struct.
265 
266  NAME should contain original non-canonicalized filename or other
267  identifier as entered by user. If there is no better source use
268  bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
269  NAME content is copied into returned objfile.
270 
271  The FLAGS word contains various bits (OBJF_*) that can be taken as
272  requests for specific operations. Other bits like OBJF_SHARED are
273  simply copied through to the new objfile flags member. */
274 
275 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
276  by jv-lang.c, to create an artificial objfile used to hold
277  information about dynamically-loaded Java classes. Unfortunately,
278  that branch of this function doesn't get tested very frequently, so
279  it's prone to breakage. (E.g. at one time the name was set to NULL
280  in that situation, which broke a loop over all names in the dynamic
281  library loader.) If you change this function, please try to leave
282  things in a consistent state even if abfd is NULL. */
283 
284 struct objfile *
285 allocate_objfile (bfd *abfd, const char *name, int flags)
286 {
287  struct objfile *objfile;
288  char *expanded_name;
289 
290  objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
291  objfile->psymbol_cache = psymbol_bcache_init ();
292  /* We could use obstack_specify_allocation here instead, but
293  gdb_obstack.h specifies the alloc/dealloc functions. */
294  obstack_init (&objfile->objfile_obstack);
295 
296  objfile_alloc_data (objfile);
297 
298  if (name == NULL)
299  {
300  gdb_assert (abfd == NULL);
301  gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
302  expanded_name = xstrdup ("<<anonymous objfile>>");
303  }
304  else if ((flags & OBJF_NOT_FILENAME) != 0
305  || is_target_filename (name))
306  expanded_name = xstrdup (name);
307  else
308  expanded_name = gdb_abspath (name);
309  objfile->original_name = obstack_copy0 (&objfile->objfile_obstack,
310  expanded_name,
311  strlen (expanded_name));
312  xfree (expanded_name);
313 
314  /* Update the per-objfile information that comes from the bfd, ensuring
315  that any data that is reference is saved in the per-objfile data
316  region. */
317 
318  objfile->obfd = abfd;
319  gdb_bfd_ref (abfd);
320  if (abfd != NULL)
321  {
322  objfile->mtime = bfd_get_mtime (abfd);
323 
324  /* Build section table. */
325  build_objfile_section_table (objfile);
326  }
327 
328  objfile->per_bfd = get_objfile_bfd_data (objfile, abfd);
329  objfile->pspace = current_program_space;
330 
332 
333  /* Initialize the section indexes for this objfile, so that we can
334  later detect if they are used w/o being properly assigned to. */
335 
336  objfile->sect_index_text = -1;
337  objfile->sect_index_data = -1;
338  objfile->sect_index_bss = -1;
339  objfile->sect_index_rodata = -1;
340 
341  /* Add this file onto the tail of the linked list of other such files. */
342 
343  objfile->next = NULL;
344  if (object_files == NULL)
345  object_files = objfile;
346  else
347  {
348  struct objfile *last_one;
349 
350  for (last_one = object_files;
351  last_one->next;
352  last_one = last_one->next);
353  last_one->next = objfile;
354  }
355 
356  /* Save passed in flag bits. */
357  objfile->flags |= flags;
358 
359  /* Rebuild section map next time we need it. */
361 
362  return objfile;
363 }
364 
365 /* Retrieve the gdbarch associated with OBJFILE. */
366 
367 struct gdbarch *
369 {
370  return objfile->per_bfd->gdbarch;
371 }
372 
373 /* If there is a valid and known entry point, function fills *ENTRY_P with it
374  and returns non-zero; otherwise it returns zero. */
375 
376 int
378 {
379  if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
380  return 0;
381 
382  *entry_p = (symfile_objfile->per_bfd->ei.entry_point
383  + ANOFFSET (symfile_objfile->section_offsets,
384  symfile_objfile->per_bfd->ei.the_bfd_section_index));
385 
386  return 1;
387 }
388 
389 /* Get current entry point address. Call error if it is not known. */
390 
391 CORE_ADDR
393 {
394  CORE_ADDR retval;
395 
396  if (!entry_point_address_query (&retval))
397  error (_("Entry point address is not known."));
398 
399  return retval;
400 }
401 
402 /* Iterator on PARENT and every separate debug objfile of PARENT.
403  The usage pattern is:
404  for (objfile = parent;
405  objfile;
406  objfile = objfile_separate_debug_iterate (parent, objfile))
407  ...
408 */
409 
410 struct objfile *
412  const struct objfile *objfile)
413 {
414  struct objfile *res;
415 
416  /* If any, return the first child. */
417  res = objfile->separate_debug_objfile;
418  if (res)
419  return res;
420 
421  /* Common case where there is no separate debug objfile. */
422  if (objfile == parent)
423  return NULL;
424 
425  /* Return the brother if any. Note that we don't iterate on brothers of
426  the parents. */
427  res = objfile->separate_debug_objfile_link;
428  if (res)
429  return res;
430 
431  for (res = objfile->separate_debug_objfile_backlink;
432  res != parent;
434  {
435  gdb_assert (res != NULL);
437  return res->separate_debug_objfile_link;
438  }
439  return NULL;
440 }
441 
442 /* Put one object file before a specified on in the global list.
443  This can be used to make sure an object file is destroyed before
444  another when using ALL_OBJFILES_SAFE to free all objfiles. */
445 void
446 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
447 {
448  struct objfile **objp;
449 
450  unlink_objfile (objfile);
451 
452  for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
453  {
454  if (*objp == before_this)
455  {
456  objfile->next = *objp;
457  *objp = objfile;
458  return;
459  }
460  }
461 
462  internal_error (__FILE__, __LINE__,
463  _("put_objfile_before: before objfile not in list"));
464 }
465 
466 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
467  list.
468 
469  It is not a bug, or error, to call this function if OBJFILE is not known
470  to be in the current list. This is done in the case of mapped objfiles,
471  for example, just to ensure that the mapped objfile doesn't appear twice
472  in the list. Since the list is threaded, linking in a mapped objfile
473  twice would create a circular list.
474 
475  If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
476  unlinking it, just to ensure that we have completely severed any linkages
477  between the OBJFILE and the list. */
478 
479 void
481 {
482  struct objfile **objpp;
483 
484  for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
485  {
486  if (*objpp == objfile)
487  {
488  *objpp = (*objpp)->next;
489  objfile->next = NULL;
490  return;
491  }
492  }
493 
494  internal_error (__FILE__, __LINE__,
495  _("unlink_objfile: objfile already unlinked"));
496 }
497 
498 /* Add OBJFILE as a separate debug objfile of PARENT. */
499 
500 void
501 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
502 {
503  gdb_assert (objfile && parent);
504 
505  /* Must not be already in a list. */
506  gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
507  gdb_assert (objfile->separate_debug_objfile_link == NULL);
508  gdb_assert (objfile->separate_debug_objfile == NULL);
510  gdb_assert (parent->separate_debug_objfile_link == NULL);
511 
512  objfile->separate_debug_objfile_backlink = parent;
514  parent->separate_debug_objfile = objfile;
515 
516  /* Put the separate debug object before the normal one, this is so that
517  usage of the ALL_OBJFILES_SAFE macro will stay safe. */
518  put_objfile_before (objfile, parent);
519 }
520 
521 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
522  itself. */
523 
524 void
526 {
527  struct objfile *child;
528 
529  for (child = objfile->separate_debug_objfile; child;)
530  {
531  struct objfile *next_child = child->separate_debug_objfile_link;
532  free_objfile (child);
533  child = next_child;
534  }
535 }
536 
537 /* Destroy an objfile and all the symtabs and psymtabs under it. */
538 
539 void
541 {
542  /* First notify observers that this objfile is about to be freed. */
544 
545  /* Free all separate debug objfiles. */
546  free_objfile_separate_debug (objfile);
547 
548  if (objfile->separate_debug_objfile_backlink)
549  {
550  /* We freed the separate debug file, make sure the base objfile
551  doesn't reference it. */
552  struct objfile *child;
553 
555 
556  if (child == objfile)
557  {
558  /* OBJFILE is the first child. */
561  }
562  else
563  {
564  /* Find OBJFILE in the list. */
565  while (1)
566  {
567  if (child->separate_debug_objfile_link == objfile)
568  {
571  break;
572  }
573  child = child->separate_debug_objfile_link;
574  gdb_assert (child);
575  }
576  }
577  }
578 
579  /* Remove any references to this objfile in the global value
580  lists. */
581  preserve_values (objfile);
582 
583  /* It still may reference data modules have associated with the objfile and
584  the symbol file data. */
586 
587  breakpoint_free_objfile (objfile);
588  btrace_free_objfile (objfile);
589 
590  /* First do any symbol file specific actions required when we are
591  finished with a particular symbol file. Note that if the objfile
592  is using reusable symbol information (via mmalloc) then each of
593  these routines is responsible for doing the correct thing, either
594  freeing things which are valid only during this particular gdb
595  execution, or leaving them to be reused during the next one. */
596 
597  if (objfile->sf != NULL)
598  {
599  (*objfile->sf->sym_finish) (objfile);
600  }
601 
602  /* Discard any data modules have associated with the objfile. The function
603  still may reference objfile->obfd. */
604  objfile_free_data (objfile);
605 
606  if (objfile->obfd)
607  gdb_bfd_unref (objfile->obfd);
608  else
610 
611  /* Remove it from the chain of all objfiles. */
612 
613  unlink_objfile (objfile);
614 
615  if (objfile == symfile_objfile)
616  symfile_objfile = NULL;
617 
618  /* Before the symbol table code was redone to make it easier to
619  selectively load and remove information particular to a specific
620  linkage unit, gdb used to do these things whenever the monolithic
621  symbol table was blown away. How much still needs to be done
622  is unknown, but we play it safe for now and keep each action until
623  it is shown to be no longer needed. */
624 
625  /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
626  for example), so we need to call this here. */
628 
629  /* Clear globals which might have pointed into a removed objfile.
630  FIXME: It's not clear which of these are supposed to persist
631  between expressions and which ought to be reset each time. */
633  innermost_block = NULL;
634 
635  /* Check to see if the current_source_symtab belongs to this objfile,
636  and if so, call clear_current_source_symtab_and_line. */
637 
638  {
640 
641  if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == objfile)
643  }
644 
645  if (objfile->global_psymbols.list)
646  xfree (objfile->global_psymbols.list);
647  if (objfile->static_psymbols.list)
648  xfree (objfile->static_psymbols.list);
649  /* Free the obstacks for non-reusable objfiles. */
651  obstack_free (&objfile->objfile_obstack, 0);
652 
653  /* Rebuild section map next time we need it. */
655 
656  /* The last thing we do is free the objfile struct itself. */
657  xfree (objfile);
658 }
659 
660 static void
662 {
663  free_objfile (obj);
664 }
665 
666 struct cleanup *
668 {
670 }
671 
672 /* Free all the object files at once and clean up their users. */
673 
674 void
676 {
677  struct objfile *objfile, *temp;
678  struct so_list *so;
679 
680  /* Any objfile referencewould become stale. */
681  for (so = master_so_list (); so; so = so->next)
682  gdb_assert (so->objfile == NULL);
683 
684  ALL_OBJFILES_SAFE (objfile, temp)
685  {
686  free_objfile (objfile);
687  }
688  clear_symtab_users (0);
689 }
690 
691 /* A helper function for objfile_relocate1 that relocates a single
692  symbol. */
693 
694 static void
696  struct section_offsets *delta)
697 {
698  fixup_symbol_section (sym, objfile);
699 
700  /* The RS6000 code from which this was taken skipped
701  any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
702  But I'm leaving out that test, on the theory that
703  they can't possibly pass the tests below. */
704  if ((SYMBOL_CLASS (sym) == LOC_LABEL
705  || SYMBOL_CLASS (sym) == LOC_STATIC)
706  && SYMBOL_SECTION (sym) >= 0)
707  {
708  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
709  }
710 }
711 
712 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
713  entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
714  Return non-zero iff any change happened. */
715 
716 static int
718  const struct section_offsets *new_offsets)
719 {
720  struct obj_section *s;
721  struct section_offsets *delta =
722  ((struct section_offsets *)
723  alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
724 
725  int i;
726  int something_changed = 0;
727 
728  for (i = 0; i < objfile->num_sections; ++i)
729  {
730  delta->offsets[i] =
731  ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
732  if (ANOFFSET (delta, i) != 0)
733  something_changed = 1;
734  }
735  if (!something_changed)
736  return 0;
737 
738  /* OK, get all the symtabs. */
739  {
740  struct compunit_symtab *cust;
741  struct symtab *s;
742 
743  ALL_OBJFILE_FILETABS (objfile, cust, s)
744  {
745  struct linetable *l;
746  int i;
747 
748  /* First the line table. */
749  l = SYMTAB_LINETABLE (s);
750  if (l)
751  {
752  for (i = 0; i < l->nitems; ++i)
753  l->item[i].pc += ANOFFSET (delta,
755  (cust));
756  }
757  }
758 
759  ALL_OBJFILE_COMPUNITS (objfile, cust)
760  {
761  const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
762  int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
763 
764  if (BLOCKVECTOR_MAP (bv))
766  ANOFFSET (delta, block_line_section));
767 
768  for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
769  {
770  struct block *b;
771  struct symbol *sym;
772  struct dict_iterator iter;
773 
774  b = BLOCKVECTOR_BLOCK (bv, i);
775  BLOCK_START (b) += ANOFFSET (delta, block_line_section);
776  BLOCK_END (b) += ANOFFSET (delta, block_line_section);
777 
778  /* We only want to iterate over the local symbols, not any
779  symbols in included symtabs. */
780  ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
781  {
782  relocate_one_symbol (sym, objfile, delta);
783  }
784  }
785  }
786  }
787 
788  /* Relocate isolated symbols. */
789  {
790  struct symbol *iter;
791 
792  for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
793  relocate_one_symbol (iter, objfile, delta);
794  }
795 
796  if (objfile->psymtabs_addrmap)
798  ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
799 
800  if (objfile->sf)
801  objfile->sf->qf->relocate (objfile, new_offsets, delta);
802 
803  {
804  int i;
805 
806  for (i = 0; i < objfile->num_sections; ++i)
807  (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
808  }
809 
810  /* Rebuild section map next time we need it. */
812 
813  /* Update the table in exec_ops, used to read memory. */
814  ALL_OBJFILE_OSECTIONS (objfile, s)
815  {
816  int idx = s - objfile->sections;
817 
818  exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
819  obj_section_addr (s));
820  }
821 
822  /* Data changed. */
823  return 1;
824 }
825 
826 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
827  entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
828 
829  The number and ordering of sections does differ between the two objfiles.
830  Only their names match. Also the file offsets will differ (objfile being
831  possibly prelinked but separate_debug_objfile is probably not prelinked) but
832  the in-memory absolute address as specified by NEW_OFFSETS must match both
833  files. */
834 
835 void
837  const struct section_offsets *new_offsets)
838 {
839  struct objfile *debug_objfile;
840  int changed = 0;
841 
842  changed |= objfile_relocate1 (objfile, new_offsets);
843 
844  for (debug_objfile = objfile->separate_debug_objfile;
845  debug_objfile;
846  debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
847  {
848  struct section_addr_info *objfile_addrs;
849  struct section_offsets *new_debug_offsets;
850  struct cleanup *my_cleanups;
851 
852  objfile_addrs = build_section_addr_info_from_objfile (objfile);
853  my_cleanups = make_cleanup (xfree, objfile_addrs);
854 
855  /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
856  relative ones must be already created according to debug_objfile. */
857 
858  addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
859 
860  gdb_assert (debug_objfile->num_sections
861  == gdb_bfd_count_sections (debug_objfile->obfd));
862  new_debug_offsets =
863  xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
864  make_cleanup (xfree, new_debug_offsets);
865  relative_addr_info_to_section_offsets (new_debug_offsets,
866  debug_objfile->num_sections,
867  objfile_addrs);
868 
869  changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
870 
871  do_cleanups (my_cleanups);
872  }
873 
874  /* Relocate breakpoints as necessary, after things are relocated. */
875  if (changed)
877 }
878 
879 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
880  not touched here.
881  Return non-zero iff any change happened. */
882 
883 static int
885 {
886  struct section_offsets *new_offsets =
887  ((struct section_offsets *)
888  alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
889  int i;
890 
891  for (i = 0; i < objfile->num_sections; ++i)
892  new_offsets->offsets[i] = slide;
893 
894  return objfile_relocate1 (objfile, new_offsets);
895 }
896 
897 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
898  SEPARATE_DEBUG_OBJFILEs. */
899 
900 void
902 {
903  struct objfile *debug_objfile;
904  int changed = 0;
905 
906  changed |= objfile_rebase1 (objfile, slide);
907 
908  for (debug_objfile = objfile->separate_debug_objfile;
909  debug_objfile;
910  debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
911  changed |= objfile_rebase1 (debug_objfile, slide);
912 
913  /* Relocate breakpoints as necessary, after things are relocated. */
914  if (changed)
916 }
917 
918 /* Return non-zero if OBJFILE has partial symbols. */
919 
920 int
922 {
923  if (!objfile->sf)
924  return 0;
925 
926  /* If we have not read psymbols, but we have a function capable of reading
927  them, then that is an indication that they are in fact available. Without
928  this function the symbols may have been already read in but they also may
929  not be present in this objfile. */
930  if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
931  && objfile->sf->sym_read_psymbols != NULL)
932  return 1;
933 
934  return objfile->sf->qf->has_symbols (objfile);
935 }
936 
937 /* Return non-zero if OBJFILE has full symbols. */
938 
939 int
941 {
942  return objfile->compunit_symtabs != NULL;
943 }
944 
945 /* Return non-zero if OBJFILE has full or partial symbols, either directly
946  or through a separate debug file. */
947 
948 int
950 {
951  struct objfile *o;
952 
953  for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
955  return 1;
956  return 0;
957 }
958 
959 
960 /* Many places in gdb want to test just to see if we have any partial
961  symbols available. This function returns zero if none are currently
962  available, nonzero otherwise. */
963 
964 int
966 {
967  struct objfile *ofp;
968 
969  ALL_OBJFILES (ofp)
970  {
971  if (objfile_has_partial_symbols (ofp))
972  return 1;
973  }
974  return 0;
975 }
976 
977 /* Many places in gdb want to test just to see if we have any full
978  symbols available. This function returns zero if none are currently
979  available, nonzero otherwise. */
980 
981 int
983 {
984  struct objfile *ofp;
985 
986  ALL_OBJFILES (ofp)
987  {
988  if (objfile_has_full_symbols (ofp))
989  return 1;
990  }
991  return 0;
992 }
993 
994 
995 /* This operations deletes all objfile entries that represent solibs that
996  weren't explicitly loaded by the user, via e.g., the add-symbol-file
997  command. */
998 
999 void
1001 {
1002  struct objfile *objf;
1003  struct objfile *temp;
1004 
1005  ALL_OBJFILES_SAFE (objf, temp)
1006  {
1007  /* We assume that the solib package has been purged already, or will
1008  be soon. */
1009 
1010  if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1011  free_objfile (objf);
1012  }
1013 }
1014 
1015 
1016 /* Many places in gdb want to test just to see if we have any minimal
1017  symbols available. This function returns zero if none are currently
1018  available, nonzero otherwise. */
1019 
1020 int
1022 {
1023  struct objfile *ofp;
1024 
1025  ALL_OBJFILES (ofp)
1026  {
1027  if (ofp->per_bfd->minimal_symbol_count > 0)
1028  {
1029  return 1;
1030  }
1031  }
1032  return 0;
1033 }
1034 
1035 /* Qsort comparison function. */
1036 
1037 static int
1038 qsort_cmp (const void *a, const void *b)
1039 {
1040  const struct obj_section *sect1 = *(const struct obj_section **) a;
1041  const struct obj_section *sect2 = *(const struct obj_section **) b;
1042  const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1043  const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1044 
1045  if (sect1_addr < sect2_addr)
1046  return -1;
1047  else if (sect1_addr > sect2_addr)
1048  return 1;
1049  else
1050  {
1051  /* Sections are at the same address. This could happen if
1052  A) we have an objfile and a separate debuginfo.
1053  B) we are confused, and have added sections without proper relocation,
1054  or something like that. */
1055 
1056  const struct objfile *const objfile1 = sect1->objfile;
1057  const struct objfile *const objfile2 = sect2->objfile;
1058 
1059  if (objfile1->separate_debug_objfile == objfile2
1060  || objfile2->separate_debug_objfile == objfile1)
1061  {
1062  /* Case A. The ordering doesn't matter: separate debuginfo files
1063  will be filtered out later. */
1064 
1065  return 0;
1066  }
1067 
1068  /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1069  triage. This section could be slow (since we iterate over all
1070  objfiles in each call to qsort_cmp), but this shouldn't happen
1071  very often (GDB is already in a confused state; one hopes this
1072  doesn't happen at all). If you discover that significant time is
1073  spent in the loops below, do 'set complaints 100' and examine the
1074  resulting complaints. */
1075 
1076  if (objfile1 == objfile2)
1077  {
1078  /* Both sections came from the same objfile. We are really confused.
1079  Sort on sequence order of sections within the objfile. */
1080 
1081  const struct obj_section *osect;
1082 
1083  ALL_OBJFILE_OSECTIONS (objfile1, osect)
1084  if (osect == sect1)
1085  return -1;
1086  else if (osect == sect2)
1087  return 1;
1088 
1089  /* We should have found one of the sections before getting here. */
1090  gdb_assert_not_reached ("section not found");
1091  }
1092  else
1093  {
1094  /* Sort on sequence number of the objfile in the chain. */
1095 
1096  const struct objfile *objfile;
1097 
1098  ALL_OBJFILES (objfile)
1099  if (objfile == objfile1)
1100  return -1;
1101  else if (objfile == objfile2)
1102  return 1;
1103 
1104  /* We should have found one of the objfiles before getting here. */
1105  gdb_assert_not_reached ("objfile not found");
1106  }
1107  }
1108 
1109  /* Unreachable. */
1110  gdb_assert_not_reached ("unexpected code path");
1111  return 0;
1112 }
1113 
1114 /* Select "better" obj_section to keep. We prefer the one that came from
1115  the real object, rather than the one from separate debuginfo.
1116  Most of the time the two sections are exactly identical, but with
1117  prelinking the .rel.dyn section in the real object may have different
1118  size. */
1119 
1120 static struct obj_section *
1122 {
1125  || (b->objfile->separate_debug_objfile == a->objfile));
1128 
1129  if (a->objfile->separate_debug_objfile != NULL)
1130  return a;
1131  return b;
1132 }
1133 
1134 /* Return 1 if SECTION should be inserted into the section map.
1135  We want to insert only non-overlay and non-TLS section. */
1136 
1137 static int
1138 insert_section_p (const struct bfd *abfd,
1139  const struct bfd_section *section)
1140 {
1141  const bfd_vma lma = bfd_section_lma (abfd, section);
1142 
1143  if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1144  && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1145  /* This is an overlay section. IN_MEMORY check is needed to avoid
1146  discarding sections from the "system supplied DSO" (aka vdso)
1147  on some Linux systems (e.g. Fedora 11). */
1148  return 0;
1149  if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1150  /* This is a TLS section. */
1151  return 0;
1152 
1153  return 1;
1154 }
1155 
1156 /* Filter out overlapping sections where one section came from the real
1157  objfile, and the other from a separate debuginfo file.
1158  Return the size of table after redundant sections have been eliminated. */
1159 
1160 static int
1161 filter_debuginfo_sections (struct obj_section **map, int map_size)
1162 {
1163  int i, j;
1164 
1165  for (i = 0, j = 0; i < map_size - 1; i++)
1166  {
1167  struct obj_section *const sect1 = map[i];
1168  struct obj_section *const sect2 = map[i + 1];
1169  const struct objfile *const objfile1 = sect1->objfile;
1170  const struct objfile *const objfile2 = sect2->objfile;
1171  const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1172  const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1173 
1174  if (sect1_addr == sect2_addr
1175  && (objfile1->separate_debug_objfile == objfile2
1176  || objfile2->separate_debug_objfile == objfile1))
1177  {
1178  map[j++] = preferred_obj_section (sect1, sect2);
1179  ++i;
1180  }
1181  else
1182  map[j++] = sect1;
1183  }
1184 
1185  if (i < map_size)
1186  {
1187  gdb_assert (i == map_size - 1);
1188  map[j++] = map[i];
1189  }
1190 
1191  /* The map should not have shrunk to less than half the original size. */
1192  gdb_assert (map_size / 2 <= j);
1193 
1194  return j;
1195 }
1196 
1197 /* Filter out overlapping sections, issuing a warning if any are found.
1198  Overlapping sections could really be overlay sections which we didn't
1199  classify as such in insert_section_p, or we could be dealing with a
1200  corrupt binary. */
1201 
1202 static int
1203 filter_overlapping_sections (struct obj_section **map, int map_size)
1204 {
1205  int i, j;
1206 
1207  for (i = 0, j = 0; i < map_size - 1; )
1208  {
1209  int k;
1210 
1211  map[j++] = map[i];
1212  for (k = i + 1; k < map_size; k++)
1213  {
1214  struct obj_section *const sect1 = map[i];
1215  struct obj_section *const sect2 = map[k];
1216  const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1217  const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1218  const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1219 
1220  gdb_assert (sect1_addr <= sect2_addr);
1221 
1222  if (sect1_endaddr <= sect2_addr)
1223  break;
1224  else
1225  {
1226  /* We have an overlap. Report it. */
1227 
1228  struct objfile *const objf1 = sect1->objfile;
1229  struct objfile *const objf2 = sect2->objfile;
1230 
1231  const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1232  const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1233 
1234  const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1235 
1236  struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1237 
1239  _("unexpected overlap between:\n"
1240  " (A) section `%s' from `%s' [%s, %s)\n"
1241  " (B) section `%s' from `%s' [%s, %s).\n"
1242  "Will ignore section B"),
1243  bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1244  paddress (gdbarch, sect1_addr),
1245  paddress (gdbarch, sect1_endaddr),
1246  bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1247  paddress (gdbarch, sect2_addr),
1248  paddress (gdbarch, sect2_endaddr));
1249  }
1250  }
1251  i = k;
1252  }
1253 
1254  if (i < map_size)
1255  {
1256  gdb_assert (i == map_size - 1);
1257  map[j++] = map[i];
1258  }
1259 
1260  return j;
1261 }
1262 
1263 
1264 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1265  TLS, overlay and overlapping sections. */
1266 
1267 static void
1269  struct obj_section ***pmap, int *pmap_size)
1270 {
1271  struct objfile_pspace_info *pspace_info;
1272  int alloc_size, map_size, i;
1273  struct obj_section *s, **map;
1274  struct objfile *objfile;
1275 
1276  pspace_info = get_objfile_pspace_data (pspace);
1277  gdb_assert (pspace_info->section_map_dirty != 0
1278  || pspace_info->new_objfiles_available != 0);
1279 
1280  map = *pmap;
1281  xfree (map);
1282 
1283  alloc_size = 0;
1284  ALL_PSPACE_OBJFILES (pspace, objfile)
1285  ALL_OBJFILE_OSECTIONS (objfile, s)
1286  if (insert_section_p (objfile->obfd, s->the_bfd_section))
1287  alloc_size += 1;
1288 
1289  /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1290  if (alloc_size == 0)
1291  {
1292  *pmap = NULL;
1293  *pmap_size = 0;
1294  return;
1295  }
1296 
1297  map = xmalloc (alloc_size * sizeof (*map));
1298 
1299  i = 0;
1300  ALL_PSPACE_OBJFILES (pspace, objfile)
1301  ALL_OBJFILE_OSECTIONS (objfile, s)
1302  if (insert_section_p (objfile->obfd, s->the_bfd_section))
1303  map[i++] = s;
1304 
1305  qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1306  map_size = filter_debuginfo_sections(map, alloc_size);
1307  map_size = filter_overlapping_sections(map, map_size);
1308 
1309  if (map_size < alloc_size)
1310  /* Some sections were eliminated. Trim excess space. */
1311  map = xrealloc (map, map_size * sizeof (*map));
1312  else
1313  gdb_assert (alloc_size == map_size);
1314 
1315  *pmap = map;
1316  *pmap_size = map_size;
1317 }
1318 
1319 /* Bsearch comparison function. */
1320 
1321 static int
1322 bsearch_cmp (const void *key, const void *elt)
1323 {
1324  const CORE_ADDR pc = *(CORE_ADDR *) key;
1325  const struct obj_section *section = *(const struct obj_section **) elt;
1326 
1327  if (pc < obj_section_addr (section))
1328  return -1;
1329  if (pc < obj_section_endaddr (section))
1330  return 0;
1331  return 1;
1332 }
1333 
1334 /* Returns a section whose range includes PC or NULL if none found. */
1335 
1336 struct obj_section *
1338 {
1339  struct objfile_pspace_info *pspace_info;
1340  struct obj_section *s, **sp;
1341 
1342  /* Check for mapped overlay section first. */
1343  s = find_pc_mapped_section (pc);
1344  if (s)
1345  return s;
1346 
1348  if (pspace_info->section_map_dirty
1349  || (pspace_info->new_objfiles_available
1350  && !pspace_info->inhibit_updates))
1351  {
1353  &pspace_info->sections,
1354  &pspace_info->num_sections);
1355 
1356  /* Don't need updates to section map until objfiles are added,
1357  removed or relocated. */
1358  pspace_info->new_objfiles_available = 0;
1359  pspace_info->section_map_dirty = 0;
1360  }
1361 
1362  /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1363  bsearch be non-NULL. */
1364  if (pspace_info->sections == NULL)
1365  {
1366  gdb_assert (pspace_info->num_sections == 0);
1367  return NULL;
1368  }
1369 
1370  sp = (struct obj_section **) bsearch (&pc,
1371  pspace_info->sections,
1372  pspace_info->num_sections,
1373  sizeof (*pspace_info->sections),
1374  bsearch_cmp);
1375  if (sp != NULL)
1376  return *sp;
1377  return NULL;
1378 }
1379 
1380 
1381 /* Return non-zero if PC is in a section called NAME. */
1382 
1383 int
1385 {
1386  struct obj_section *s;
1387  int retval = 0;
1388 
1389  s = find_pc_section (pc);
1390 
1391  retval = (s != NULL
1392  && s->the_bfd_section->name != NULL
1393  && strcmp (s->the_bfd_section->name, name) == 0);
1394  return (retval);
1395 }
1396 
1397 
1398 /* Set section_map_dirty so section map will be rebuilt next time it
1399  is used. Called by reread_symbols. */
1400 
1401 void
1403 {
1404  /* Rebuild section map next time we need it. */
1406 }
1407 
1408 /* See comments in objfiles.h. */
1409 
1410 void
1412 {
1414 }
1415 
1416 /* See comments in objfiles.h. */
1417 
1418 void
1420 {
1422 }
1423 
1424 /* See comments in objfiles.h. */
1425 
1426 void
1428 {
1430 }
1431 
1432 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1433  otherwise. */
1434 
1435 int
1437 {
1438  struct obj_section *osect;
1439 
1440  if (objfile == NULL)
1441  return 0;
1442 
1443  ALL_OBJFILE_OSECTIONS (objfile, osect)
1444  {
1445  if (section_is_overlay (osect) && !section_is_mapped (osect))
1446  continue;
1447 
1448  if (obj_section_addr (osect) <= addr
1449  && addr < obj_section_endaddr (osect))
1450  return 1;
1451  }
1452  return 0;
1453 }
1454 
1455 int
1457  CORE_ADDR address)
1458 {
1459  struct objfile *objfile;
1460 
1461  ALL_PSPACE_OBJFILES (pspace, objfile)
1462  {
1463  if ((objfile->flags & OBJF_SHARED) != 0
1464  && is_addr_in_objfile (address, objfile))
1465  return 1;
1466  }
1467 
1468  return 0;
1469 }
1470 
1471 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1472  gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1473  searching the objfiles in the order they are stored internally,
1474  ignoring CURRENT_OBJFILE.
1475 
1476  On most platorms, it should be close enough to doing the best
1477  we can without some knowledge specific to the architecture. */
1478 
1479 void
1481  (struct gdbarch *gdbarch,
1483  void *cb_data, struct objfile *current_objfile)
1484 {
1485  int stop = 0;
1486  struct objfile *objfile;
1487 
1488  ALL_OBJFILES (objfile)
1489  {
1490  stop = cb (objfile, cb_data);
1491  if (stop)
1492  return;
1493  }
1494 }
1495 
1496 /* See objfiles.h. */
1497 
1498 const char *
1500 {
1501  if (objfile->obfd != NULL)
1502  return bfd_get_filename (objfile->obfd);
1503 
1504  return objfile->original_name;
1505 }
1506 
1507 /* See objfiles.h. */
1508 
1509 const char *
1511 {
1512  if (objfile->obfd != NULL)
1513  return bfd_get_filename (objfile->obfd);
1514 
1515  return NULL;
1516 }
1517 
1518 /* See objfiles.h. */
1519 
1520 const char *
1522 {
1523  return lbasename (objfile->original_name);
1524 }
1525 
1526 /* Provide a prototype to silence -Wmissing-prototypes. */
1528 
1529 void
1531 {
1532  objfiles_pspace_data
1533  = register_program_space_data_with_cleanup (NULL,
1535 
1536  objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1538 }
int sect_index_text
Definition: objfiles.h:372
void objfiles_changed(void)
Definition: objfiles.c:1402
struct psymbol_allocation_list static_psymbols
Definition: objfiles.h:339
#define OBJF_USERLOADED
Definition: objfiles.h:445
void resume_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1419
#define OBJF_SHARED
Definition: objfiles.h:432
void addr_info_make_relative(struct section_addr_info *addrs, bfd *abfd)
Definition: symfile.c:573
#define object_files
Definition: progspace.h:220
static void do_free_objfile_cleanup(void *obj)
Definition: objfiles.c:661
CORE_ADDR offsets[1]
Definition: symtab.h:907
struct htab * demangled_names_hash
Definition: objfiles.h:198
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
#define ALL_OBJFILE_FILETABS(objfile, cu, s)
Definition: objfiles.h:591
char * gdb_abspath(const char *path)
Definition: utils.c:2945
struct psymbol_bcache * psymbol_bcache_init(void)
Definition: psymtab.c:1575
struct obstack storage_obstack
Definition: objfiles.h:177
#define DEFINE_REGISTRY(TAG, ACCESS)
Definition: registry.h:154
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct linetable_entry item[1]
Definition: symtab.h:892
void psymbol_bcache_free(struct psymbol_bcache *bcache)
Definition: psymtab.c:1584
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:806
void xfree(void *)
Definition: common-utils.c:97
void free_all_objfiles(void)
Definition: objfiles.c:675
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
struct so_list * next
Definition: solist.h:36
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:3089
struct symbol * hash_next
Definition: symtab.h:782
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
void relative_addr_info_to_section_offsets(struct section_offsets *section_offsets, int num_sections, const struct section_addr_info *addrs)
Definition: symfile.c:490
struct psymbol_allocation_list global_psymbols
Definition: objfiles.h:338
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:949
struct program_space * pspace
Definition: objfiles.h:286
int gdb_bfd_requires_relocations(bfd *abfd)
Definition: gdb_bfd.c:832
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:181
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define obj_section_endaddr(s)
Definition: objfiles.h:141
long mtime
Definition: objfiles.h:323
const char * objfile_filename(const struct objfile *objfile)
Definition: objfiles.c:1510
#define REGISTRY_ACCESS_FIELD(CONTAINER)
Definition: registry.h:85
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:836
struct section_addr_info * build_section_addr_info_from_objfile(const struct objfile *objfile)
Definition: symfile.c:322
#define ALL_DICT_SYMBOLS(dict, iter, sym)
Definition: dictionary.h:179
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition: objfiles.c:192
const struct block * innermost_block
Definition: parse.c:69
int have_partial_symbols(void)
Definition: objfiles.c:965
Definition: solist.h:30
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
#define OBJF_NOT_FILENAME
Definition: objfiles.h:460
#define _(String)
Definition: gdb_locale.h:40
void inhibit_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1411
char * original_name
Definition: objfiles.h:275
#define BLOCK_START(bl)
Definition: block.h:116
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct symbol * template_symbols
Definition: objfiles.h:414
int is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition: objfiles.c:1436
static int objfile_rebase1(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:884
void set_objfile_per_bfd(struct objfile *objfile)
Definition: objfiles.c:183
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
void breakpoint_free_objfile(struct objfile *objfile)
Definition: breakpoint.c:15561
#define obj_section_addr(s)
Definition: objfiles.h:135
void gdb_bfd_ref(struct bfd *abfd)
Definition: gdb_bfd.c:439
struct obstack objfile_obstack
Definition: objfiles.h:328
void observer_notify_free_objfile(struct objfile *objfile)
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
void default_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
Definition: objfiles.c:1481
#define SIZEOF_N_SECTION_OFFSETS(n)
Definition: symtab.h:917
int( iterate_over_objfiles_in_search_order_cb_ftype)(struct objfile *objfile, void *cb_data)
Definition: gdbarch.h:89
struct so_list * master_so_list(void)
Definition: solib.c:659
int objfile_has_partial_symbols(struct objfile *objfile)
Definition: objfiles.c:921
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
int shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition: objfiles.c:1456
static void update_section_map(struct program_space *pspace, struct obj_section ***pmap, int *pmap_size)
Definition: objfiles.c:1268
void breakpoint_re_set(void)
Definition: breakpoint.c:14273
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
void free_objfile_separate_debug(struct objfile *objfile)
Definition: objfiles.c:525
void free_objfile(struct objfile *objfile)
Definition: objfiles.c:540
struct cleanup * make_cleanup_free_objfile(struct objfile *obj)
Definition: objfiles.c:667
void clear_current_source_symtab_and_line(void)
Definition: source.c:242
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
CORE_ADDR pc
Definition: symtab.h:865
void initialize_file_ftype(void)
Definition: defs.h:281
int objfile_has_full_symbols(struct objfile *objfile)
Definition: objfiles.c:940
void * xzalloc(size_t size)
Definition: common-utils.c:91
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:970
static const struct program_space_data * objfiles_pspace_data
Definition: objfiles.c:81
static void objfiles_pspace_data_cleanup(struct program_space *pspace, void *arg)
Definition: objfiles.c:84
struct obj_section ** sections
Definition: objfiles.c:66
void preserve_values(struct objfile *objfile)
Definition: value.c:2534
void add_separate_debug_objfile(struct objfile *objfile, struct objfile *parent)
Definition: objfiles.c:501
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
const struct sym_fns * sf
Definition: objfiles.h:347
void build_objfile_section_table(struct objfile *objfile)
Definition: objfiles.c:243
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
int sect_index_rodata
Definition: objfiles.h:375
struct obj_section * sections
Definition: objfiles.h:386
static int filter_overlapping_sections(struct obj_section **map, int map_size)
Definition: objfiles.c:1203
struct bcache * bcache_xmalloc(unsigned long(*hash_function)(const void *, int length), int(*compare_function)(const void *, const void *, int length))
Definition: bcache.c:305
void forget_cached_source_info_for_objfile(struct objfile *objfile)
Definition: source.c:371
struct objfile * separate_debug_objfile
Definition: objfiles.h:397
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int objfile_relocate1(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:717
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:291
#define symfile_objfile
Definition: progspace.h:216
#define BLOCK_END(bl)
Definition: block.h:117
static int qsort_cmp(const void *a, const void *b)
Definition: objfiles.c:1038
static void add_to_objfile_sections(struct bfd *abfd, struct bfd_section *asect, void *objfilep)
Definition: objfiles.c:231
#define BLOCK_DICT(bl)
Definition: block.h:120
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:3129
static void relocate_one_symbol(struct symbol *sym, struct objfile *objfile, struct section_offsets *delta)
Definition: objfiles.c:695
void(* sym_finish)(struct objfile *)
Definition: symfile.h:363
Definition: symtab.h:925
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
void * xmalloc(YYSIZE_T)
void(* relocate)(struct objfile *objfile, const struct section_offsets *new_offsets, const struct section_offsets *delta)
Definition: symfile.h:223
struct symtab * symtab
Definition: symtab.h:1369
initialize_file_ftype _initialize_objfiles
void(* sym_read_psymbols)(struct objfile *)
Definition: symfile.h:357
Definition: block.h:60
#define ALL_OBJFILE_COMPUNITS(objfile, cu)
Definition: objfiles.h:597
struct bcache * macro_cache
Definition: objfiles.h:184
struct objfile * separate_debug_objfile_link
Definition: objfiles.h:405
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition: exec.c:980
struct bcache * filename_cache
Definition: objfiles.h:181
void clear_pc_function_cache(void)
Definition: blockframe.c:167
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int have_minimal_symbols(void)
Definition: objfiles.c:1021
void objfile_purge_solibs(void)
Definition: objfiles.c:1000
void clear_symtab_users(int add_flags)
Definition: symfile.c:2996
#define OBJF_PSYMTABS_READ
Definition: objfiles.h:450
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1809
int entry_point_address_query(CORE_ADDR *entry_p)
Definition: objfiles.c:377
void unlink_objfile(struct objfile *objfile)
Definition: objfiles.c:480
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition: arch-utils.c:560
CORE_ADDR entry_point_address(void)
Definition: objfiles.c:392
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3314
const char * name_of_main
Definition: objfiles.h:209
int num_sections
Definition: objfiles.h:363
void btrace_free_objfile(struct objfile *objfile)
Definition: btrace.c:1353
static struct objfile_pspace_info * get_objfile_pspace_data(struct program_space *pspace)
Definition: objfiles.c:96
struct obj_section * sections_end
Definition: objfiles.h:386
struct complaints * symfile_complaints
Definition: complaints.c:105
int gdb_bfd_count_sections(bfd *abfd)
Definition: gdb_bfd.c:824
#define COMPUNIT_BLOCK_LINE_SECTION(cust)
Definition: symtab.h:1100
struct gdbarch * gdbarch
Definition: objfiles.h:191
struct objfile * objfile_separate_debug_iterate(const struct objfile *parent, const struct objfile *objfile)
Definition: objfiles.c:411
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1521
struct objfile * next
Definition: objfiles.h:267
struct objfile * objfile
Definition: objfiles.h:124
enum language language_of_main
Definition: objfiles.h:210
#define qsort
Definition: ada-exp.c:2747
static int bsearch_cmp(const void *key, const void *elt)
Definition: objfiles.c:1322
#define ALL_OBJFILES_SAFE(obj, nxt)
Definition: objfiles.h:584
int pc_in_section(CORE_ADDR pc, char *name)
Definition: objfiles.c:1384
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:135
int have_full_symbols(void)
Definition: objfiles.c:982
struct objfile * allocate_objfile(bfd *abfd, const char *name, int flags)
Definition: objfiles.c:285
static void free_objfile_per_bfd_storage(struct objfile_per_bfd_storage *storage)
Definition: objfiles.c:162
void bcache_xfree(struct bcache *bcache)
Definition: bcache.c:327
void addrmap_relocate(struct addrmap *map, CORE_ADDR offset)
Definition: addrmap.c:75
static const struct bfd_data * objfiles_bfd_data
Definition: objfiles.c:114
struct partial_symbol ** list
Definition: symfile.h:59
const struct block * expression_context_block
Definition: parse.c:67
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:3081
struct program_space * current_program_space
Definition: progspace.c:35
struct addrmap * psymtabs_addrmap
Definition: objfiles.h:304
language
Definition: defs.h:167
int nitems
Definition: symtab.h:887
Definition: symtab.h:703
unsigned short flags
Definition: objfiles.h:282
static struct obj_section * preferred_obj_section(struct obj_section *a, struct obj_section *b)
Definition: objfiles.c:1121
#define BLOCKVECTOR_MAP(blocklist)
Definition: block.h:137
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
int sect_index_bss
Definition: objfiles.h:374
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:188
int new_objfiles_available
Definition: objfiles.c:71
struct section_offsets * section_offsets
Definition: objfiles.h:362
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1343
int ovly_mapped
Definition: objfiles.h:127
static int insert_section_p(const struct bfd *abfd, const struct bfd_section *section)
Definition: objfiles.c:1138
const struct quick_symbol_functions * qf
Definition: symfile.h:398
struct objfile * objfile
Definition: solist.h:69
int sect_index_data
Definition: objfiles.h:373
void put_objfile_before(struct objfile *objfile, struct objfile *before_this)
Definition: objfiles.c:446
static int filter_debuginfo_sections(struct obj_section **map, int map_size)
Definition: objfiles.c:1161
static void add_to_objfile_sections_full(struct bfd *abfd, struct bfd_section *asect, struct objfile *objfile, int force)
Definition: objfiles.c:210
int(* has_symbols)(struct objfile *objfile)
Definition: symfile.h:170
#define ALL_PSPACE_OBJFILES(ss, obj)
Definition: objfiles.h:576
int is_target_filename(const char *name)
Definition: gdb_bfd.c:145
void resume_section_map_updates_cleanup(void *arg)
Definition: objfiles.c:1427
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:966
struct psymbol_bcache * psymbol_cache
Definition: objfiles.h:333
static struct objfile_per_bfd_storage * get_objfile_bfd_data(struct objfile *objfile, struct bfd *abfd)
Definition: objfiles.c:125
void error(const char *fmt,...)
Definition: errors.c:38
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:901
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static void objfile_bfd_data_free(struct bfd *unused, void *d)
Definition: objfiles.c:175