GDB (xrefs)
Loading...
Searching...
No Matches
objfiles.c
Go to the documentation of this file.
1/* GDB routines for manipulating objfiles.
2
3 Copyright (C) 1992-2023 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 "gdbsupport/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 "observable.h"
50#include "complaints.h"
51#include "psymtab.h"
52#include "solist.h"
53#include "gdb_bfd.h"
54#include "btrace.h"
55#include "gdbsupport/pathstuff.h"
56
57#include <algorithm>
58#include <vector>
59
60/* Externally visible variables that are owned by this module.
61 See declarations in objfile.h for more info. */
62
64{
65 objfile_pspace_info () = default;
67
68 struct obj_section **sections = nullptr;
69 int num_sections = 0;
70
71 /* Nonzero if object files have been added since the section map
72 was last updated. */
74
75 /* Nonzero if the section map MUST be updated before use. */
77
78 /* Nonzero if section map updates should be inhibited if possible. */
80};
81
82/* Per-program-space data key. */
85
87{
89}
90
91/* Get the current svr4 data. If none is found yet, add it now. This
92 function always returns a valid object. */
93
94static struct objfile_pspace_info *
96{
97 struct objfile_pspace_info *info;
98
99 info = objfiles_pspace_data.get (pspace);
100 if (info == NULL)
101 info = objfiles_pspace_data.emplace (pspace);
102
103 return info;
104}
105
106
107
108/* Per-BFD data key. */
109
111
113{
114}
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. */
119
120void
122{
123 bfd *abfd = objfile->obfd.get ();
124 struct objfile_per_bfd_storage *storage = NULL;
125
126 if (abfd != NULL)
127 storage = objfiles_bfd_data.get (abfd);
128
129 if (storage == NULL)
130 {
131 storage = new objfile_per_bfd_storage (abfd);
132 /* If the object requires gdb to do relocations, we simply fall
133 back to not sharing data across users. These cases are rare
134 enough that this seems reasonable. */
135 if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
136 objfiles_bfd_data.set (abfd, storage);
137 else
138 objfile->per_bfd_storage.reset (storage);
139
140 /* Look up the gdbarch associated with the BFD. */
141 if (abfd != NULL)
142 storage->gdbarch = gdbarch_from_bfd (abfd);
143 }
144
145 objfile->per_bfd = storage;
146}
147
148/* Set the objfile's per-BFD notion of the "main" name and
149 language. */
150
151void
153 const char *name, enum language lang)
154{
155 if (objfile->per_bfd->name_of_main == NULL
156 || strcmp (objfile->per_bfd->name_of_main, name) != 0)
158 = obstack_strdup (&objfile->per_bfd->storage_obstack, name);
160}
161
162/* Helper structure to map blocks to static link properties in hash tables. */
163
165{
166 const struct block *block;
168};
169
170/* Return a hash code for struct static_link_htab_entry *P. */
171
172static hashval_t
174{
175 const struct static_link_htab_entry *e
176 = (const struct static_link_htab_entry *) p;
177
178 return htab_hash_pointer (e->block);
179}
180
181/* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
182 mappings for the same block. */
183
184static int
185static_link_htab_entry_eq (const void *p1, const void *p2)
186{
187 const struct static_link_htab_entry *e1
188 = (const struct static_link_htab_entry *) p1;
189 const struct static_link_htab_entry *e2
190 = (const struct static_link_htab_entry *) p2;
191
192 return e1->block == e2->block;
193}
194
195/* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
196 Must not be called more than once for each BLOCK. */
197
198void
200 const struct block *block,
201 const struct dynamic_prop *static_link)
202{
203 void **slot;
204 struct static_link_htab_entry lookup_entry;
205 struct static_link_htab_entry *entry;
206
207 if (objfile->static_links == NULL)
208 objfile->static_links.reset (htab_create_alloc
210 xcalloc, xfree));
211
212 /* Create a slot for the mapping, make sure it's the first mapping for this
213 block and then create the mapping itself. */
214 lookup_entry.block = block;
215 slot = htab_find_slot (objfile->static_links.get (), &lookup_entry, INSERT);
216 gdb_assert (*slot == NULL);
217
219 entry->block = block;
220 entry->static_link = static_link;
221 *slot = (void *) entry;
222}
223
224/* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
225 none was found. */
226
227const struct dynamic_prop *
229 const struct block *block)
230{
231 struct static_link_htab_entry *entry;
232 struct static_link_htab_entry lookup_entry;
233
234 if (objfile->static_links == NULL)
235 return NULL;
236 lookup_entry.block = block;
237 entry = ((struct static_link_htab_entry *)
238 htab_find (objfile->static_links.get (), &lookup_entry));
239 if (entry == NULL)
240 return NULL;
241
242 gdb_assert (entry->block == block);
243 return entry->static_link;
244}
245
246
247
248/* Build up the section table that the objfile references. The
249 objfile contains pointers to the start of the table
250 (objfile->sections) and to the first location after the end of the
251 table (objfile->sections_end). */
252
253static void
254add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
255 struct objfile *objfile, int force)
256{
257 struct obj_section *section;
258
259 if (!force)
260 {
261 flagword aflag;
262
263 aflag = bfd_section_flags (asect);
264 if (!(aflag & SEC_ALLOC))
265 return;
266 }
267
268 section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
269 section->objfile = objfile;
270 section->the_bfd_section = asect;
271 section->ovly_mapped = 0;
272}
273
274/* Builds a section table for OBJFILE.
275
276 Note that the OFFSET and OVLY_MAPPED in each table entry are
277 initialized to zero. */
278
279void
281{
282 int count = gdb_bfd_count_sections (objfile->obfd.get ());
283
284 objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
285 count,
286 struct obj_section);
287 objfile->sections_end = (objfile->sections + count);
288 for (asection *sect : gdb_bfd_sections (objfile->obfd))
289 add_to_objfile_sections (objfile->obfd.get (), sect, objfile, 0);
290
291 /* See gdb_bfd_section_index. */
292 add_to_objfile_sections (objfile->obfd.get (), bfd_com_section_ptr,
293 objfile, 1);
294 add_to_objfile_sections (objfile->obfd.get (), bfd_und_section_ptr,
295 objfile, 1);
296 add_to_objfile_sections (objfile->obfd.get (), bfd_abs_section_ptr,
297 objfile, 1);
298 add_to_objfile_sections (objfile->obfd.get (), bfd_ind_section_ptr,
299 objfile, 1);
300}
301
302/* Given a pointer to an initialized bfd (ABFD) and some flag bits,
303 initialize the new objfile as best we can and link it into the list
304 of all known objfiles.
305
306 NAME should contain original non-canonicalized filename or other
307 identifier as entered by user. If there is no better source use
308 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
309 NAME content is copied into returned objfile.
310
311 The FLAGS word contains various bits (OBJF_*) that can be taken as
312 requests for specific operations. Other bits like OBJF_SHARED are
313 simply copied through to the new objfile flags member. */
314
315objfile::objfile (gdb_bfd_ref_ptr bfd_, const char *name, objfile_flags flags_)
316 : flags (flags_),
317 pspace (current_program_space),
318 obfd (std::move (bfd_))
319{
320 const char *expanded_name;
321
322 std::string name_holder;
323 if (name == NULL)
324 {
325 gdb_assert (obfd == nullptr);
326 gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
327 expanded_name = "<<anonymous objfile>>";
328 }
329 else if ((flags & OBJF_NOT_FILENAME) != 0
331 expanded_name = name;
332 else
333 {
334 name_holder = gdb_abspath (name);
335 expanded_name = name_holder.c_str ();
336 }
337 original_name = obstack_strdup (&objfile_obstack, expanded_name);
338
339 /* Update the per-objfile information that comes from the bfd, ensuring
340 that any data that is reference is saved in the per-objfile data
341 region. */
342
343 if (obfd != nullptr)
344 {
345 mtime = bfd_get_mtime (obfd.get ());
346
347 /* Build section table. */
349 }
350
351 set_objfile_per_bfd (this);
352}
353
354/* If there is a valid and known entry point, function fills *ENTRY_P with it
355 and returns non-zero; otherwise it returns zero. */
356
357int
358entry_point_address_query (CORE_ADDR *entry_p)
359{
361 if (objf == NULL || !objf->per_bfd->ei.entry_point_p)
362 return 0;
363
364 int idx = objf->per_bfd->ei.the_bfd_section_index;
365 *entry_p = objf->per_bfd->ei.entry_point + objf->section_offsets[idx];
366
367 return 1;
368}
369
370/* Get current entry point address. Call error if it is not known. */
371
372CORE_ADDR
374{
375 CORE_ADDR retval;
376
377 if (!entry_point_address_query (&retval))
378 error (_("Entry point address is not known."));
379
380 return retval;
381}
382
385{
386 gdb_assert (m_objfile != nullptr);
387
388 struct objfile *res;
389
390 /* If any, return the first child. */
392 if (res != nullptr)
393 {
394 m_objfile = res;
395 return *this;
396 }
397
398 /* Common case where there is no separate debug objfile. */
399 if (m_objfile == m_parent)
400 {
401 m_objfile = nullptr;
402 return *this;
403 }
404
405 /* Return the brother if any. Note that we don't iterate on brothers of
406 the parents. */
408 if (res != nullptr)
409 {
410 m_objfile = res;
411 return *this;
412 }
413
415 res != m_parent;
417 {
418 gdb_assert (res != nullptr);
419 if (res->separate_debug_objfile_link != nullptr)
420 {
422 return *this;
423 }
424 }
425 m_objfile = nullptr;
426 return *this;
427}
428
429/* Add OBJFILE as a separate debug objfile of PARENT. */
430
431static void
433{
434 gdb_assert (objfile && parent);
435
436 /* Must not be already in a list. */
437 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
438 gdb_assert (objfile->separate_debug_objfile_link == NULL);
439 gdb_assert (objfile->separate_debug_objfile == NULL);
440 gdb_assert (parent->separate_debug_objfile_backlink == NULL);
441 gdb_assert (parent->separate_debug_objfile_link == NULL);
442
446}
447
448/* See objfiles.h. */
449
450objfile *
451objfile::make (gdb_bfd_ref_ptr bfd_, const char *name_, objfile_flags flags_,
452 objfile *parent)
453{
454 objfile *result = new objfile (std::move (bfd_), name_, flags_);
455 if (parent != nullptr)
456 add_separate_debug_objfile (result, parent);
457
458 current_program_space->add_objfile (std::unique_ptr<objfile> (result),
459 parent);
460
461 /* Rebuild section map next time we need it. */
463
464 return result;
465}
466
467/* See objfiles.h. */
468
469void
471{
473}
474
475/* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
476 itself. */
477
478void
480{
481 struct objfile *child;
482
483 for (child = objfile->separate_debug_objfile; child;)
484 {
485 struct objfile *next_child = child->separate_debug_objfile_link;
486 child->unlink ();
487 child = next_child;
488 }
489}
490
491/* Destroy an objfile and all the symtabs and psymtabs under it. */
492
494{
495 /* First notify observers that this objfile is about to be freed. */
496 gdb::observers::free_objfile.notify (this);
497
498 /* Free all separate debug objfiles. */
500
502 {
503 /* We freed the separate debug file, make sure the base objfile
504 doesn't reference it. */
505 struct objfile *child;
506
508
509 if (child == this)
510 {
511 /* THIS is the first child. */
514 }
515 else
516 {
517 /* Find THIS in the list. */
518 while (1)
519 {
520 if (child->separate_debug_objfile_link == this)
521 {
524 break;
525 }
526 child = child->separate_debug_objfile_link;
527 gdb_assert (child);
528 }
529 }
530 }
531
532 /* Remove any references to this objfile in the global value
533 lists. */
534 preserve_values (this);
535
536 /* It still may reference data modules have associated with the objfile and
537 the symbol file data. */
539
541 btrace_free_objfile (this);
542
543 /* First do any symbol file specific actions required when we are
544 finished with a particular symbol file. Note that if the objfile
545 is using reusable symbol information (via mmalloc) then each of
546 these routines is responsible for doing the correct thing, either
547 freeing things which are valid only during this particular gdb
548 execution, or leaving them to be reused during the next one. */
549
550 if (sf != NULL)
551 (*sf->sym_finish) (this);
552
553 /* Before the symbol table code was redone to make it easier to
554 selectively load and remove information particular to a specific
555 linkage unit, gdb used to do these things whenever the monolithic
556 symbol table was blown away. How much still needs to be done
557 is unknown, but we play it safe for now and keep each action until
558 it is shown to be no longer needed. */
559
560 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
561 for example), so we need to call this here. */
563
564 /* Check to see if the current_source_symtab belongs to this objfile,
565 and if so, call clear_current_source_symtab_and_line. */
566
567 {
569
570 if (cursal.symtab && cursal.symtab->compunit ()->objfile () == this)
572 }
573
574 /* Rebuild section map next time we need it. */
576}
577
578
579/* A helper function for objfile_relocate1 that relocates a single
580 symbol. */
581
582static void
584 const section_offsets &delta)
585{
587
588 /* The RS6000 code from which this was taken skipped
589 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
590 But I'm leaving out that test, on the theory that
591 they can't possibly pass the tests below. */
592 if ((sym->aclass () == LOC_LABEL
593 || sym->aclass () == LOC_STATIC)
594 && sym->section_index () >= 0)
595 sym->set_value_address (sym->value_address ()
596 + delta[sym->section_index ()]);
597}
598
599/* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
600 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
601 Return non-zero iff any change happened. */
602
603static int
605 const section_offsets &new_offsets)
606{
607 section_offsets delta (objfile->section_offsets.size ());
608
609 int something_changed = 0;
610
611 for (int i = 0; i < objfile->section_offsets.size (); ++i)
612 {
613 delta[i] = new_offsets[i] - objfile->section_offsets[i];
614 if (delta[i] != 0)
615 something_changed = 1;
616 }
617 if (!something_changed)
618 return 0;
619
620 /* OK, get all the symtabs. */
621 {
622 for (compunit_symtab *cust : objfile->compunits ())
623 {
624 for (symtab *s : cust->filetabs ())
625 {
626 struct linetable *l;
627
628 /* First the line table. */
629 l = s->linetable ();
630 if (l)
631 {
632 for (int i = 0; i < l->nitems; ++i)
633 l->item[i].pc += delta[cust->block_line_section ()];
634 }
635 }
636 }
637
638 for (compunit_symtab *cust : objfile->compunits ())
639 {
640 struct blockvector *bv = cust->blockvector ();
641 int block_line_section = cust->block_line_section ();
642
643 if (bv->map () != nullptr)
644 bv->map ()->relocate (delta[block_line_section]);
645
646 for (block *b : bv->blocks ())
647 {
648 struct symbol *sym;
649 struct mdict_iterator miter;
650
651 b->set_start (b->start () + delta[block_line_section]);
652 b->set_end (b->end () + delta[block_line_section]);
653
654 for (blockrange &r : b->ranges ())
655 {
656 r.set_start (r.start () + delta[block_line_section]);
657 r.set_end (r.end () + delta[block_line_section]);
658 }
659
660 /* We only want to iterate over the local symbols, not any
661 symbols in included symtabs. */
662 ALL_DICT_SYMBOLS (b->multidict (), miter, sym)
663 {
664 relocate_one_symbol (sym, objfile, delta);
665 }
666 }
667 }
668 }
669
670 /* Notify the quick symbol object. */
671 for (const auto &iter : objfile->qf)
672 iter->relocated ();
673
674 /* Relocate isolated symbols. */
675 {
676 struct symbol *iter;
677
678 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
679 relocate_one_symbol (iter, objfile, delta);
680 }
681
682 {
683 int i;
684
685 for (i = 0; i < objfile->section_offsets.size (); ++i)
686 objfile->section_offsets[i] = new_offsets[i];
687 }
688
689 /* Rebuild section map next time we need it. */
691
692 /* Update the table in exec_ops, used to read memory. */
693 struct obj_section *s;
695 {
696 int idx = s - objfile->sections;
697
698 exec_set_section_address (bfd_get_filename (objfile->obfd.get ()), idx,
699 s->addr ());
700 }
701
702 /* Data changed. */
703 return 1;
704}
705
706/* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
707 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
708
709 The number and ordering of sections does differ between the two objfiles.
710 Only their names match. Also the file offsets will differ (objfile being
711 possibly prelinked but separate_debug_objfile is probably not prelinked) but
712 the in-memory absolute address as specified by NEW_OFFSETS must match both
713 files. */
714
715void
717 const section_offsets &new_offsets)
718{
719 int changed = 0;
720
721 changed |= objfile_relocate1 (objfile, new_offsets);
722
723 for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
724 {
725 if (debug_objfile == objfile)
726 continue;
727
728 section_addr_info objfile_addrs
730
731 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
732 relative ones must be already created according to debug_objfile. */
733
734 addr_info_make_relative (&objfile_addrs, debug_objfile->obfd.get ());
735
736 gdb_assert (debug_objfile->section_offsets.size ()
737 == gdb_bfd_count_sections (debug_objfile->obfd.get ()));
738 section_offsets new_debug_offsets
739 (debug_objfile->section_offsets.size ());
740 relative_addr_info_to_section_offsets (new_debug_offsets, objfile_addrs);
741
742 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
743 }
744
745 /* Relocate breakpoints as necessary, after things are relocated. */
746 if (changed)
748}
749
750/* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
751 not touched here.
752 Return non-zero iff any change happened. */
753
754static int
755objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
756{
757 section_offsets new_offsets (objfile->section_offsets.size (), slide);
758 return objfile_relocate1 (objfile, new_offsets);
759}
760
761/* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
762 SEPARATE_DEBUG_OBJFILEs. */
763
764void
765objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
766{
767 int changed = 0;
768
769 for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
770 changed |= objfile_rebase1 (debug_objfile, slide);
771
772 /* Relocate breakpoints as necessary, after things are relocated. */
773 if (changed)
775}
776
777/* Return non-zero if OBJFILE has full symbols. */
778
779int
781{
782 return objfile->compunit_symtabs != NULL;
783}
784
785/* Return non-zero if OBJFILE has full or partial symbols, either directly
786 or through a separate debug file. */
787
788int
790{
792 if (o->has_partial_symbols () || objfile_has_full_symbols (o))
793 return 1;
794 return 0;
795}
796
797
798/* Many places in gdb want to test just to see if we have any partial
799 symbols available. This function returns zero if none are currently
800 available, nonzero otherwise. */
801
802int
804{
805 for (objfile *ofp : current_program_space->objfiles ())
806 {
807 if (ofp->has_partial_symbols ())
808 return 1;
809 }
810 return 0;
811}
812
813/* Many places in gdb want to test just to see if we have any full
814 symbols available. This function returns zero if none are currently
815 available, nonzero otherwise. */
816
817int
819{
820 for (objfile *ofp : current_program_space->objfiles ())
821 {
822 if (objfile_has_full_symbols (ofp))
823 return 1;
824 }
825 return 0;
826}
827
828
829/* This operations deletes all objfile entries that represent solibs that
830 weren't explicitly loaded by the user, via e.g., the add-symbol-file
831 command. */
832
833void
835{
837 {
838 /* We assume that the solib package has been purged already, or will
839 be soon. */
840
841 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
842 objf->unlink ();
843 }
844}
845
846
847/* Many places in gdb want to test just to see if we have any minimal
848 symbols available. This function returns zero if none are currently
849 available, nonzero otherwise. */
850
851int
853{
854 for (objfile *ofp : current_program_space->objfiles ())
855 {
856 if (ofp->per_bfd->minimal_symbol_count > 0)
857 {
858 return 1;
859 }
860 }
861 return 0;
862}
863
864/* Qsort comparison function. */
865
866static bool
867sort_cmp (const struct obj_section *sect1, const obj_section *sect2)
868{
869 const CORE_ADDR sect1_addr = sect1->addr ();
870 const CORE_ADDR sect2_addr = sect2->addr ();
871
872 if (sect1_addr < sect2_addr)
873 return true;
874 else if (sect1_addr > sect2_addr)
875 return false;
876 else
877 {
878 /* Sections are at the same address. This could happen if
879 A) we have an objfile and a separate debuginfo.
880 B) we are confused, and have added sections without proper relocation,
881 or something like that. */
882
883 const struct objfile *const objfile1 = sect1->objfile;
884 const struct objfile *const objfile2 = sect2->objfile;
885
886 if (objfile1->separate_debug_objfile == objfile2
887 || objfile2->separate_debug_objfile == objfile1)
888 {
889 /* Case A. The ordering doesn't matter: separate debuginfo files
890 will be filtered out later. */
891
892 return false;
893 }
894
895 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
896 triage. This section could be slow (since we iterate over all
897 objfiles in each call to sort_cmp), but this shouldn't happen
898 very often (GDB is already in a confused state; one hopes this
899 doesn't happen at all). If you discover that significant time is
900 spent in the loops below, do 'set complaints 100' and examine the
901 resulting complaints. */
902 if (objfile1 == objfile2)
903 {
904 /* Both sections came from the same objfile. We are really
905 confused. Sort on sequence order of sections within the
906 objfile. The order of checks is important here, if we find a
907 match on SECT2 first then either SECT2 is before SECT1, or,
908 SECT2 == SECT1, in both cases we should return false. The
909 second case shouldn't occur during normal use, but std::sort
910 does check that '!(a < a)' when compiled in debug mode. */
911
912 const struct obj_section *osect;
913
914 ALL_OBJFILE_OSECTIONS (objfile1, osect)
915 if (osect == sect2)
916 return false;
917 else if (osect == sect1)
918 return true;
919
920 /* We should have found one of the sections before getting here. */
921 gdb_assert_not_reached ("section not found");
922 }
923 else
924 {
925 /* Sort on sequence number of the objfile in the chain. */
926
928 if (objfile == objfile1)
929 return true;
930 else if (objfile == objfile2)
931 return false;
932
933 /* We should have found one of the objfiles before getting here. */
934 gdb_assert_not_reached ("objfile not found");
935 }
936 }
937
938 /* Unreachable. */
939 gdb_assert_not_reached ("unexpected code path");
940 return false;
941}
942
943/* Select "better" obj_section to keep. We prefer the one that came from
944 the real object, rather than the one from separate debuginfo.
945 Most of the time the two sections are exactly identical, but with
946 prelinking the .rel.dyn section in the real object may have different
947 size. */
948
949static struct obj_section *
951{
952 gdb_assert (a->addr () == b->addr ());
953 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
954 || (b->objfile->separate_debug_objfile == a->objfile));
955 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
957
958 if (a->objfile->separate_debug_objfile != NULL)
959 return a;
960 return b;
961}
962
963/* Return 1 if SECTION should be inserted into the section map.
964 We want to insert only non-overlay non-TLS non-empty sections. */
965
966static int
967insert_section_p (const struct bfd *abfd,
968 const struct bfd_section *section)
969{
970 const bfd_vma lma = bfd_section_lma (section);
971
972 if (overlay_debugging && lma != 0 && lma != bfd_section_vma (section)
973 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
974 /* This is an overlay section. IN_MEMORY check is needed to avoid
975 discarding sections from the "system supplied DSO" (aka vdso)
976 on some Linux systems (e.g. Fedora 11). */
977 return 0;
978 if ((bfd_section_flags (section) & SEC_THREAD_LOCAL) != 0)
979 /* This is a TLS section. */
980 return 0;
981 if (bfd_section_size (section) == 0)
982 {
983 /* This is an empty section. It has no PCs for find_pc_section (), so
984 there is no reason to insert it into the section map. */
985 return 0;
986 }
987
988 return 1;
989}
990
991/* Filter out overlapping sections where one section came from the real
992 objfile, and the other from a separate debuginfo file.
993 Return the size of table after redundant sections have been eliminated. */
994
995static int
996filter_debuginfo_sections (struct obj_section **map, int map_size)
997{
998 int i, j;
999
1000 for (i = 0, j = 0; i < map_size - 1; i++)
1001 {
1002 struct obj_section *const sect1 = map[i];
1003 struct obj_section *const sect2 = map[i + 1];
1004 const struct objfile *const objfile1 = sect1->objfile;
1005 const struct objfile *const objfile2 = sect2->objfile;
1006 const CORE_ADDR sect1_addr = sect1->addr ();
1007 const CORE_ADDR sect2_addr = sect2->addr ();
1008
1009 if (sect1_addr == sect2_addr
1010 && (objfile1->separate_debug_objfile == objfile2
1011 || objfile2->separate_debug_objfile == objfile1))
1012 {
1013 map[j++] = preferred_obj_section (sect1, sect2);
1014 ++i;
1015 }
1016 else
1017 map[j++] = sect1;
1018 }
1019
1020 if (i < map_size)
1021 {
1022 gdb_assert (i == map_size - 1);
1023 map[j++] = map[i];
1024 }
1025
1026 /* The map should not have shrunk to less than half the original size. */
1027 gdb_assert (map_size / 2 <= j);
1028
1029 return j;
1030}
1031
1032/* Filter out overlapping sections, issuing a warning if any are found.
1033 Overlapping sections could really be overlay sections which we didn't
1034 classify as such in insert_section_p, or we could be dealing with a
1035 corrupt binary. */
1036
1037static int
1038filter_overlapping_sections (struct obj_section **map, int map_size)
1039{
1040 int i, j;
1041
1042 for (i = 0, j = 0; i < map_size - 1; )
1043 {
1044 int k;
1045
1046 map[j++] = map[i];
1047 for (k = i + 1; k < map_size; k++)
1048 {
1049 struct obj_section *const sect1 = map[i];
1050 struct obj_section *const sect2 = map[k];
1051 const CORE_ADDR sect1_addr = sect1->addr ();
1052 const CORE_ADDR sect2_addr = sect2->addr ();
1053 const CORE_ADDR sect1_endaddr = sect1->endaddr ();
1054
1055 gdb_assert (sect1_addr <= sect2_addr);
1056
1057 if (sect1_endaddr <= sect2_addr)
1058 break;
1059 else
1060 {
1061 /* We have an overlap. Report it. */
1062
1063 struct objfile *const objf1 = sect1->objfile;
1064 struct objfile *const objf2 = sect2->objfile;
1065
1066 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1067 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1068
1069 const CORE_ADDR sect2_endaddr = sect2->endaddr ();
1070
1071 struct gdbarch *const gdbarch = objf1->arch ();
1072
1073 complaint (_("unexpected overlap between:\n"
1074 " (A) section `%s' from `%s' [%s, %s)\n"
1075 " (B) section `%s' from `%s' [%s, %s).\n"
1076 "Will ignore section B"),
1077 bfd_section_name (bfds1), objfile_name (objf1),
1078 paddress (gdbarch, sect1_addr),
1079 paddress (gdbarch, sect1_endaddr),
1080 bfd_section_name (bfds2), objfile_name (objf2),
1081 paddress (gdbarch, sect2_addr),
1082 paddress (gdbarch, sect2_endaddr));
1083 }
1084 }
1085 i = k;
1086 }
1087
1088 if (i < map_size)
1089 {
1090 gdb_assert (i == map_size - 1);
1091 map[j++] = map[i];
1092 }
1093
1094 return j;
1095}
1096
1097
1098/* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1099 TLS, overlay and overlapping sections. */
1100
1101static void
1103 struct obj_section ***pmap, int *pmap_size)
1104{
1105 struct objfile_pspace_info *pspace_info;
1106 int alloc_size, map_size, i;
1107 struct obj_section *s, **map;
1108
1109 pspace_info = get_objfile_pspace_data (pspace);
1110 gdb_assert (pspace_info->section_map_dirty != 0
1111 || pspace_info->new_objfiles_available != 0);
1112
1113 map = *pmap;
1114 xfree (map);
1115
1116 alloc_size = 0;
1117 for (objfile *objfile : pspace->objfiles ())
1119 if (insert_section_p (objfile->obfd.get (), s->the_bfd_section))
1120 alloc_size += 1;
1121
1122 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1123 if (alloc_size == 0)
1124 {
1125 *pmap = NULL;
1126 *pmap_size = 0;
1127 return;
1128 }
1129
1130 map = XNEWVEC (struct obj_section *, alloc_size);
1131
1132 i = 0;
1133 for (objfile *objfile : pspace->objfiles ())
1135 if (insert_section_p (objfile->obfd.get (), s->the_bfd_section))
1136 map[i++] = s;
1137
1138 std::sort (map, map + alloc_size, sort_cmp);
1139 map_size = filter_debuginfo_sections(map, alloc_size);
1140 map_size = filter_overlapping_sections(map, map_size);
1141
1142 if (map_size < alloc_size)
1143 /* Some sections were eliminated. Trim excess space. */
1144 map = XRESIZEVEC (struct obj_section *, map, map_size);
1145 else
1146 gdb_assert (alloc_size == map_size);
1147
1148 *pmap = map;
1149 *pmap_size = map_size;
1150}
1151
1152/* Bsearch comparison function. */
1153
1154static int
1155bsearch_cmp (const void *key, const void *elt)
1156{
1157 const CORE_ADDR pc = *(CORE_ADDR *) key;
1158 const struct obj_section *section = *(const struct obj_section **) elt;
1159
1160 if (pc < section->addr ())
1161 return -1;
1162 if (pc < section->endaddr ())
1163 return 0;
1164 return 1;
1165}
1166
1167/* Returns a section whose range includes PC or NULL if none found. */
1168
1169struct obj_section *
1170find_pc_section (CORE_ADDR pc)
1171{
1172 struct objfile_pspace_info *pspace_info;
1173 struct obj_section *s, **sp;
1174
1175 /* Check for mapped overlay section first. */
1176 s = find_pc_mapped_section (pc);
1177 if (s)
1178 return s;
1179
1181 if (pspace_info->section_map_dirty
1182 || (pspace_info->new_objfiles_available
1183 && !pspace_info->inhibit_updates))
1184 {
1186 &pspace_info->sections,
1187 &pspace_info->num_sections);
1188
1189 /* Don't need updates to section map until objfiles are added,
1190 removed or relocated. */
1191 pspace_info->new_objfiles_available = 0;
1192 pspace_info->section_map_dirty = 0;
1193 }
1194
1195 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1196 bsearch be non-NULL. */
1197 if (pspace_info->sections == NULL)
1198 {
1199 gdb_assert (pspace_info->num_sections == 0);
1200 return NULL;
1201 }
1202
1203 sp = (struct obj_section **) bsearch (&pc,
1204 pspace_info->sections,
1205 pspace_info->num_sections,
1206 sizeof (*pspace_info->sections),
1207 bsearch_cmp);
1208 if (sp != NULL)
1209 return *sp;
1210 return NULL;
1211}
1212
1213
1214/* Return non-zero if PC is in a section called NAME. */
1215
1216int
1217pc_in_section (CORE_ADDR pc, const char *name)
1218{
1219 struct obj_section *s;
1220 int retval = 0;
1221
1222 s = find_pc_section (pc);
1223
1224 retval = (s != NULL
1225 && s->the_bfd_section->name != NULL
1226 && strcmp (s->the_bfd_section->name, name) == 0);
1227 return (retval);
1228}
1229
1230
1231/* Set section_map_dirty so section map will be rebuilt next time it
1232 is used. Called by reread_symbols. */
1233
1234void
1236{
1237 /* Rebuild section map next time we need it. */
1239}
1240
1241/* See comments in objfiles.h. */
1242
1243scoped_restore_tmpl<int>
1245{
1246 return scoped_restore_tmpl<int>
1247 (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
1248}
1249
1250/* See objfiles.h. */
1251
1252bool
1253is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1254{
1255 struct obj_section *osect;
1256
1257 if (objfile == NULL)
1258 return false;
1259
1261 {
1262 if (section_is_overlay (osect) && !section_is_mapped (osect))
1263 continue;
1264
1265 if (osect->addr () <= addr && addr < osect->endaddr ())
1266 return true;
1267 }
1268 return false;
1269}
1270
1271/* See objfiles.h. */
1272
1273bool
1275 CORE_ADDR address)
1276{
1277 for (objfile *objfile : pspace->objfiles ())
1278 {
1279 if ((objfile->flags & OBJF_SHARED) != 0
1280 && is_addr_in_objfile (address, objfile))
1281 return true;
1282 }
1283
1284 return false;
1285}
1286
1287/* The default implementation for the "iterate_over_objfiles_in_search_order"
1288 gdbarch method. It is equivalent to use the objfiles iterable,
1289 searching the objfiles in the order they are stored internally,
1290 ignoring CURRENT_OBJFILE.
1291
1292 On most platforms, it should be close enough to doing the best
1293 we can without some knowledge specific to the architecture. */
1294
1295void
1298 objfile *current_objfile)
1299{
1301 if (cb (objfile))
1302 return;
1303}
1304
1305/* See objfiles.h. */
1306
1307const char *
1309{
1310 if (objfile->obfd != NULL)
1311 return bfd_get_filename (objfile->obfd.get ());
1312
1313 return objfile->original_name;
1314}
1315
1316/* See objfiles.h. */
1317
1318const char *
1320{
1321 if (objfile->obfd != NULL)
1322 return bfd_get_filename (objfile->obfd.get ());
1323
1324 return NULL;
1325}
1326
1327/* See objfiles.h. */
1328
1329const char *
1331{
1332 return lbasename (objfile->original_name);
1333}
1334
1335/* See objfiles.h. */
1336
1337const char *
1339{
1340 if (objfile->obfd != NULL)
1341 return bfd_flavour_name (bfd_get_flavour (objfile->obfd.get ()));
1342 return NULL;
1343}
1344
1345/* See objfiles.h. */
1346
1347struct type *
1348objfile_int_type (struct objfile *of, int size_in_bytes, bool unsigned_p)
1349{
1350 struct type *int_type;
1351
1352 /* Helper macro to examine the various builtin types. */
1353#define TRY_TYPE(F) \
1354 int_type = (unsigned_p \
1355 ? objfile_type (of)->builtin_unsigned_ ## F \
1356 : objfile_type (of)->builtin_ ## F); \
1357 if (int_type != NULL && int_type->length () == size_in_bytes) \
1358 return int_type
1359
1360 TRY_TYPE (char);
1361 TRY_TYPE (short);
1362 TRY_TYPE (int);
1363 TRY_TYPE (long);
1364 TRY_TYPE (long_long);
1365
1366#undef TRY_TYPE
1367
1368 gdb_assert_not_reached ("unable to find suitable integer type");
1369}
const char *const name
void xfree(void *)
void * xcalloc(size_t number, size_t size)
Definition alloc.c:85
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition arch-utils.c:637
void clear_pc_function_cache(void)
Definition blockframe.c:201
void breakpoint_re_set(void)
void breakpoint_free_objfile(struct objfile *objfile)
void btrace_free_objfile(struct objfile *objfile)
Definition btrace.c:2012
void set(unsigned key, void *datum)
Definition registry.h:204
void * get(unsigned key)
Definition registry.h:211
separate_debug_iterator & operator++()
Definition objfiles.c:384
struct objfile * m_objfile
Definition objfiles.h:374
struct objfile * m_parent
Definition objfiles.h:375
#define complaint(FMT,...)
Definition complaints.h:47
language
Definition defs.h:211
#define ALL_DICT_SYMBOLS(dict, iter, sym)
Definition dictionary.h:174
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition exec.c:1023
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition gdb_bfd.c:980
int gdb_bfd_requires_relocations(bfd *abfd)
Definition gdb_bfd.c:1006
int gdb_bfd_count_sections(bfd *abfd)
Definition gdb_bfd.c:998
int is_target_filename(const char *name)
Definition gdb_bfd.c:207
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:78
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:222
bfd * obfd
gdb::function_view< bool(objfile *)> iterate_over_objfiles_in_search_order_cb_ftype
Definition gdbarch.h:91
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly 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:1862
observable< struct objfile * > free_objfile
Definition aarch64.h:50
@ OBJF_USERLOADED
@ OBJF_SHARED
@ OBJF_NOT_FILENAME
const char * objfile_flavour_name(struct objfile *objfile)
Definition objfiles.c:1338
int objfile_has_full_symbols(struct objfile *objfile)
Definition objfiles.c:780
static int bsearch_cmp(const void *key, const void *elt)
Definition objfiles.c:1155
void objfiles_changed(void)
Definition objfiles.c:1235
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition objfiles.c:152
static int objfile_relocate1(struct objfile *objfile, const section_offsets &new_offsets)
Definition objfiles.c:604
bool shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition objfiles.c:1274
static struct objfile_pspace_info * get_objfile_pspace_data(struct program_space *pspace)
Definition objfiles.c:95
const char * objfile_debug_name(const struct objfile *objfile)
Definition objfiles.c:1330
static void update_section_map(struct program_space *pspace, struct obj_section ***pmap, int *pmap_size)
Definition objfiles.c:1102
#define TRY_TYPE(F)
int objfile_has_symbols(struct objfile *objfile)
Definition objfiles.c:789
void objfile_purge_solibs(void)
Definition objfiles.c:834
static void relocate_one_symbol(struct symbol *sym, struct objfile *objfile, const section_offsets &delta)
Definition objfiles.c:583
void default_iterate_over_objfiles_in_search_order(gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, objfile *current_objfile)
Definition objfiles.c:1297
int pc_in_section(CORE_ADDR pc, const char *name)
Definition objfiles.c:1217
int have_minimal_symbols(void)
Definition objfiles.c:852
struct type * objfile_int_type(struct objfile *of, int size_in_bytes, bool unsigned_p)
Definition objfiles.c:1348
static int filter_overlapping_sections(struct obj_section **map, int map_size)
Definition objfiles.c:1038
static void add_to_objfile_sections(struct bfd *abfd, struct bfd_section *asect, struct objfile *objfile, int force)
Definition objfiles.c:254
scoped_restore_tmpl< int > inhibit_section_map_updates(struct program_space *pspace)
Definition objfiles.c:1244
static int static_link_htab_entry_eq(const void *p1, const void *p2)
Definition objfiles.c:185
void objfile_relocate(struct objfile *objfile, const section_offsets &new_offsets)
Definition objfiles.c:716
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1170
static hashval_t static_link_htab_entry_hash(const void *p)
Definition objfiles.c:173
const struct dynamic_prop * objfile_lookup_static_link(struct objfile *objfile, const struct block *block)
Definition objfiles.c:228
static int objfile_rebase1(struct objfile *objfile, CORE_ADDR slide)
Definition objfiles.c:755
bool is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition objfiles.c:1253
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition objfiles.c:765
CORE_ADDR entry_point_address(void)
Definition objfiles.c:373
static int insert_section_p(const struct bfd *abfd, const struct bfd_section *section)
Definition objfiles.c:967
static bool sort_cmp(const struct obj_section *sect1, const obj_section *sect2)
Definition objfiles.c:867
int have_partial_symbols(void)
Definition objfiles.c:803
int entry_point_address_query(CORE_ADDR *entry_p)
Definition objfiles.c:358
static void add_separate_debug_objfile(struct objfile *objfile, struct objfile *parent)
Definition objfiles.c:432
void free_objfile_separate_debug(struct objfile *objfile)
Definition objfiles.c:479
static int filter_debuginfo_sections(struct obj_section **map, int map_size)
Definition objfiles.c:996
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
static struct obj_section * preferred_obj_section(struct obj_section *a, struct obj_section *b)
Definition objfiles.c:950
static const registry< program_space >::key< objfile_pspace_info > objfiles_pspace_data
Definition objfiles.c:84
const char * objfile_filename(const struct objfile *objfile)
Definition objfiles.c:1319
static const registry< bfd >::key< objfile_per_bfd_storage > objfiles_bfd_data
Definition objfiles.c:110
int have_full_symbols(void)
Definition objfiles.c:818
void objfile_register_static_link(struct objfile *objfile, const struct block *block, const struct dynamic_prop *static_link)
Definition objfiles.c:199
void build_objfile_section_table(struct objfile *objfile)
Definition objfiles.c:280
void set_objfile_per_bfd(struct objfile *objfile)
Definition objfiles.c:121
void build_objfile_section_table(struct objfile *)
Definition objfiles.c:280
void set_objfile_per_bfd(struct objfile *obj)
Definition objfiles.c:121
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition objfiles.h:130
void free_objfile_separate_debug(struct objfile *)
Definition objfiles.c:479
struct program_space * current_program_space
Definition progspace.c:39
void forget_cached_source_info_for_objfile(struct objfile *objfile)
Definition source.c:424
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition source.c:238
void clear_current_source_symtab_and_line(void)
Definition source.c:301
virtual void relocate(CORE_ADDR offset)=0
Definition block.h:109
addrmap * map()
Definition block.h:310
gdb::array_view< struct block * > blocks()
Definition block.h:258
struct objfile * objfile() const
Definition symtab.h:1714
CORE_ADDR entry_point
Definition objfiles.h:118
int the_bfd_section_index
Definition objfiles.h:121
unsigned entry_point_p
Definition objfiles.h:124
short section_index() const
Definition symtab.h:604
CORE_ADDR pc
Definition symtab.h:1560
int nitems
Definition symtab.h:1582
struct linetable_entry item[1]
Definition symtab.h:1587
CORE_ADDR addr() const
Definition objfiles.h:822
CORE_ADDR endaddr() const
Definition objfiles.h:829
struct objfile * objfile
Definition objfiles.h:838
int ovly_mapped
Definition objfiles.h:841
struct bfd_section * the_bfd_section
Definition objfiles.h:835
enum language language_of_main
Definition objfiles.h:296
auto_obstack storage_obstack
Definition objfiles.h:265
struct gdbarch * gdbarch
Definition objfiles.h:276
const char * name_of_main
Definition objfiles.h:295
objfile_pspace_info()=default
struct obj_section ** sections
Definition objfiles.c:68
const char * original_name
Definition objfiles.h:631
const struct sym_fns * sf
Definition objfiles.h:681
~objfile()
Definition objfiles.c:493
struct obj_section * sections_end
Definition objfiles.h:726
struct compunit_symtab * compunit_symtabs
Definition objfiles.h:646
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:743
struct program_space * pspace
Definition objfiles.h:641
struct objfile * separate_debug_objfile_link
Definition objfiles.h:748
struct objfile * separate_debug_objfile
Definition objfiles.h:738
struct gdbarch * arch() const
Definition objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:657
static objfile * make(gdb_bfd_ref_ptr bfd_, const char *name_, objfile_flags flags_, objfile *parent=nullptr)
Definition objfiles.c:451
objfile(gdb_bfd_ref_ptr, const char *, objfile_flags)
Definition objfiles.c:315
htab_up static_links
Definition objfiles.h:772
struct obj_section * sections
Definition objfiles.h:725
gdb_bfd_ref_ptr obfd
Definition objfiles.h:653
compunit_symtab_range compunits()
Definition objfiles.h:426
objfile_flags flags
Definition objfiles.h:637
std::unique_ptr< objfile_per_bfd_storage > per_bfd_storage
Definition objfiles.h:663
auto_obstack objfile_obstack
Definition objfiles.h:673
std::forward_list< quick_symbol_functions_up > qf
Definition objfiles.h:685
separate_debug_range separate_debug_objfiles()
Definition objfiles.h:450
struct symbol * template_symbols
Definition objfiles.h:759
::section_offsets section_offsets
Definition objfiles.h:699
void unlink()
Definition objfiles.c:470
long mtime
Definition objfiles.h:668
objfiles_safe_range objfiles_safe()
Definition progspace.h:225
objfiles_range objfiles()
Definition progspace.h:209
void remove_objfile(struct objfile *objfile)
Definition progspace.c:161
void add_objfile(std::unique_ptr< objfile > &&objfile, struct objfile *before)
Definition progspace.c:141
struct objfile * symfile_object_file
Definition progspace.h:353
Definition objfiles.c:165
const struct block * block
Definition objfiles.c:166
const struct dynamic_prop * static_link
Definition objfiles.c:167
void(* sym_finish)(struct objfile *)
Definition symfile.h:144
address_class aclass() const
Definition symtab.h:1235
void set_value_address(CORE_ADDR address)
Definition symtab.h:1323
CORE_ADDR value_address() const
Definition symtab.h:1315
struct symbol * hash_next
Definition symtab.h:1485
struct symtab * symtab
Definition symtab.h:2263
struct compunit_symtab * compunit() const
Definition symtab.h:1603
section_addr_info build_section_addr_info_from_objfile(const struct objfile *objfile)
Definition symfile.c:259
int section_is_mapped(struct obj_section *osect)
Definition symfile.c:2978
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition symfile.c:3162
void addr_info_make_relative(section_addr_info *addrs, bfd *abfd)
Definition symfile.c:485
void relative_addr_info_to_section_offsets(section_offsets &section_offsets, const section_addr_info &addrs)
Definition symfile.c:406
int section_is_overlay(struct obj_section *section)
Definition symfile.c:2940
enum overlay_debugging_state overlay_debugging
Definition symfile.c:2932
std::vector< other_sections > section_addr_info
Definition symfile.h:74
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition symtab.c:1788
@ LOC_STATIC
Definition symtab.h:950
@ LOC_LABEL
Definition symtab.h:993
std::vector< CORE_ADDR > section_offsets
Definition symtab.h:1595
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
void preserve_values(struct objfile *objfile)
Definition value.c:2676