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