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