GDB (xrefs)
Loading...
Searching...
No Matches
objfiles.h
Go to the documentation of this file.
1/* Definitions for symbol file management in GDB.
2
3 Copyright (C) 1992-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#if !defined (OBJFILES_H)
21#define OBJFILES_H
22
23#include "hashtab.h"
24#include "gdbsupport/gdb_obstack.h"
25#include "objfile-flags.h"
26#include "symfile.h"
27#include "progspace.h"
28#include "registry.h"
29#include "gdb_bfd.h"
30#include <atomic>
31#include <bitset>
32#include <vector>
33#include "gdbsupport/next-iterator.h"
34#include "gdbsupport/safe-iterator.h"
35#include "bcache.h"
36#include "gdbarch.h"
37#include "gdbsupport/refcounted-object.h"
38#include "jit.h"
39#include "quick-symbol.h"
40#include <forward_list>
41
42struct htab;
43struct objfile_data;
44struct partial_symbol;
45
46/* This structure maintains information on a per-objfile basis about the
47 "entry point" of the objfile, and the scope within which the entry point
48 exists. It is possible that gdb will see more than one objfile that is
49 executable, each with its own entry point.
50
51 For example, for dynamically linked executables in SVR4, the dynamic linker
52 code is contained within the shared C library, which is actually executable
53 and is run by the kernel first when an exec is done of a user executable
54 that is dynamically linked. The dynamic linker within the shared C library
55 then maps in the various program segments in the user executable and jumps
56 to the user executable's recorded entry point, as if the call had been made
57 directly by the kernel.
58
59 The traditional gdb method of using this info was to use the
60 recorded entry point to set the entry-file's lowpc and highpc from
61 the debugging information, where these values are the starting
62 address (inclusive) and ending address (exclusive) of the
63 instruction space in the executable which correspond to the
64 "startup file", i.e. crt0.o in most cases. This file is assumed to
65 be a startup file and frames with pc's inside it are treated as
66 nonexistent. Setting these variables is necessary so that
67 backtraces do not fly off the bottom of the stack.
68
69 NOTE: cagney/2003-09-09: It turns out that this "traditional"
70 method doesn't work. Corinna writes: ``It turns out that the call
71 to test for "inside entry file" destroys a meaningful backtrace
72 under some conditions. E.g. the backtrace tests in the asm-source
73 testcase are broken for some targets. In this test the functions
74 are all implemented as part of one file and the testcase is not
75 necessarily linked with a start file (depending on the target).
76 What happens is, that the first frame is printed normally and
77 following frames are treated as being inside the entry file then.
78 This way, only the #0 frame is printed in the backtrace output.''
79 Ref "frame.c" "NOTE: vinschen/2003-04-01".
80
81 Gdb also supports an alternate method to avoid running off the bottom
82 of the stack.
83
84 There are two frames that are "special", the frame for the function
85 containing the process entry point, since it has no predecessor frame,
86 and the frame for the function containing the user code entry point
87 (the main() function), since all the predecessor frames are for the
88 process startup code. Since we have no guarantee that the linked
89 in startup modules have any debugging information that gdb can use,
90 we need to avoid following frame pointers back into frames that might
91 have been built in the startup code, as we might get hopelessly
92 confused. However, we almost always have debugging information
93 available for main().
94
95 These variables are used to save the range of PC values which are
96 valid within the main() function and within the function containing
97 the process entry point. If we always consider the frame for
98 main() as the outermost frame when debugging user code, and the
99 frame for the process entry point function as the outermost frame
100 when debugging startup code, then all we have to do is have
101 DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
102 current PC is within the range specified by these variables. In
103 essence, we set "ceilings" in the frame chain beyond which we will
104 not proceed when following the frame chain back up the stack.
105
106 A nice side effect is that we can still debug startup code without
107 running off the end of the frame chain, assuming that we have usable
108 debugging information in the startup modules, and if we choose to not
109 use the block at main, or can't find it for some reason, everything
110 still works as before. And if we have no startup code debugging
111 information but we do have usable information for main(), backtraces
112 from user code don't go wandering off into the startup code. */
113
115{
116 /* The unrelocated value we should use for this objfile entry point. */
117 CORE_ADDR entry_point;
118
119 /* The index of the section in which the entry point appears. */
121
122 /* Set to 1 iff ENTRY_POINT contains a valid value. */
123 unsigned entry_point_p : 1;
124
125 /* Set to 1 iff this object was initialized. */
126 unsigned initialized : 1;
127};
128
129#define SECT_OFF_DATA(objfile) \
130 ((objfile->sect_index_data == -1) \
131 ? (internal_error (_("sect_index_data not initialized")), -1) \
132 : objfile->sect_index_data)
133
134#define SECT_OFF_RODATA(objfile) \
135 ((objfile->sect_index_rodata == -1) \
136 ? (internal_error (_("sect_index_rodata not initialized")), -1) \
137 : objfile->sect_index_rodata)
138
139#define SECT_OFF_TEXT(objfile) \
140 ((objfile->sect_index_text == -1) \
141 ? (internal_error (_("sect_index_text not initialized")), -1) \
142 : objfile->sect_index_text)
143
144/* Sometimes the .bss section is missing from the objfile, so we don't
145 want to die here. Let the users of SECT_OFF_BSS deal with an
146 uninitialized section index. */
147#define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
148
149/* The "objstats" structure provides a place for gdb to record some
150 interesting information about its internal state at runtime, on a
151 per objfile basis, such as information about the number of symbols
152 read, size of string table (if any), etc. */
153
155{
156 /* Number of full symbols read. */
157 int n_syms = 0;
158
159 /* Number of ".stabs" read (if applicable). */
160 int n_stabs = 0;
161
162 /* Number of types. */
163 int n_types = 0;
164
165 /* Size of stringtable, (if applicable). */
166 int sz_strtab = 0;
167};
168
169#define OBJSTAT(objfile, expr) (objfile -> stats.expr)
170#define OBJSTATS struct objstats stats
171extern void print_objfile_statistics (void);
172
173/* Number of entries in the minimal symbol hash table. */
174#define MINIMAL_SYMBOL_HASH_SIZE 2039
175
176/* An iterator for minimal symbols. */
177
179{
181 typedef struct minimal_symbol *value_type;
182 typedef struct minimal_symbol *&reference;
183 typedef struct minimal_symbol **pointer;
184 typedef std::forward_iterator_tag iterator_category;
185 typedef int difference_type;
186
188 : m_msym (msym)
189 {
190 }
191
193 {
194 return m_msym;
195 }
196
197 bool operator== (const self_type &other) const
198 {
199 return m_msym == other.m_msym;
200 }
201
202 bool operator!= (const self_type &other) const
203 {
204 return m_msym != other.m_msym;
205 }
206
208 {
209 ++m_msym;
210 return *this;
211 }
212
213private:
215};
216
217/* Some objfile data is hung off the BFD. This enables sharing of the
218 data across all objfiles using the BFD. The data is stored in an
219 instance of this structure, and associated with the BFD using the
220 registry system. */
221
223{
225 : minsyms_read (false), m_bfd (bfd)
226 {}
227
229
230 /* Intern STRING in this object's string cache and return the unique copy.
231 The copy has the same lifetime as this object.
232
233 STRING must be null-terminated. */
234
235 const char *intern (const char *str)
236 {
237 return (const char *) string_cache.insert (str, strlen (str) + 1);
238 }
239
240 /* Same as the above, but for an std::string. */
241
242 const char *intern (const std::string &str)
243 {
244 return (const char *) string_cache.insert (str.c_str (), str.size () + 1);
245 }
246
247 /* Get the BFD this object is associated to. */
248
249 bfd *get_bfd () const
250 {
251 return m_bfd;
252 }
253
254 /* The storage has an obstack of its own. */
255
256 auto_obstack storage_obstack;
257
258 /* String cache. */
259
261
262 /* The gdbarch associated with the BFD. Note that this gdbarch is
263 determined solely from BFD information, without looking at target
264 information. The gdbarch determined from a running target may
265 differ from this e.g. with respect to register types and names. */
266
267 struct gdbarch *gdbarch = NULL;
268
269 /* Hash table for mapping symbol names to demangled names. Each
270 entry in the hash table is a demangled_name_entry struct, storing the
271 language and two consecutive strings, both null-terminated; the first one
272 is a mangled or linkage name, and the second is the demangled name or just
273 a zero byte if the name doesn't demangle. */
274
276
277 /* The per-objfile information about the entry point, the scope (file/func)
278 containing the entry point, and the scope of the user's main() func. */
279
281
282 /* The name and language of any "main" found in this objfile. The
283 name can be NULL, which means that the information was not
284 recorded. */
285
286 const char *name_of_main = NULL;
288
289 /* Each file contains a pointer to an array of minimal symbols for all
290 global symbols that are defined within the file. The array is
291 terminated by a "null symbol", one that has a NULL pointer for the
292 name and a zero value for the address. This makes it easy to walk
293 through the array when passed a pointer to somewhere in the middle
294 of it. There is also a count of the number of symbols, which does
295 not include the terminating null symbol. */
296
297 gdb::unique_xmalloc_ptr<minimal_symbol> msymbols;
299
300 /* The number of minimal symbols read, before any minimal symbol
301 de-duplication is applied. Note in particular that this has only
302 a passing relationship with the actual size of the table above;
303 use minimal_symbol_count if you need the true size. */
304
305 int n_minsyms = 0;
306
307 /* This is true if minimal symbols have already been read. Symbol
308 readers can use this to bypass minimal symbol reading. Also, the
309 minimal symbol table management code in minsyms.c uses this to
310 suppress new minimal symbols. You might think that MSYMBOLS or
311 MINIMAL_SYMBOL_COUNT could be used for this, but it is possible
312 for multiple readers to install minimal symbols into a given
313 per-BFD. */
314
315 bool minsyms_read : 1;
316
317 /* This is a hash table used to index the minimal symbols by (mangled)
318 name. */
319
321
322 /* This hash table is used to index the minimal symbols by their
323 demangled names. Uses a language-specific hash function via
324 search_name_hash. */
325
327
328 /* All the different languages of symbols found in the demangled
329 hash table. */
330 std::bitset<nr_languages> demangled_hash_languages;
331
332private:
333 /* The BFD this object is associated to. */
334
335 bfd *m_bfd;
336};
337
338/* An iterator that first returns a parent objfile, and then each
339 separate debug objfile. */
340
342{
343public:
344
346 : m_objfile (objfile),
348 {
349 }
350
352 {
353 return m_objfile != other.m_objfile;
354 }
355
357
359 {
360 return m_objfile;
361 }
362
363private:
364
367};
368
369/* A range adapter wrapping separate_debug_iterator. */
370
371typedef iterator_range<separate_debug_iterator> separate_debug_range;
372
373/* Sections in an objfile. The section offsets are stored in the
374 OBJFILE. */
375
377{
378 /* Relocation offset applied to the section. */
379 CORE_ADDR offset () const;
380
381 /* Set the relocation offset applied to the section. */
382 void set_offset (CORE_ADDR offset);
383
384 /* The memory address of the section (vma + offset). */
385 CORE_ADDR addr () const
386 {
387 return bfd_section_vma (this->the_bfd_section) + this->offset ();
388 }
389
390 /* The one-passed-the-end memory address of the section
391 (vma + size + offset). */
392 CORE_ADDR endaddr () const
393 {
394 return this->addr () + bfd_section_size (this->the_bfd_section);
395 }
396
397 /* BFD section pointer */
398 struct bfd_section *the_bfd_section;
399
400 /* Objfile this section is part of. */
402
403 /* True if this "overlay section" is mapped into an "overlay region". */
405};
406
407/* Master structure for keeping track of each file from which
408 gdb reads symbols. There are several ways these get allocated: 1.
409 The main symbol file, symfile_objfile, set by the symbol-file command,
410 2. Additional symbol files added by the add-symbol-file command,
411 3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files
412 for modules that were loaded when GDB attached to a remote system
413 (see remote-vx.c).
414
415 GDB typically reads symbols twice -- first an initial scan which just
416 reads "partial symbols"; these are partial information for the
417 static/global symbols in a symbol file. When later looking up
418 symbols, lookup_symbol is used to check if we only have a partial
419 symbol and if so, read and expand the full compunit. */
420
422{
423private:
424
425 /* The only way to create an objfile is to call objfile::make. */
426 objfile (gdb_bfd_ref_ptr, const char *, objfile_flags);
427
428public:
429
430 /* Normally you should not call delete. Instead, call 'unlink' to
431 remove it from the program space's list. In some cases, you may
432 need to hold a reference to an objfile that is independent of its
433 existence on the program space's list; for this case, the
434 destructor must be public so that unique_ptr can reference
435 it. */
436 ~objfile ();
437
438 /* Create an objfile. */
439 static objfile *make (gdb_bfd_ref_ptr bfd_, const char *name_,
440 objfile_flags flags_, objfile *parent = nullptr);
441
442 /* Remove an objfile from the current program space, and free
443 it. */
444 void unlink ();
445
447
448 /* A range adapter that makes it possible to iterate over all
449 compunits in one objfile. */
450
455
456 /* A range adapter that makes it possible to iterate over all
457 minimal symbols of an objfile. */
458
459 typedef iterator_range<minimal_symbol_iterator> msymbols_range;
460
461 /* Return a range adapter for iterating over all minimal
462 symbols. */
463
465 {
466 auto start = minimal_symbol_iterator (per_bfd->msymbols.get ());
467 auto end = minimal_symbol_iterator (per_bfd->msymbols.get ()
469 return msymbols_range (start, end);
470 }
471
472 /* Return a range adapter for iterating over all the separate debug
473 objfiles of this objfile. */
474
476 {
477 auto start = separate_debug_iterator (this);
478 auto end = separate_debug_iterator (nullptr);
479 return separate_debug_range (start, end);
480 }
481
482 CORE_ADDR text_section_offset () const
483 {
484 return section_offsets[SECT_OFF_TEXT (this)];
485 }
486
487 CORE_ADDR data_section_offset () const
488 {
489 return section_offsets[SECT_OFF_DATA (this)];
490 }
491
492 /* Intern STRING and return the unique copy. The copy has the same
493 lifetime as the per-BFD object. */
494 const char *intern (const char *str)
495 {
496 return per_bfd->intern (str);
497 }
498
499 /* Intern STRING and return the unique copy. The copy has the same
500 lifetime as the per-BFD object. */
501 const char *intern (const std::string &str)
502 {
503 return per_bfd->intern (str);
504 }
505
506 /* Retrieve the gdbarch associated with this objfile. */
507 struct gdbarch *arch () const
508 {
509 return per_bfd->gdbarch;
510 }
511
512 /* Return true if OBJFILE has partial symbols. */
513
514 bool has_partial_symbols ();
515
516 /* Return true if this objfile has any unexpanded symbols. A return
517 value of false indicates either, that this objfile has all its
518 symbols fully expanded (i.e. fully read in), or that this objfile has
519 no symbols at all (i.e. no debug information). */
521
522 /* See quick_symbol_functions. */
524
525 /* See quick_symbol_functions. */
527
528 /* Expand and iterate over each "partial" symbol table in OBJFILE
529 where the source file is named NAME.
530
531 If NAME is not absolute, a match after a '/' in the symbol table's
532 file name will also work, REAL_PATH is NULL then. If NAME is
533 absolute then REAL_PATH is non-NULL absolute file name as resolved
534 via gdb_realpath from NAME.
535
536 If a match is found, the "partial" symbol table is expanded.
537 Then, this calls iterate_over_some_symtabs (or equivalent) over
538 all newly-created symbol tables, passing CALLBACK to it.
539 The result of this call is returned. */
541 (const char *name, const char *real_path,
542 gdb::function_view<bool (symtab *)> callback);
543
544 /* Check to see if the symbol is defined in a "partial" symbol table
545 of this objfile. BLOCK_INDEX should be either GLOBAL_BLOCK or
546 STATIC_BLOCK, depending on whether we want to search global
547 symbols or static symbols. NAME is the name of the symbol to
548 look for. DOMAIN indicates what sort of symbol to search for.
549
550 Returns the newly-expanded compunit in which the symbol is
551 defined, or NULL if no such symbol table exists. If OBJFILE
552 contains !TYPE_OPAQUE symbol prefer its compunit. If it contains
553 only TYPE_OPAQUE symbol(s), return at least that compunit. */
554 struct compunit_symtab *lookup_symbol (block_enum kind, const char *name,
555 domain_enum domain);
556
557 /* See quick_symbol_functions. */
558 void print_stats (bool print_bcache);
559
560 /* See quick_symbol_functions. */
561 void dump ();
562
563 /* Find all the symbols in OBJFILE named FUNC_NAME, and ensure that
564 the corresponding symbol tables are loaded. */
565 void expand_symtabs_for_function (const char *func_name);
566
567 /* See quick_symbol_functions. */
568 void expand_all_symtabs ();
569
570 /* Read all symbol tables associated with OBJFILE which have
571 symtab_to_fullname equal to FULLNAME.
572 This is for the purposes of examining code only, e.g., expand_line_sal.
573 The routine may ignore debug info that is known to not be useful with
574 code, e.g., DW_TAG_type_unit for dwarf debug info. */
575 void expand_symtabs_with_fullname (const char *fullname);
576
577 /* See quick_symbol_functions. */
579 (const lookup_name_info &name, domain_enum domain,
580 int global,
581 symbol_compare_ftype *ordered_compare);
582
583 /* See quick_symbol_functions. */
585 (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
586 const lookup_name_info *lookup_name,
587 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
588 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
589 block_search_flags search_flags,
590 domain_enum domain,
591 enum search_domain kind);
592
593 /* See quick_symbol_functions. */
595 (struct bound_minimal_symbol msymbol,
596 CORE_ADDR pc,
597 struct obj_section *section,
598 int warn_if_readin);
599
600 /* See quick_symbol_functions. */
601 void map_symbol_filenames (gdb::function_view<symbol_filename_ftype> fun,
602 bool need_fullname);
603
604 /* See quick_symbol_functions. */
605 struct compunit_symtab *find_compunit_symtab_by_address (CORE_ADDR address);
606
607 /* See quick_symbol_functions. */
609 domain_enum domain,
610 bool *symbol_found_p);
611
612 /* See quick_symbol_functions. */
613 void require_partial_symbols (bool verbose);
614
615 /* Return the relocation offset applied to SECTION. */
616 CORE_ADDR section_offset (bfd_section *section) const
617 {
618 /* The section's owner can be nullptr if it is one of the _bfd_std_section
619 section. */
620 gdb_assert (section->owner == nullptr || section->owner == this->obfd);
621
622 int idx = gdb_bfd_section_index (this->obfd.get (), section);
623 return this->section_offsets[idx];
624 }
625
626 /* Set the relocation offset applied to SECTION. */
627 void set_section_offset (bfd_section *section, CORE_ADDR offset)
628 {
629 /* The section's owner can be nullptr if it is one of the _bfd_std_section
630 section. */
631 gdb_assert (section->owner == nullptr || section->owner == this->obfd);
632
633 int idx = gdb_bfd_section_index (this->obfd.get (), section);
634 this->section_offsets[idx] = offset;
635 }
636
638 {
639 public:
644
647
649 { return m_iter; }
650
652 {
653 ++m_iter;
654 skip_null ();
655 return *this;
656 }
657
658 bool operator== (const section_iterator &other) const
659 { return m_iter == other.m_iter && m_end == other.m_end; }
660
661 bool operator!= (const section_iterator &other) const
662 { return !(*this == other); }
663
664 private:
665
666 friend class objfile;
667
669 : m_iter (iter),
670 m_end (end)
671 {
672 skip_null ();
673 }
674
675 void skip_null ()
676 {
677 while (m_iter < m_end && m_iter->the_bfd_section == nullptr)
678 ++m_iter;
679 }
680
683 };
684
685 iterator_range<section_iterator> sections ()
686 {
687 return (iterator_range<section_iterator>
690 }
691
692 iterator_range<section_iterator> sections () const
693 {
694 return (iterator_range<section_iterator>
697 }
698
699private:
700
701 /* Ensure that partial symbols have been read and return the "quick" (aka
702 partial) symbol functions for this symbol reader. */
703 const std::forward_list<quick_symbol_functions_up> &
705 {
706 this->require_partial_symbols (true);
707 return qf;
708 }
709
710public:
711
712 /* The object file's original name as specified by the user,
713 made absolute, and tilde-expanded. However, it is not canonicalized
714 (i.e., it has not been passed through gdb_realpath).
715 This pointer is never NULL. This does not have to be freed; it is
716 guaranteed to have a lifetime at least as long as the objfile. */
717
718 const char *original_name = nullptr;
719
720 CORE_ADDR addr_low = 0;
721
722 /* Some flag bits for this objfile. */
723
724 objfile_flags flags;
725
726 /* The program space associated with this objfile. */
727
729
730 /* List of compunits.
731 These are used to do symbol lookups and file/line-number lookups. */
732
734
735 /* The object file's BFD. Can be null if the objfile contains only
736 minimal symbols (e.g. the run time common symbols for SunOS4) or
737 if the objfile is a dynamic objfile (e.g. created by JIT reader
738 API). */
739
741
742 /* The per-BFD data. */
743
745
746 /* In some cases, the per_bfd object is owned by this objfile and
747 not by the BFD itself. In this situation, this holds the owning
748 pointer. */
749
750 std::unique_ptr<objfile_per_bfd_storage> per_bfd_storage;
751
752 /* The modification timestamp of the object file, as of the last time
753 we read its symbols. */
754
755 long mtime = 0;
756
757 /* Obstack to hold objects that should be freed when we load a new symbol
758 table from this object file. */
759
760 auto_obstack objfile_obstack;
761
762 /* Structure which keeps track of functions that manipulate objfile's
763 of the same type as this objfile. I.e. the function to read partial
764 symbols for example. Note that this structure is in statically
765 allocated memory, and is shared by all objfiles that use the
766 object module reader of this type. */
767
768 const struct sym_fns *sf = nullptr;
769
770 /* The "quick" (aka partial) symbol functions for this symbol
771 reader. */
772 std::forward_list<quick_symbol_functions_up> qf;
773
774 /* Per objfile data-pointers required by other GDB modules. */
775
777
778 /* Set of relocation offsets to apply to each section.
779 The table is indexed by the_bfd_section->index, thus it is generally
780 as large as the number of sections in the binary.
781
782 These offsets indicate that all symbols (including partial and
783 minimal symbols) which have been read have been relocated by this
784 much. Symbols which are yet to be read need to be relocated by it. */
785
787
788 /* Indexes in the section_offsets array. These are initialized by the
789 *_symfile_offsets() family of functions (som_symfile_offsets,
790 xcoff_symfile_offsets, default_symfile_offsets). In theory they
791 should correspond to the section indexes used by bfd for the
792 current objfile. The exception to this for the time being is the
793 SOM version.
794
795 These are initialized to -1 so that we can later detect if they
796 are used w/o being properly assigned to. */
797
802
803 /* These pointers are used to locate the section table, which among
804 other things, is used to map pc addresses into sections.
805 SECTIONS_START points to the first entry in the table, and
806 SECTIONS_END points to the first location past the last entry in
807 the table. The table is stored on the objfile_obstack. The
808 sections are indexed by the BFD section index; but the structure
809 data is only valid for certain sections (e.g. non-empty,
810 SEC_ALLOC). */
811
812 struct obj_section *sections_start = nullptr;
813 struct obj_section *sections_end = nullptr;
814
815 /* GDB allows to have debug symbols in separate object files. This is
816 used by .gnu_debuglink, ELF build id note and Mach-O OSO.
817 Although this is a tree structure, GDB only support one level
818 (ie a separate debug for a separate debug is not supported). Note that
819 separate debug object are in the main chain and therefore will be
820 visited by objfiles & co iterators. Separate debug objfile always
821 has a non-nul separate_debug_objfile_backlink. */
822
823 /* Link to the first separate debug object, if any. */
824
826
827 /* If this is a separate debug object, this is used as a link to the
828 actual executable objfile. */
829
831
832 /* If this is a separate debug object, this is a link to the next one
833 for the same executable objfile. */
834
836
837 /* Place to stash various statistics about this objfile. */
838
840
841 /* A linked list of symbols created when reading template types or
842 function templates. These symbols are not stored in any symbol
843 table, so we have to keep them here to relocate them
844 properly. */
845
846 struct symbol *template_symbols = nullptr;
847
848 /* Associate a static link (struct dynamic_prop *) to all blocks (struct
849 block *) that have one.
850
851 In the context of nested functions (available in Pascal, Ada and GNU C,
852 for instance), a static link (as in DWARF's DW_AT_static_link attribute)
853 for a function is a way to get the frame corresponding to the enclosing
854 function.
855
856 Very few blocks have a static link, so it's more memory efficient to
857 store these here rather than in struct block. Static links must be
858 allocated on the objfile's obstack. */
860
861 /* JIT-related data for this objfile, if the objfile is a JITer;
862 that is, it produces JITed objfiles. */
863 std::unique_ptr<jiter_objfile_data> jiter_data = nullptr;
864
865 /* JIT-related data for this objfile, if the objfile is JITed;
866 that is, it was produced by a JITer. */
867 std::unique_ptr<jited_objfile_data> jited_data = nullptr;
868
869 /* A flag that is set to true if the JIT interface symbols are not
870 found in this objfile, so that we can skip the symbol lookup the
871 next time. If an objfile does not have the symbols, it will
872 never have them. */
874
875 /* Flag which indicates, when true, that the object format
876 potentially supports copy relocations. ABIs for some
877 architectures that use ELF have a copy relocation in which the
878 initialization for a global variable defined in a shared object
879 will be copied to memory allocated to the main program during
880 dynamic linking. Therefore this flag will be set for ELF
881 objfiles. Other object formats that use the same copy relocation
882 mechanism as ELF should set this flag too. This flag is used in
883 conjunction with the minimal_symbol::maybe_copied method. */
885};
886
887/* A deleter for objfile. */
888
890{
891 void operator() (objfile *ptr) const
892 {
893 ptr->unlink ();
894 }
895};
896
897/* A unique pointer that holds an objfile. */
898
899typedef std::unique_ptr<objfile, objfile_deleter> objfile_up;
900
901/* Relocation offset applied to the section. */
902inline CORE_ADDR
904{
905 return this->objfile->section_offset (this->the_bfd_section);
906}
907
908/* Set the relocation offset applied to the section. */
909inline void
910obj_section::set_offset (CORE_ADDR offset)
911{
912 this->objfile->set_section_offset (this->the_bfd_section, offset);
913}
914
915/* Declarations for functions defined in objfiles.c */
916
917extern int entry_point_address_query (CORE_ADDR *entry_p);
918
919extern CORE_ADDR entry_point_address (void);
920
921extern void build_objfile_section_table (struct objfile *);
922
923extern void free_objfile_separate_debug (struct objfile *);
924
925extern void objfile_relocate (struct objfile *, const section_offsets &);
926extern void objfile_rebase (struct objfile *, CORE_ADDR);
927
928extern int objfile_has_full_symbols (struct objfile *objfile);
929
930extern int objfile_has_symbols (struct objfile *objfile);
931
932extern int have_partial_symbols (void);
933
934extern int have_full_symbols (void);
935
936extern void objfile_set_sym_fns (struct objfile *objfile,
937 const struct sym_fns *sf);
938
939extern void objfiles_changed (void);
940
941/* Return true if ADDR maps into one of the sections of OBJFILE and false
942 otherwise. */
943
944extern bool is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile);
945
946/* Return true if ADDRESS maps into one of the sections of a
947 OBJF_SHARED objfile of PSPACE and false otherwise. */
948
949extern bool shared_objfile_contains_address_p (struct program_space *pspace,
950 CORE_ADDR address);
951
952/* This operation deletes all objfile entries that represent solibs that
953 weren't explicitly loaded by the user, via e.g., the add-symbol-file
954 command. */
955
956extern void objfile_purge_solibs (void);
957
958/* Functions for dealing with the minimal symbol table, really a misc
959 address<->symbol mapping for things we don't have debug symbols for. */
960
961extern int have_minimal_symbols (void);
962
963extern struct obj_section *find_pc_section (CORE_ADDR pc);
964
965/* Return true if PC is in a section called NAME. */
966extern bool pc_in_section (CORE_ADDR, const char *);
967
968/* Return non-zero if PC is in a SVR4-style procedure linkage table
969 section. */
970
971static inline int
972in_plt_section (CORE_ADDR pc)
973{
974 return (pc_in_section (pc, ".plt")
975 || pc_in_section (pc, ".plt.sec"));
976}
977
978/* In normal use, the section map will be rebuilt by find_pc_section
979 if objfiles have been added, removed or relocated since it was last
980 called. Calling inhibit_section_map_updates will inhibit this
981 behavior until the returned scoped_restore object is destroyed. If
982 you call inhibit_section_map_updates you must ensure that every
983 call to find_pc_section in the inhibited region relates to a
984 section that is already in the section map and has not since been
985 removed or relocated. */
986extern scoped_restore_tmpl<int> inhibit_section_map_updates
987 (struct program_space *pspace);
988
991 objfile *current_objfile);
992
993/* Reset the per-BFD storage area on OBJ. */
994
995void set_objfile_per_bfd (struct objfile *obj);
996
997/* Return canonical name for OBJFILE.
998 This is the real file name if the file has been opened.
999 Otherwise it is the original name supplied by the user. */
1000
1001const char *objfile_name (const struct objfile *objfile);
1002
1003/* Return the (real) file name of OBJFILE if the file has been opened,
1004 otherwise return NULL. */
1005
1006const char *objfile_filename (const struct objfile *objfile);
1007
1008/* Return the name to print for OBJFILE in debugging messages. */
1009
1010extern const char *objfile_debug_name (const struct objfile *objfile);
1011
1012/* Return the name of the file format of OBJFILE if the file has been opened,
1013 otherwise return NULL. */
1014
1015const char *objfile_flavour_name (struct objfile *objfile);
1016
1017/* Set the objfile's notion of the "main" name and language. */
1018
1019extern void set_objfile_main_name (struct objfile *objfile,
1020 const char *name, enum language lang);
1021
1022/* Find an integer type SIZE_IN_BYTES bytes in size from OF and return it.
1023 UNSIGNED_P controls if the integer is unsigned or not. */
1024extern struct type *objfile_int_type (struct objfile *of, int size_in_bytes,
1025 bool unsigned_p);
1026
1028 (struct objfile *objfile,
1029 const struct block *block,
1030 const struct dynamic_prop *static_link);
1031
1032extern const struct dynamic_prop *objfile_lookup_static_link
1033 (struct objfile *objfile, const struct block *block);
1034
1035#endif /* !defined (OBJFILES_H) */
const char *const name
bool operator==(const section_iterator &other) const
Definition objfiles.h:658
obj_section * value_type
Definition objfiles.h:646
section_iterator(obj_section *iter, obj_section *end)
Definition objfiles.h:668
section_iterator & operator++()
Definition objfiles.h:651
section_iterator self_type
Definition objfiles.h:645
bool operator!=(const section_iterator &other) const
Definition objfiles.h:661
section_iterator(const section_iterator &)=default
section_iterator(section_iterator &&)=default
section_iterator & operator=(const section_iterator &)=default
separate_debug_iterator & operator++()
Definition objfiles.c:382
bool operator!=(const separate_debug_iterator &other)
Definition objfiles.h:351
struct objfile * m_objfile
Definition objfiles.h:365
separate_debug_iterator(struct objfile *objfile)
Definition objfiles.h:345
struct objfile * m_parent
Definition objfiles.h:366
struct objfile * operator*()
Definition objfiles.h:358
block_enum
Definition defs.h:584
language
Definition defs.h:211
@ language_unknown
Definition defs.h:212
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition gdb_bfd.c:984
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:79
bfd * obfd
gdb::function_view< bool(objfile *)> iterate_over_objfiles_in_search_order_cb_ftype
Definition gdbarch.h:93
const char * objfile_flavour_name(struct objfile *objfile)
Definition objfiles.c:1289
int objfile_has_full_symbols(struct objfile *objfile)
Definition objfiles.c:740
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
#define MINIMAL_SYMBOL_HASH_SIZE
Definition objfiles.h:174
bool shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition objfiles.c:1225
const char * objfile_debug_name(const struct objfile *objfile)
Definition objfiles.c:1281
void build_objfile_section_table(struct objfile *)
Definition objfiles.c:278
void objfile_rebase(struct objfile *, CORE_ADDR)
Definition objfiles.c:725
#define SECT_OFF_DATA(objfile)
Definition objfiles.h:129
int objfile_has_symbols(struct objfile *objfile)
Definition objfiles.c:749
void objfile_purge_solibs(void)
Definition objfiles.c:794
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
void objfile_set_sym_fns(struct objfile *objfile, const struct sym_fns *sf)
bool pc_in_section(CORE_ADDR, const char *)
Definition objfiles.c:1175
void print_objfile_statistics(void)
Definition symmisc.c:52
scoped_restore_tmpl< int > inhibit_section_map_updates(struct program_space *pspace)
Definition objfiles.c:1197
#define SECT_OFF_TEXT(objfile)
Definition objfiles.h:139
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1128
const struct dynamic_prop * objfile_lookup_static_link(struct objfile *objfile, const struct block *block)
Definition objfiles.c:226
bool is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition objfiles.c:1206
void set_objfile_per_bfd(struct objfile *obj)
Definition objfiles.c:119
CORE_ADDR entry_point_address(void)
Definition objfiles.c:371
std::unique_ptr< objfile, objfile_deleter > objfile_up
Definition objfiles.h:899
int have_partial_symbols(void)
Definition objfiles.c:763
int entry_point_address_query(CORE_ADDR *entry_p)
Definition objfiles.c:356
iterator_range< separate_debug_iterator > separate_debug_range
Definition objfiles.h:371
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
void objfile_relocate(struct objfile *, const section_offsets &)
Definition objfiles.c:676
static int in_plt_section(CORE_ADDR pc)
Definition objfiles.h:972
const char * objfile_filename(const struct objfile *objfile)
Definition objfiles.c:1270
int have_full_symbols(void)
Definition objfiles.c:778
void free_objfile_separate_debug(struct objfile *)
Definition objfiles.c:477
void objfile_register_static_link(struct objfile *objfile, const struct block *block, const struct dynamic_prop *static_link)
Definition objfiles.c:197
int symbol_compare_ftype(const char *string1, const char *string2)
Definition block.h:109
CORE_ADDR entry_point
Definition objfiles.h:117
unsigned initialized
Definition objfiles.h:126
int the_bfd_section_index
Definition objfiles.h:120
unsigned entry_point_p
Definition objfiles.h:123
const void * insert(const void *addr, int length, bool *added=nullptr)
Definition bcache.c:143
bool operator!=(const self_type &other) const
Definition objfiles.h:202
struct minimal_symbol * value_type
Definition objfiles.h:181
struct minimal_symbol *& reference
Definition objfiles.h:182
struct minimal_symbol * m_msym
Definition objfiles.h:214
value_type operator*() const
Definition objfiles.h:192
minimal_symbol_iterator self_type
Definition objfiles.h:180
std::forward_iterator_tag iterator_category
Definition objfiles.h:184
bool operator==(const self_type &other) const
Definition objfiles.h:197
minimal_symbol_iterator(struct minimal_symbol *msym)
Definition objfiles.h:187
self_type & operator++()
Definition objfiles.h:207
struct minimal_symbol ** pointer
Definition objfiles.h:183
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
CORE_ADDR offset() const
Definition objfiles.h:903
void set_offset(CORE_ADDR offset)
Definition objfiles.h:910
struct bfd_section * the_bfd_section
Definition objfiles.h:398
void operator()(objfile *ptr) const
Definition objfiles.h:891
objfile_per_bfd_storage(bfd *bfd)
Definition objfiles.h:224
const char * intern(const std::string &str)
Definition objfiles.h:242
const char * intern(const char *str)
Definition objfiles.h:235
minimal_symbol * msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition objfiles.h:320
bfd * get_bfd() const
Definition objfiles.h:249
enum language language_of_main
Definition objfiles.h:287
auto_obstack storage_obstack
Definition objfiles.h:256
gdb::bcache string_cache
Definition objfiles.h:260
struct gdbarch * gdbarch
Definition objfiles.h:267
minimal_symbol * msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition objfiles.h:326
std::bitset< nr_languages > demangled_hash_languages
Definition objfiles.h:330
const char * name_of_main
Definition objfiles.h:286
gdb::unique_xmalloc_ptr< minimal_symbol > msymbols
Definition objfiles.h:297
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
int sect_index_rodata
Definition objfiles.h:801
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
std::unique_ptr< jiter_objfile_data > jiter_data
Definition objfiles.h:863
struct compunit_symtab * lookup_symbol(block_enum kind, const char *name, domain_enum domain)
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
CORE_ADDR section_offset(bfd_section *section) const
Definition objfiles.h:616
void set_section_offset(bfd_section *section, CORE_ADDR offset)
Definition objfiles.h:627
struct objfile * separate_debug_objfile
Definition objfiles.h:825
registry< objfile > registry_fields
Definition objfiles.h:776
int sect_index_bss
Definition objfiles.h:800
void expand_symtabs_with_fullname(const char *fullname)
struct symtab * find_last_source_symtab()
void expand_symtabs_for_function(const char *func_name)
int sect_index_data
Definition objfiles.h:799
struct gdbarch * arch() const
Definition objfiles.h:507
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:744
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info *lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, domain_enum domain, enum search_domain kind)
static objfile * make(gdb_bfd_ref_ptr bfd_, const char *name_, objfile_flags flags_, objfile *parent=nullptr)
Definition objfiles.c:449
bool object_format_has_copy_relocs
Definition objfiles.h:884
CORE_ADDR addr_low
Definition objfiles.h:720
void print_stats(bool print_bcache)
objfile(gdb_bfd_ref_ptr, const char *, objfile_flags)
Definition objfiles.c:313
bool map_symtabs_matching_filename(const char *name, const char *real_path, gdb::function_view< bool(symtab *)> callback)
htab_up static_links
Definition objfiles.h:859
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
CORE_ADDR text_section_offset() const
Definition objfiles.h:482
void expand_all_symtabs()
std::unique_ptr< jited_objfile_data > jited_data
Definition objfiles.h:867
void require_partial_symbols(bool verbose)
const char * intern(const char *str)
Definition objfiles.h:494
compunit_symtab_range compunits()
Definition objfiles.h:451
objfile_flags flags
Definition objfiles.h:724
void dump()
std::unique_ptr< objfile_per_bfd_storage > per_bfd_storage
Definition objfiles.h:750
bool has_unexpanded_symtabs()
bool skip_jit_symbol_lookup
Definition objfiles.h:873
int sect_index_text
Definition objfiles.h:798
auto_obstack objfile_obstack
Definition objfiles.h:760
std::forward_list< quick_symbol_functions_up > qf
Definition objfiles.h:772
DISABLE_COPY_AND_ASSIGN(objfile)
separate_debug_range separate_debug_objfiles()
Definition objfiles.h:475
CORE_ADDR data_section_offset() const
Definition objfiles.h:487
struct symbol * template_symbols
Definition objfiles.h:846
iterator_range< minimal_symbol_iterator > msymbols_range
Definition objfiles.h:459
enum language lookup_global_symbol_language(const char *name, domain_enum domain, bool *symbol_found_p)
::section_offsets section_offsets
Definition objfiles.h:786
void map_symbol_filenames(gdb::function_view< symbol_filename_ftype > fun, bool need_fullname)
iterator_range< section_iterator > sections() const
Definition objfiles.h:692
void expand_matching_symbols(const lookup_name_info &name, domain_enum domain, int global, symbol_compare_ftype *ordered_compare)
const std::forward_list< quick_symbol_functions_up > & qf_require_partial_symbols()
Definition objfiles.h:704
const char * intern(const std::string &str)
Definition objfiles.h:501
struct compunit_symtab * find_compunit_symtab_by_address(CORE_ADDR address)
void unlink()
Definition objfiles.c:468
struct compunit_symtab * find_pc_sect_compunit_symtab(struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin)
bool has_partial_symbols()
msymbols_range msymbols()
Definition objfiles.h:464
long mtime
Definition objfiles.h:755
int n_types
Definition objfiles.h:163
int n_syms
Definition objfiles.h:157
int n_stabs
Definition objfiles.h:160
int sz_strtab
Definition objfiles.h:166
next_range< compunit_symtab > compunit_symtab_range
Definition symtab.h:1984
search_domain
Definition symtab.h:945
domain_enum
Definition symtab.h:900
std::vector< CORE_ADDR > section_offsets
Definition symtab.h:1669