GDB (xrefs)

/tmp/gdb-8.1/gdb/symtab.h
Go to the documentation of this file.
1 /* Symbol table definitions for GDB.
2
3 Copyright (C) 1986-2018 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 (SYMTAB_H)
21 #define SYMTAB_H 1
22
23 #include <array>
24 #include <vector>
25 #include <string>
26 #include "gdb_vecs.h"
27 #include "gdbtypes.h"
28 #include "common/enum-flags.h"
29 #include "common/function-view.h"
30 #include "common/gdb_optional.h"
31 #include "completer.h"
32
33 /* Opaque declarations. */
34 struct ui_file;
35 struct frame_info;
36 struct symbol;
37 struct obstack;
38 struct objfile;
39 struct block;
40 struct blockvector;
41 struct axs_value;
42 struct agent_expr;
43 struct program_space;
44 struct language_defn;
45 struct common_block;
46 struct obj_section;
47 struct cmd_list_element;
48 class probe;
49 struct lookup_name_info;
50
51 /* How to match a lookup name against a symbol search name. */
52 enum class symbol_name_match_type
53 {
54 /* Wild matching. Matches unqualified symbol names in all
55 namespace/module/packages, etc. */
56 WILD,
57
58 /* Full matching. The lookup name indicates a fully-qualified name,
59 and only matches symbol search names in the specified
60 namespace/module/package. */
61 FULL,
62
63 /* Search name matching. This is like FULL, but the search name did
64 not come from the user; instead it is already a search name
65 retrieved from a SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call.
66 For Ada, this avoids re-encoding an already-encoded search name
67 (which would potentially incorrectly lowercase letters in the
68 linkage/search name that should remain uppercase). For C++, it
69 avoids trying to demangle a name we already know is
70 demangled. */
71 SEARCH_NAME,
72
73 /* Expression matching. The same as FULL matching in most
74 languages. The same as WILD matching in Ada. */
75 EXPRESSION,
76 };
77
78 /* Hash the given symbol search name according to LANGUAGE's
79 rules. */
80 extern unsigned int search_name_hash (enum language language,
81 const char *search_name);
82
83 /* Ada-specific bits of a lookup_name_info object. This is lazily
84 constructed on demand. */
85
86 class ada_lookup_name_info final
87 {
88 public:
89 /* Construct. */
90 explicit ada_lookup_name_info (const lookup_name_info &lookup_name);
91
92 /* Compare SYMBOL_SEARCH_NAME with our lookup name, using MATCH_TYPE
93 as name match type. Returns true if there's a match, false
94 otherwise. If non-NULL, store the matching results in MATCH. */
95 bool matches (const char *symbol_search_name,
96 symbol_name_match_type match_type,
97 completion_match_result *comp_match_res) const;
98
99 /* The Ada-encoded lookup name. */
100 const std::string &lookup_name () const
101 { return m_encoded_name; }
102
103 /* Return true if we're supposed to be doing a wild match look
104 up. */
105 bool wild_match_p () const
106 { return m_wild_match_p; }
107
108 /* Return true if we're looking up a name inside package
109 Standard. */
110 bool standard_p () const
111 { return m_standard_p; }
112
113 /* Return true if doing a verbatim match. */
114 bool verbatim_p () const
115 { return m_verbatim_p; }
116
117 private:
118 /* The Ada-encoded lookup name. */
119 std::string m_encoded_name;
120
121 /* Whether the user-provided lookup name was Ada encoded. If so,
122 then return encoded names in the 'matches' method's 'completion
123 match result' output. */
124 bool m_encoded_p : 1;
125
126 /* True if really doing wild matching. Even if the user requests
127 wild matching, some cases require full matching. */
128 bool m_wild_match_p : 1;
129
130 /* True if doing a verbatim match. This is true if the decoded
131 version of the symbol name is wrapped in '<'/'>'. This is an
132 escape hatch users can use to look up symbols the Ada encoding
133 does not understand. */
134 bool m_verbatim_p : 1;
135
136 /* True if the user specified a symbol name that is inside package
137 Standard. Symbol names inside package Standard are handled
138 specially. We always do a non-wild match of the symbol name
139 without the "standard__" prefix, and only search static and
140 global symbols. This was primarily introduced in order to allow
141 the user to specifically access the standard exceptions using,
142 for instance, Standard.Constraint_Error when Constraint_Error is
143 ambiguous (due to the user defining its own Constraint_Error
144 entity inside its program). */
145 bool m_standard_p : 1;
146 };
147
148 /* Language-specific bits of a lookup_name_info object, for languages
149 that do name searching using demangled names (C++/D/Go). This is
150 lazily constructed on demand. */
151
152 struct demangle_for_lookup_info final
153 {
154 public:
155 demangle_for_lookup_info (const lookup_name_info &lookup_name,
156 language lang);
157
158 /* The demangled lookup name. */
159 const std::string &lookup_name () const
160 { return m_demangled_name; }
161
162 private:
163 /* The demangled lookup name. */
164 std::string m_demangled_name;
165 };
166
167 /* Object that aggregates all information related to a symbol lookup
168 name. I.e., the name that is matched against the symbol's search
169 name. Caches per-language information so that it doesn't require
170 recomputing it for every symbol comparison, like for example the
171 Ada encoded name and the symbol's name hash for a given language.
172 The object is conceptually immutable once constructed, and thus has
173 no setters. This is to prevent some code path from tweaking some
174 property of the lookup name for some local reason and accidentally
175 altering the results of any continuing search(es).
176 lookup_name_info objects are generally passed around as a const
177 reference to reinforce that. (They're not passed around by value
178 because they're not small.) */
179 class lookup_name_info final
180 {
181 public:
182 /* Create a new object. */
183 lookup_name_info (std::string name,
184 symbol_name_match_type match_type,
185 bool completion_mode = false,
186 bool ignore_parameters = false)
187 : m_match_type (match_type),
188 m_completion_mode (completion_mode),
189 m_ignore_parameters (ignore_parameters),
190 m_name (std::move (name))
191 {}
192
193 /* Getters. See description of each corresponding field. */
194 symbol_name_match_type match_type () const { return m_match_type; }
195 bool completion_mode () const { return m_completion_mode; }
196 const std::string &name () const { return m_name; }
197 const bool ignore_parameters () const { return m_ignore_parameters; }
198
199 /* Return a version of this lookup name that is usable with
200 comparisons against symbols have no parameter info, such as
201 psymbols and GDB index symbols. */
202 lookup_name_info make_ignore_params () const
203 {
204 return lookup_name_info (m_name, m_match_type, m_completion_mode,
205 true /* ignore params */);
206 }
207
208 /* Get the search name hash for searches in language LANG. */
209 unsigned int search_name_hash (language lang) const
210 {
211 /* Only compute each language's hash once. */
212 if (!m_demangled_hashes_p[lang])
213 {
214 m_demangled_hashes[lang]
215 = ::search_name_hash (lang, language_lookup_name (lang).c_str ());
216 m_demangled_hashes_p[lang] = true;
217 }
218 return m_demangled_hashes[lang];
219 }
220
221 /* Get the search name for searches in language LANG. */
222 const std::string &language_lookup_name (language lang) const
223 {
224 switch (lang)
225 {
226 case language_ada:
227 return ada ().lookup_name ();
228 case language_cplus:
229 return cplus ().lookup_name ();
230 case language_d:
231 return d ().lookup_name ();
232 case language_go:
233 return go ().lookup_name ();
234 default:
235 return m_name;
236 }
237 }
238
239 /* Get the Ada-specific lookup info. */
240 const ada_lookup_name_info &ada () const
241 {
242 maybe_init (m_ada);
243 return *m_ada;
244 }
245
246 /* Get the C++-specific lookup info. */
247 const demangle_for_lookup_info &cplus () const
248 {
249 maybe_init (m_cplus, language_cplus);
250 return *m_cplus;
251 }
252
253 /* Get the D-specific lookup info. */
254 const demangle_for_lookup_info &d () const
255 {
256 maybe_init (m_d, language_d);
257 return *m_d;
258 }
259
260 /* Get the Go-specific lookup info. */
261 const demangle_for_lookup_info &go () const
262 {
263 maybe_init (m_go, language_go);
264 return *m_go;
265 }
266
267 /* Get a reference to a lookup_name_info object that matches any
268 symbol name. */
269 static const lookup_name_info &match_any ();
270
271 private:
272 /* Initialize FIELD, if not initialized yet. */
273 template<typename Field, typename... Args>
274 void maybe_init (Field &field, Args&&... args) const
275 {
276 if (!field)
277 field.emplace (*this, std::forward<Args> (args)...);
278 }
279
280 /* The lookup info as passed to the ctor. */
281 symbol_name_match_type m_match_type;
282 bool m_completion_mode;
283 bool m_ignore_parameters;
284 std::string m_name;
285
286 /* Language-specific info. These fields are filled lazily the first
287 time a lookup is done in the corresponding language. They're
288 mutable because lookup_name_info objects are typically passed
289 around by const reference (see intro), and they're conceptually
290 "cache" that can always be reconstructed from the non-mutable
291 fields. */
292 mutable gdb::optional<ada_lookup_name_info> m_ada;
293 mutable gdb::optional<demangle_for_lookup_info> m_cplus;
294 mutable gdb::optional<demangle_for_lookup_info> m_d;
295 mutable gdb::optional<demangle_for_lookup_info> m_go;
296
297 /* The demangled hashes. Stored in an array with one entry for each
298 possible language. The second array records whether we've
299 already computed the each language's hash. (These are separate
300 arrays instead of a single array of optional<unsigned> to avoid
301 alignment padding). */
302 mutable std::array<unsigned int, nr_languages> m_demangled_hashes;
303 mutable std::array<bool, nr_languages> m_demangled_hashes_p {};
304 };
305
306 /* Comparison function for completion symbol lookup.
307
308 Returns true if the symbol name matches against LOOKUP_NAME.
309
310 SYMBOL_SEARCH_NAME should be a symbol's "search" name.
311
312 On success and if non-NULL, COMP_MATCH_RES->match is set to point
313 to the symbol name as should be presented to the user as a
314 completion match list element. In most languages, this is the same
315 as the symbol's search name, but in some, like Ada, the display
316 name is dynamically computed within the comparison routine.
317
318 Also, on success and if non-NULL, COMP_MATCH_RES->match_for_lcd
319 points the part of SYMBOL_SEARCH_NAME that was considered to match
320 LOOKUP_NAME. E.g., in C++, in linespec/wild mode, if the symbol is
321 "foo::function()" and LOOKUP_NAME is "function(", MATCH_FOR_LCD
322 points to "function()" inside SYMBOL_SEARCH_NAME. */
323 typedef bool (symbol_name_matcher_ftype)
324 (const char *symbol_search_name,
325 const lookup_name_info &lookup_name,
326 completion_match_result *comp_match_res);
327
328 /* Some of the structures in this file are space critical.
329 The space-critical structures are:
330
331 struct general_symbol_info
332 struct symbol
333 struct partial_symbol
334
335 These structures are laid out to encourage good packing.
336 They use ENUM_BITFIELD and short int fields, and they order the
337 structure members so that fields less than a word are next
338 to each other so they can be packed together. */
339
340 /* Rearranged: used ENUM_BITFIELD and rearranged field order in
341 all the space critical structures (plus struct minimal_symbol).
342 Memory usage dropped from 99360768 bytes to 90001408 bytes.
343 I measured this with before-and-after tests of
344 "HEAD-old-gdb -readnow HEAD-old-gdb" and
345 "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
346 red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
347 typing "maint space 1" at the first command prompt.
348
349 Here is another measurement (from andrew c):
350 # no /usr/lib/debug, just plain glibc, like a normal user
351 gdb HEAD-old-gdb
352 (gdb) break internal_error
353 (gdb) run
354 (gdb) maint internal-error
355 (gdb) backtrace
356 (gdb) maint space 1
357
358 gdb gdb_6_0_branch 2003-08-19 space used: 8896512
359 gdb HEAD 2003-08-19 space used: 8904704
360 gdb HEAD 2003-08-21 space used: 8396800 (+symtab.h)
361 gdb HEAD 2003-08-21 space used: 8265728 (+gdbtypes.h)
362
363 The third line shows the savings from the optimizations in symtab.h.
364 The fourth line shows the savings from the optimizations in
365 gdbtypes.h. Both optimizations are in gdb HEAD now.
366
367 --chastain 2003-08-21 */
368
369 /* Define a structure for the information that is common to all symbol types,
370 including minimal symbols, partial symbols, and full symbols. In a
371 multilanguage environment, some language specific information may need to
372 be recorded along with each symbol. */
373
374 /* This structure is space critical. See space comments at the top. */
375
376 struct general_symbol_info
377 {
378 /* Name of the symbol. This is a required field. Storage for the
379 name is allocated on the objfile_obstack for the associated
380 objfile. For languages like C++ that make a distinction between
381 the mangled name and demangled name, this is the mangled
382 name. */
383
384 const char *name;
385
386 /* Value of the symbol. Which member of this union to use, and what
387 it means, depends on what kind of symbol this is and its
388 SYMBOL_CLASS. See comments there for more details. All of these
389 are in host byte order (though what they point to might be in
390 target byte order, e.g. LOC_CONST_BYTES). */
391
392 union
393 {
394 LONGEST ivalue;
395
396 const struct block *block;
397
398 const gdb_byte *bytes;
399
400 CORE_ADDR address;
401
402 /* A common block. Used with LOC_COMMON_BLOCK. */
403
404 const struct common_block *common_block;
405
406 /* For opaque typedef struct chain. */
407
408 struct symbol *chain;
409 }
410 value;
411
412 /* Since one and only one language can apply, wrap the language specific
413 information inside a union. */
414
415 union
416 {
417 /* A pointer to an obstack that can be used for storage associated
418 with this symbol. This is only used by Ada, and only when the
419 'ada_mangled' field is zero. */
420 struct obstack *obstack;
421
422 /* This is used by languages which wish to store a demangled name.
423 currently used by Ada, C++, and Objective C. */
424 const char *demangled_name;
425 }
426 language_specific;
427
428 /* Record the source code language that applies to this symbol.
429 This is used to select one of the fields from the language specific
430 union above. */
431
432 ENUM_BITFIELD(language) language : LANGUAGE_BITS;
433
434 /* This is only used by Ada. If set, then the 'demangled_name' field
435 of language_specific is valid. Otherwise, the 'obstack' field is
436 valid. */
437 unsigned int ada_mangled : 1;
438
439 /* Which section is this symbol in? This is an index into
440 section_offsets for this objfile. Negative means that the symbol
441 does not get relocated relative to a section. */
442
443 short section;
444 };
445
446 extern void symbol_set_demangled_name (struct general_symbol_info *,
447 const char *,
448 struct obstack *);
449
450 extern const char *symbol_get_demangled_name
451 (const struct general_symbol_info *);
452
453 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
454
455 /* Note that all the following SYMBOL_* macros are used with the
456 SYMBOL argument being either a partial symbol or
457 a full symbol. Both types have a ginfo field. In particular
458 the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
459 macros cannot be entirely substituted by
460 functions, unless the callers are changed to pass in the ginfo
461 field only, instead of the SYMBOL parameter. */
462
463 #define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.ivalue
464 #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address
465 #define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes
466 #define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
467 #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block
468 #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain
469 #define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.language
470 #define SYMBOL_SECTION(symbol) (symbol)->ginfo.section
471 #define SYMBOL_OBJ_SECTION(objfile, symbol) \
472 (((symbol)->ginfo.section >= 0) \
473 ? (&(((objfile)->sections)[(symbol)->ginfo.section])) \
474 : NULL)
475
476 /* Initializes the language dependent portion of a symbol
477 depending upon the language for the symbol. */
478 #define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
479 (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
480 extern void symbol_set_language (struct general_symbol_info *symbol,
481 enum language language,
482 struct obstack *obstack);
483
484 /* Set just the linkage name of a symbol; do not try to demangle
485 it. Used for constructs which do not have a mangled name,
486 e.g. struct tags. Unlike SYMBOL_SET_NAMES, linkage_name must
487 be terminated and either already on the objfile's obstack or
488 permanently allocated. */
489 #define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
490 (symbol)->ginfo.name = (linkage_name)
491
492 /* Set the linkage and natural names of a symbol, by demangling
493 the linkage name. */
494 #define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
495 symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
496 extern void symbol_set_names (struct general_symbol_info *symbol,
497 const char *linkage_name, int len, int copy_name,
498 struct objfile *objfile);
499
500 /* Now come lots of name accessor macros. Short version as to when to
501 use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
502 symbol in the original source code. Use SYMBOL_LINKAGE_NAME if you
503 want to know what the linker thinks the symbol's name is. Use
504 SYMBOL_PRINT_NAME for output. Use SYMBOL_DEMANGLED_NAME if you
505 specifically need to know whether SYMBOL_NATURAL_NAME and
506 SYMBOL_LINKAGE_NAME are different. */
507
508 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
509 the original source code. In languages like C++ where symbols may
510 be mangled for ease of manipulation by the linker, this is the
511 demangled name. */
512
513 #define SYMBOL_NATURAL_NAME(symbol) \
514 (symbol_natural_name (&(symbol)->ginfo))
515 extern const char *symbol_natural_name
516 (const struct general_symbol_info *symbol);
517
518 /* Return SYMBOL's name from the point of view of the linker. In
519 languages like C++ where symbols may be mangled for ease of
520 manipulation by the linker, this is the mangled name; otherwise,
521 it's the same as SYMBOL_NATURAL_NAME. */
522
523 #define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
524
525 /* Return the demangled name for a symbol based on the language for
526 that symbol. If no demangled name exists, return NULL. */
527 #define SYMBOL_DEMANGLED_NAME(symbol) \
528 (symbol_demangled_name (&(symbol)->ginfo))
529 extern const char *symbol_demangled_name
530 (const struct general_symbol_info *symbol);
531
532 /* Macro that returns a version of the name of a symbol that is
533 suitable for output. In C++ this is the "demangled" form of the
534 name if demangle is on and the "mangled" form of the name if
535 demangle is off. In other languages this is just the symbol name.
536 The result should never be NULL. Don't use this for internal
537 purposes (e.g. storing in a hashtable): it's only suitable for output.
538
539 N.B. symbol may be anything with a ginfo member,
540 e.g., struct symbol or struct minimal_symbol. */
541
542 #define SYMBOL_PRINT_NAME(symbol) \
543 (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
544 extern int demangle;
545
546 /* Macro that returns the name to be used when sorting and searching symbols.
547 In C++, we search for the demangled form of a name,
548 and so sort symbols accordingly. In Ada, however, we search by mangled
549 name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
550 returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
551 #define SYMBOL_SEARCH_NAME(symbol) \
552 (symbol_search_name (&(symbol)->ginfo))
553 extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
554
555 /* Return true if NAME matches the "search" name of SYMBOL, according
556 to the symbol's language. */
557 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
558 symbol_matches_search_name (&(symbol)->ginfo, (name))
559
560 /* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
561 and psymbols. */
562 extern bool symbol_matches_search_name
563 (const struct general_symbol_info *gsymbol,
564 const lookup_name_info &name);
565
566 /* Compute the hash of the given symbol search name of a symbol of
567 language LANGUAGE. */
568 extern unsigned int search_name_hash (enum language language,
569 const char *search_name);
570
571 /* Classification types for a minimal symbol. These should be taken as
572 "advisory only", since if gdb can't easily figure out a
573 classification it simply selects mst_unknown. It may also have to
574 guess when it can't figure out which is a better match between two
575 types (mst_data versus mst_bss) for example. Since the minimal
576 symbol info is sometimes derived from the BFD library's view of a
577 file, we need to live with what information bfd supplies. */
578
579 enum minimal_symbol_type
580 {
581 mst_unknown = 0, /* Unknown type, the default */
582 mst_text, /* Generally executable instructions */
583 mst_text_gnu_ifunc, /* Executable code returning address
584 of executable code */
585 mst_slot_got_plt, /* GOT entries for .plt sections */
586 mst_data, /* Generally initialized data */
587 mst_bss, /* Generally uninitialized data */
588 mst_abs, /* Generally absolute (nonrelocatable) */
589 /* GDB uses mst_solib_trampoline for the start address of a shared
590 library trampoline entry. Breakpoints for shared library functions
591 are put there if the shared library is not yet loaded.
592 After the shared library is loaded, lookup_minimal_symbol will
593 prefer the minimal symbol from the shared library (usually
594 a mst_text symbol) over the mst_solib_trampoline symbol, and the
595 breakpoints will be moved to their true address in the shared
596 library via breakpoint_re_set. */
597 mst_solib_trampoline, /* Shared library trampoline code */
598 /* For the mst_file* types, the names are only guaranteed to be unique
599 within a given .o file. */
600 mst_file_text, /* Static version of mst_text */
601 mst_file_data, /* Static version of mst_data */
602 mst_file_bss, /* Static version of mst_bss */
603 nr_minsym_types
604 };
605
606 /* The number of enum minimal_symbol_type values, with some padding for
607 reasonable growth. */
608 #define MINSYM_TYPE_BITS 4
609 gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
610
611 /* Define a simple structure used to hold some very basic information about
612 all defined global symbols (text, data, bss, abs, etc). The only required
613 information is the general_symbol_info.
614
615 In many cases, even if a file was compiled with no special options for
616 debugging at all, as long as was not stripped it will contain sufficient
617 information to build a useful minimal symbol table using this structure.
618 Even when a file contains enough debugging information to build a full
619 symbol table, these minimal symbols are still useful for quickly mapping
620 between names and addresses, and vice versa. They are also sometimes
621 used to figure out what full symbol table entries need to be read in. */
622
623 struct minimal_symbol
624 {
625
626 /* The general symbol info required for all types of symbols.
627
628 The SYMBOL_VALUE_ADDRESS contains the address that this symbol
629 corresponds to. */
630
631 struct general_symbol_info mginfo;
632
633 /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this
634 information to calculate the end of the partial symtab based on the
635 address of the last symbol plus the size of the last symbol. */
636
637 unsigned long size;
638
639 /* Which source file is this symbol in? Only relevant for mst_file_*. */
640 const char *filename;
641
642 /* Classification type for this minimal symbol. */
643
644 ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
645
646 /* Non-zero if this symbol was created by gdb.
647 Such symbols do not appear in the output of "info var|fun". */
648 unsigned int created_by_gdb : 1;
649
650 /* Two flag bits provided for the use of the target. */
651 unsigned int target_flag_1 : 1;
652 unsigned int target_flag_2 : 1;
653
654 /* Nonzero iff the size of the minimal symbol has been set.
655 Symbol size information can sometimes not be determined, because
656 the object file format may not carry that piece of information. */
657 unsigned int has_size : 1;
658
659 /* Minimal symbols with the same hash key are kept on a linked
660 list. This is the link. */
661
662 struct minimal_symbol *hash_next;
663
664 /* Minimal symbols are stored in two different hash tables. This is
665 the `next' pointer for the demangled hash table. */
666
667 struct minimal_symbol *demangled_hash_next;
668 };
669
670 #define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
671 #define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
672 #define MSYMBOL_SIZE(msymbol) ((msymbol)->size + 0)
673 #define SET_MSYMBOL_SIZE(msymbol, sz) \
674 do \
675 { \
676 (msymbol)->size = sz; \
677 (msymbol)->has_size = 1; \
678 } while (0)
679 #define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0)
680 #define MSYMBOL_TYPE(msymbol) (msymbol)->type
681
682 #define MSYMBOL_VALUE(symbol) (symbol)->mginfo.value.ivalue
683 /* The unrelocated address of the minimal symbol. */
684 #define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
685 /* The relocated address of the minimal symbol, using the section
686 offsets from OBJFILE. */
687 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
688 ((symbol)->mginfo.value.address \
689 + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
690 /* For a bound minsym, we can easily compute the address directly. */
691 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
692 MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
693 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \
694 ((symbol)->mginfo.value.address = (new_value))
695 #define MSYMBOL_VALUE_BYTES(symbol) (symbol)->mginfo.value.bytes
696 #define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->mginfo.value.block
697 #define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->mginfo.value.chain
698 #define MSYMBOL_LANGUAGE(symbol) (symbol)->mginfo.language
699 #define MSYMBOL_SECTION(symbol) (symbol)->mginfo.section
700 #define MSYMBOL_OBJ_SECTION(objfile, symbol) \
701 (((symbol)->mginfo.section >= 0) \
702 ? (&(((objfile)->sections)[(symbol)->mginfo.section])) \
703 : NULL)
704
705 #define MSYMBOL_NATURAL_NAME(symbol) \
706 (symbol_natural_name (&(symbol)->mginfo))
707 #define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->mginfo.name
708 #define MSYMBOL_PRINT_NAME(symbol) \
709 (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
710 #define MSYMBOL_DEMANGLED_NAME(symbol) \
711 (symbol_demangled_name (&(symbol)->mginfo))
712 #define MSYMBOL_SET_LANGUAGE(symbol,language,obstack) \
713 (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
714 #define MSYMBOL_SEARCH_NAME(symbol) \
715 (symbol_search_name (&(symbol)->mginfo))
716 #define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
717 symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
718
719 #include "minsyms.h"
720
721
722
723 /* Represent one symbol name; a variable, constant, function or typedef. */
724
725 /* Different name domains for symbols. Looking up a symbol specifies a
726 domain and ignores symbol definitions in other name domains. */
727
728 typedef enum domain_enum_tag
729 {
730 /* UNDEF_DOMAIN is used when a domain has not been discovered or
731 none of the following apply. This usually indicates an error either
732 in the symbol information or in gdb's handling of symbols. */
733
734 UNDEF_DOMAIN,
735
736 /* VAR_DOMAIN is the usual domain. In C, this contains variables,
737 function names, typedef names and enum type values. */
738
739 VAR_DOMAIN,
740
741 /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
742 Thus, if `struct foo' is used in a C program, it produces a symbol named
743 `foo' in the STRUCT_DOMAIN. */
744
745 STRUCT_DOMAIN,
746
747 /* MODULE_DOMAIN is used in Fortran to hold module type names. */
748
749 MODULE_DOMAIN,
750
751 /* LABEL_DOMAIN may be used for names of labels (for gotos). */
752
753 LABEL_DOMAIN,
754
755 /* Fortran common blocks. Their naming must be separate from VAR_DOMAIN.
756 They also always use LOC_COMMON_BLOCK. */
757 COMMON_BLOCK_DOMAIN,
758
759 /* This must remain last. */
760 NR_DOMAINS
761 } domain_enum;
762
763 /* The number of bits in a symbol used to represent the domain. */
764
765 #define SYMBOL_DOMAIN_BITS 3
766 gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
767
768 extern const char *domain_name (domain_enum);
769
770 /* Searching domains, used for `search_symbols'. Element numbers are
771 hardcoded in GDB, check all enum uses before changing it. */
772
773 enum search_domain
774 {
775 /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
776 TYPES_DOMAIN. */
777 VARIABLES_DOMAIN = 0,
778
779 /* All functions -- for some reason not methods, though. */
780 FUNCTIONS_DOMAIN = 1,
781
782 /* All defined types */
783 TYPES_DOMAIN = 2,
784
785 /* Any type. */
786 ALL_DOMAIN = 3
787 };
788
789 extern const char *search_domain_name (enum search_domain);
790
791 /* An address-class says where to find the value of a symbol. */
792
793 enum address_class
794 {
795 /* Not used; catches errors. */
796
797 LOC_UNDEF,
798
799 /* Value is constant int SYMBOL_VALUE, host byteorder. */
800
801 LOC_CONST,
802
803 /* Value is at fixed address SYMBOL_VALUE_ADDRESS. */
804
805 LOC_STATIC,
806
807 /* Value is in register. SYMBOL_VALUE is the register number
808 in the original debug format. SYMBOL_REGISTER_OPS holds a
809 function that can be called to transform this into the
810 actual register number this represents in a specific target
811 architecture (gdbarch).
812
813 For some symbol formats (stabs, for some compilers at least),
814 the compiler generates two symbols, an argument and a register.
815 In some cases we combine them to a single LOC_REGISTER in symbol
816 reading, but currently not for all cases (e.g. it's passed on the
817 stack and then loaded into a register). */
818
819 LOC_REGISTER,
820
821 /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */
822
823 LOC_ARG,
824
825 /* Value address is at SYMBOL_VALUE offset in arglist. */
826
827 LOC_REF_ARG,
828
829 /* Value is in specified register. Just like LOC_REGISTER except the
830 register holds the address of the argument instead of the argument
831 itself. This is currently used for the passing of structs and unions
832 on sparc and hppa. It is also used for call by reference where the
833 address is in a register, at least by mipsread.c. */
834
835 LOC_REGPARM_ADDR,
836
837 /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */
838
839 LOC_LOCAL,
840
841 /* Value not used; definition in SYMBOL_TYPE. Symbols in the domain
842 STRUCT_DOMAIN all have this class. */
843
844 LOC_TYPEDEF,
845
846 /* Value is address SYMBOL_VALUE_ADDRESS in the code. */
847
848 LOC_LABEL,
849
850 /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
851 In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
852 of the block. Function names have this class. */
853
854 LOC_BLOCK,
855
856 /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
857 target byte order. */
858
859 LOC_CONST_BYTES,
860
861 /* Value is at fixed address, but the address of the variable has
862 to be determined from the minimal symbol table whenever the
863 variable is referenced.
864 This happens if debugging information for a global symbol is
865 emitted and the corresponding minimal symbol is defined
866 in another object file or runtime common storage.
867 The linker might even remove the minimal symbol if the global
868 symbol is never referenced, in which case the symbol remains
869 unresolved.
870
871 GDB would normally find the symbol in the minimal symbol table if it will
872 not find it in the full symbol table. But a reference to an external
873 symbol in a local block shadowing other definition requires full symbol
874 without possibly having its address available for LOC_STATIC. Testcase
875 is provided as `gdb.dwarf2/dw2-unresolved.exp'.
876
877 This is also used for thread local storage (TLS) variables. In this case,
878 the address of the TLS variable must be determined when the variable is
879 referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
880 of the TLS variable in the thread local storage of the shared
881 library/object. */
882
883 LOC_UNRESOLVED,
884
885 /* The variable does not actually exist in the program.
886 The value is ignored. */
887
888 LOC_OPTIMIZED_OUT,
889
890 /* The variable's address is computed by a set of location
891 functions (see "struct symbol_computed_ops" below). */
892 LOC_COMPUTED,
893
894 /* The variable uses general_symbol_info->value->common_block field.
895 It also always uses COMMON_BLOCK_DOMAIN. */
896 LOC_COMMON_BLOCK,
897
898 /* Not used, just notes the boundary of the enum. */
899 LOC_FINAL_VALUE
900 };
901
902 /* The number of bits needed for values in enum address_class, with some
903 padding for reasonable growth, and room for run-time registered address
904 classes. See symtab.c:MAX_SYMBOL_IMPLS.
905 This is a #define so that we can have a assertion elsewhere to
906 verify that we have reserved enough space for synthetic address
907 classes. */
908 #define SYMBOL_ACLASS_BITS 5
909 gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
910
911 /* The methods needed to implement LOC_COMPUTED. These methods can
912 use the symbol's .aux_value for additional per-symbol information.
913
914 At present this is only used to implement location expressions. */
915
916 struct symbol_computed_ops
917 {
918
919 /* Return the value of the variable SYMBOL, relative to the stack
920 frame FRAME. If the variable has been optimized out, return
921 zero.
922
923 Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
924 FRAME may be zero. */
925
926 struct value *(*read_variable) (struct symbol * symbol,
927 struct frame_info * frame);
928
929 /* Read variable SYMBOL like read_variable at (callee) FRAME's function
930 entry. SYMBOL should be a function parameter, otherwise
931 NO_ENTRY_VALUE_ERROR will be thrown. */
932 struct value *(*read_variable_at_entry) (struct symbol *symbol,
933 struct frame_info *frame);
934
935 /* Find the "symbol_needs_kind" value for the given symbol. This
936 value determines whether reading the symbol needs memory (e.g., a
937 global variable), just registers (a thread-local), or a frame (a
938 local variable). */
939 enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
940
941 /* Write to STREAM a natural-language description of the location of
942 SYMBOL, in the context of ADDR. */
943 void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
944 struct ui_file * stream);
945
946 /* Non-zero if this symbol's address computation is dependent on PC. */
947 unsigned char location_has_loclist;
948
949 /* Tracepoint support. Append bytecodes to the tracepoint agent
950 expression AX that push the address of the object SYMBOL. Set
951 VALUE appropriately. Note --- for objects in registers, this
952 needn't emit any code; as long as it sets VALUE properly, then
953 the caller will generate the right code in the process of
954 treating this as an lvalue or rvalue. */
955
956 void (*tracepoint_var_ref) (struct symbol *symbol, struct agent_expr *ax,
957 struct axs_value *value);
958
959 /* Generate C code to compute the location of SYMBOL. The C code is
960 emitted to STREAM. GDBARCH is the current architecture and PC is
961 the PC at which SYMBOL's location should be evaluated.
962 REGISTERS_USED is a vector indexed by register number; the
963 generator function should set an element in this vector if the
964 corresponding register is needed by the location computation.
965 The generated C code must assign the location to a local
966 variable; this variable's name is RESULT_NAME. */
967
968 void (*generate_c_location) (struct symbol *symbol, string_file &stream,
969 struct gdbarch *gdbarch,
970 unsigned char *registers_used,
971 CORE_ADDR pc, const char *result_name);
972
973 };
974
975 /* The methods needed to implement LOC_BLOCK for inferior functions.
976 These methods can use the symbol's .aux_value for additional
977 per-symbol information. */
978
979 struct symbol_block_ops
980 {
981 /* Fill in *START and *LENGTH with DWARF block data of function
982 FRAMEFUNC valid for inferior context address PC. Set *LENGTH to
983 zero if such location is not valid for PC; *START is left
984 uninitialized in such case. */
985 void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
986 const gdb_byte **start, size_t *length);
987
988 /* Return the frame base address. FRAME is the frame for which we want to
989 compute the base address while FRAMEFUNC is the symbol for the
990 corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
991 information we need).
992
993 This method is designed to work with static links (nested functions
994 handling). Static links are function properties whose evaluation returns
995 the frame base address for the enclosing frame. However, there are
996 multiple definitions for "frame base": the content of the frame base
997 register, the CFA as defined by DWARF unwinding information, ...
998
999 So this specific method is supposed to compute the frame base address such
1000 as for nested fuctions, the static link computes the same address. For
1001 instance, considering DWARF debugging information, the static link is
1002 computed with DW_AT_static_link and this method must be used to compute
1003 the corresponding DW_AT_frame_base attribute. */
1004 CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
1005 struct frame_info *frame);
1006 };
1007
1008 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1009
1010 struct symbol_register_ops
1011 {
1012 int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
1013 };
1014
1015 /* Objects of this type are used to find the address class and the
1016 various computed ops vectors of a symbol. */
1017
1018 struct symbol_impl
1019 {
1020 enum address_class aclass;
1021
1022 /* Used with LOC_COMPUTED. */
1023 const struct symbol_computed_ops *ops_computed;
1024
1025 /* Used with LOC_BLOCK. */
1026 const struct symbol_block_ops *ops_block;
1027
1028 /* Used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1029 const struct symbol_register_ops *ops_register;
1030 };
1031
1032 /* struct symbol has some subclasses. This enum is used to
1033 differentiate between them. */
1034
1035 enum symbol_subclass_kind
1036 {
1037 /* Plain struct symbol. */
1038 SYMBOL_NONE,
1039
1040 /* struct template_symbol. */
1041 SYMBOL_TEMPLATE,
1042
1043 /* struct rust_vtable_symbol. */
1044 SYMBOL_RUST_VTABLE
1045 };
1046
1047 /* This structure is space critical. See space comments at the top. */
1048
1049 struct symbol
1050 {
1051
1052 /* The general symbol info required for all types of symbols. */
1053
1054 struct general_symbol_info ginfo;
1055
1056 /* Data type of value */
1057
1058 struct type *type;
1059
1060 /* The owner of this symbol.
1061 Which one to use is defined by symbol.is_objfile_owned. */
1062
1063 union
1064 {
1065 /* The symbol table containing this symbol. This is the file associated
1066 with LINE. It can be NULL during symbols read-in but it is never NULL
1067 during normal operation. */
1068 struct symtab *symtab;
1069
1070 /* For types defined by the architecture. */
1071 struct gdbarch *arch;
1072 } owner;
1073
1074 /* Domain code. */
1075
1076 ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
1077
1078 /* Address class. This holds an index into the 'symbol_impls'
1079 table. The actual enum address_class value is stored there,
1080 alongside any per-class ops vectors. */
1081
1082 unsigned int aclass_index : SYMBOL_ACLASS_BITS;
1083
1084 /* If non-zero then symbol is objfile-owned, use owner.symtab.
1085 Otherwise symbol is arch-owned, use owner.arch. */
1086
1087 unsigned int is_objfile_owned : 1;
1088
1089 /* Whether this is an argument. */
1090
1091 unsigned is_argument : 1;
1092
1093 /* Whether this is an inlined function (class LOC_BLOCK only). */
1094 unsigned is_inlined : 1;
1095
1096 /* The concrete type of this symbol. */
1097
1098 ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
1099
1100 /* Line number of this symbol's definition, except for inlined
1101 functions. For an inlined function (class LOC_BLOCK and
1102 SYMBOL_INLINED set) this is the line number of the function's call
1103 site. Inlined function symbols are not definitions, and they are
1104 never found by symbol table lookup.
1105 If this symbol is arch-owned, LINE shall be zero.
1106
1107 FIXME: Should we really make the assumption that nobody will try
1108 to debug files longer than 64K lines? What about machine
1109 generated programs? */
1110
1111 unsigned short line;
1112
1113 /* An arbitrary data pointer, allowing symbol readers to record
1114 additional information on a per-symbol basis. Note that this data
1115 must be allocated using the same obstack as the symbol itself. */
1116 /* So far it is only used by:
1117 LOC_COMPUTED: to find the location information
1118 LOC_BLOCK (DWARF2 function): information used internally by the
1119 DWARF 2 code --- specifically, the location expression for the frame
1120 base for this function. */
1121 /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
1122 to add a magic symbol to the block containing this information,
1123 or to have a generic debug info annotation slot for symbols. */
1124
1125 void *aux_value;
1126
1127 struct symbol *hash_next;
1128 };
1129
1130 /* Several lookup functions return both a symbol and the block in which the
1131 symbol is found. This structure is used in these cases. */
1132
1133 struct block_symbol
1134 {
1135 /* The symbol that was found, or NULL if no symbol was found. */
1136 struct symbol *symbol;
1137
1138 /* If SYMBOL is not NULL, then this is the block in which the symbol is
1139 defined. */
1140 const struct block *block;
1141 };
1142
1143 extern const struct symbol_impl *symbol_impls;
1144
1145 /* For convenience. All fields are NULL. This means "there is no
1146 symbol". */
1147 extern const struct block_symbol null_block_symbol;
1148
1149 /* Note: There is no accessor macro for symbol.owner because it is
1150 "private". */
1151
1152 #define SYMBOL_DOMAIN(symbol) (symbol)->domain
1153 #define SYMBOL_IMPL(symbol) (symbol_impls[(symbol)->aclass_index])
1154 #define SYMBOL_ACLASS_INDEX(symbol) (symbol)->aclass_index
1155 #define SYMBOL_CLASS(symbol) (SYMBOL_IMPL (symbol).aclass)
1156 #define SYMBOL_OBJFILE_OWNED(symbol) ((symbol)->is_objfile_owned)
1157 #define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
1158 #define SYMBOL_INLINED(symbol) (symbol)->is_inlined
1159 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
1160 (((symbol)->subclass) == SYMBOL_TEMPLATE)
1161 #define SYMBOL_TYPE(symbol) (symbol)->type
1162 #define SYMBOL_LINE(symbol) (symbol)->line
1163 #define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
1164 #define SYMBOL_BLOCK_OPS(symbol) (SYMBOL_IMPL (symbol).ops_block)
1165 #define SYMBOL_REGISTER_OPS(symbol) (SYMBOL_IMPL (symbol).ops_register)
1166 #define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
1167
1168 extern int register_symbol_computed_impl (enum address_class,
1169 const struct symbol_computed_ops *);
1170
1171 extern int register_symbol_block_impl (enum address_class aclass,
1172 const struct symbol_block_ops *ops);
1173
1174 extern int register_symbol_register_impl (enum address_class,
1175 const struct symbol_register_ops *);
1176
1177 /* Return the OBJFILE of SYMBOL.
1178 It is an error to call this if symbol.is_objfile_owned is false, which
1179 only happens for architecture-provided types. */
1180
1181 extern struct objfile *symbol_objfile (const struct symbol *symbol);
1182
1183 /* Return the ARCH of SYMBOL. */
1184
1185 extern struct gdbarch *symbol_arch (const struct symbol *symbol);
1186
1187 /* Return the SYMTAB of SYMBOL.
1188 It is an error to call this if symbol.is_objfile_owned is false, which
1189 only happens for architecture-provided types. */
1190
1191 extern struct symtab *symbol_symtab (const struct symbol *symbol);
1192
1193 /* Set the symtab of SYMBOL to SYMTAB.
1194 It is an error to call this if symbol.is_objfile_owned is false, which
1195 only happens for architecture-provided types. */
1196
1197 extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
1198
1199 /* An instance of this type is used to represent a C++ template
1200 function. A symbol is really of this type iff
1201 SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true. */
1202
1203 struct template_symbol : public symbol
1204 {
1205 /* The number of template arguments. */
1206 int n_template_arguments;
1207
1208 /* The template arguments. This is an array with
1209 N_TEMPLATE_ARGUMENTS elements. */
1210 struct symbol **template_arguments;
1211 };
1212
1213 /* A symbol that represents a Rust virtual table object. */
1214
1215 struct rust_vtable_symbol : public symbol
1216 {
1217 /* The concrete type for which this vtable was created; that is, in
1218 "impl Trait for Type", this is "Type". */
1219 struct type *concrete_type;
1220 };
1221
1222
1223 /* Each item represents a line-->pc (or the reverse) mapping. This is
1224 somewhat more wasteful of space than one might wish, but since only
1225 the files which are actually debugged are read in to core, we don't
1226 waste much space. */
1227
1228 struct linetable_entry
1229 {
1230 int line;
1231 CORE_ADDR pc;
1232 };
1233
1234 /* The order of entries in the linetable is significant. They should
1235 be sorted by increasing values of the pc field. If there is more than
1236 one entry for a given pc, then I'm not sure what should happen (and
1237 I not sure whether we currently handle it the best way).
1238
1239 Example: a C for statement generally looks like this
1240
1241 10 0x100 - for the init/test part of a for stmt.
1242 20 0x200
1243 30 0x300
1244 10 0x400 - for the increment part of a for stmt.
1245
1246 If an entry has a line number of zero, it marks the start of a PC
1247 range for which no line number information is available. It is
1248 acceptable, though wasteful of table space, for such a range to be
1249 zero length. */
1250
1251 struct linetable
1252 {
1253 int nitems;
1254
1255 /* Actually NITEMS elements. If you don't like this use of the
1256 `struct hack', you can shove it up your ANSI (seriously, if the
1257 committee tells us how to do it, we can probably go along). */
1258 struct linetable_entry item[1];
1259 };
1260
1261 /* How to relocate the symbols from each section in a symbol file.
1262 Each struct contains an array of offsets.
1263 The ordering and meaning of the offsets is file-type-dependent;
1264 typically it is indexed by section numbers or symbol types or
1265 something like that.
1266
1267 To give us flexibility in changing the internal representation
1268 of these offsets, the ANOFFSET macro must be used to insert and
1269 extract offset values in the struct. */
1270
1271 struct section_offsets
1272 {
1273 CORE_ADDR offsets[1]; /* As many as needed. */
1274 };
1275
1276 #define ANOFFSET(secoff, whichone) \
1277 ((whichone == -1) \
1278 ? (internal_error (__FILE__, __LINE__, \
1279 _("Section index is uninitialized")), -1) \
1280 : secoff->offsets[whichone])
1281
1282 /* The size of a section_offsets table for N sections. */
1283 #define SIZEOF_N_SECTION_OFFSETS(n) \
1284 (sizeof (struct section_offsets) \
1285 + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
1286
1287 /* Each source file or header is represented by a struct symtab.
1288 The name "symtab" is historical, another name for it is "filetab".
1289 These objects are chained through the `next' field. */
1290
1291 struct symtab
1292 {
1293 /* Unordered chain of all filetabs in the compunit, with the exception
1294 that the "main" source file is the first entry in the list. */
1295
1296 struct symtab *next;
1297
1298 /* Backlink to containing compunit symtab. */
1299
1300 struct compunit_symtab *compunit_symtab;
1301
1302 /* Table mapping core addresses to line numbers for this file.
1303 Can be NULL if none. Never shared between different symtabs. */
1304
1305 struct linetable *linetable;
1306
1307 /* Name of this source file. This pointer is never NULL. */
1308
1309 const char *filename;
1310
1311 /* Total number of lines found in source file. */
1312
1313 int nlines;
1314
1315 /* line_charpos[N] is the position of the (N-1)th line of the
1316 source file. "position" means something we can lseek() to; it
1317 is not guaranteed to be useful any other way. */
1318
1319 int *line_charpos;
1320
1321 /* Language of this source file. */
1322
1323 enum language language;
1324
1325 /* Full name of file as found by searching the source path.
1326 NULL if not yet known. */
1327
1328 char *fullname;
1329 };
1330
1331 #define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1332 #define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1333 #define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1334 #define SYMTAB_BLOCKVECTOR(symtab) \
1335 COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1336 #define SYMTAB_OBJFILE(symtab) \
1337 COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1338 #define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1339 #define SYMTAB_DIRNAME(symtab) \
1340 COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1341
1342 typedef struct symtab *symtab_ptr;
1343 DEF_VEC_P (symtab_ptr);
1344
1345 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1346 as the list of all source files (what gdb has historically associated with
1347 the term "symtab").
1348 Additional information is recorded here that is common to all symtabs in a
1349 compilation unit (DWARF or otherwise).
1350
1351 Example:
1352 For the case of a program built out of these files:
1353
1354 foo.c
1355 foo1.h
1356 foo2.h
1357 bar.c
1358 foo1.h
1359 bar.h
1360
1361 This is recorded as:
1362
1363 objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1364 | |
1365 v v
1366 foo.c bar.c
1367 | |
1368 v v
1369 foo1.h foo1.h
1370 | |
1371 v v
1372 foo2.h bar.h
1373 | |
1374 v v
1375 NULL NULL
1376
1377 where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1378 and the files foo.c, etc. are struct symtab objects. */
1379
1380 struct compunit_symtab
1381 {
1382 /* Unordered chain of all compunit symtabs of this objfile. */
1383 struct compunit_symtab *next;
1384
1385 /* Object file from which this symtab information was read. */
1386 struct objfile *objfile;
1387
1388 /* Name of the symtab.
1389 This is *not* intended to be a usable filename, and is
1390 for debugging purposes only. */
1391 const char *name;
1392
1393 /* Unordered list of file symtabs, except that by convention the "main"
1394 source file (e.g., .c, .cc) is guaranteed to be first.
1395 Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1396 or header (e.g., .h). */
1397 struct symtab *filetabs;
1398
1399 /* Last entry in FILETABS list.
1400 Subfiles are added to the end of the list so they accumulate in order,
1401 with the main source subfile living at the front.
1402 The main reason is so that the main source file symtab is at the head
1403 of the list, and the rest appear in order for debugging convenience. */
1404 struct symtab *last_filetab;
1405
1406 /* Non-NULL string that identifies the format of the debugging information,
1407 such as "stabs", "dwarf 1", "dwarf 2", "coff", etc. This is mostly useful
1408 for automated testing of gdb but may also be information that is
1409 useful to the user. */
1410 const char *debugformat;
1411
1412 /* String of producer version information, or NULL if we don't know. */
1413 const char *producer;
1414
1415 /* Directory in which it was compiled, or NULL if we don't know. */
1416 const char *dirname;
1417
1418 /* List of all symbol scope blocks for this symtab. It is shared among
1419 all symtabs in a given compilation unit. */
1420 const struct blockvector *blockvector;
1421
1422 /* Section in objfile->section_offsets for the blockvector and
1423 the linetable. Probably always SECT_OFF_TEXT. */
1424 int block_line_section;
1425
1426 /* Symtab has been compiled with both optimizations and debug info so that
1427 GDB may stop skipping prologues as variables locations are valid already
1428 at function entry points. */
1429 unsigned int locations_valid : 1;
1430
1431 /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1432 instruction). This is supported by GCC since 4.5.0. */
1433 unsigned int epilogue_unwind_valid : 1;
1434
1435 /* struct call_site entries for this compilation unit or NULL. */
1436 htab_t call_site_htab;
1437
1438 /* The macro table for this symtab. Like the blockvector, this
1439 is shared between different symtabs in a given compilation unit.
1440 It's debatable whether it *should* be shared among all the symtabs in
1441 the given compilation unit, but it currently is. */
1442 struct macro_table *macro_table;
1443
1444 /* If non-NULL, then this points to a NULL-terminated vector of
1445 included compunits. When searching the static or global
1446 block of this compunit, the corresponding block of all
1447 included compunits will also be searched. Note that this
1448 list must be flattened -- the symbol reader is responsible for
1449 ensuring that this vector contains the transitive closure of all
1450 included compunits. */
1451 struct compunit_symtab **includes;
1452
1453 /* If this is an included compunit, this points to one includer
1454 of the table. This user is considered the canonical compunit
1455 containing this one. An included compunit may itself be
1456 included by another. */
1457 struct compunit_symtab *user;
1458 };
1459
1460 #define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1461 #define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1462 #define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1463 #define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1464 #define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1465 #define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1466 #define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1467 #define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1468 #define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1469 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1470 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
1471
1472 /* Iterate over all file tables (struct symtab) within a compunit. */
1473
1474 #define ALL_COMPUNIT_FILETABS(cu, s) \
1475 for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next)
1476
1477 /* Return the primary symtab of CUST. */
1478
1479 extern struct symtab *
1480 compunit_primary_filetab (const struct compunit_symtab *cust);
1481
1482 /* Return the language of CUST. */
1483
1484 extern enum language compunit_language (const struct compunit_symtab *cust);
1485
1486 typedef struct compunit_symtab *compunit_symtab_ptr;
1487 DEF_VEC_P (compunit_symtab_ptr);
1488
1489
1490
1491 /* The virtual function table is now an array of structures which have the
1492 form { int16 offset, delta; void *pfn; }.
1493
1494 In normal virtual function tables, OFFSET is unused.
1495 DELTA is the amount which is added to the apparent object's base
1496 address in order to point to the actual object to which the
1497 virtual function should be applied.
1498 PFN is a pointer to the virtual function.
1499
1500 Note that this macro is g++ specific (FIXME). */
1501
1502 #define VTBL_FNADDR_OFFSET 2
1503
1504 /* External variables and functions for the objects described above. */
1505
1506 /* True if we are nested inside psymtab_to_symtab. */
1507
1508 extern int currently_reading_symtab;
1509
1510 /* symtab.c lookup functions */
1511
1512 extern const char multiple_symbols_ask[];
1513 extern const char multiple_symbols_all[];
1514 extern const char multiple_symbols_cancel[];
1515
1516 const char *multiple_symbols_select_mode (void);
1517
1518 int symbol_matches_domain (enum language symbol_language,
1519 domain_enum symbol_domain,
1520 domain_enum domain);
1521
1522 /* lookup a symbol table by source file name. */
1523
1524 extern struct symtab *lookup_symtab (const char *);
1525
1526 /* An object of this type is passed as the 'is_a_field_of_this'
1527 argument to lookup_symbol and lookup_symbol_in_language. */
1528
1529 struct field_of_this_result
1530 {
1531 /* The type in which the field was found. If this is NULL then the
1532 symbol was not found in 'this'. If non-NULL, then one of the
1533 other fields will be non-NULL as well. */
1534
1535 struct type *type;
1536
1537 /* If the symbol was found as an ordinary field of 'this', then this
1538 is non-NULL and points to the particular field. */
1539
1540 struct field *field;
1541
1542 /* If the symbol was found as a function field of 'this', then this
1543 is non-NULL and points to the particular field. */
1544
1545 struct fn_fieldlist *fn_field;
1546 };
1547
1548 /* Find the definition for a specified symbol name NAME
1549 in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1550 if non-NULL or from global/static blocks if BLOCK is NULL.
1551 Returns the struct symbol pointer, or NULL if no symbol is found.
1552 C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1553 NAME is a field of the current implied argument `this'. If so fill in the
1554 fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
1555 The symbol's section is fixed up if necessary. */
1556
1557 extern struct block_symbol
1558 lookup_symbol_in_language (const char *,
1559 const struct block *,
1560 const domain_enum,
1561 enum language,
1562 struct field_of_this_result *);
1563
1564 /* Same as lookup_symbol_in_language, but using the current language. */
1565
1566 extern struct block_symbol lookup_symbol (const char *,
1567 const struct block *,
1568 const domain_enum,
1569 struct field_of_this_result *);
1570
1571 /* Find the definition for a specified symbol search name in domain
1572 DOMAIN, visible from lexical block BLOCK if non-NULL or from
1573 global/static blocks if BLOCK is NULL. The passed-in search name
1574 should not come from the user; instead it should already be a
1575 search name as retrieved from a
1576 SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call. See definition of
1577 symbol_name_match_type::SEARCH_NAME. Returns the struct symbol
1578 pointer, or NULL if no symbol is found. The symbol's section is
1579 fixed up if necessary. */
1580
1581 extern struct block_symbol lookup_symbol_search_name (const char *search_name,
1582 const struct block *block,
1583 domain_enum domain);
1584
1585 /* A default version of lookup_symbol_nonlocal for use by languages
1586 that can't think of anything better to do.
1587 This implements the C lookup rules. */
1588
1589 extern struct block_symbol
1590 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
1591 const char *,
1592 const struct block *,
1593 const domain_enum);
1594
1595 /* Some helper functions for languages that need to write their own
1596 lookup_symbol_nonlocal functions. */
1597
1598 /* Lookup a symbol in the static block associated to BLOCK, if there
1599 is one; do nothing if BLOCK is NULL or a global block.
1600 Upon success fixes up the symbol's section if necessary. */
1601
1602 extern struct block_symbol
1603 lookup_symbol_in_static_block (const char *name,
1604 const struct block *block,
1605 const domain_enum domain);
1606
1607 /* Search all static file-level symbols for NAME from DOMAIN.
1608 Upon success fixes up the symbol's section if necessary. */
1609
1610 extern struct block_symbol lookup_static_symbol (const char *name,
1611 const domain_enum domain);
1612
1613 /* Lookup a symbol in all files' global blocks.
1614
1615 If BLOCK is non-NULL then it is used for two things:
1616 1) If a target-specific lookup routine for libraries exists, then use the
1617 routine for the objfile of BLOCK, and
1618 2) The objfile of BLOCK is used to assist in determining the search order
1619 if the target requires it.
1620 See gdbarch_iterate_over_objfiles_in_search_order.
1621
1622 Upon success fixes up the symbol's section if necessary. */
1623
1624 extern struct block_symbol
1625 lookup_global_symbol (const char *name,
1626 const struct block *block,
1627 const domain_enum domain);
1628
1629 /* Lookup a symbol in block BLOCK.
1630 Upon success fixes up the symbol's section if necessary. */
1631
1632 extern struct symbol *
1633 lookup_symbol_in_block (const char *name,
1634 symbol_name_match_type match_type,
1635 const struct block *block,
1636 const domain_enum domain);
1637
1638 /* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1639 found, or NULL if not found. */
1640
1641 extern struct block_symbol
1642 lookup_language_this (const struct language_defn *lang,
1643 const struct block *block);
1644
1645 /* Lookup a [struct, union, enum] by name, within a specified block. */
1646
1647 extern struct type *lookup_struct (const char *, const struct block *);
1648
1649 extern struct type *lookup_union (const char *, const struct block *);
1650
1651 extern struct type *lookup_enum (const char *, const struct block *);
1652
1653 /* from blockframe.c: */
1654
1655 /* lookup the function symbol corresponding to the address. */
1656
1657 extern struct symbol *find_pc_function (CORE_ADDR);
1658
1659 /* lookup the function corresponding to the address and section. */
1660
1661 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
1662
1663 /* Find the symbol at the given address. Returns NULL if no symbol
1664 found. Only exact matches for ADDRESS are considered. */
1665
1666 extern struct symbol *find_symbol_at_address (CORE_ADDR);
1667
1668 extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
1669 CORE_ADDR *address,
1670 CORE_ADDR *endaddr,
1671 int *is_gnu_ifunc_p);
1672
1673 /* lookup function from address, return name, start addr and end addr. */
1674
1675 extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *,
1676 CORE_ADDR *);
1677
1678 extern void clear_pc_function_cache (void);
1679
1680 /* Expand symtab containing PC, SECTION if not already expanded. */
1681
1682 extern void expand_symtab_containing_pc (CORE_ADDR, struct obj_section *);
1683
1684 /* lookup full symbol table by address. */
1685
1686 extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
1687
1688 /* lookup full symbol table by address and section. */
1689
1690 extern struct compunit_symtab *
1691 find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
1692
1693 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1694
1695 extern void reread_symbols (void);
1696
1697 /* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1698 The type returned must not be opaque -- i.e., must have at least one field
1699 defined. */
1700
1701 extern struct type *lookup_transparent_type (const char *);
1702
1703 extern struct type *basic_lookup_transparent_type (const char *);
1704
1705 /* Macro for name of symbol to indicate a file compiled with gcc. */
1706 #ifndef GCC_COMPILED_FLAG_SYMBOL
1707 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1708 #endif
1709
1710 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1711 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1712 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1713 #endif
1714
1715 extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1716
1717 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1718 for ELF symbol files. */
1719
1720 struct gnu_ifunc_fns
1721 {
1722 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
1723 CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1724
1725 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
1726 int (*gnu_ifunc_resolve_name) (const char *function_name,
1727 CORE_ADDR *function_address_p);
1728
1729 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
1730 void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1731
1732 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
1733 void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
1734 };
1735
1736 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1737 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1738 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1739 #define gnu_ifunc_resolver_return_stop \
1740 gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1741
1742 extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1743
1744 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1745
1746 struct symtab_and_line
1747 {
1748 /* The program space of this sal. */
1749 struct program_space *pspace = NULL;
1750
1751 struct symtab *symtab = NULL;
1752 struct symbol *symbol = NULL;
1753 struct obj_section *section = NULL;
1754 /* Line number. Line numbers start at 1 and proceed through symtab->nlines.
1755 0 is never a valid line number; it is used to indicate that line number
1756 information is not available. */
1757 int line = 0;
1758
1759 CORE_ADDR pc = 0;
1760 CORE_ADDR end = 0;
1761 bool explicit_pc = false;
1762 bool explicit_line = false;
1763
1764 /* The probe associated with this symtab_and_line. */
1765 probe *prob = NULL;
1766 /* If PROBE is not NULL, then this is the objfile in which the probe
1767 originated. */
1768 struct objfile *objfile = NULL;
1769 };
1770
1771
1772
1773 /* Given a pc value, return line number it is in. Second arg nonzero means
1774 if pc is on the boundary use the previous statement's line number. */
1775
1776 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1777
1778 /* Same function, but specify a section as well as an address. */
1779
1780 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1781 struct obj_section *, int);
1782
1783 /* Wrapper around find_pc_line to just return the symtab. */
1784
1785 extern struct symtab *find_pc_line_symtab (CORE_ADDR);
1786
1787 /* Given a symtab and line number, return the pc there. */
1788
1789 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1790
1791 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1792 CORE_ADDR *);
1793
1794 extern void resolve_sal_pc (struct symtab_and_line *);
1795
1796 /* solib.c */
1797
1798 extern void clear_solib (void);
1799
1800 /* source.c */
1801
1802 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1803
1804 /* Flags passed as 4th argument to print_source_lines. */
1805
1806 enum print_source_lines_flag
1807 {
1808 /* Do not print an error message. */
1809 PRINT_SOURCE_LINES_NOERROR = (1 << 0),
1810
1811 /* Print the filename in front of the source lines. */
1812 PRINT_SOURCE_LINES_FILENAME = (1 << 1)
1813 };
1814 DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags);
1815
1816 extern void print_source_lines (struct symtab *, int, int,
1817 print_source_lines_flags);
1818
1819 extern void forget_cached_source_info_for_objfile (struct objfile *);
1820 extern void forget_cached_source_info (void);
1821
1822 extern void select_source_symtab (struct symtab *);
1823
1824 /* The reason we're calling into a completion match list collector
1825 function. */
1826 enum class complete_symbol_mode
1827 {
1828 /* Completing an expression. */
1829 EXPRESSION,
1830
1831 /* Completing a linespec. */
1832 LINESPEC,
1833 };
1834
1835 extern void default_collect_symbol_completion_matches_break_on
1836 (completion_tracker &tracker,
1837 complete_symbol_mode mode,
1838 symbol_name_match_type name_match_type,
1839 const char *text, const char *word, const char *break_on,
1840 enum type_code code);
1841 extern void default_collect_symbol_completion_matches
1842 (completion_tracker &tracker,
1843 complete_symbol_mode,
1844 symbol_name_match_type name_match_type,
1845 const char *,
1846 const char *,
1847 enum type_code);
1848 extern void collect_symbol_completion_matches
1849 (completion_tracker &tracker,
1850 complete_symbol_mode mode,
1851 symbol_name_match_type name_match_type,
1852 const char *, const char *);
1853 extern void collect_symbol_completion_matches_type (completion_tracker &tracker,
1854 const char *, const char *,
1855 enum type_code);
1856
1857 extern void collect_file_symbol_completion_matches
1858 (completion_tracker &tracker,
1859 complete_symbol_mode,
1860 symbol_name_match_type name_match_type,
1861 const char *, const char *, const char *);
1862
1863 extern completion_list
1864 make_source_files_completion_list (const char *, const char *);
1865
1866 /* Return whether SYM is a function/method, as opposed to a data symbol. */
1867
1868 extern bool symbol_is_function_or_method (symbol *sym);
1869
1870 /* Return whether MSYMBOL is a function/method, as opposed to a data
1871 symbol */
1872
1873 extern bool symbol_is_function_or_method (minimal_symbol *msymbol);
1874
1875 /* Return whether SYM should be skipped in completion mode MODE. In
1876 linespec mode, we're only interested in functions/methods. */
1877
1878 template<typename Symbol>
1879 static bool
1880 completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
1881 {
1882 return (mode == complete_symbol_mode::LINESPEC
1883 && !symbol_is_function_or_method (sym));
1884 }
1885
1886 /* symtab.c */
1887
1888 int matching_obj_sections (struct obj_section *, struct obj_section *);
1889
1890 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1891
1892 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1893 int);
1894
1895 extern void skip_prologue_sal (struct symtab_and_line *);
1896
1897 /* symtab.c */
1898
1899 extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1900 CORE_ADDR func_addr);
1901
1902 extern struct symbol *fixup_symbol_section (struct symbol *,
1903 struct objfile *);
1904
1905 /* If MSYMBOL is an text symbol, look for a function debug symbol with
1906 the same address. Returns NULL if not found. This is necessary in
1907 case a function is an alias to some other function, because debug
1908 information is only emitted for the alias target function's
1909 definition, not for the alias. */
1910 extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
1911
1912 /* Symbol searching */
1913 /* Note: struct symbol_search, search_symbols, et.al. are declared here,
1914 instead of making them local to symtab.c, for gdbtk's sake. */
1915
1916 /* When using search_symbols, a vector of the following structs is
1917 returned. */
1918 struct symbol_search
1919 {
1920 symbol_search (int block_, struct symbol *symbol_)
1921 : block (block_),
1922 symbol (symbol_)
1923 {
1924 msymbol.minsym = nullptr;
1925 msymbol.objfile = nullptr;
1926 }
1927
1928 symbol_search (int block_, struct minimal_symbol *minsym,
1929 struct objfile *objfile)
1930 : block (block_),
1931 symbol (nullptr)
1932 {
1933 msymbol.minsym = minsym;
1934 msymbol.objfile = objfile;
1935 }
1936
1937 bool operator< (const symbol_search &other) const
1938 {
1939 return compare_search_syms (*this, other) < 0;
1940 }
1941
1942 bool operator== (const symbol_search &other) const
1943 {
1944 return compare_search_syms (*this, other) == 0;
1945 }
1946
1947 /* The block in which the match was found. Could be, for example,
1948 STATIC_BLOCK or GLOBAL_BLOCK. */
1949 int block;
1950
1951 /* Information describing what was found.
1952
1953 If symbol is NOT NULL, then information was found for this match. */
1954 struct symbol *symbol;
1955
1956 /* If msymbol is non-null, then a match was made on something for
1957 which only minimal_symbols exist. */
1958 struct bound_minimal_symbol msymbol;
1959
1960 private:
1961
1962 static int compare_search_syms (const symbol_search &sym_a,
1963 const symbol_search &sym_b);
1964 };
1965
1966 extern std::vector<symbol_search> search_symbols (const char *,
1967 enum search_domain, int,
1968 const char **);
1969
1970 /* The name of the ``main'' function.
1971 FIXME: cagney/2001-03-20: Can't make main_name() const since some
1972 of the calling code currently assumes that the string isn't
1973 const. */
1974 extern /*const */ char *main_name (void);
1975 extern enum language main_language (void);
1976
1977 /* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
1978 This searches MAIN_OBJFILE as well as any associated separate debug info
1979 objfiles of MAIN_OBJFILE.
1980 Upon success fixes up the symbol's section if necessary. */
1981
1982 extern struct block_symbol
1983 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
1984 const char *name,
1985 const domain_enum domain);
1986
1987 /* Return 1 if the supplied producer string matches the ARM RealView
1988 compiler (armcc). */
1989 int producer_is_realview (const char *producer);
1990
1991 void fixup_section (struct general_symbol_info *ginfo,
1992 CORE_ADDR addr, struct objfile *objfile);
1993
1994 /* Look up objfile containing BLOCK. */
1995
1996 struct objfile *lookup_objfile_from_block (const struct block *block);
1997
1998 extern unsigned int symtab_create_debug;
1999
2000 extern unsigned int symbol_lookup_debug;
2001
2002 extern int basenames_may_differ;
2003
2004 int compare_filenames_for_search (const char *filename,
2005 const char *search_name);
2006
2007 int compare_glob_filenames_for_search (const char *filename,
2008 const char *search_name);
2009
2010 bool iterate_over_some_symtabs (const char *name,
2011 const char *real_path,
2012 struct compunit_symtab *first,
2013 struct compunit_symtab *after_last,
2014 gdb::function_view<bool (symtab *)> callback);
2015
2016 void iterate_over_symtabs (const char *name,
2017 gdb::function_view<bool (symtab *)> callback);
2018
2019
2020 std::vector<CORE_ADDR> find_pcs_for_symtab_line
2021 (struct symtab *symtab, int line, struct linetable_entry **best_entry);
2022
2023 /* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
2024 is called once per matching symbol SYM. The callback should return
2025 true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
2026 iterating, or false to indicate that the iteration should end. */
2027
2028 typedef bool (symbol_found_callback_ftype) (symbol *sym);
2029
2030 void iterate_over_symbols (const struct block *block,
2031 const lookup_name_info &name,
2032 const domain_enum domain,
2033 gdb::function_view<symbol_found_callback_ftype> callback);
2034
2035 /* Storage type used by demangle_for_lookup. demangle_for_lookup
2036 either returns a const char * pointer that points to either of the
2037 fields of this type, or a pointer to the input NAME. This is done
2038 this way because the underlying functions that demangle_for_lookup
2039 calls either return a std::string (e.g., cp_canonicalize_string) or
2040 a malloc'ed buffer (libiberty's demangled), and we want to avoid
2041 unnecessary reallocation/string copying. */
2042 class demangle_result_storage
2043 {
2044 public:
2045
2046 /* Swap the std::string storage with STR, and return a pointer to
2047 the beginning of the new string. */
2048 const char *swap_string (std::string &str)
2049 {
2050 std::swap (m_string, str);
2051 return m_string.c_str ();
2052 }
2053
2054 /* Set the malloc storage to now point at PTR. Any previous malloc
2055 storage is released. */
2056 const char *set_malloc_ptr (char *ptr)
2057 {
2058 m_malloc.reset (ptr);
2059 return ptr;
2060 }
2061
2062 private:
2063
2064 /* The storage. */
2065 std::string m_string;
2066 gdb::unique_xmalloc_ptr<char> m_malloc;
2067 };
2068
2069 const char *
2070 demangle_for_lookup (const char *name, enum language lang,
2071 demangle_result_storage &storage);
2072
2073 struct symbol *allocate_symbol (struct objfile *);
2074
2075 void initialize_objfile_symbol (struct symbol *);
2076
2077 struct template_symbol *allocate_template_symbol (struct objfile *);
2078
2079 /* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
2080 SYMNAME (which is already demangled for C++ symbols) matches
2081 SYM_TEXT in the first SYM_TEXT_LEN characters. If so, add it to
2082 the current completion list. */
2083 void completion_list_add_name (completion_tracker &tracker,
2084 language symbol_language,
2085 const char *symname,
2086 const lookup_name_info &lookup_name,
2087 const char *text, const char *word);
2088
2089 #endif /* !defined(SYMTAB_H) */
symbol_block_ops
Definition: symtab.h:979
symbol_is_function_or_method
bool symbol_is_function_or_method(symbol *sym)
Definition: symtab.c:4918
gdbarch
Definition: gdbarch.c:127
domain_enum_tag
domain_enum_tag
Definition: symtab.h:728
string
const char * string
Definition: signals.c:50
template_symbol::n_template_arguments
int n_template_arguments
Definition: symtab.h:1206
probe
Definition: probe.h:112
lookup_name_info::ada
const ada_lookup_name_info & ada() const
Definition: symtab.h:240
symbol_impl::ops_register
const struct symbol_register_ops * ops_register
Definition: symtab.h:1029
axs_value
Definition: ax-gdb.h:77
template_symbol
Definition: symtab.h:1203
symbol_set_symtab
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:5812
type_code
type_code
Definition: gdbtypes.h:80
symbol::owner
union symbol::@173 owner
ada_lookup_name_info::verbatim_p
bool verbatim_p() const
Definition: symtab.h:114
find_line_symtab
struct symtab * find_line_symtab(struct symtab *, int, int *, int *)
Definition: symtab.c:3322
symbol_natural_name
const char * symbol_natural_name(const struct general_symbol_info *symbol)
Definition: symtab.c:891
completer.h
symtab::next
struct symtab * next
Definition: symtab.h:1296
compunit_primary_filetab
struct symtab * compunit_primary_filetab(const struct compunit_symtab *cust)
Definition: symtab.c:292
symbol_search::operator==
bool operator==(const symbol_search &other) const
Definition: symtab.h:1942
symbol_search::block
int block
Definition: symtab.h:1949
section_offsets::offsets
CORE_ADDR offsets[1]
Definition: symtab.h:1273
find_function_start_sal
struct symtab_and_line find_function_start_sal(struct symbol *sym, int)
Definition: symtab.c:3585
print_source_lines
void print_source_lines(struct symtab *, int, int, print_source_lines_flags)
Definition: source.c:1471
lookup_symbol_search_name
struct block_symbol lookup_symbol_search_name(const char *search_name, const struct block *block, domain_enum domain)
Definition: symtab.c:1905
minimal_symbol::hash_next
struct minimal_symbol * hash_next
Definition: symtab.h:662
lookup_name_info::m_ada
gdb::optional< ada_lookup_name_info > m_ada
Definition: symtab.h:292
minimal_symbol::target_flag_1
unsigned int target_flag_1
Definition: symtab.h:651
compunit_symtab::blockvector
const struct blockvector * blockvector
Definition: symtab.h:1420
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
linetable::item
struct linetable_entry item[1]
Definition: symtab.h:1258
mst_bss
Definition: symtab.h:587
reread_symbols
void reread_symbols(void)
Definition: symfile.c:2411
symbol_computed_ops::describe_location
void(* describe_location)(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
Definition: symtab.h:943
register_symbol_register_impl
int register_symbol_register_impl(enum address_class, const struct symbol_register_ops *)
Definition: symtab.c:5707
null_block_symbol
const struct block_symbol null_block_symbol
Definition: symtab.c:96
LOC_BLOCK
Definition: symtab.h:854
clear_pc_function_cache
void clear_pc_function_cache(void)
Definition: blockframe.c:167
ada_lookup_name_info::wild_match_p
bool wild_match_p() const
Definition: symtab.h:105
symbol::symtab
struct symtab * symtab
Definition: symtab.h:1068
iterate_over_symtabs
void iterate_over_symtabs(const char *name, gdb::function_view< bool(symtab *)> callback)
Definition: symtab.c:462
SYMBOL_DOMAIN_BITS
#define SYMBOL_DOMAIN_BITS
Definition: symtab.h:765
demangle_result_storage::set_malloc_ptr
const char * set_malloc_ptr(char *ptr)
Definition: symtab.h:2056
function-view.h
cmd_list_element
Definition: cli-decode.h:46
symbol::hash_next
struct symbol * hash_next
Definition: symtab.h:1127
symbol_search
Definition: symtab.h:1918
symbol_impl::aclass
enum address_class aclass
Definition: symtab.h:1020
symtab_and_line::end
CORE_ADDR end
Definition: symtab.h:1760
demangle_for_lookup_info::lookup_name
const std::string & lookup_name() const
Definition: symtab.h:159
enum-flags.h
register_symbol_block_impl
int register_symbol_block_impl(enum address_class aclass, const struct symbol_block_ops *ops)
Definition: symtab.c:5684
main_name
char * main_name(void)
Definition: symtab.c:5568
compunit_symtab::epilogue_unwind_valid
unsigned int epilogue_unwind_valid
Definition: symtab.h:1433
lookup_name_info::completion_mode
bool completion_mode() const
Definition: symtab.h:195
complete_symbol_mode
complete_symbol_mode
Definition: symtab.h:1826
LOC_FINAL_VALUE
Definition: symtab.h:899
domain_enum
enum domain_enum_tag domain_enum
lookup_transparent_type
struct type * lookup_transparent_type(const char *)
Definition: symtab.c:2722
LOC_COMMON_BLOCK
Definition: symtab.h:896
lookup_symbol_in_block
struct symbol * lookup_symbol_in_block(const char *name, symbol_name_match_type match_type, const struct block *block, const domain_enum domain)
Definition: symtab.c:2190
symbol_computed_ops::generate_c_location
void(* generate_c_location)(struct symbol *symbol, string_file &stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name)
Definition: symtab.h:968
symbol_search_name
const char * symbol_search_name(const struct general_symbol_info *ginfo)
Definition: symtab.c:943
search_symbols
std::vector< symbol_search > search_symbols(const char *, enum search_domain, int, const char **)
symbol_matches_search_name
bool symbol_matches_search_name(const struct general_symbol_info *gsymbol, const lookup_name_info &name)
Definition: symtab.c:954
ada_lookup_name_info
Definition: symtab.h:86
LOC_UNDEF
Definition: symtab.h:797
symtab::line_charpos
int * line_charpos
Definition: symtab.h:1319
symbol::aux_value
void * aux_value
Definition: symtab.h:1125
general_symbol_info::value
union general_symbol_info::@171 value
template_symbol::template_arguments
struct symbol ** template_arguments
Definition: symtab.h:1210
symbol_name_matcher_ftype
bool() symbol_name_matcher_ftype(const char *symbol_search_name, const lookup_name_info &lookup_name, completion_match_result *comp_match_res)
Definition: symtab.h:324
ALL_DOMAIN
Definition: symtab.h:786
general_symbol_info::section
short section
Definition: symtab.h:443
minimal_symbol::type
__extension__ enum minimal_symbol_type type
Definition: symtab.h:644
agent_expr
Definition: ax.h:83
frame_info
Definition: frame.c:85
symbol_search::operator<
bool operator<(const symbol_search &other) const
Definition: symtab.h:1937
mst_abs
Definition: symtab.h:588
demangle_for_lookup_info
Definition: symtab.h:152
compunit_symtab
Definition: symtab.h:1380
symbol_register_ops
Definition: symtab.h:1010
UNDEF_DOMAIN
Definition: symtab.h:734
LOC_TYPEDEF
Definition: symtab.h:844
gnu_ifunc_fns::gnu_ifunc_resolve_name
int(* gnu_ifunc_resolve_name)(const char *function_name, CORE_ADDR *function_address_p)
Definition: symtab.h:1726
symbol_computed_ops::location_has_loclist
unsigned char location_has_loclist
Definition: symtab.h:947
symtab_and_line::section
struct obj_section * section
Definition: symtab.h:1753
symbol::line
unsigned short line
Definition: symtab.h:1111
mst_text_gnu_ifunc
Definition: symtab.h:583
lookup_name_info::m_d
gdb::optional< demangle_for_lookup_info > m_d
Definition: symtab.h:294
symtab::filename
const char * filename
Definition: symtab.h:1309
search_domain
search_domain
Definition: symtab.h:773
find_pc_sect_function
struct symbol * find_pc_sect_function(CORE_ADDR, struct obj_section *)
Definition: blockframe.c:136
compunit_symtab::producer
const char * producer
Definition: symtab.h:1413
minimal_symbol::size
unsigned long size
Definition: symtab.h:637
STRUCT_DOMAIN
Definition: symtab.h:745
demangle_result_storage
Definition: symtab.h:2042
common_block
Definition: f-lang.h:42
ui_file
Definition: ui-file.h:26
mst_file_data
Definition: symtab.h:601
symbol_search::symbol_search
symbol_search(int block_, struct minimal_symbol *minsym, struct objfile *objfile)
Definition: symtab.h:1928
find_symbol_at_address
struct symbol * find_symbol_at_address(CORE_ADDR)
Definition: symtab.c:2996
in_gnu_ifunc_stub
int in_gnu_ifunc_stub(CORE_ADDR pc)
Definition: minsyms.c:945
general_symbol_info::obstack
struct obstack * obstack
Definition: symtab.h:420
multiple_symbols_ask
const char multiple_symbols_ask[]
Definition: symtab.c:237
lookup_symbol_in_language
struct block_symbol lookup_symbol_in_language(const char *, const struct block *, const domain_enum, enum language, struct field_of_this_result *)
Definition: symtab.c:1877
macro_table
Definition: macrotab.c:35
SYMBOL_RUST_VTABLE
Definition: symtab.h:1044
MINSYM_TYPE_BITS
#define MINSYM_TYPE_BITS
Definition: symtab.h:608
symbol::aclass_index
unsigned int aclass_index
Definition: symtab.h:1082
LOC_ARG
Definition: symtab.h:823
compunit_symtab::name
const char * name
Definition: symtab.h:1391
skip_prologue_using_sal
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3854
symbol_search::compare_search_syms
static int compare_search_syms(const symbol_search &sym_a, const symbol_search &sym_b)
Definition: symtab.c:4227
compunit_symtab_ptr
struct compunit_symtab * compunit_symtab_ptr
Definition: symtab.h:1486
NR_DOMAINS
Definition: symtab.h:760
LABEL_DOMAIN
Definition: symtab.h:753
symtab::linetable
struct linetable * linetable
Definition: symtab.h:1305
symbol_impl::ops_block
const struct symbol_block_ops * ops_block
Definition: symtab.h:1026
fn_fieldlist
Definition: gdbtypes.h:812
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR, const char **, CORE_ADDR *, CORE_ADDR *)
Definition: blockframe.c:320
LOC_LOCAL
Definition: symtab.h:839
completion_match_result
Definition: completer.h:205
ada_lookup_name_info::ada_lookup_name_info
ada_lookup_name_info(const lookup_name_info &lookup_name)
Definition: ada-lang.c:14354
language_defn
Definition: language.h:132
LOC_REGISTER
Definition: symtab.h:819
symbol::subclass
__extension__ enum symbol_subclass_kind subclass
Definition: symtab.h:1098
lookup_name_info::match_type
symbol_name_match_type match_type() const
Definition: symtab.h:194
symtab_and_line::explicit_line
bool explicit_line
Definition: symtab.h:1762
symbol_lookup_debug
unsigned int symbol_lookup_debug
Definition: symtab.c:218
symbol_search::symbol_search
symbol_search(int block_, struct symbol *symbol_)
Definition: symtab.h:1920
compunit_symtab::objfile
struct objfile * objfile
Definition: symtab.h:1386
symbol_arch
struct gdbarch * symbol_arch(const struct symbol *symbol)
Definition: symtab.c:5793
field_of_this_result::fn_field
struct fn_fieldlist * fn_field
Definition: symtab.h:1545
symbol_needs_kind
symbol_needs_kind
Definition: defs.h:544
name
const char *const name
Definition: aarch64-tdep.c:76
collect_symbol_completion_matches_type
void collect_symbol_completion_matches_type(completion_tracker &tracker, const char *, const char *, enum type_code)
Definition: symtab.c:5221
multiple_symbols_select_mode
const char * multiple_symbols_select_mode(void)
Definition: symtab.c:252
compunit_symtab::includes
struct compunit_symtab ** includes
Definition: symtab.h:1451
FUNCTIONS_DOMAIN
Definition: symtab.h:780
symbol_block_ops::find_frame_base_location
void(* find_frame_base_location)(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: symtab.h:985
minimal_symbol::created_by_gdb
unsigned int created_by_gdb
Definition: symtab.h:648
demangle
int demangle
Definition: demangle.c:47
symbol_demangled_name
const char * symbol_demangled_name(const struct general_symbol_info *symbol)
Definition: symtab.c:915
find_pc_line_symtab
struct symtab * find_pc_line_symtab(CORE_ADDR)
Definition: symtab.c:3301
gdb_optional.h
lookup_symtab
struct symtab * lookup_symtab(const char *)
Definition: symtab.c:502
section_offsets
Definition: symtab.h:1271
minsyms.h
LOC_CONST_BYTES
Definition: symtab.h:859
LOC_COMPUTED
Definition: symtab.h:892
demangle_result_storage::m_string
std::string m_string
Definition: symtab.h:2065
symbol_impls
const struct symbol_impl * symbol_impls
Definition: symtab.c:5646
allocate_symbol
struct symbol * allocate_symbol(struct objfile *)
Definition: symtab.c:5757
expand_symtab_containing_pc
void expand_symtab_containing_pc(CORE_ADDR, struct obj_section *)
Definition: symtab.c:1032
completion_list_add_name
void completion_list_add_name(completion_tracker &tracker, language symbol_language, const char *symname, const lookup_name_info &lookup_name, const char *text, const char *word)
Definition: symtab.c:4717
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
minimal_symbol::demangled_hash_next
struct minimal_symbol * demangled_hash_next
Definition: symtab.h:667
find_pc_line_pc_range
int find_pc_line_pc_range(CORE_ADDR, CORE_ADDR *, CORE_ADDR *)
Definition: symtab.c:3567
MODULE_DOMAIN
Definition: symtab.h:749
symtab_ptr
struct symtab * symtab_ptr
Definition: symtab.h:1342
ada_lookup_name_info::m_wild_match_p
bool m_wild_match_p
Definition: symtab.h:128
linetable_entry::pc
CORE_ADDR pc
Definition: symtab.h:1231
mst_data
Definition: symtab.h:586
compare_glob_filenames_for_search
int compare_glob_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:356
language_ada
Definition: defs.h:219
COMMON_BLOCK_DOMAIN
Definition: symtab.h:757
symbol_register_ops::register_number
int(* register_number)(struct symbol *symbol, struct gdbarch *gdbarch)
Definition: symtab.h:1012
collect_file_symbol_completion_matches
void collect_file_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode, symbol_name_match_type name_match_type, const char *, const char *, const char *)
Definition: symtab.c:5240
mst_slot_got_plt
Definition: symtab.h:585
TYPES_DOMAIN
Definition: symtab.h:783
block_symbol::block
const struct block * block
Definition: symtab.h:1140
bound_minimal_symbol
Definition: minsyms.h:29
compunit_symtab::dirname
const char * dirname
Definition: symtab.h:1416
minimal_symbol::filename
const char * filename
Definition: symtab.h:640
lookup_name_info::match_any
static const lookup_name_info & match_any()
Definition: symtab.c:1794
completion_list
std::vector< gdb::unique_xmalloc_ptr< char > > completion_list
Definition: completer.h:69
linetable
Definition: symtab.h:1251
symbol_computed_ops::tracepoint_var_ref
void(* tracepoint_var_ref)(struct symbol *symbol, struct agent_expr *ax, struct axs_value *value)
Definition: symtab.h:956
symbol_block_ops::get_frame_base
CORE_ADDR(* get_frame_base)(struct symbol *framefunc, struct frame_info *frame)
Definition: symtab.h:1004
block_symbol
Definition: symtab.h:1133
lookup_name_info::d
const demangle_for_lookup_info & d() const
Definition: symtab.h:254
find_pc_partial_function_gnu_ifunc
int find_pc_partial_function_gnu_ifunc(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, int *is_gnu_ifunc_p)
Definition: blockframe.c:191
select_source_symtab
void select_source_symtab(struct symtab *)
Definition: source.c:247
iterate_over_symbols
void iterate_over_symbols(const struct block *block, const lookup_name_info &name, const domain_enum domain, gdb::function_view< symbol_found_callback_ftype > callback)
Definition: symtab.c:2849
collect_symbol_completion_matches
void collect_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *, const char *)
Definition: symtab.c:5206
default_collect_symbol_completion_matches
void default_collect_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode, symbol_name_match_type name_match_type, const char *, const char *, enum type_code)
Definition: symtab.c:5190
breakpoint
Definition: breakpoint.h:684
compunit_symtab::call_site_htab
htab_t call_site_htab
Definition: symtab.h:1436
ada_lookup_name_info::standard_p
bool standard_p() const
Definition: symtab.h:110
ada_lookup_name_info::m_standard_p
bool m_standard_p
Definition: symtab.h:145
compunit_symtab::locations_valid
unsigned int locations_valid
Definition: symtab.h:1429
find_pc_function
struct symbol * find_pc_function(CORE_ADDR)
Definition: blockframe.c:150
linetable_entry
Definition: symtab.h:1228
type
Definition: gdbtypes.h:749
completion_skip_symbol
static bool completion_skip_symbol(complete_symbol_mode mode, Symbol *sym)
Definition: symtab.h:1880
forget_cached_source_info_for_objfile
void forget_cached_source_info_for_objfile(struct objfile *)
Definition: source.c:360
DEF_VEC_P
DEF_VEC_P(symtab_ptr)
demangle_for_lookup_info::demangle_for_lookup_info
demangle_for_lookup_info(const lookup_name_info &lookup_name, language lang)
Definition: symtab.c:1765
LOC_CONST
Definition: symtab.h:801
LOC_UNRESOLVED
Definition: symtab.h:883
lookup_name_info::ignore_parameters
const bool ignore_parameters() const
Definition: symtab.h:197
lookup_name_info::m_go
gdb::optional< demangle_for_lookup_info > m_go
Definition: symtab.h:295
general_symbol_info::language_specific
union general_symbol_info::@172 language_specific
lookup_union
struct type * lookup_union(const char *, const struct block *)
Definition: gdbtypes.c:1578
symtab::language
enum language language
Definition: symtab.h:1323
ada_lookup_name_info::m_encoded_name
std::string m_encoded_name
Definition: symtab.h:119
gdb_static_assert
gdb_static_assert(nr_minsym_types<=(1<< MINSYM_TYPE_BITS))
find_line_pc_range
int find_line_pc_range(struct symtab_and_line, CORE_ADDR *, CORE_ADDR *)
Definition: symtab.c:3483
address_class
address_class
Definition: symtab.h:793
symbol_objfile
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:5784
SYMBOL_ACLASS_BITS
#define SYMBOL_ACLASS_BITS
Definition: symtab.h:908
field
Definition: gdbtypes.h:517
rust_vtable_symbol
Definition: symtab.h:1215
general_symbol_info::block
const struct block * block
Definition: symtab.h:396
matching_obj_sections
int matching_obj_sections(struct obj_section *, struct obj_section *)
Definition: symtab.c:969
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
basenames_may_differ
int basenames_may_differ
Definition: symtab.c:231
symtab::nlines
int nlines
Definition: symtab.h:1313
compunit_symtab::block_line_section
int block_line_section
Definition: symtab.h:1424
lookup_name_info::m_match_type
symbol_name_match_type m_match_type
Definition: symtab.h:281
demangle_result_storage::m_malloc
gdb::unique_xmalloc_ptr< char > m_malloc
Definition: symtab.h:2066
LOC_STATIC
Definition: symtab.h:805
find_pc_sect_compunit_symtab
struct compunit_symtab * find_pc_sect_compunit_symtab(CORE_ADDR, struct obj_section *)
Definition: symtab.c:2872
currently_reading_symtab
int currently_reading_symtab
Definition: symfile.c:179
complete_symbol_mode::LINESPEC
lookup_name_info::go
const demangle_for_lookup_info & go() const
Definition: symtab.h:261
compunit_symtab::next
struct compunit_symtab * next
Definition: symtab.h:1383
lookup_enum
struct type * lookup_enum(const char *, const struct block *)
Definition: gdbtypes.c:1602
lookup_global_symbol_from_objfile
struct block_symbol lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2226
general_symbol_info::bytes
const gdb_byte * bytes
Definition: symtab.h:398
demangle_for_lookup
const char * demangle_for_lookup(const char *name, enum language lang, demangle_result_storage &storage)
Definition: symtab.c:1823
domain_name
const char * domain_name(domain_enum)
Definition: symtab.c:260
symbol::is_inlined
unsigned is_inlined
Definition: symtab.h:1094
resolve_sal_pc
void resolve_sal_pc(struct symtab_and_line *)
Definition: breakpoint.c:9543
demangle_result_storage::swap_string
const char * swap_string(std::string &str)
Definition: symtab.h:2048
gnu_ifunc_fns::gnu_ifunc_resolver_stop
void(* gnu_ifunc_resolver_stop)(struct breakpoint *b)
Definition: symtab.h:1730
symtab
Definition: symtab.h:1291
LOC_REGPARM_ADDR
Definition: symtab.h:835
register_symbol_computed_impl
int register_symbol_computed_impl(enum address_class, const struct symbol_computed_ops *)
Definition: symtab.c:5658
basic_lookup_symbol_nonlocal
struct block_symbol basic_lookup_symbol_nonlocal(const struct language_defn *langdef, const char *, const struct block *, const domain_enum)
Definition: symtab.c:2417
lookup_name_info::m_completion_mode
bool m_completion_mode
Definition: symtab.h:282
identify_source_line
int identify_source_line(struct symtab *, int, int, CORE_ADDR)
Definition: source.c:1295
find_solib_trampoline_target
CORE_ADDR find_solib_trampoline_target(struct frame_info *, CORE_ADDR)
Definition: minsyms.c:1492
symbol_overlayed_address
CORE_ADDR symbol_overlayed_address(CORE_ADDR, struct obj_section *)
Definition: symfile.c:3143
language_d
Definition: defs.h:210
compunit_symtab::last_filetab
struct symtab * last_filetab
Definition: symtab.h:1404
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
general_symbol_info::name
const char * name
Definition: symtab.h:384
minimal_symbol::mginfo
struct general_symbol_info mginfo
Definition: symtab.h:631
LOC_REF_ARG
Definition: symtab.h:827
block
Definition: block.h:60
lookup_global_symbol
struct block_symbol lookup_global_symbol(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2651
field_of_this_result::type
struct type * type
Definition: symtab.h:1535
value
Definition: value.c:169
ada_lookup_name_info::m_encoded_p
bool m_encoded_p
Definition: symtab.h:124
basic_lookup_transparent_type
struct type * basic_lookup_transparent_type(const char *)
Definition: symtab.c:2792
blockvector
Definition: block.h:112
lookup_name_info::maybe_init
void maybe_init(Field &field, Args &&... args) const
Definition: symtab.h:274
gnu_ifunc_fns_p
const struct gnu_ifunc_fns * gnu_ifunc_fns_p
Definition: minsyms.c:1003
lookup_name_info::language_lookup_name
const std::string & language_lookup_name(language lang) const
Definition: symtab.h:222
lookup_symbol_in_static_block
struct block_symbol lookup_symbol_in_static_block(const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2487
objfile
Definition: objfiles.h:286
symtab_and_line
Definition: symtab.h:1746
lookup_name_info::m_demangled_hashes
std::array< unsigned int, nr_languages > m_demangled_hashes
Definition: symtab.h:302
search_domain_name
const char * search_domain_name(enum search_domain)
Definition: symtab.c:277
lookup_name_info::m_ignore_parameters
bool m_ignore_parameters
Definition: symtab.h:283
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
VARIABLES_DOMAIN
Definition: symtab.h:777
lookup_name_info::search_name_hash
unsigned int search_name_hash(language lang) const
Definition: symtab.h:209
gnu_ifunc_fns
Definition: symtab.h:1720
rust_vtable_symbol::concrete_type
struct type * concrete_type
Definition: symtab.h:1219
gnu_ifunc_fns::gnu_ifunc_resolver_return_stop
void(* gnu_ifunc_resolver_return_stop)(struct breakpoint *b)
Definition: symtab.h:1733
find_pc_sect_line
struct symtab_and_line find_pc_sect_line(CORE_ADDR, struct obj_section *, int)
Definition: symtab.c:3051
lookup_name_info::make_ignore_params
lookup_name_info make_ignore_params() const
Definition: symtab.h:202
lookup_name_info::cplus
const demangle_for_lookup_info & cplus() const
Definition: symtab.h:247
symbol::type
struct type * type
Definition: symtab.h:1058
producer_is_realview
int producer_is_realview(const char *producer)
Definition: symtab.c:5605
multiple_symbols_cancel
const char multiple_symbols_cancel[]
Definition: symtab.c:239
compunit_symtab::macro_table
struct macro_table * macro_table
Definition: symtab.h:1442
ada_lookup_name_info::matches
bool matches(const char *symbol_search_name, symbol_name_match_type match_type, completion_match_result *comp_match_res) const
Definition: ada-lang.c:6380
compunit_symtab::filetabs
struct symtab * filetabs
Definition: symtab.h:1397
lookup_static_symbol
struct block_symbol lookup_static_symbol(const char *name, const domain_enum domain)
Definition: symtab.c:2574
linespec_complete_what::EXPRESSION
compunit_symtab::debugformat
const char * debugformat
Definition: symtab.h:1410
gnu_ifunc_fns::gnu_ifunc_resolve_addr
CORE_ADDR(* gnu_ifunc_resolve_addr)(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: symtab.h:1723
symbol_search::msymbol
struct bound_minimal_symbol msymbol
Definition: symtab.h:1958
gdb::optional< ada_lookup_name_info >
gdb::function_view
Definition: function-view.h:177
lookup_name_info::name
const std::string & name() const
Definition: symtab.h:196
symbol::is_objfile_owned
unsigned int is_objfile_owned
Definition: symtab.h:1087
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR, int)
Definition: symtab.c:3288
general_symbol_info
Definition: symtab.h:376
symbol_set_demangled_name
void symbol_set_demangled_name(struct general_symbol_info *, const char *, struct obstack *)
Definition: symtab.c:606
symbol_name_match_type::SEARCH_NAME
field_of_this_result::field
struct field * field
Definition: symtab.h:1540
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
symbol_matches_domain
int symbol_matches_domain(enum language symbol_language, domain_enum symbol_domain, domain_enum domain)
Definition: symtab.c:2700
general_symbol_info::language
__extension__ enum language language
Definition: symtab.h:432
lookup_name_info::m_cplus
gdb::optional< demangle_for_lookup_info > m_cplus
Definition: symtab.h:293
symbol
const char * symbol
Definition: signals.c:48
minimal_symbol::target_flag_2
unsigned int target_flag_2
Definition: symtab.h:652
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
mst_unknown
Definition: symtab.h:581
language_go
Definition: defs.h:211
symbol_search::symbol
struct symbol * symbol
Definition: symtab.h:1954
gdb_vecs.h
fixup_symbol_section
struct symbol * fixup_symbol_section(struct symbol *, struct objfile *)
Definition: symtab.c:1718
find_line_pc
int find_line_pc(struct symtab *, int, CORE_ADDR *)
Definition: symtab.c:3456
code
int code
Definition: ser-unix.c:239
lookup_struct
struct type * lookup_struct(const char *, const struct block *)
Definition: gdbtypes.c:1556
symbol::ginfo
struct general_symbol_info ginfo
Definition: symtab.h:1054
symbol_get_demangled_name
const char * symbol_get_demangled_name(const struct general_symbol_info *)
Definition: symtab.c:630
general_symbol_info::ada_mangled
unsigned int ada_mangled
Definition: symtab.h:437
symtab_create_debug
unsigned int symtab_create_debug
Definition: symtab.c:215
symtab_and_line::prob
probe * prob
Definition: symtab.h:1765
LOC_LABEL
Definition: symtab.h:848
mst_text
Definition: symtab.h:582
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
minimal_symbol::has_size
unsigned int has_size
Definition: symtab.h:657
symtab::compunit_symtab
struct compunit_symtab * compunit_symtab
Definition: symtab.h:1300
symbol_set_language
void symbol_set_language(struct general_symbol_info *symbol, enum language language, struct obstack *obstack)
Definition: symtab.c:647
VAR_DOMAIN
Definition: symtab.h:739
mst_solib_trampoline
Definition: symtab.h:597
lookup_objfile_from_block
struct objfile * lookup_objfile_from_block(const struct block *block)
Definition: symtab.c:2164
clear_solib
void clear_solib(void)
Definition: solib.c:1203
symbol::arch
struct gdbarch * arch
Definition: symtab.h:1071
LANGUAGE_BITS
#define LANGUAGE_BITS
Definition: defs.h:225
allocate_template_symbol
struct template_symbol * allocate_template_symbol(struct objfile *)
Definition: symtab.c:5771
gdbtypes.h
lookup_name_info::lookup_name_info
lookup_name_info(std::string name, symbol_name_match_type match_type, bool completion_mode=false, bool ignore_parameters=false)
Definition: symtab.h:183
default_collect_symbol_completion_matches_break_on
void default_collect_symbol_completion_matches_break_on(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word, const char *break_on, enum type_code code)
Definition: symtab.c:4986
forget_cached_source_info
void forget_cached_source_info(void)
Definition: source.c:388
language
language
Definition: defs.h:203
general_symbol_info::address
CORE_ADDR address
Definition: symtab.h:400
nr_minsym_types
Definition: symtab.h:603
iterate_over_some_symtabs
bool iterate_over_some_symtabs(const char *name, const char *real_path, struct compunit_symtab *first, struct compunit_symtab *after_last, gdb::function_view< bool(symtab *)> callback)
Definition: symtab.c:399
lookup_symbol
struct block_symbol lookup_symbol(const char *, const struct block *, const domain_enum, struct field_of_this_result *)
Definition: symtab.c:1893
find_pcs_for_symtab_line
std::vector< CORE_ADDR > find_pcs_for_symtab_line(struct symtab *symtab, int line, struct linetable_entry **best_entry)
Definition: symtab.c:3416
DEF_ENUM_FLAGS_TYPE
DEF_ENUM_FLAGS_TYPE(enum print_source_lines_flag, print_source_lines_flags)
field_of_this_result
Definition: symtab.h:1529
completion_tracker
Definition: completer.h:310
linetable::nitems
int nitems
Definition: symtab.h:1253
lookup_language_this
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1915
symbol
Definition: symtab.h:1049
symbol_impl
Definition: symtab.h:1018
find_function_alias_target
symbol * find_function_alias_target(bound_minimal_symbol msymbol)
Definition: symtab.c:3953
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
general_symbol_info::common_block
const struct common_block * common_block
Definition: symtab.h:404
initialize_objfile_symbol
void initialize_objfile_symbol(struct symbol *)
Definition: symtab.c:5747
PRINT_SOURCE_LINES_NOERROR
Definition: symtab.h:1809
symtab_and_line::line
int line
Definition: symtab.h:1757
minimal_symbol
Definition: symtab.h:623
symbol_symtab
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:5803
demangle_for_lookup_info::m_demangled_name
std::string m_demangled_name
Definition: symtab.h:164
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
symtab::fullname
char * fullname
Definition: symtab.h:1328
ada_lookup_name_info::lookup_name
const std::string & lookup_name() const
Definition: symtab.h:100
PRINT_SOURCE_LINES_FILENAME
Definition: symtab.h:1812
symbol_computed_ops::get_symbol_read_needs
enum symbol_needs_kind(* get_symbol_read_needs)(struct symbol *symbol)
Definition: symtab.h:939
multiple_symbols_all
const char multiple_symbols_all[]
Definition: symtab.c:238
mst_file_bss
Definition: symtab.h:602
linetable_entry::line
int line
Definition: symtab.h:1230
minimal_symbol_type
minimal_symbol_type
Definition: symtab.h:579
lookup_name_info::m_demangled_hashes_p
std::array< bool, nr_languages > m_demangled_hashes_p
Definition: symtab.h:303
general_symbol_info::ivalue
LONGEST ivalue
Definition: symtab.h:394
find_pc_compunit_symtab
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR)
Definition: symtab.c:2988
compunit_symtab::user
struct compunit_symtab * user
Definition: symtab.h:1457
symbol_impl::ops_computed
const struct symbol_computed_ops * ops_computed
Definition: symtab.h:1023
symbol_name_match_type::FULL
symbol_subclass_kind
symbol_subclass_kind
Definition: symtab.h:1035
lookup_name_info
Definition: symtab.h:179
make_source_files_completion_list
completion_list make_source_files_completion_list(const char *, const char *)
Definition: symtab.c:5381
general_symbol_info::chain
struct symbol * chain
Definition: symtab.h:408
compare_filenames_for_search
int compare_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:318
symbol_computed_ops
Definition: symtab.h:916
symbol::is_argument
unsigned is_argument
Definition: symtab.h:1091
language_cplus
Definition: defs.h:209
SYMBOL_NONE
Definition: symtab.h:1038
skip_prologue_sal
void skip_prologue_sal(struct symtab_and_line *)
Definition: symtab.c:3671
fixup_section
void fixup_section(struct general_symbol_info *ginfo, CORE_ADDR addr, struct objfile *objfile)
Definition: symtab.c:1637
SYMBOL_TEMPLATE
Definition: symtab.h:1041
symbol_name_match_type::WILD
lookup_name_info::m_name
std::string m_name
Definition: symtab.h:284
LONGEST
long long LONGEST
Definition: common-types.h:52
symtab_and_line::explicit_pc
bool explicit_pc
Definition: symtab.h:1761
ada_lookup_name_info::m_verbatim_p
bool m_verbatim_p
Definition: symtab.h:134
print_source_lines_flag
print_source_lines_flag
Definition: symtab.h:1806
program_space
Definition: progspace.h:137
mst_file_text
Definition: symtab.h:600
symbol_found_callback_ftype
bool() symbol_found_callback_ftype(symbol *sym)
Definition: symtab.h:2028
main_language
enum language main_language(void)
Definition: symtab.c:5582
search_name_hash
unsigned int search_name_hash(enum language language, const char *search_name)
Definition: symtab.c:1859
copy_name
char * copy_name(struct stoken token)
Definition: parse.c:761
symbol_name_match_type
symbol_name_match_type
Definition: symtab.h:52
general_symbol_info::demangled_name
const char * demangled_name
Definition: symtab.h:424
symbol::domain
__extension__ enum domain_enum_tag domain
Definition: symtab.h:1076
symbol_set_names
void symbol_set_names(struct general_symbol_info *symbol, const char *linkage_name, int len, int copy_name, struct objfile *objfile)
Definition: symtab.c:773
string_file
Definition: ui-file.h:106