1 /* Symbol table definitions for GDB.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 #if !defined (SYMTAB_H)
27 #include "gdbsupport/gdb_vecs.h"
29 #include "gdb_obstack.h"
30 #include "gdb_regex.h"
31 #include "gdbsupport/enum-flags.h"
32 #include "gdbsupport/function-view.h"
33 #include "gdbsupport/gdb_optional.h"
34 #include "gdbsupport/gdb_string_view.h"
35 #include "gdbsupport/next-iterator.h"
36 #include "completer.h"
37 #include "gdb-demangle.h"
39 /* Opaque declarations. */
53 struct cmd_list_element
;
55 struct lookup_name_info
;
57 /* How to match a lookup name against a symbol search name. */
58 enum class symbol_name_match_type
60 /* Wild matching. Matches unqualified symbol names in all
61 namespace/module/packages, etc. */
64 /* Full matching. The lookup name indicates a fully-qualified name,
65 and only matches symbol search names in the specified
66 namespace/module/package. */
69 /* Search name matching. This is like FULL, but the search name did
70 not come from the user; instead it is already a search name
71 retrieved from a search_name () call.
72 For Ada, this avoids re-encoding an already-encoded search name
73 (which would potentially incorrectly lowercase letters in the
74 linkage/search name that should remain uppercase). For C++, it
75 avoids trying to demangle a name we already know is
79 /* Expression matching. The same as FULL matching in most
80 languages. The same as WILD matching in Ada. */
84 /* Hash the given symbol search name according to LANGUAGE's
86 extern unsigned int search_name_hash (enum language language
,
87 const char *search_name
);
89 /* Ada-specific bits of a lookup_name_info object. This is lazily
90 constructed on demand. */
92 class ada_lookup_name_info final
96 explicit ada_lookup_name_info (const lookup_name_info
&lookup_name
);
98 /* Compare SYMBOL_SEARCH_NAME with our lookup name, using MATCH_TYPE
99 as name match type. Returns true if there's a match, false
100 otherwise. If non-NULL, store the matching results in MATCH. */
101 bool matches (const char *symbol_search_name
,
102 symbol_name_match_type match_type
,
103 completion_match_result
*comp_match_res
) const;
105 /* The Ada-encoded lookup name. */
106 const std::string
&lookup_name () const
107 { return m_encoded_name
; }
109 /* Return true if we're supposed to be doing a wild match look
111 bool wild_match_p () const
112 { return m_wild_match_p
; }
114 /* Return true if we're looking up a name inside package
116 bool standard_p () const
117 { return m_standard_p
; }
119 /* Return true if doing a verbatim match. */
120 bool verbatim_p () const
121 { return m_verbatim_p
; }
124 /* The Ada-encoded lookup name. */
125 std::string m_encoded_name
;
127 /* Whether the user-provided lookup name was Ada encoded. If so,
128 then return encoded names in the 'matches' method's 'completion
129 match result' output. */
130 bool m_encoded_p
: 1;
132 /* True if really doing wild matching. Even if the user requests
133 wild matching, some cases require full matching. */
134 bool m_wild_match_p
: 1;
136 /* True if doing a verbatim match. This is true if the decoded
137 version of the symbol name is wrapped in '<'/'>'. This is an
138 escape hatch users can use to look up symbols the Ada encoding
139 does not understand. */
140 bool m_verbatim_p
: 1;
142 /* True if the user specified a symbol name that is inside package
143 Standard. Symbol names inside package Standard are handled
144 specially. We always do a non-wild match of the symbol name
145 without the "standard__" prefix, and only search static and
146 global symbols. This was primarily introduced in order to allow
147 the user to specifically access the standard exceptions using,
148 for instance, Standard.Constraint_Error when Constraint_Error is
149 ambiguous (due to the user defining its own Constraint_Error
150 entity inside its program). */
151 bool m_standard_p
: 1;
154 /* Language-specific bits of a lookup_name_info object, for languages
155 that do name searching using demangled names (C++/D/Go). This is
156 lazily constructed on demand. */
158 struct demangle_for_lookup_info final
161 demangle_for_lookup_info (const lookup_name_info
&lookup_name
,
164 /* The demangled lookup name. */
165 const std::string
&lookup_name () const
166 { return m_demangled_name
; }
169 /* The demangled lookup name. */
170 std::string m_demangled_name
;
173 /* Object that aggregates all information related to a symbol lookup
174 name. I.e., the name that is matched against the symbol's search
175 name. Caches per-language information so that it doesn't require
176 recomputing it for every symbol comparison, like for example the
177 Ada encoded name and the symbol's name hash for a given language.
178 The object is conceptually immutable once constructed, and thus has
179 no setters. This is to prevent some code path from tweaking some
180 property of the lookup name for some local reason and accidentally
181 altering the results of any continuing search(es).
182 lookup_name_info objects are generally passed around as a const
183 reference to reinforce that. (They're not passed around by value
184 because they're not small.) */
185 class lookup_name_info final
188 /* Create a new object. */
189 lookup_name_info (std::string name
,
190 symbol_name_match_type match_type
,
191 bool completion_mode
= false,
192 bool ignore_parameters
= false)
193 : m_match_type (match_type
),
194 m_completion_mode (completion_mode
),
195 m_ignore_parameters (ignore_parameters
),
196 m_name (std::move (name
))
199 /* Getters. See description of each corresponding field. */
200 symbol_name_match_type
match_type () const { return m_match_type
; }
201 bool completion_mode () const { return m_completion_mode
; }
202 const std::string
&name () const { return m_name
; }
203 const bool ignore_parameters () const { return m_ignore_parameters
; }
205 /* Return a version of this lookup name that is usable with
206 comparisons against symbols have no parameter info, such as
207 psymbols and GDB index symbols. */
208 lookup_name_info
make_ignore_params () const
210 return lookup_name_info (m_name
, m_match_type
, m_completion_mode
,
211 true /* ignore params */);
214 /* Get the search name hash for searches in language LANG. */
215 unsigned int search_name_hash (language lang
) const
217 /* Only compute each language's hash once. */
218 if (!m_demangled_hashes_p
[lang
])
220 m_demangled_hashes
[lang
]
221 = ::search_name_hash (lang
, language_lookup_name (lang
).c_str ());
222 m_demangled_hashes_p
[lang
] = true;
224 return m_demangled_hashes
[lang
];
227 /* Get the search name for searches in language LANG. */
228 const std::string
&language_lookup_name (language lang
) const
233 return ada ().lookup_name ();
235 return cplus ().lookup_name ();
237 return d ().lookup_name ();
239 return go ().lookup_name ();
245 /* Get the Ada-specific lookup info. */
246 const ada_lookup_name_info
&ada () const
252 /* Get the C++-specific lookup info. */
253 const demangle_for_lookup_info
&cplus () const
255 maybe_init (m_cplus
, language_cplus
);
259 /* Get the D-specific lookup info. */
260 const demangle_for_lookup_info
&d () const
262 maybe_init (m_d
, language_d
);
266 /* Get the Go-specific lookup info. */
267 const demangle_for_lookup_info
&go () const
269 maybe_init (m_go
, language_go
);
273 /* Get a reference to a lookup_name_info object that matches any
275 static const lookup_name_info
&match_any ();
278 /* Initialize FIELD, if not initialized yet. */
279 template<typename Field
, typename
... Args
>
280 void maybe_init (Field
&field
, Args
&&... args
) const
283 field
.emplace (*this, std::forward
<Args
> (args
)...);
286 /* The lookup info as passed to the ctor. */
287 symbol_name_match_type m_match_type
;
288 bool m_completion_mode
;
289 bool m_ignore_parameters
;
292 /* Language-specific info. These fields are filled lazily the first
293 time a lookup is done in the corresponding language. They're
294 mutable because lookup_name_info objects are typically passed
295 around by const reference (see intro), and they're conceptually
296 "cache" that can always be reconstructed from the non-mutable
298 mutable gdb::optional
<ada_lookup_name_info
> m_ada
;
299 mutable gdb::optional
<demangle_for_lookup_info
> m_cplus
;
300 mutable gdb::optional
<demangle_for_lookup_info
> m_d
;
301 mutable gdb::optional
<demangle_for_lookup_info
> m_go
;
303 /* The demangled hashes. Stored in an array with one entry for each
304 possible language. The second array records whether we've
305 already computed the each language's hash. (These are separate
306 arrays instead of a single array of optional<unsigned> to avoid
307 alignment padding). */
308 mutable std::array
<unsigned int, nr_languages
> m_demangled_hashes
;
309 mutable std::array
<bool, nr_languages
> m_demangled_hashes_p
{};
312 /* Comparison function for completion symbol lookup.
314 Returns true if the symbol name matches against LOOKUP_NAME.
316 SYMBOL_SEARCH_NAME should be a symbol's "search" name.
318 On success and if non-NULL, COMP_MATCH_RES->match is set to point
319 to the symbol name as should be presented to the user as a
320 completion match list element. In most languages, this is the same
321 as the symbol's search name, but in some, like Ada, the display
322 name is dynamically computed within the comparison routine.
324 Also, on success and if non-NULL, COMP_MATCH_RES->match_for_lcd
325 points the part of SYMBOL_SEARCH_NAME that was considered to match
326 LOOKUP_NAME. E.g., in C++, in linespec/wild mode, if the symbol is
327 "foo::function()" and LOOKUP_NAME is "function(", MATCH_FOR_LCD
328 points to "function()" inside SYMBOL_SEARCH_NAME. */
329 typedef bool (symbol_name_matcher_ftype
)
330 (const char *symbol_search_name
,
331 const lookup_name_info
&lookup_name
,
332 completion_match_result
*comp_match_res
);
334 /* Some of the structures in this file are space critical.
335 The space-critical structures are:
337 struct general_symbol_info
339 struct partial_symbol
341 These structures are laid out to encourage good packing.
342 They use ENUM_BITFIELD and short int fields, and they order the
343 structure members so that fields less than a word are next
344 to each other so they can be packed together. */
346 /* Rearranged: used ENUM_BITFIELD and rearranged field order in
347 all the space critical structures (plus struct minimal_symbol).
348 Memory usage dropped from 99360768 bytes to 90001408 bytes.
349 I measured this with before-and-after tests of
350 "HEAD-old-gdb -readnow HEAD-old-gdb" and
351 "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
352 red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
353 typing "maint space 1" at the first command prompt.
355 Here is another measurement (from andrew c):
356 # no /usr/lib/debug, just plain glibc, like a normal user
358 (gdb) break internal_error
360 (gdb) maint internal-error
364 gdb gdb_6_0_branch 2003-08-19 space used: 8896512
365 gdb HEAD 2003-08-19 space used: 8904704
366 gdb HEAD 2003-08-21 space used: 8396800 (+symtab.h)
367 gdb HEAD 2003-08-21 space used: 8265728 (+gdbtypes.h)
369 The third line shows the savings from the optimizations in symtab.h.
370 The fourth line shows the savings from the optimizations in
371 gdbtypes.h. Both optimizations are in gdb HEAD now.
373 --chastain 2003-08-21 */
375 /* Define a structure for the information that is common to all symbol types,
376 including minimal symbols, partial symbols, and full symbols. In a
377 multilanguage environment, some language specific information may need to
378 be recorded along with each symbol. */
380 /* This structure is space critical. See space comments at the top. */
382 struct general_symbol_info
384 /* Short version as to when to use which name accessor:
385 Use natural_name () to refer to the name of the symbol in the original
386 source code. Use linkage_name () if you want to know what the linker
387 thinks the symbol's name is. Use print_name () for output. Use
388 demangled_name () if you specifically need to know whether natural_name ()
389 and linkage_name () are different. */
391 const char *linkage_name () const
394 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
395 the original source code. In languages like C++ where symbols may
396 be mangled for ease of manipulation by the linker, this is the
398 const char *natural_name () const;
400 /* Returns a version of the name of a symbol that is
401 suitable for output. In C++ this is the "demangled" form of the
402 name if demangle is on and the "mangled" form of the name if
403 demangle is off. In other languages this is just the symbol name.
404 The result should never be NULL. Don't use this for internal
405 purposes (e.g. storing in a hashtable): it's only suitable for output. */
406 const char *print_name () const
407 { return demangle
? natural_name () : linkage_name (); }
409 /* Return the demangled name for a symbol based on the language for
410 that symbol. If no demangled name exists, return NULL. */
411 const char *demangled_name () const;
413 /* Returns the name to be used when sorting and searching symbols.
414 In C++, we search for the demangled form of a name,
415 and so sort symbols accordingly. In Ada, however, we search by mangled
416 name. If there is no distinct demangled name, then this
417 returns the same value (same pointer) as linkage_name (). */
418 const char *search_name () const;
420 /* Set just the linkage name of a symbol; do not try to demangle
421 it. Used for constructs which do not have a mangled name,
422 e.g. struct tags. Unlike SYMBOL_SET_NAMES, linkage_name must
423 be terminated and either already on the objfile's obstack or
424 permanently allocated. */
425 void set_linkage_name (const char *linkage_name
)
426 { name
= linkage_name
; }
428 enum language
language () const
429 { return m_language
; }
431 /* Name of the symbol. This is a required field. Storage for the
432 name is allocated on the objfile_obstack for the associated
433 objfile. For languages like C++ that make a distinction between
434 the mangled name and demangled name, this is the mangled
439 /* Value of the symbol. Which member of this union to use, and what
440 it means, depends on what kind of symbol this is and its
441 SYMBOL_CLASS. See comments there for more details. All of these
442 are in host byte order (though what they point to might be in
443 target byte order, e.g. LOC_CONST_BYTES). */
449 const struct block
*block
;
451 const gdb_byte
*bytes
;
455 /* A common block. Used with LOC_COMMON_BLOCK. */
457 const struct common_block
*common_block
;
459 /* For opaque typedef struct chain. */
461 struct symbol
*chain
;
465 /* Since one and only one language can apply, wrap the language specific
466 information inside a union. */
470 /* A pointer to an obstack that can be used for storage associated
471 with this symbol. This is only used by Ada, and only when the
472 'ada_mangled' field is zero. */
473 struct obstack
*obstack
;
475 /* This is used by languages which wish to store a demangled name.
476 currently used by Ada, C++, and Objective C. */
477 const char *demangled_name
;
481 /* Record the source code language that applies to this symbol.
482 This is used to select one of the fields from the language specific
485 ENUM_BITFIELD(language
) m_language
: LANGUAGE_BITS
;
487 /* This is only used by Ada. If set, then the 'demangled_name' field
488 of language_specific is valid. Otherwise, the 'obstack' field is
490 unsigned int ada_mangled
: 1;
492 /* Which section is this symbol in? This is an index into
493 section_offsets for this objfile. Negative means that the symbol
494 does not get relocated relative to a section. */
499 extern void symbol_set_demangled_name (struct general_symbol_info
*,
503 extern const char *symbol_get_demangled_name
504 (const struct general_symbol_info
*);
506 extern CORE_ADDR
symbol_overlayed_address (CORE_ADDR
, struct obj_section
*);
508 /* Return the address of SYM. The MAYBE_COPIED flag must be set on
509 SYM. If SYM appears in the main program's minimal symbols, then
510 that minsym's address is returned; otherwise, SYM's address is
511 returned. This should generally only be used via the
512 SYMBOL_VALUE_ADDRESS macro. */
514 extern CORE_ADDR
get_symbol_address (const struct symbol
*sym
);
516 /* Note that these macros only work with symbol, not partial_symbol. */
518 #define SYMBOL_VALUE(symbol) (symbol)->value.ivalue
519 #define SYMBOL_VALUE_ADDRESS(symbol) \
520 (((symbol)->maybe_copied) ? get_symbol_address (symbol) \
521 : ((symbol)->value.address))
522 #define SET_SYMBOL_VALUE_ADDRESS(symbol, new_value) \
523 ((symbol)->value.address = (new_value))
524 #define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
525 #define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->value.common_block
526 #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
527 #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
528 #define SYMBOL_SECTION(symbol) (symbol)->section
529 #define SYMBOL_OBJ_SECTION(objfile, symbol) \
530 (((symbol)->section >= 0) \
531 ? (&(((objfile)->sections)[(symbol)->section])) \
534 /* Initializes the language dependent portion of a symbol
535 depending upon the language for the symbol. */
536 #define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
537 (symbol_set_language ((symbol), (language), (obstack)))
538 extern void symbol_set_language (struct general_symbol_info
*symbol
,
539 enum language language
,
540 struct obstack
*obstack
);
542 /* Try to determine the demangled name for a symbol, based on the
543 language of that symbol. If the language is set to language_auto,
544 it will attempt to find any demangling algorithm that works and
545 then set the language appropriately. The returned name is allocated
546 by the demangler and should be xfree'd. */
548 extern char *symbol_find_demangled_name (struct general_symbol_info
*gsymbol
,
549 const char *mangled
);
551 /* Set the linkage and natural names of a symbol, by demangling
552 the linkage name. If linkage_name may not be nullterminated,
553 copy_name must be set to true. */
554 #define SYMBOL_SET_NAMES(symbol,linkage_name,copy_name,objfile) \
555 symbol_set_names ((symbol), linkage_name, copy_name, \
557 extern void symbol_set_names (struct general_symbol_info
*symbol
,
558 gdb::string_view linkage_name
, bool copy_name
,
559 struct objfile_per_bfd_storage
*per_bfd
,
560 gdb::optional
<hashval_t
> hash
561 = gdb::optional
<hashval_t
> ());
563 /* Return true if NAME matches the "search" name of SYMBOL, according
564 to the symbol's language. */
565 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
566 symbol_matches_search_name ((symbol), (name))
568 /* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
570 extern bool symbol_matches_search_name
571 (const struct general_symbol_info
*gsymbol
,
572 const lookup_name_info
&name
);
574 /* Compute the hash of the given symbol search name of a symbol of
575 language LANGUAGE. */
576 extern unsigned int search_name_hash (enum language language
,
577 const char *search_name
);
579 /* Classification types for a minimal symbol. These should be taken as
580 "advisory only", since if gdb can't easily figure out a
581 classification it simply selects mst_unknown. It may also have to
582 guess when it can't figure out which is a better match between two
583 types (mst_data versus mst_bss) for example. Since the minimal
584 symbol info is sometimes derived from the BFD library's view of a
585 file, we need to live with what information bfd supplies. */
587 enum minimal_symbol_type
589 mst_unknown
= 0, /* Unknown type, the default */
590 mst_text
, /* Generally executable instructions */
592 /* A GNU ifunc symbol, in the .text section. GDB uses to know
593 whether the user is setting a breakpoint on a GNU ifunc function,
594 and thus GDB needs to actually set the breakpoint on the target
595 function. It is also used to know whether the program stepped
596 into an ifunc resolver -- the resolver may get a separate
597 symbol/alias under a different name, but it'll have the same
598 address as the ifunc symbol. */
599 mst_text_gnu_ifunc
, /* Executable code returning address
600 of executable code */
602 /* A GNU ifunc function descriptor symbol, in a data section
603 (typically ".opd"). Seen on architectures that use function
604 descriptors, like PPC64/ELFv1. In this case, this symbol's value
605 is the address of the descriptor. There'll be a corresponding
606 mst_text_gnu_ifunc synthetic symbol for the text/entry
608 mst_data_gnu_ifunc
, /* Executable code returning address
609 of executable code */
611 mst_slot_got_plt
, /* GOT entries for .plt sections */
612 mst_data
, /* Generally initialized data */
613 mst_bss
, /* Generally uninitialized data */
614 mst_abs
, /* Generally absolute (nonrelocatable) */
615 /* GDB uses mst_solib_trampoline for the start address of a shared
616 library trampoline entry. Breakpoints for shared library functions
617 are put there if the shared library is not yet loaded.
618 After the shared library is loaded, lookup_minimal_symbol will
619 prefer the minimal symbol from the shared library (usually
620 a mst_text symbol) over the mst_solib_trampoline symbol, and the
621 breakpoints will be moved to their true address in the shared
622 library via breakpoint_re_set. */
623 mst_solib_trampoline
, /* Shared library trampoline code */
624 /* For the mst_file* types, the names are only guaranteed to be unique
625 within a given .o file. */
626 mst_file_text
, /* Static version of mst_text */
627 mst_file_data
, /* Static version of mst_data */
628 mst_file_bss
, /* Static version of mst_bss */
632 /* The number of enum minimal_symbol_type values, with some padding for
633 reasonable growth. */
634 #define MINSYM_TYPE_BITS 4
635 gdb_static_assert (nr_minsym_types
<= (1 << MINSYM_TYPE_BITS
));
637 /* Define a simple structure used to hold some very basic information about
638 all defined global symbols (text, data, bss, abs, etc). The only required
639 information is the general_symbol_info.
641 In many cases, even if a file was compiled with no special options for
642 debugging at all, as long as was not stripped it will contain sufficient
643 information to build a useful minimal symbol table using this structure.
644 Even when a file contains enough debugging information to build a full
645 symbol table, these minimal symbols are still useful for quickly mapping
646 between names and addresses, and vice versa. They are also sometimes
647 used to figure out what full symbol table entries need to be read in. */
649 struct minimal_symbol
: public general_symbol_info
651 /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this
652 information to calculate the end of the partial symtab based on the
653 address of the last symbol plus the size of the last symbol. */
657 /* Which source file is this symbol in? Only relevant for mst_file_*. */
658 const char *filename
;
660 /* Classification type for this minimal symbol. */
662 ENUM_BITFIELD(minimal_symbol_type
) type
: MINSYM_TYPE_BITS
;
664 /* Non-zero if this symbol was created by gdb.
665 Such symbols do not appear in the output of "info var|fun". */
666 unsigned int created_by_gdb
: 1;
668 /* Two flag bits provided for the use of the target. */
669 unsigned int target_flag_1
: 1;
670 unsigned int target_flag_2
: 1;
672 /* Nonzero iff the size of the minimal symbol has been set.
673 Symbol size information can sometimes not be determined, because
674 the object file format may not carry that piece of information. */
675 unsigned int has_size
: 1;
677 /* For data symbols only, if this is set, then the symbol might be
678 subject to copy relocation. In this case, a minimal symbol
679 matching the symbol's linkage name is first looked for in the
680 main objfile. If found, then that address is used; otherwise the
681 address in this symbol is used. */
683 unsigned maybe_copied
: 1;
685 /* Non-zero if this symbol ever had its demangled name set (even if
686 it was set to NULL). */
687 unsigned int name_set
: 1;
689 /* Minimal symbols with the same hash key are kept on a linked
690 list. This is the link. */
692 struct minimal_symbol
*hash_next
;
694 /* Minimal symbols are stored in two different hash tables. This is
695 the `next' pointer for the demangled hash table. */
697 struct minimal_symbol
*demangled_hash_next
;
699 /* True if this symbol is of some data type. */
701 bool data_p () const;
703 /* True if MSYMBOL is of some text type. */
705 bool text_p () const;
708 /* Return the address of MINSYM, which comes from OBJF. The
709 MAYBE_COPIED flag must be set on MINSYM. If MINSYM appears in the
710 main program's minimal symbols, then that minsym's address is
711 returned; otherwise, MINSYM's address is returned. This should
712 generally only be used via the MSYMBOL_VALUE_ADDRESS macro. */
714 extern CORE_ADDR
get_msymbol_address (struct objfile
*objf
,
715 const struct minimal_symbol
*minsym
);
717 #define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
718 #define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
719 #define MSYMBOL_SIZE(msymbol) ((msymbol)->size + 0)
720 #define SET_MSYMBOL_SIZE(msymbol, sz) \
723 (msymbol)->size = sz; \
724 (msymbol)->has_size = 1; \
726 #define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0)
727 #define MSYMBOL_TYPE(msymbol) (msymbol)->type
729 #define MSYMBOL_VALUE(symbol) (symbol)->value.ivalue
730 /* The unrelocated address of the minimal symbol. */
731 #define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->value.address + 0)
732 /* The relocated address of the minimal symbol, using the section
733 offsets from OBJFILE. */
734 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
735 (((symbol)->maybe_copied) ? get_msymbol_address (objfile, symbol) \
736 : ((symbol)->value.address \
737 + ANOFFSET ((objfile)->section_offsets, ((symbol)->section))))
738 /* For a bound minsym, we can easily compute the address directly. */
739 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
740 MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
741 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \
742 ((symbol)->value.address = (new_value))
743 #define MSYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
744 #define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
745 #define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
746 #define MSYMBOL_SECTION(symbol) (symbol)->section
747 #define MSYMBOL_OBJ_SECTION(objfile, symbol) \
748 (((symbol)->section >= 0) \
749 ? (&(((objfile)->sections)[(symbol)->section])) \
756 /* Represent one symbol name; a variable, constant, function or typedef. */
758 /* Different name domains for symbols. Looking up a symbol specifies a
759 domain and ignores symbol definitions in other name domains. */
761 typedef enum domain_enum_tag
763 /* UNDEF_DOMAIN is used when a domain has not been discovered or
764 none of the following apply. This usually indicates an error either
765 in the symbol information or in gdb's handling of symbols. */
769 /* VAR_DOMAIN is the usual domain. In C, this contains variables,
770 function names, typedef names and enum type values. */
774 /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
775 Thus, if `struct foo' is used in a C program, it produces a symbol named
776 `foo' in the STRUCT_DOMAIN. */
780 /* MODULE_DOMAIN is used in Fortran to hold module type names. */
784 /* LABEL_DOMAIN may be used for names of labels (for gotos). */
788 /* Fortran common blocks. Their naming must be separate from VAR_DOMAIN.
789 They also always use LOC_COMMON_BLOCK. */
792 /* This must remain last. */
796 /* The number of bits in a symbol used to represent the domain. */
798 #define SYMBOL_DOMAIN_BITS 3
799 gdb_static_assert (NR_DOMAINS
<= (1 << SYMBOL_DOMAIN_BITS
));
801 extern const char *domain_name (domain_enum
);
803 /* Searching domains, used when searching for symbols. Element numbers are
804 hardcoded in GDB, check all enum uses before changing it. */
808 /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
810 VARIABLES_DOMAIN
= 0,
812 /* All functions -- for some reason not methods, though. */
813 FUNCTIONS_DOMAIN
= 1,
815 /* All defined types */
825 extern const char *search_domain_name (enum search_domain
);
827 /* An address-class says where to find the value of a symbol. */
831 /* Not used; catches errors. */
835 /* Value is constant int SYMBOL_VALUE, host byteorder. */
839 /* Value is at fixed address SYMBOL_VALUE_ADDRESS. */
843 /* Value is in register. SYMBOL_VALUE is the register number
844 in the original debug format. SYMBOL_REGISTER_OPS holds a
845 function that can be called to transform this into the
846 actual register number this represents in a specific target
847 architecture (gdbarch).
849 For some symbol formats (stabs, for some compilers at least),
850 the compiler generates two symbols, an argument and a register.
851 In some cases we combine them to a single LOC_REGISTER in symbol
852 reading, but currently not for all cases (e.g. it's passed on the
853 stack and then loaded into a register). */
857 /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */
861 /* Value address is at SYMBOL_VALUE offset in arglist. */
865 /* Value is in specified register. Just like LOC_REGISTER except the
866 register holds the address of the argument instead of the argument
867 itself. This is currently used for the passing of structs and unions
868 on sparc and hppa. It is also used for call by reference where the
869 address is in a register, at least by mipsread.c. */
873 /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */
877 /* Value not used; definition in SYMBOL_TYPE. Symbols in the domain
878 STRUCT_DOMAIN all have this class. */
882 /* Value is address SYMBOL_VALUE_ADDRESS in the code. */
886 /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
887 In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
888 of the block. Function names have this class. */
892 /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
893 target byte order. */
897 /* Value is at fixed address, but the address of the variable has
898 to be determined from the minimal symbol table whenever the
899 variable is referenced.
900 This happens if debugging information for a global symbol is
901 emitted and the corresponding minimal symbol is defined
902 in another object file or runtime common storage.
903 The linker might even remove the minimal symbol if the global
904 symbol is never referenced, in which case the symbol remains
907 GDB would normally find the symbol in the minimal symbol table if it will
908 not find it in the full symbol table. But a reference to an external
909 symbol in a local block shadowing other definition requires full symbol
910 without possibly having its address available for LOC_STATIC. Testcase
911 is provided as `gdb.dwarf2/dw2-unresolved.exp'.
913 This is also used for thread local storage (TLS) variables. In this case,
914 the address of the TLS variable must be determined when the variable is
915 referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
916 of the TLS variable in the thread local storage of the shared
921 /* The variable does not actually exist in the program.
922 The value is ignored. */
926 /* The variable's address is computed by a set of location
927 functions (see "struct symbol_computed_ops" below). */
930 /* The variable uses general_symbol_info->value->common_block field.
931 It also always uses COMMON_BLOCK_DOMAIN. */
934 /* Not used, just notes the boundary of the enum. */
938 /* The number of bits needed for values in enum address_class, with some
939 padding for reasonable growth, and room for run-time registered address
940 classes. See symtab.c:MAX_SYMBOL_IMPLS.
941 This is a #define so that we can have a assertion elsewhere to
942 verify that we have reserved enough space for synthetic address
944 #define SYMBOL_ACLASS_BITS 5
945 gdb_static_assert (LOC_FINAL_VALUE
<= (1 << SYMBOL_ACLASS_BITS
));
947 /* The methods needed to implement LOC_COMPUTED. These methods can
948 use the symbol's .aux_value for additional per-symbol information.
950 At present this is only used to implement location expressions. */
952 struct symbol_computed_ops
955 /* Return the value of the variable SYMBOL, relative to the stack
956 frame FRAME. If the variable has been optimized out, return
959 Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
960 FRAME may be zero. */
962 struct value
*(*read_variable
) (struct symbol
* symbol
,
963 struct frame_info
* frame
);
965 /* Read variable SYMBOL like read_variable at (callee) FRAME's function
966 entry. SYMBOL should be a function parameter, otherwise
967 NO_ENTRY_VALUE_ERROR will be thrown. */
968 struct value
*(*read_variable_at_entry
) (struct symbol
*symbol
,
969 struct frame_info
*frame
);
971 /* Find the "symbol_needs_kind" value for the given symbol. This
972 value determines whether reading the symbol needs memory (e.g., a
973 global variable), just registers (a thread-local), or a frame (a
975 enum symbol_needs_kind (*get_symbol_read_needs
) (struct symbol
* symbol
);
977 /* Write to STREAM a natural-language description of the location of
978 SYMBOL, in the context of ADDR. */
979 void (*describe_location
) (struct symbol
* symbol
, CORE_ADDR addr
,
980 struct ui_file
* stream
);
982 /* Non-zero if this symbol's address computation is dependent on PC. */
983 unsigned char location_has_loclist
;
985 /* Tracepoint support. Append bytecodes to the tracepoint agent
986 expression AX that push the address of the object SYMBOL. Set
987 VALUE appropriately. Note --- for objects in registers, this
988 needn't emit any code; as long as it sets VALUE properly, then
989 the caller will generate the right code in the process of
990 treating this as an lvalue or rvalue. */
992 void (*tracepoint_var_ref
) (struct symbol
*symbol
, struct agent_expr
*ax
,
993 struct axs_value
*value
);
995 /* Generate C code to compute the location of SYMBOL. The C code is
996 emitted to STREAM. GDBARCH is the current architecture and PC is
997 the PC at which SYMBOL's location should be evaluated.
998 REGISTERS_USED is a vector indexed by register number; the
999 generator function should set an element in this vector if the
1000 corresponding register is needed by the location computation.
1001 The generated C code must assign the location to a local
1002 variable; this variable's name is RESULT_NAME. */
1004 void (*generate_c_location
) (struct symbol
*symbol
, string_file
*stream
,
1005 struct gdbarch
*gdbarch
,
1006 unsigned char *registers_used
,
1007 CORE_ADDR pc
, const char *result_name
);
1011 /* The methods needed to implement LOC_BLOCK for inferior functions.
1012 These methods can use the symbol's .aux_value for additional
1013 per-symbol information. */
1015 struct symbol_block_ops
1017 /* Fill in *START and *LENGTH with DWARF block data of function
1018 FRAMEFUNC valid for inferior context address PC. Set *LENGTH to
1019 zero if such location is not valid for PC; *START is left
1020 uninitialized in such case. */
1021 void (*find_frame_base_location
) (struct symbol
*framefunc
, CORE_ADDR pc
,
1022 const gdb_byte
**start
, size_t *length
);
1024 /* Return the frame base address. FRAME is the frame for which we want to
1025 compute the base address while FRAMEFUNC is the symbol for the
1026 corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
1027 information we need).
1029 This method is designed to work with static links (nested functions
1030 handling). Static links are function properties whose evaluation returns
1031 the frame base address for the enclosing frame. However, there are
1032 multiple definitions for "frame base": the content of the frame base
1033 register, the CFA as defined by DWARF unwinding information, ...
1035 So this specific method is supposed to compute the frame base address such
1036 as for nested functions, the static link computes the same address. For
1037 instance, considering DWARF debugging information, the static link is
1038 computed with DW_AT_static_link and this method must be used to compute
1039 the corresponding DW_AT_frame_base attribute. */
1040 CORE_ADDR (*get_frame_base
) (struct symbol
*framefunc
,
1041 struct frame_info
*frame
);
1044 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1046 struct symbol_register_ops
1048 int (*register_number
) (struct symbol
*symbol
, struct gdbarch
*gdbarch
);
1051 /* Objects of this type are used to find the address class and the
1052 various computed ops vectors of a symbol. */
1056 enum address_class aclass
;
1058 /* Used with LOC_COMPUTED. */
1059 const struct symbol_computed_ops
*ops_computed
;
1061 /* Used with LOC_BLOCK. */
1062 const struct symbol_block_ops
*ops_block
;
1064 /* Used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1065 const struct symbol_register_ops
*ops_register
;
1068 /* struct symbol has some subclasses. This enum is used to
1069 differentiate between them. */
1071 enum symbol_subclass_kind
1073 /* Plain struct symbol. */
1076 /* struct template_symbol. */
1079 /* struct rust_vtable_symbol. */
1083 /* This structure is space critical. See space comments at the top. */
1085 struct symbol
: public general_symbol_info
, public allocate_on_obstack
1088 /* Class-initialization of bitfields is only allowed in C++20. */
1089 : domain (UNDEF_DOMAIN
),
1091 is_objfile_owned (0),
1095 subclass (SYMBOL_NONE
)
1097 /* We can't use an initializer list for members of a base class, and
1098 general_symbol_info needs to stay a POD type. */
1101 language_specific
.obstack
= nullptr;
1102 m_language
= language_unknown
;
1105 /* GCC 4.8.5 (on CentOS 7) does not correctly compile class-
1106 initialization of unions, so we initialize it manually here. */
1107 owner
.symtab
= nullptr;
1110 /* Data type of value */
1112 struct type
*type
= nullptr;
1114 /* The owner of this symbol.
1115 Which one to use is defined by symbol.is_objfile_owned. */
1119 /* The symbol table containing this symbol. This is the file associated
1120 with LINE. It can be NULL during symbols read-in but it is never NULL
1121 during normal operation. */
1122 struct symtab
*symtab
;
1124 /* For types defined by the architecture. */
1125 struct gdbarch
*arch
;
1130 ENUM_BITFIELD(domain_enum_tag
) domain
: SYMBOL_DOMAIN_BITS
;
1132 /* Address class. This holds an index into the 'symbol_impls'
1133 table. The actual enum address_class value is stored there,
1134 alongside any per-class ops vectors. */
1136 unsigned int aclass_index
: SYMBOL_ACLASS_BITS
;
1138 /* If non-zero then symbol is objfile-owned, use owner.symtab.
1139 Otherwise symbol is arch-owned, use owner.arch. */
1141 unsigned int is_objfile_owned
: 1;
1143 /* Whether this is an argument. */
1145 unsigned is_argument
: 1;
1147 /* Whether this is an inlined function (class LOC_BLOCK only). */
1148 unsigned is_inlined
: 1;
1150 /* For LOC_STATIC only, if this is set, then the symbol might be
1151 subject to copy relocation. In this case, a minimal symbol
1152 matching the symbol's linkage name is first looked for in the
1153 main objfile. If found, then that address is used; otherwise the
1154 address in this symbol is used. */
1156 unsigned maybe_copied
: 1;
1158 /* The concrete type of this symbol. */
1160 ENUM_BITFIELD (symbol_subclass_kind
) subclass
: 2;
1162 /* Line number of this symbol's definition, except for inlined
1163 functions. For an inlined function (class LOC_BLOCK and
1164 SYMBOL_INLINED set) this is the line number of the function's call
1165 site. Inlined function symbols are not definitions, and they are
1166 never found by symbol table lookup.
1167 If this symbol is arch-owned, LINE shall be zero.
1169 FIXME: Should we really make the assumption that nobody will try
1170 to debug files longer than 64K lines? What about machine
1171 generated programs? */
1173 unsigned short line
= 0;
1175 /* An arbitrary data pointer, allowing symbol readers to record
1176 additional information on a per-symbol basis. Note that this data
1177 must be allocated using the same obstack as the symbol itself. */
1178 /* So far it is only used by:
1179 LOC_COMPUTED: to find the location information
1180 LOC_BLOCK (DWARF2 function): information used internally by the
1181 DWARF 2 code --- specifically, the location expression for the frame
1182 base for this function. */
1183 /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
1184 to add a magic symbol to the block containing this information,
1185 or to have a generic debug info annotation slot for symbols. */
1187 void *aux_value
= nullptr;
1189 struct symbol
*hash_next
= nullptr;
1192 /* Several lookup functions return both a symbol and the block in which the
1193 symbol is found. This structure is used in these cases. */
1197 /* The symbol that was found, or NULL if no symbol was found. */
1198 struct symbol
*symbol
;
1200 /* If SYMBOL is not NULL, then this is the block in which the symbol is
1202 const struct block
*block
;
1205 extern const struct symbol_impl
*symbol_impls
;
1207 /* Note: There is no accessor macro for symbol.owner because it is
1210 #define SYMBOL_DOMAIN(symbol) (symbol)->domain
1211 #define SYMBOL_IMPL(symbol) (symbol_impls[(symbol)->aclass_index])
1212 #define SYMBOL_ACLASS_INDEX(symbol) (symbol)->aclass_index
1213 #define SYMBOL_CLASS(symbol) (SYMBOL_IMPL (symbol).aclass)
1214 #define SYMBOL_OBJFILE_OWNED(symbol) ((symbol)->is_objfile_owned)
1215 #define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
1216 #define SYMBOL_INLINED(symbol) (symbol)->is_inlined
1217 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
1218 (((symbol)->subclass) == SYMBOL_TEMPLATE)
1219 #define SYMBOL_TYPE(symbol) (symbol)->type
1220 #define SYMBOL_LINE(symbol) (symbol)->line
1221 #define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
1222 #define SYMBOL_BLOCK_OPS(symbol) (SYMBOL_IMPL (symbol).ops_block)
1223 #define SYMBOL_REGISTER_OPS(symbol) (SYMBOL_IMPL (symbol).ops_register)
1224 #define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
1226 extern int register_symbol_computed_impl (enum address_class
,
1227 const struct symbol_computed_ops
*);
1229 extern int register_symbol_block_impl (enum address_class aclass
,
1230 const struct symbol_block_ops
*ops
);
1232 extern int register_symbol_register_impl (enum address_class
,
1233 const struct symbol_register_ops
*);
1235 /* Return the OBJFILE of SYMBOL.
1236 It is an error to call this if symbol.is_objfile_owned is false, which
1237 only happens for architecture-provided types. */
1239 extern struct objfile
*symbol_objfile (const struct symbol
*symbol
);
1241 /* Return the ARCH of SYMBOL. */
1243 extern struct gdbarch
*symbol_arch (const struct symbol
*symbol
);
1245 /* Return the SYMTAB of SYMBOL.
1246 It is an error to call this if symbol.is_objfile_owned is false, which
1247 only happens for architecture-provided types. */
1249 extern struct symtab
*symbol_symtab (const struct symbol
*symbol
);
1251 /* Set the symtab of SYMBOL to SYMTAB.
1252 It is an error to call this if symbol.is_objfile_owned is false, which
1253 only happens for architecture-provided types. */
1255 extern void symbol_set_symtab (struct symbol
*symbol
, struct symtab
*symtab
);
1257 /* An instance of this type is used to represent a C++ template
1258 function. A symbol is really of this type iff
1259 SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true. */
1261 struct template_symbol
: public symbol
1263 /* The number of template arguments. */
1264 int n_template_arguments
= 0;
1266 /* The template arguments. This is an array with
1267 N_TEMPLATE_ARGUMENTS elements. */
1268 struct symbol
**template_arguments
= nullptr;
1271 /* A symbol that represents a Rust virtual table object. */
1273 struct rust_vtable_symbol
: public symbol
1275 /* The concrete type for which this vtable was created; that is, in
1276 "impl Trait for Type", this is "Type". */
1277 struct type
*concrete_type
= nullptr;
1281 /* Each item represents a line-->pc (or the reverse) mapping. This is
1282 somewhat more wasteful of space than one might wish, but since only
1283 the files which are actually debugged are read in to core, we don't
1284 waste much space. */
1286 struct linetable_entry
1292 /* The order of entries in the linetable is significant. They should
1293 be sorted by increasing values of the pc field. If there is more than
1294 one entry for a given pc, then I'm not sure what should happen (and
1295 I not sure whether we currently handle it the best way).
1297 Example: a C for statement generally looks like this
1299 10 0x100 - for the init/test part of a for stmt.
1302 10 0x400 - for the increment part of a for stmt.
1304 If an entry has a line number of zero, it marks the start of a PC
1305 range for which no line number information is available. It is
1306 acceptable, though wasteful of table space, for such a range to be
1313 /* Actually NITEMS elements. If you don't like this use of the
1314 `struct hack', you can shove it up your ANSI (seriously, if the
1315 committee tells us how to do it, we can probably go along). */
1316 struct linetable_entry item
[1];
1319 /* How to relocate the symbols from each section in a symbol file.
1320 Each struct contains an array of offsets.
1321 The ordering and meaning of the offsets is file-type-dependent;
1322 typically it is indexed by section numbers or symbol types or
1323 something like that.
1325 To give us flexibility in changing the internal representation
1326 of these offsets, the ANOFFSET macro must be used to insert and
1327 extract offset values in the struct. */
1329 struct section_offsets
1331 CORE_ADDR offsets
[1]; /* As many as needed. */
1334 #define ANOFFSET(secoff, whichone) \
1336 ? (internal_error (__FILE__, __LINE__, \
1337 _("Section index is uninitialized")), -1) \
1338 : secoff->offsets[whichone])
1340 /* The size of a section_offsets table for N sections. */
1341 #define SIZEOF_N_SECTION_OFFSETS(n) \
1342 (sizeof (struct section_offsets) \
1343 + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
1345 /* Each source file or header is represented by a struct symtab.
1346 The name "symtab" is historical, another name for it is "filetab".
1347 These objects are chained through the `next' field. */
1351 /* Unordered chain of all filetabs in the compunit, with the exception
1352 that the "main" source file is the first entry in the list. */
1354 struct symtab
*next
;
1356 /* Backlink to containing compunit symtab. */
1358 struct compunit_symtab
*compunit_symtab
;
1360 /* Table mapping core addresses to line numbers for this file.
1361 Can be NULL if none. Never shared between different symtabs. */
1363 struct linetable
*linetable
;
1365 /* Name of this source file. This pointer is never NULL. */
1367 const char *filename
;
1369 /* Language of this source file. */
1371 enum language language
;
1373 /* Full name of file as found by searching the source path.
1374 NULL if not yet known. */
1379 #define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1380 #define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1381 #define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1382 #define SYMTAB_BLOCKVECTOR(symtab) \
1383 COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1384 #define SYMTAB_OBJFILE(symtab) \
1385 COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1386 #define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1387 #define SYMTAB_DIRNAME(symtab) \
1388 COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1390 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1391 as the list of all source files (what gdb has historically associated with
1393 Additional information is recorded here that is common to all symtabs in a
1394 compilation unit (DWARF or otherwise).
1397 For the case of a program built out of these files:
1406 This is recorded as:
1408 objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1422 where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1423 and the files foo.c, etc. are struct symtab objects. */
1425 struct compunit_symtab
1427 /* Unordered chain of all compunit symtabs of this objfile. */
1428 struct compunit_symtab
*next
;
1430 /* Object file from which this symtab information was read. */
1431 struct objfile
*objfile
;
1433 /* Name of the symtab.
1434 This is *not* intended to be a usable filename, and is
1435 for debugging purposes only. */
1438 /* Unordered list of file symtabs, except that by convention the "main"
1439 source file (e.g., .c, .cc) is guaranteed to be first.
1440 Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1441 or header (e.g., .h). */
1442 struct symtab
*filetabs
;
1444 /* Last entry in FILETABS list.
1445 Subfiles are added to the end of the list so they accumulate in order,
1446 with the main source subfile living at the front.
1447 The main reason is so that the main source file symtab is at the head
1448 of the list, and the rest appear in order for debugging convenience. */
1449 struct symtab
*last_filetab
;
1451 /* Non-NULL string that identifies the format of the debugging information,
1452 such as "stabs", "dwarf 1", "dwarf 2", "coff", etc. This is mostly useful
1453 for automated testing of gdb but may also be information that is
1454 useful to the user. */
1455 const char *debugformat
;
1457 /* String of producer version information, or NULL if we don't know. */
1458 const char *producer
;
1460 /* Directory in which it was compiled, or NULL if we don't know. */
1461 const char *dirname
;
1463 /* List of all symbol scope blocks for this symtab. It is shared among
1464 all symtabs in a given compilation unit. */
1465 const struct blockvector
*blockvector
;
1467 /* Section in objfile->section_offsets for the blockvector and
1468 the linetable. Probably always SECT_OFF_TEXT. */
1469 int block_line_section
;
1471 /* Symtab has been compiled with both optimizations and debug info so that
1472 GDB may stop skipping prologues as variables locations are valid already
1473 at function entry points. */
1474 unsigned int locations_valid
: 1;
1476 /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1477 instruction). This is supported by GCC since 4.5.0. */
1478 unsigned int epilogue_unwind_valid
: 1;
1480 /* struct call_site entries for this compilation unit or NULL. */
1481 htab_t call_site_htab
;
1483 /* The macro table for this symtab. Like the blockvector, this
1484 is shared between different symtabs in a given compilation unit.
1485 It's debatable whether it *should* be shared among all the symtabs in
1486 the given compilation unit, but it currently is. */
1487 struct macro_table
*macro_table
;
1489 /* If non-NULL, then this points to a NULL-terminated vector of
1490 included compunits. When searching the static or global
1491 block of this compunit, the corresponding block of all
1492 included compunits will also be searched. Note that this
1493 list must be flattened -- the symbol reader is responsible for
1494 ensuring that this vector contains the transitive closure of all
1495 included compunits. */
1496 struct compunit_symtab
**includes
;
1498 /* If this is an included compunit, this points to one includer
1499 of the table. This user is considered the canonical compunit
1500 containing this one. An included compunit may itself be
1501 included by another. */
1502 struct compunit_symtab
*user
;
1505 #define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1506 #define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1507 #define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1508 #define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1509 #define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1510 #define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1511 #define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1512 #define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1513 #define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1514 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1515 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
1517 /* A range adapter to allowing iterating over all the file tables
1518 within a compunit. */
1520 struct compunit_filetabs
: public next_adapter
<struct symtab
>
1522 compunit_filetabs (struct compunit_symtab
*cu
)
1523 : next_adapter
<struct symtab
> (cu
->filetabs
)
1528 /* Return the primary symtab of CUST. */
1530 extern struct symtab
*
1531 compunit_primary_filetab (const struct compunit_symtab
*cust
);
1533 /* Return the language of CUST. */
1535 extern enum language
compunit_language (const struct compunit_symtab
*cust
);
1539 /* The virtual function table is now an array of structures which have the
1540 form { int16 offset, delta; void *pfn; }.
1542 In normal virtual function tables, OFFSET is unused.
1543 DELTA is the amount which is added to the apparent object's base
1544 address in order to point to the actual object to which the
1545 virtual function should be applied.
1546 PFN is a pointer to the virtual function.
1548 Note that this macro is g++ specific (FIXME). */
1550 #define VTBL_FNADDR_OFFSET 2
1552 /* External variables and functions for the objects described above. */
1554 /* True if we are nested inside psymtab_to_symtab. */
1556 extern int currently_reading_symtab
;
1558 /* symtab.c lookup functions */
1560 extern const char multiple_symbols_ask
[];
1561 extern const char multiple_symbols_all
[];
1562 extern const char multiple_symbols_cancel
[];
1564 const char *multiple_symbols_select_mode (void);
1566 bool symbol_matches_domain (enum language symbol_language
,
1567 domain_enum symbol_domain
,
1568 domain_enum domain
);
1570 /* lookup a symbol table by source file name. */
1572 extern struct symtab
*lookup_symtab (const char *);
1574 /* An object of this type is passed as the 'is_a_field_of_this'
1575 argument to lookup_symbol and lookup_symbol_in_language. */
1577 struct field_of_this_result
1579 /* The type in which the field was found. If this is NULL then the
1580 symbol was not found in 'this'. If non-NULL, then one of the
1581 other fields will be non-NULL as well. */
1585 /* If the symbol was found as an ordinary field of 'this', then this
1586 is non-NULL and points to the particular field. */
1588 struct field
*field
;
1590 /* If the symbol was found as a function field of 'this', then this
1591 is non-NULL and points to the particular field. */
1593 struct fn_fieldlist
*fn_field
;
1596 /* Find the definition for a specified symbol name NAME
1597 in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1598 if non-NULL or from global/static blocks if BLOCK is NULL.
1599 Returns the struct symbol pointer, or NULL if no symbol is found.
1600 C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1601 NAME is a field of the current implied argument `this'. If so fill in the
1602 fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
1603 The symbol's section is fixed up if necessary. */
1605 extern struct block_symbol
1606 lookup_symbol_in_language (const char *,
1607 const struct block
*,
1610 struct field_of_this_result
*);
1612 /* Same as lookup_symbol_in_language, but using the current language. */
1614 extern struct block_symbol
lookup_symbol (const char *,
1615 const struct block
*,
1617 struct field_of_this_result
*);
1619 /* Find the definition for a specified symbol search name in domain
1620 DOMAIN, visible from lexical block BLOCK if non-NULL or from
1621 global/static blocks if BLOCK is NULL. The passed-in search name
1622 should not come from the user; instead it should already be a
1623 search name as retrieved from a search_name () call. See definition of
1624 symbol_name_match_type::SEARCH_NAME. Returns the struct symbol
1625 pointer, or NULL if no symbol is found. The symbol's section is
1626 fixed up if necessary. */
1628 extern struct block_symbol
lookup_symbol_search_name (const char *search_name
,
1629 const struct block
*block
,
1630 domain_enum domain
);
1632 /* A default version of lookup_symbol_nonlocal for use by languages
1633 that can't think of anything better to do.
1634 This implements the C lookup rules. */
1636 extern struct block_symbol
1637 basic_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
1639 const struct block
*,
1642 /* Some helper functions for languages that need to write their own
1643 lookup_symbol_nonlocal functions. */
1645 /* Lookup a symbol in the static block associated to BLOCK, if there
1646 is one; do nothing if BLOCK is NULL or a global block.
1647 Upon success fixes up the symbol's section if necessary. */
1649 extern struct block_symbol
1650 lookup_symbol_in_static_block (const char *name
,
1651 const struct block
*block
,
1652 const domain_enum domain
);
1654 /* Search all static file-level symbols for NAME from DOMAIN.
1655 Upon success fixes up the symbol's section if necessary. */
1657 extern struct block_symbol
lookup_static_symbol (const char *name
,
1658 const domain_enum domain
);
1660 /* Lookup a symbol in all files' global blocks.
1662 If BLOCK is non-NULL then it is used for two things:
1663 1) If a target-specific lookup routine for libraries exists, then use the
1664 routine for the objfile of BLOCK, and
1665 2) The objfile of BLOCK is used to assist in determining the search order
1666 if the target requires it.
1667 See gdbarch_iterate_over_objfiles_in_search_order.
1669 Upon success fixes up the symbol's section if necessary. */
1671 extern struct block_symbol
1672 lookup_global_symbol (const char *name
,
1673 const struct block
*block
,
1674 const domain_enum domain
);
1676 /* Lookup a symbol in block BLOCK.
1677 Upon success fixes up the symbol's section if necessary. */
1679 extern struct symbol
*
1680 lookup_symbol_in_block (const char *name
,
1681 symbol_name_match_type match_type
,
1682 const struct block
*block
,
1683 const domain_enum domain
);
1685 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1686 found, or NULL if not found. */
1688 extern struct block_symbol
1689 lookup_language_this (const struct language_defn
*lang
,
1690 const struct block
*block
);
1692 /* Lookup a [struct, union, enum] by name, within a specified block. */
1694 extern struct type
*lookup_struct (const char *, const struct block
*);
1696 extern struct type
*lookup_union (const char *, const struct block
*);
1698 extern struct type
*lookup_enum (const char *, const struct block
*);
1700 /* from blockframe.c: */
1702 /* lookup the function symbol corresponding to the address. The
1703 return value will not be an inlined function; the containing
1704 function will be returned instead. */
1706 extern struct symbol
*find_pc_function (CORE_ADDR
);
1708 /* lookup the function corresponding to the address and section. The
1709 return value will not be an inlined function; the containing
1710 function will be returned instead. */
1712 extern struct symbol
*find_pc_sect_function (CORE_ADDR
, struct obj_section
*);
1714 /* lookup the function symbol corresponding to the address and
1715 section. The return value will be the closest enclosing function,
1716 which might be an inline function. */
1718 extern struct symbol
*find_pc_sect_containing_function
1719 (CORE_ADDR pc
, struct obj_section
*section
);
1721 /* Find the symbol at the given address. Returns NULL if no symbol
1722 found. Only exact matches for ADDRESS are considered. */
1724 extern struct symbol
*find_symbol_at_address (CORE_ADDR
);
1726 /* Finds the "function" (text symbol) that is smaller than PC but
1727 greatest of all of the potential text symbols in SECTION. Sets
1728 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
1729 If ENDADDR is non-null, then set *ENDADDR to be the end of the
1730 function (exclusive). If the optional parameter BLOCK is non-null,
1731 then set *BLOCK to the address of the block corresponding to the
1732 function symbol, if such a symbol could be found during the lookup;
1733 nullptr is used as a return value for *BLOCK if no block is found.
1734 This function either succeeds or fails (not halfway succeeds). If
1735 it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real
1736 information and returns true. If it fails, it sets *NAME, *ADDRESS
1737 and *ENDADDR to zero and returns false.
1739 If the function in question occupies non-contiguous ranges,
1740 *ADDRESS and *ENDADDR are (subject to the conditions noted above) set
1741 to the start and end of the range in which PC is found. Thus
1742 *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges
1743 from other functions might be found).
1745 This property allows find_pc_partial_function to be used (as it had
1746 been prior to the introduction of non-contiguous range support) by
1747 various tdep files for finding a start address and limit address
1748 for prologue analysis. This still isn't ideal, however, because we
1749 probably shouldn't be doing prologue analysis (in which
1750 instructions are scanned to determine frame size and stack layout)
1751 for any range that doesn't contain the entry pc. Moreover, a good
1752 argument can be made that prologue analysis ought to be performed
1753 starting from the entry pc even when PC is within some other range.
1754 This might suggest that *ADDRESS and *ENDADDR ought to be set to the
1755 limits of the entry pc range, but that will cause the
1756 *ADDRESS <= PC < *ENDADDR condition to be violated; many of the
1757 callers of find_pc_partial_function expect this condition to hold.
1759 Callers which require the start and/or end addresses for the range
1760 containing the entry pc should instead call
1761 find_function_entry_range_from_pc. */
1763 extern bool find_pc_partial_function (CORE_ADDR pc
, const char **name
,
1764 CORE_ADDR
*address
, CORE_ADDR
*endaddr
,
1765 const struct block
**block
= nullptr);
1767 /* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
1768 set to start and end addresses of the range containing the entry pc.
1770 Note that it is not necessarily the case that (for non-NULL ADDRESS
1771 and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will
1774 See comment for find_pc_partial_function, above, for further
1777 extern bool find_function_entry_range_from_pc (CORE_ADDR pc
,
1780 CORE_ADDR
*endaddr
);
1782 /* Return the type of a function with its first instruction exactly at
1783 the PC address. Return NULL otherwise. */
1785 extern struct type
*find_function_type (CORE_ADDR pc
);
1787 /* See if we can figure out the function's actual type from the type
1788 that the resolver returns. RESOLVER_FUNADDR is the address of the
1791 extern struct type
*find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr
);
1793 /* Find the GNU ifunc minimal symbol that matches SYM. */
1794 extern bound_minimal_symbol
find_gnu_ifunc (const symbol
*sym
);
1796 extern void clear_pc_function_cache (void);
1798 /* Expand symtab containing PC, SECTION if not already expanded. */
1800 extern void expand_symtab_containing_pc (CORE_ADDR
, struct obj_section
*);
1802 /* lookup full symbol table by address. */
1804 extern struct compunit_symtab
*find_pc_compunit_symtab (CORE_ADDR
);
1806 /* lookup full symbol table by address and section. */
1808 extern struct compunit_symtab
*
1809 find_pc_sect_compunit_symtab (CORE_ADDR
, struct obj_section
*);
1811 extern bool find_pc_line_pc_range (CORE_ADDR
, CORE_ADDR
*, CORE_ADDR
*);
1813 extern void reread_symbols (void);
1815 /* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1816 The type returned must not be opaque -- i.e., must have at least one field
1819 extern struct type
*lookup_transparent_type (const char *);
1821 extern struct type
*basic_lookup_transparent_type (const char *);
1823 /* Macro for name of symbol to indicate a file compiled with gcc. */
1824 #ifndef GCC_COMPILED_FLAG_SYMBOL
1825 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1828 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1829 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1830 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1833 extern bool in_gnu_ifunc_stub (CORE_ADDR pc
);
1835 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1836 for ELF symbol files. */
1838 struct gnu_ifunc_fns
1840 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
1841 CORE_ADDR (*gnu_ifunc_resolve_addr
) (struct gdbarch
*gdbarch
, CORE_ADDR pc
);
1843 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
1844 bool (*gnu_ifunc_resolve_name
) (const char *function_name
,
1845 CORE_ADDR
*function_address_p
);
1847 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
1848 void (*gnu_ifunc_resolver_stop
) (struct breakpoint
*b
);
1850 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
1851 void (*gnu_ifunc_resolver_return_stop
) (struct breakpoint
*b
);
1854 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1855 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1856 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1857 #define gnu_ifunc_resolver_return_stop \
1858 gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1860 extern const struct gnu_ifunc_fns
*gnu_ifunc_fns_p
;
1862 extern CORE_ADDR
find_solib_trampoline_target (struct frame_info
*, CORE_ADDR
);
1864 struct symtab_and_line
1866 /* The program space of this sal. */
1867 struct program_space
*pspace
= NULL
;
1869 struct symtab
*symtab
= NULL
;
1870 struct symbol
*symbol
= NULL
;
1871 struct obj_section
*section
= NULL
;
1872 struct minimal_symbol
*msymbol
= NULL
;
1873 /* Line number. Line numbers start at 1 and proceed through symtab->nlines.
1874 0 is never a valid line number; it is used to indicate that line number
1875 information is not available. */
1880 bool explicit_pc
= false;
1881 bool explicit_line
= false;
1883 /* The probe associated with this symtab_and_line. */
1885 /* If PROBE is not NULL, then this is the objfile in which the probe
1887 struct objfile
*objfile
= NULL
;
1892 /* Given a pc value, return line number it is in. Second arg nonzero means
1893 if pc is on the boundary use the previous statement's line number. */
1895 extern struct symtab_and_line
find_pc_line (CORE_ADDR
, int);
1897 /* Same function, but specify a section as well as an address. */
1899 extern struct symtab_and_line
find_pc_sect_line (CORE_ADDR
,
1900 struct obj_section
*, int);
1902 /* Wrapper around find_pc_line to just return the symtab. */
1904 extern struct symtab
*find_pc_line_symtab (CORE_ADDR
);
1906 /* Given a symtab and line number, return the pc there. */
1908 extern bool find_line_pc (struct symtab
*, int, CORE_ADDR
*);
1910 extern bool find_line_pc_range (struct symtab_and_line
, CORE_ADDR
*,
1913 extern void resolve_sal_pc (struct symtab_and_line
*);
1917 extern void clear_solib (void);
1919 /* The reason we're calling into a completion match list collector
1921 enum class complete_symbol_mode
1923 /* Completing an expression. */
1926 /* Completing a linespec. */
1930 extern void default_collect_symbol_completion_matches_break_on
1931 (completion_tracker
&tracker
,
1932 complete_symbol_mode mode
,
1933 symbol_name_match_type name_match_type
,
1934 const char *text
, const char *word
, const char *break_on
,
1935 enum type_code code
);
1936 extern void default_collect_symbol_completion_matches
1937 (completion_tracker
&tracker
,
1938 complete_symbol_mode
,
1939 symbol_name_match_type name_match_type
,
1943 extern void collect_symbol_completion_matches
1944 (completion_tracker
&tracker
,
1945 complete_symbol_mode mode
,
1946 symbol_name_match_type name_match_type
,
1947 const char *, const char *);
1948 extern void collect_symbol_completion_matches_type (completion_tracker
&tracker
,
1949 const char *, const char *,
1952 extern void collect_file_symbol_completion_matches
1953 (completion_tracker
&tracker
,
1954 complete_symbol_mode
,
1955 symbol_name_match_type name_match_type
,
1956 const char *, const char *, const char *);
1958 extern completion_list
1959 make_source_files_completion_list (const char *, const char *);
1961 /* Return whether SYM is a function/method, as opposed to a data symbol. */
1963 extern bool symbol_is_function_or_method (symbol
*sym
);
1965 /* Return whether MSYMBOL is a function/method, as opposed to a data
1968 extern bool symbol_is_function_or_method (minimal_symbol
*msymbol
);
1970 /* Return whether SYM should be skipped in completion mode MODE. In
1971 linespec mode, we're only interested in functions/methods. */
1973 template<typename Symbol
>
1975 completion_skip_symbol (complete_symbol_mode mode
, Symbol
*sym
)
1977 return (mode
== complete_symbol_mode::LINESPEC
1978 && !symbol_is_function_or_method (sym
));
1983 bool matching_obj_sections (struct obj_section
*, struct obj_section
*);
1985 extern struct symtab
*find_line_symtab (struct symtab
*, int, int *, bool *);
1987 /* Given a function symbol SYM, find the symtab and line for the start
1988 of the function. If FUNFIRSTLINE is true, we want the first line
1989 of real code inside the function. */
1990 extern symtab_and_line
find_function_start_sal (symbol
*sym
, bool
1993 /* Same, but start with a function address/section instead of a
1995 extern symtab_and_line
find_function_start_sal (CORE_ADDR func_addr
,
1996 obj_section
*section
,
1999 extern void skip_prologue_sal (struct symtab_and_line
*);
2003 extern CORE_ADDR
skip_prologue_using_sal (struct gdbarch
*gdbarch
,
2004 CORE_ADDR func_addr
);
2006 extern struct symbol
*fixup_symbol_section (struct symbol
*,
2009 /* If MSYMBOL is an text symbol, look for a function debug symbol with
2010 the same address. Returns NULL if not found. This is necessary in
2011 case a function is an alias to some other function, because debug
2012 information is only emitted for the alias target function's
2013 definition, not for the alias. */
2014 extern symbol
*find_function_alias_target (bound_minimal_symbol msymbol
);
2016 /* Symbol searching */
2018 /* When using the symbol_searcher struct to search for symbols, a vector of
2019 the following structs is returned. */
2020 struct symbol_search
2022 symbol_search (int block_
, struct symbol
*symbol_
)
2026 msymbol
.minsym
= nullptr;
2027 msymbol
.objfile
= nullptr;
2030 symbol_search (int block_
, struct minimal_symbol
*minsym
,
2031 struct objfile
*objfile
)
2035 msymbol
.minsym
= minsym
;
2036 msymbol
.objfile
= objfile
;
2039 bool operator< (const symbol_search
&other
) const
2041 return compare_search_syms (*this, other
) < 0;
2044 bool operator== (const symbol_search
&other
) const
2046 return compare_search_syms (*this, other
) == 0;
2049 /* The block in which the match was found. Could be, for example,
2050 STATIC_BLOCK or GLOBAL_BLOCK. */
2053 /* Information describing what was found.
2055 If symbol is NOT NULL, then information was found for this match. */
2056 struct symbol
*symbol
;
2058 /* If msymbol is non-null, then a match was made on something for
2059 which only minimal_symbols exist. */
2060 struct bound_minimal_symbol msymbol
;
2064 static int compare_search_syms (const symbol_search
&sym_a
,
2065 const symbol_search
&sym_b
);
2068 /* In order to search for global symbols of a particular kind matching
2069 particular regular expressions, create an instance of this structure and
2070 call the SEARCH member function. */
2071 class global_symbol_searcher
2076 global_symbol_searcher (enum search_domain kind
,
2077 const char *symbol_name_regexp
)
2079 m_symbol_name_regexp (symbol_name_regexp
)
2081 /* The symbol searching is designed to only find one kind of thing. */
2082 gdb_assert (m_kind
!= ALL_DOMAIN
);
2085 /* Set the optional regexp that matches against the symbol type. */
2086 void set_symbol_type_regexp (const char *regexp
)
2088 m_symbol_type_regexp
= regexp
;
2091 /* Set the flag to exclude minsyms from the search results. */
2092 void set_exclude_minsyms (bool exclude_minsyms
)
2094 m_exclude_minsyms
= exclude_minsyms
;
2097 /* Set the maximum number of search results to be returned. */
2098 void set_max_search_results (size_t max_search_results
)
2100 m_max_search_results
= max_search_results
;
2103 /* Search the symbols from all objfiles in the current program space
2104 looking for matches as defined by the current state of this object.
2106 Within each file the results are sorted locally; each symtab's global
2107 and static blocks are separately alphabetized. Duplicate entries are
2109 std::vector
<symbol_search
> search () const;
2111 /* The set of source files to search in for matching symbols. This is
2112 currently public so that it can be populated after this object has
2113 been constructed. */
2114 std::vector
<const char *> filenames
;
2117 /* The kind of symbols are we searching for.
2118 VARIABLES_DOMAIN - Search all symbols, excluding functions, type
2119 names, and constants (enums).
2120 FUNCTIONS_DOMAIN - Search all functions..
2121 TYPES_DOMAIN - Search all type names.
2122 MODULES_DOMAIN - Search all Fortran modules.
2123 ALL_DOMAIN - Not valid for this function. */
2124 enum search_domain m_kind
;
2126 /* Regular expression to match against the symbol name. */
2127 const char *m_symbol_name_regexp
= nullptr;
2129 /* Regular expression to match against the symbol type. */
2130 const char *m_symbol_type_regexp
= nullptr;
2132 /* When this flag is false then minsyms that match M_SYMBOL_REGEXP will
2133 be included in the results, otherwise they are excluded. */
2134 bool m_exclude_minsyms
= false;
2136 /* Maximum number of search results. We currently impose a hard limit
2137 of SIZE_MAX, there is no "unlimited". */
2138 size_t m_max_search_results
= SIZE_MAX
;
2140 /* Expand symtabs in OBJFILE that match PREG, are of type M_KIND. Return
2141 true if any msymbols were seen that we should later consider adding to
2142 the results list. */
2143 bool expand_symtabs (objfile
*objfile
,
2144 const gdb::optional
<compiled_regex
> &preg
) const;
2146 /* Add symbols from symtabs in OBJFILE that match PREG, and TREG, and are
2147 of type M_KIND, to the results set RESULTS_SET. Return false if we
2148 stop adding results early due to having already found too many results
2149 (based on M_MAX_SEARCH_RESULTS limit), otherwise return true.
2150 Returning true does not indicate that any results were added, just
2151 that we didn't _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
2152 bool add_matching_symbols (objfile
*objfile
,
2153 const gdb::optional
<compiled_regex
> &preg
,
2154 const gdb::optional
<compiled_regex
> &treg
,
2155 std::set
<symbol_search
> *result_set
) const;
2157 /* Add msymbols from OBJFILE that match PREG and M_KIND, to the results
2158 vector RESULTS. Return false if we stop adding results early due to
2159 having already found too many results (based on max search results
2160 limit M_MAX_SEARCH_RESULTS), otherwise return true. Returning true
2161 does not indicate that any results were added, just that we didn't
2162 _not_ add a result due to reaching MAX_SEARCH_RESULTS. */
2163 bool add_matching_msymbols (objfile
*objfile
,
2164 const gdb::optional
<compiled_regex
> &preg
,
2165 std::vector
<symbol_search
> *results
) const;
2167 /* Return true if MSYMBOL is of type KIND. */
2168 static bool is_suitable_msymbol (const enum search_domain kind
,
2169 const minimal_symbol
*msymbol
);
2172 /* When searching for Fortran symbols within modules (functions/variables)
2173 we return a vector of this type. The first item in the pair is the
2174 module symbol, and the second item is the symbol for the function or
2175 variable we found. */
2176 typedef std::pair
<symbol_search
, symbol_search
> module_symbol_search
;
2178 /* Searches the symbols to find function and variables symbols (depending
2179 on KIND) within Fortran modules. The MODULE_REGEXP matches against the
2180 name of the module, REGEXP matches against the name of the symbol within
2181 the module, and TYPE_REGEXP matches against the type of the symbol
2182 within the module. */
2183 extern std::vector
<module_symbol_search
> search_module_symbols
2184 (const char *module_regexp
, const char *regexp
,
2185 const char *type_regexp
, search_domain kind
);
2187 /* Convert a global or static symbol SYM (based on BLOCK, which should be
2188 either GLOBAL_BLOCK or STATIC_BLOCK) into a string for use in 'info'
2189 type commands (e.g. 'info variables', 'info functions', etc). KIND is
2190 the type of symbol that was searched for which gave us SYM. */
2192 extern std::string
symbol_to_info_string (struct symbol
*sym
, int block
,
2193 enum search_domain kind
);
2195 extern bool treg_matches_sym_type_name (const compiled_regex
&treg
,
2196 const struct symbol
*sym
);
2198 /* The name of the ``main'' function. */
2199 extern const char *main_name ();
2200 extern enum language
main_language (void);
2202 /* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global or static blocks,
2203 as specified by BLOCK_INDEX.
2204 This searches MAIN_OBJFILE as well as any associated separate debug info
2205 objfiles of MAIN_OBJFILE.
2206 BLOCK_INDEX can be GLOBAL_BLOCK or STATIC_BLOCK.
2207 Upon success fixes up the symbol's section if necessary. */
2209 extern struct block_symbol
2210 lookup_global_symbol_from_objfile (struct objfile
*main_objfile
,
2211 enum block_enum block_index
,
2213 const domain_enum domain
);
2215 /* Return 1 if the supplied producer string matches the ARM RealView
2216 compiler (armcc). */
2217 bool producer_is_realview (const char *producer
);
2219 void fixup_section (struct general_symbol_info
*ginfo
,
2220 CORE_ADDR addr
, struct objfile
*objfile
);
2222 /* Look up objfile containing BLOCK. */
2224 struct objfile
*lookup_objfile_from_block (const struct block
*block
);
2226 extern unsigned int symtab_create_debug
;
2228 extern unsigned int symbol_lookup_debug
;
2230 extern bool basenames_may_differ
;
2232 bool compare_filenames_for_search (const char *filename
,
2233 const char *search_name
);
2235 bool compare_glob_filenames_for_search (const char *filename
,
2236 const char *search_name
);
2238 bool iterate_over_some_symtabs (const char *name
,
2239 const char *real_path
,
2240 struct compunit_symtab
*first
,
2241 struct compunit_symtab
*after_last
,
2242 gdb::function_view
<bool (symtab
*)> callback
);
2244 void iterate_over_symtabs (const char *name
,
2245 gdb::function_view
<bool (symtab
*)> callback
);
2248 std::vector
<CORE_ADDR
> find_pcs_for_symtab_line
2249 (struct symtab
*symtab
, int line
, struct linetable_entry
**best_entry
);
2251 /* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
2252 is called once per matching symbol SYM. The callback should return
2253 true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
2254 iterating, or false to indicate that the iteration should end. */
2256 typedef bool (symbol_found_callback_ftype
) (struct block_symbol
*bsym
);
2258 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
2260 For each symbol that matches, CALLBACK is called. The symbol is
2261 passed to the callback.
2263 If CALLBACK returns false, the iteration ends and this function
2264 returns false. Otherwise, the search continues, and the function
2265 eventually returns true. */
2267 bool iterate_over_symbols (const struct block
*block
,
2268 const lookup_name_info
&name
,
2269 const domain_enum domain
,
2270 gdb::function_view
<symbol_found_callback_ftype
> callback
);
2272 /* Like iterate_over_symbols, but if all calls to CALLBACK return
2273 true, then calls CALLBACK one additional time with a block_symbol
2274 that has a valid block but a NULL symbol. */
2276 bool iterate_over_symbols_terminated
2277 (const struct block
*block
,
2278 const lookup_name_info
&name
,
2279 const domain_enum domain
,
2280 gdb::function_view
<symbol_found_callback_ftype
> callback
);
2282 /* Storage type used by demangle_for_lookup. demangle_for_lookup
2283 either returns a const char * pointer that points to either of the
2284 fields of this type, or a pointer to the input NAME. This is done
2285 this way because the underlying functions that demangle_for_lookup
2286 calls either return a std::string (e.g., cp_canonicalize_string) or
2287 a malloc'ed buffer (libiberty's demangled), and we want to avoid
2288 unnecessary reallocation/string copying. */
2289 class demangle_result_storage
2293 /* Swap the std::string storage with STR, and return a pointer to
2294 the beginning of the new string. */
2295 const char *swap_string (std::string
&str
)
2297 std::swap (m_string
, str
);
2298 return m_string
.c_str ();
2301 /* Set the malloc storage to now point at PTR. Any previous malloc
2302 storage is released. */
2303 const char *set_malloc_ptr (char *ptr
)
2305 m_malloc
.reset (ptr
);
2312 std::string m_string
;
2313 gdb::unique_xmalloc_ptr
<char> m_malloc
;
2317 demangle_for_lookup (const char *name
, enum language lang
,
2318 demangle_result_storage
&storage
);
2320 struct symbol
*allocate_symbol (struct objfile
*);
2322 void initialize_objfile_symbol (struct symbol
*);
2324 struct template_symbol
*allocate_template_symbol (struct objfile
*);
2326 /* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
2327 SYMNAME (which is already demangled for C++ symbols) matches
2328 SYM_TEXT in the first SYM_TEXT_LEN characters. If so, add it to
2329 the current completion list. */
2330 void completion_list_add_name (completion_tracker
&tracker
,
2331 language symbol_language
,
2332 const char *symname
,
2333 const lookup_name_info
&lookup_name
,
2334 const char *text
, const char *word
);
2336 /* A simple symbol searching class. */
2338 class symbol_searcher
2341 /* Returns the symbols found for the search. */
2342 const std::vector
<block_symbol
> &
2343 matching_symbols () const
2348 /* Returns the minimal symbols found for the search. */
2349 const std::vector
<bound_minimal_symbol
> &
2350 matching_msymbols () const
2352 return m_minimal_symbols
;
2355 /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting
2356 search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL
2357 to search all symtabs and program spaces. */
2358 void find_all_symbols (const std::string
&name
,
2359 const struct language_defn
*language
,
2360 enum search_domain search_domain
,
2361 std::vector
<symtab
*> *search_symtabs
,
2362 struct program_space
*search_pspace
);
2364 /* Reset this object to perform another search. */
2368 m_minimal_symbols
.clear ();
2372 /* Matching debug symbols. */
2373 std::vector
<block_symbol
> m_symbols
;
2375 /* Matching non-debug symbols. */
2376 std::vector
<bound_minimal_symbol
> m_minimal_symbols
;
2379 #endif /* !defined(SYMTAB_H) */