Fix running to breakpoint set in inline function by lineno/address
[deliverable/binutils-gdb.git] / gdb / symtab.h
CommitLineData
c906108c 1/* Symbol table definitions for GDB.
1bac305b 2
e2882c85 3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#if !defined (SYMTAB_H)
21#define SYMTAB_H 1
22
a014b87a 23#include <array>
67d89901 24#include <vector>
b5ec771e 25#include <string>
49c4e619 26#include "gdb_vecs.h"
2f68a895 27#include "gdbtypes.h"
8d297bbf 28#include "common/enum-flags.h"
14bc53a8 29#include "common/function-view.h"
b5ec771e 30#include "common/gdb_optional.h"
eb3ff9a5 31#include "completer.h"
f8eba3c6 32
5f8a3188 33/* Opaque declarations. */
da3331ec
AC
34struct ui_file;
35struct frame_info;
36struct symbol;
5f8a3188 37struct obstack;
6a2f5abf 38struct objfile;
fe898f56
DC
39struct block;
40struct blockvector;
4c2df51b
DJ
41struct axs_value;
42struct agent_expr;
6c95b8df 43struct program_space;
66a17cb6 44struct language_defn;
4357ac6c 45struct common_block;
06096720
AB
46struct obj_section;
47struct cmd_list_element;
935676c9 48class probe;
b5ec771e
PA
49struct lookup_name_info;
50
51/* How to match a lookup name against a symbol search name. */
52enum 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
de63c46b
PA
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
b5ec771e
PA
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. */
80extern 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
86class 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,
a207cff2 97 completion_match_result *comp_match_res) const;
b5ec771e
PA
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
c63d3e8d
PA
113 /* Return true if doing a verbatim match. */
114 bool verbatim_p () const
115 { return m_verbatim_p; }
116
117private:
b5ec771e
PA
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
152struct demangle_for_lookup_info final
153{
154public:
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
162private:
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.) */
179class 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,
c62446b1
PA
185 bool completion_mode = false,
186 bool ignore_parameters = false)
b5ec771e
PA
187 : m_match_type (match_type),
188 m_completion_mode (completion_mode),
c62446b1 189 m_ignore_parameters (ignore_parameters),
b5ec771e
PA
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; }
c62446b1
PA
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 }
b5ec771e
PA
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
271private:
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;
c62446b1 283 bool m_ignore_parameters;
b5ec771e
PA
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
a207cff2
PA
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. */
b5ec771e
PA
323typedef bool (symbol_name_matcher_ftype)
324 (const char *symbol_search_name,
325 const lookup_name_info &lookup_name,
a207cff2 326 completion_match_result *comp_match_res);
c906108c 327
a7f19c79
MC
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
5bccb4d1 335 These structures are laid out to encourage good packing.
a7f19c79
MC
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
c378eb4e 338 to each other so they can be packed together. */
a7f19c79
MC
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
c906108c
SS
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
c378eb4e 372 be recorded along with each symbol. */
c906108c 373
c378eb4e 374/* This structure is space critical. See space comments at the top. */
c906108c
SS
375
376struct general_symbol_info
17c5ed2c 377{
22abf04a 378 /* Name of the symbol. This is a required field. Storage for the
4a146b47
EZ
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. */
c906108c 383
0d5cff50 384 const char *name;
c906108c 385
17c5ed2c
DC
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). */
c906108c 391
17c5ed2c
DC
392 union
393 {
12df843f 394 LONGEST ivalue;
c906108c 395
3977b71f 396 const struct block *block;
c906108c 397
d47a1bc1 398 const gdb_byte *bytes;
c906108c 399
17c5ed2c 400 CORE_ADDR address;
c906108c 401
5a352474 402 /* A common block. Used with LOC_COMMON_BLOCK. */
4357ac6c 403
17a40b44 404 const struct common_block *common_block;
4357ac6c 405
c378eb4e 406 /* For opaque typedef struct chain. */
c906108c 407
17c5ed2c
DC
408 struct symbol *chain;
409 }
410 value;
c906108c 411
17c5ed2c 412 /* Since one and only one language can apply, wrap the language specific
29df156d 413 information inside a union. */
c906108c 414
17c5ed2c
DC
415 union
416 {
f85f34ed
TT
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
afa16725 422 /* This is used by languages which wish to store a demangled name.
9c37b5ae 423 currently used by Ada, C++, and Objective C. */
615b3f62 424 const char *demangled_name;
17c5ed2c
DC
425 }
426 language_specific;
c5aa993b 427
17c5ed2c
DC
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
c378eb4e 430 union above. */
c5aa993b 431
51cdc993 432 ENUM_BITFIELD(language) language : LANGUAGE_BITS;
c5aa993b 433
a04a15f5 434 /* This is only used by Ada. If set, then the 'demangled_name' field
f85f34ed
TT
435 of language_specific is valid. Otherwise, the 'obstack' field is
436 valid. */
437 unsigned int ada_mangled : 1;
438
17c5ed2c
DC
439 /* Which section is this symbol in? This is an index into
440 section_offsets for this objfile. Negative means that the symbol
e27d198c 441 does not get relocated relative to a section. */
c5aa993b 442
17c5ed2c 443 short section;
17c5ed2c 444};
c906108c 445
cfc594ee
TT
446extern void symbol_set_demangled_name (struct general_symbol_info *,
447 const char *,
ccde22c0 448 struct obstack *);
b250c185 449
0d5cff50
DE
450extern const char *symbol_get_demangled_name
451 (const struct general_symbol_info *);
b250c185 452
714835d5 453extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
c906108c 454
88cda038 455/* Note that all the following SYMBOL_* macros are used with the
efd66ac6
TT
456 SYMBOL argument being either a partial symbol or
457 a full symbol. Both types have a ginfo field. In particular
33e5013e 458 the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
d6350901 459 macros cannot be entirely substituted by
88cda038
EZ
460 functions, unless the callers are changed to pass in the ginfo
461 field only, instead of the SYMBOL parameter. */
462
c906108c
SS
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
4357ac6c 466#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
c906108c
SS
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
e27d198c
TT
471#define SYMBOL_OBJ_SECTION(objfile, symbol) \
472 (((symbol)->ginfo.section >= 0) \
473 ? (&(((objfile)->sections)[(symbol)->ginfo.section])) \
474 : NULL)
c906108c 475
89aad1f9 476/* Initializes the language dependent portion of a symbol
c378eb4e 477 depending upon the language for the symbol. */
f85f34ed
TT
478#define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
479 (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
33e5013e 480extern void symbol_set_language (struct general_symbol_info *symbol,
f85f34ed
TT
481 enum language language,
482 struct obstack *obstack);
c906108c 483
3567439c
DJ
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
1c9e8358
TT
487 be terminated and either already on the objfile's obstack or
488 permanently allocated. */
3567439c
DJ
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. */
04a679b8
TT
494#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
495 symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
2de7ced7 496extern void symbol_set_names (struct general_symbol_info *symbol,
04a679b8 497 const char *linkage_name, int len, int copy_name,
2de7ced7
DJ
498 struct objfile *objfile);
499
22abf04a
DC
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
3567439c 506 SYMBOL_LINKAGE_NAME are different. */
22abf04a
DC
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))
0d5cff50
DE
515extern const char *symbol_natural_name
516 (const struct general_symbol_info *symbol);
22abf04a
DC
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,
3567439c 521 it's the same as SYMBOL_NATURAL_NAME. */
22abf04a
DC
522
523#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
524
9cc0d196 525/* Return the demangled name for a symbol based on the language for
c378eb4e 526 that symbol. If no demangled name exists, return NULL. */
9cc0d196
EZ
527#define SYMBOL_DEMANGLED_NAME(symbol) \
528 (symbol_demangled_name (&(symbol)->ginfo))
0d5cff50
DE
529extern const char *symbol_demangled_name
530 (const struct general_symbol_info *symbol);
c906108c 531
de5ad195
DC
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
50f182aa
DE
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. */
de5ad195
DC
541
542#define SYMBOL_PRINT_NAME(symbol) \
22abf04a 543 (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
50f182aa 544extern int demangle;
c906108c 545
c378eb4e 546/* Macro that returns the name to be used when sorting and searching symbols.
9c37b5ae 547 In C++, we search for the demangled form of a name,
4725b721
PH
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
c378eb4e 550 returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
4725b721
PH
551#define SYMBOL_SEARCH_NAME(symbol) \
552 (symbol_search_name (&(symbol)->ginfo))
b5ec771e 553extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
4725b721 554
b5ec771e
PA
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. */
562extern bool symbol_matches_search_name
563 (const struct general_symbol_info *gsymbol,
564 const lookup_name_info &name);
4725b721 565
5ffa0793
PA
566/* Compute the hash of the given symbol search name of a symbol of
567 language LANGUAGE. */
568extern unsigned int search_name_hash (enum language language,
569 const char *search_name);
570
87193939
MC
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
c378eb4e 577 file, we need to live with what information bfd supplies. */
87193939
MC
578
579enum minimal_symbol_type
580{
581 mst_unknown = 0, /* Unknown type, the default */
582 mst_text, /* Generally executable instructions */
f50776aa
PA
583
584 /* A GNU ifunc symbol, in the .text section. GDB uses to know
585 whether the user is setting a breakpoint on a GNU ifunc function,
586 and thus GDB needs to actually set the breakpoint on the target
587 function. It is also used to know whether the program stepped
588 into an ifunc resolver -- the resolver may get a separate
589 symbol/alias under a different name, but it'll have the same
590 address as the ifunc symbol. */
591 mst_text_gnu_ifunc, /* Executable code returning address
592 of executable code */
593
594 /* A GNU ifunc function descriptor symbol, in a data section
595 (typically ".opd"). Seen on architectures that use function
596 descriptors, like PPC64/ELFv1. In this case, this symbol's value
597 is the address of the descriptor. There'll be a corresponding
598 mst_text_gnu_ifunc synthetic symbol for the text/entry
599 address. */
600 mst_data_gnu_ifunc, /* Executable code returning address
0875794a 601 of executable code */
f50776aa 602
0875794a 603 mst_slot_got_plt, /* GOT entries for .plt sections */
87193939
MC
604 mst_data, /* Generally initialized data */
605 mst_bss, /* Generally uninitialized data */
606 mst_abs, /* Generally absolute (nonrelocatable) */
607 /* GDB uses mst_solib_trampoline for the start address of a shared
608 library trampoline entry. Breakpoints for shared library functions
609 are put there if the shared library is not yet loaded.
610 After the shared library is loaded, lookup_minimal_symbol will
611 prefer the minimal symbol from the shared library (usually
612 a mst_text symbol) over the mst_solib_trampoline symbol, and the
613 breakpoints will be moved to their true address in the shared
614 library via breakpoint_re_set. */
615 mst_solib_trampoline, /* Shared library trampoline code */
616 /* For the mst_file* types, the names are only guaranteed to be unique
617 within a given .o file. */
618 mst_file_text, /* Static version of mst_text */
619 mst_file_data, /* Static version of mst_data */
51cdc993
DE
620 mst_file_bss, /* Static version of mst_bss */
621 nr_minsym_types
87193939
MC
622};
623
51cdc993
DE
624/* The number of enum minimal_symbol_type values, with some padding for
625 reasonable growth. */
626#define MINSYM_TYPE_BITS 4
627gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
628
c906108c
SS
629/* Define a simple structure used to hold some very basic information about
630 all defined global symbols (text, data, bss, abs, etc). The only required
631 information is the general_symbol_info.
632
633 In many cases, even if a file was compiled with no special options for
634 debugging at all, as long as was not stripped it will contain sufficient
635 information to build a useful minimal symbol table using this structure.
636 Even when a file contains enough debugging information to build a full
637 symbol table, these minimal symbols are still useful for quickly mapping
638 between names and addresses, and vice versa. They are also sometimes
c378eb4e 639 used to figure out what full symbol table entries need to be read in. */
c906108c
SS
640
641struct minimal_symbol
17c5ed2c 642{
c906108c 643
17c5ed2c 644 /* The general symbol info required for all types of symbols.
c906108c 645
17c5ed2c
DC
646 The SYMBOL_VALUE_ADDRESS contains the address that this symbol
647 corresponds to. */
c906108c 648
efd66ac6 649 struct general_symbol_info mginfo;
c906108c 650
8763cede 651 /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this
f594e5e9
MC
652 information to calculate the end of the partial symtab based on the
653 address of the last symbol plus the size of the last symbol. */
654
655 unsigned long size;
656
17c5ed2c 657 /* Which source file is this symbol in? Only relevant for mst_file_*. */
04aba065 658 const char *filename;
c906108c 659
87193939 660 /* Classification type for this minimal symbol. */
17c5ed2c 661
51cdc993 662 ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
17c5ed2c 663
422d65e7
DE
664 /* Non-zero if this symbol was created by gdb.
665 Such symbols do not appear in the output of "info var|fun". */
666 unsigned int created_by_gdb : 1;
667
b887350f
TT
668 /* Two flag bits provided for the use of the target. */
669 unsigned int target_flag_1 : 1;
670 unsigned int target_flag_2 : 1;
671
d9eaeb59
JB
672 /* Nonzero iff the size of the minimal symbol has been set.
673 Symbol size information can sometimes not be determined, because
674 the object file format may not carry that piece of information. */
675 unsigned int has_size : 1;
676
17c5ed2c
DC
677 /* Minimal symbols with the same hash key are kept on a linked
678 list. This is the link. */
679
680 struct minimal_symbol *hash_next;
681
682 /* Minimal symbols are stored in two different hash tables. This is
683 the `next' pointer for the demangled hash table. */
684
685 struct minimal_symbol *demangled_hash_next;
686};
c906108c 687
b887350f
TT
688#define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
689#define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
d9eaeb59
JB
690#define MSYMBOL_SIZE(msymbol) ((msymbol)->size + 0)
691#define SET_MSYMBOL_SIZE(msymbol, sz) \
692 do \
693 { \
694 (msymbol)->size = sz; \
695 (msymbol)->has_size = 1; \
696 } while (0)
697#define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0)
c906108c 698#define MSYMBOL_TYPE(msymbol) (msymbol)->type
c906108c 699
efd66ac6 700#define MSYMBOL_VALUE(symbol) (symbol)->mginfo.value.ivalue
77e371c0
TT
701/* The unrelocated address of the minimal symbol. */
702#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
2273f0ac
TT
703/* The relocated address of the minimal symbol, using the section
704 offsets from OBJFILE. */
77e371c0
TT
705#define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
706 ((symbol)->mginfo.value.address \
2273f0ac 707 + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
77e371c0
TT
708/* For a bound minsym, we can easily compute the address directly. */
709#define BMSYMBOL_VALUE_ADDRESS(symbol) \
710 MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
711#define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \
40c1a007 712 ((symbol)->mginfo.value.address = (new_value))
efd66ac6
TT
713#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->mginfo.value.bytes
714#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->mginfo.value.block
715#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->mginfo.value.chain
716#define MSYMBOL_LANGUAGE(symbol) (symbol)->mginfo.language
717#define MSYMBOL_SECTION(symbol) (symbol)->mginfo.section
718#define MSYMBOL_OBJ_SECTION(objfile, symbol) \
719 (((symbol)->mginfo.section >= 0) \
720 ? (&(((objfile)->sections)[(symbol)->mginfo.section])) \
721 : NULL)
722
723#define MSYMBOL_NATURAL_NAME(symbol) \
724 (symbol_natural_name (&(symbol)->mginfo))
725#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->mginfo.name
726#define MSYMBOL_PRINT_NAME(symbol) \
727 (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
728#define MSYMBOL_DEMANGLED_NAME(symbol) \
729 (symbol_demangled_name (&(symbol)->mginfo))
730#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack) \
731 (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
732#define MSYMBOL_SEARCH_NAME(symbol) \
733 (symbol_search_name (&(symbol)->mginfo))
efd66ac6
TT
734#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
735 symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
736
c35384fb
TT
737#include "minsyms.h"
738
c906108c 739\f
c5aa993b 740
c906108c
SS
741/* Represent one symbol name; a variable, constant, function or typedef. */
742
176620f1 743/* Different name domains for symbols. Looking up a symbol specifies a
c378eb4e 744 domain and ignores symbol definitions in other name domains. */
c906108c 745
87193939 746typedef enum domain_enum_tag
17c5ed2c 747{
176620f1 748 /* UNDEF_DOMAIN is used when a domain has not been discovered or
17c5ed2c 749 none of the following apply. This usually indicates an error either
c378eb4e 750 in the symbol information or in gdb's handling of symbols. */
c906108c 751
176620f1 752 UNDEF_DOMAIN,
c906108c 753
176620f1 754 /* VAR_DOMAIN is the usual domain. In C, this contains variables,
c378eb4e 755 function names, typedef names and enum type values. */
c906108c 756
176620f1 757 VAR_DOMAIN,
c906108c 758
176620f1 759 /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
17c5ed2c 760 Thus, if `struct foo' is used in a C program, it produces a symbol named
c378eb4e 761 `foo' in the STRUCT_DOMAIN. */
c906108c 762
176620f1 763 STRUCT_DOMAIN,
c906108c 764
530e8392
KB
765 /* MODULE_DOMAIN is used in Fortran to hold module type names. */
766
767 MODULE_DOMAIN,
768
0f5238ed 769 /* LABEL_DOMAIN may be used for names of labels (for gotos). */
c906108c 770
4357ac6c
TT
771 LABEL_DOMAIN,
772
5a352474
JK
773 /* Fortran common blocks. Their naming must be separate from VAR_DOMAIN.
774 They also always use LOC_COMMON_BLOCK. */
51cdc993
DE
775 COMMON_BLOCK_DOMAIN,
776
777 /* This must remain last. */
778 NR_DOMAINS
8903c50d 779} domain_enum;
c906108c 780
c01feb36
DE
781/* The number of bits in a symbol used to represent the domain. */
782
51cdc993
DE
783#define SYMBOL_DOMAIN_BITS 3
784gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
c01feb36 785
20c681d1
DE
786extern const char *domain_name (domain_enum);
787
e8930875
JK
788/* Searching domains, used for `search_symbols'. Element numbers are
789 hardcoded in GDB, check all enum uses before changing it. */
c906108c 790
8903c50d
TT
791enum search_domain
792{
bd2e94ce
TT
793 /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
794 TYPES_DOMAIN. */
e8930875 795 VARIABLES_DOMAIN = 0,
c906108c 796
c378eb4e 797 /* All functions -- for some reason not methods, though. */
e8930875 798 FUNCTIONS_DOMAIN = 1,
c906108c 799
17c5ed2c 800 /* All defined types */
e8930875 801 TYPES_DOMAIN = 2,
7b08b9eb
JK
802
803 /* Any type. */
804 ALL_DOMAIN = 3
8903c50d 805};
c906108c 806
20c681d1
DE
807extern const char *search_domain_name (enum search_domain);
808
c906108c
SS
809/* An address-class says where to find the value of a symbol. */
810
811enum address_class
17c5ed2c 812{
c378eb4e 813 /* Not used; catches errors. */
c5aa993b 814
17c5ed2c 815 LOC_UNDEF,
c906108c 816
c378eb4e 817 /* Value is constant int SYMBOL_VALUE, host byteorder. */
c906108c 818
17c5ed2c 819 LOC_CONST,
c906108c 820
c378eb4e 821 /* Value is at fixed address SYMBOL_VALUE_ADDRESS. */
c906108c 822
17c5ed2c 823 LOC_STATIC,
c906108c 824
768a979c
UW
825 /* Value is in register. SYMBOL_VALUE is the register number
826 in the original debug format. SYMBOL_REGISTER_OPS holds a
827 function that can be called to transform this into the
828 actual register number this represents in a specific target
829 architecture (gdbarch).
2a2d4dc3
AS
830
831 For some symbol formats (stabs, for some compilers at least),
832 the compiler generates two symbols, an argument and a register.
833 In some cases we combine them to a single LOC_REGISTER in symbol
834 reading, but currently not for all cases (e.g. it's passed on the
835 stack and then loaded into a register). */
c906108c 836
17c5ed2c 837 LOC_REGISTER,
c906108c 838
17c5ed2c 839 /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */
c906108c 840
17c5ed2c 841 LOC_ARG,
c906108c 842
17c5ed2c 843 /* Value address is at SYMBOL_VALUE offset in arglist. */
c906108c 844
17c5ed2c 845 LOC_REF_ARG,
c906108c 846
2a2d4dc3 847 /* Value is in specified register. Just like LOC_REGISTER except the
17c5ed2c 848 register holds the address of the argument instead of the argument
c378eb4e 849 itself. This is currently used for the passing of structs and unions
17c5ed2c
DC
850 on sparc and hppa. It is also used for call by reference where the
851 address is in a register, at least by mipsread.c. */
c906108c 852
17c5ed2c 853 LOC_REGPARM_ADDR,
c906108c 854
17c5ed2c 855 /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */
c906108c 856
17c5ed2c 857 LOC_LOCAL,
c906108c 858
176620f1
EZ
859 /* Value not used; definition in SYMBOL_TYPE. Symbols in the domain
860 STRUCT_DOMAIN all have this class. */
c906108c 861
17c5ed2c 862 LOC_TYPEDEF,
c906108c 863
c378eb4e 864 /* Value is address SYMBOL_VALUE_ADDRESS in the code. */
c906108c 865
17c5ed2c 866 LOC_LABEL,
c906108c 867
17c5ed2c
DC
868 /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
869 In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
c378eb4e 870 of the block. Function names have this class. */
c906108c 871
17c5ed2c 872 LOC_BLOCK,
c906108c 873
17c5ed2c
DC
874 /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
875 target byte order. */
c906108c 876
17c5ed2c 877 LOC_CONST_BYTES,
c906108c 878
17c5ed2c
DC
879 /* Value is at fixed address, but the address of the variable has
880 to be determined from the minimal symbol table whenever the
881 variable is referenced.
882 This happens if debugging information for a global symbol is
883 emitted and the corresponding minimal symbol is defined
884 in another object file or runtime common storage.
885 The linker might even remove the minimal symbol if the global
886 symbol is never referenced, in which case the symbol remains
de40b933
JK
887 unresolved.
888
889 GDB would normally find the symbol in the minimal symbol table if it will
890 not find it in the full symbol table. But a reference to an external
891 symbol in a local block shadowing other definition requires full symbol
892 without possibly having its address available for LOC_STATIC. Testcase
5382cfab
PW
893 is provided as `gdb.dwarf2/dw2-unresolved.exp'.
894
895 This is also used for thread local storage (TLS) variables. In this case,
896 the address of the TLS variable must be determined when the variable is
897 referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
898 of the TLS variable in the thread local storage of the shared
899 library/object. */
c906108c 900
17c5ed2c 901 LOC_UNRESOLVED,
c906108c 902
17c5ed2c
DC
903 /* The variable does not actually exist in the program.
904 The value is ignored. */
c906108c 905
17c5ed2c 906 LOC_OPTIMIZED_OUT,
c906108c 907
4c2df51b 908 /* The variable's address is computed by a set of location
768a979c 909 functions (see "struct symbol_computed_ops" below). */
4c2df51b 910 LOC_COMPUTED,
5a352474
JK
911
912 /* The variable uses general_symbol_info->value->common_block field.
913 It also always uses COMMON_BLOCK_DOMAIN. */
914 LOC_COMMON_BLOCK,
f1e6e072
TT
915
916 /* Not used, just notes the boundary of the enum. */
917 LOC_FINAL_VALUE
4c2df51b
DJ
918};
919
51cdc993
DE
920/* The number of bits needed for values in enum address_class, with some
921 padding for reasonable growth, and room for run-time registered address
922 classes. See symtab.c:MAX_SYMBOL_IMPLS.
923 This is a #define so that we can have a assertion elsewhere to
924 verify that we have reserved enough space for synthetic address
925 classes. */
926#define SYMBOL_ACLASS_BITS 5
927gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
928
768a979c 929/* The methods needed to implement LOC_COMPUTED. These methods can
a67af2b9
AC
930 use the symbol's .aux_value for additional per-symbol information.
931
932 At present this is only used to implement location expressions. */
933
768a979c 934struct symbol_computed_ops
4c2df51b
DJ
935{
936
937 /* Return the value of the variable SYMBOL, relative to the stack
938 frame FRAME. If the variable has been optimized out, return
939 zero.
940
0b31a4bc
TT
941 Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
942 FRAME may be zero. */
4c2df51b
DJ
943
944 struct value *(*read_variable) (struct symbol * symbol,
945 struct frame_info * frame);
946
e18b2753
JK
947 /* Read variable SYMBOL like read_variable at (callee) FRAME's function
948 entry. SYMBOL should be a function parameter, otherwise
949 NO_ENTRY_VALUE_ERROR will be thrown. */
950 struct value *(*read_variable_at_entry) (struct symbol *symbol,
951 struct frame_info *frame);
952
0b31a4bc
TT
953 /* Find the "symbol_needs_kind" value for the given symbol. This
954 value determines whether reading the symbol needs memory (e.g., a
955 global variable), just registers (a thread-local), or a frame (a
956 local variable). */
957 enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
4c2df51b
DJ
958
959 /* Write to STREAM a natural-language description of the location of
08922a10
SS
960 SYMBOL, in the context of ADDR. */
961 void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
962 struct ui_file * stream);
4c2df51b 963
f1e6e072
TT
964 /* Non-zero if this symbol's address computation is dependent on PC. */
965 unsigned char location_has_loclist;
966
4c2df51b
DJ
967 /* Tracepoint support. Append bytecodes to the tracepoint agent
968 expression AX that push the address of the object SYMBOL. Set
969 VALUE appropriately. Note --- for objects in registers, this
970 needn't emit any code; as long as it sets VALUE properly, then
971 the caller will generate the right code in the process of
972 treating this as an lvalue or rvalue. */
973
40f4af28
SM
974 void (*tracepoint_var_ref) (struct symbol *symbol, struct agent_expr *ax,
975 struct axs_value *value);
bb2ec1b3
TT
976
977 /* Generate C code to compute the location of SYMBOL. The C code is
978 emitted to STREAM. GDBARCH is the current architecture and PC is
979 the PC at which SYMBOL's location should be evaluated.
980 REGISTERS_USED is a vector indexed by register number; the
981 generator function should set an element in this vector if the
982 corresponding register is needed by the location computation.
983 The generated C code must assign the location to a local
984 variable; this variable's name is RESULT_NAME. */
985
d7e74731 986 void (*generate_c_location) (struct symbol *symbol, string_file &stream,
bb2ec1b3
TT
987 struct gdbarch *gdbarch,
988 unsigned char *registers_used,
989 CORE_ADDR pc, const char *result_name);
990
17c5ed2c 991};
c906108c 992
f1e6e072
TT
993/* The methods needed to implement LOC_BLOCK for inferior functions.
994 These methods can use the symbol's .aux_value for additional
995 per-symbol information. */
996
997struct symbol_block_ops
998{
999 /* Fill in *START and *LENGTH with DWARF block data of function
1000 FRAMEFUNC valid for inferior context address PC. Set *LENGTH to
1001 zero if such location is not valid for PC; *START is left
1002 uninitialized in such case. */
1003 void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
1004 const gdb_byte **start, size_t *length);
63e43d3a
PMR
1005
1006 /* Return the frame base address. FRAME is the frame for which we want to
1007 compute the base address while FRAMEFUNC is the symbol for the
1008 corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
1009 information we need).
1010
1011 This method is designed to work with static links (nested functions
1012 handling). Static links are function properties whose evaluation returns
1013 the frame base address for the enclosing frame. However, there are
1014 multiple definitions for "frame base": the content of the frame base
1015 register, the CFA as defined by DWARF unwinding information, ...
1016
1017 So this specific method is supposed to compute the frame base address such
1018 as for nested fuctions, the static link computes the same address. For
1019 instance, considering DWARF debugging information, the static link is
1020 computed with DW_AT_static_link and this method must be used to compute
1021 the corresponding DW_AT_frame_base attribute. */
1022 CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
1023 struct frame_info *frame);
f1e6e072
TT
1024};
1025
768a979c
UW
1026/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1027
1028struct symbol_register_ops
1029{
1030 int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
1031};
1032
f1e6e072
TT
1033/* Objects of this type are used to find the address class and the
1034 various computed ops vectors of a symbol. */
1035
1036struct symbol_impl
1037{
1038 enum address_class aclass;
1039
1040 /* Used with LOC_COMPUTED. */
1041 const struct symbol_computed_ops *ops_computed;
1042
1043 /* Used with LOC_BLOCK. */
1044 const struct symbol_block_ops *ops_block;
1045
1046 /* Used with LOC_REGISTER and LOC_REGPARM_ADDR. */
1047 const struct symbol_register_ops *ops_register;
1048};
1049
cf724bc9
TT
1050/* struct symbol has some subclasses. This enum is used to
1051 differentiate between them. */
1052
1053enum symbol_subclass_kind
1054{
1055 /* Plain struct symbol. */
1056 SYMBOL_NONE,
1057
1058 /* struct template_symbol. */
1059 SYMBOL_TEMPLATE,
1060
1061 /* struct rust_vtable_symbol. */
1062 SYMBOL_RUST_VTABLE
1063};
1064
c378eb4e 1065/* This structure is space critical. See space comments at the top. */
a7f19c79 1066
c906108c 1067struct symbol
17c5ed2c 1068{
c906108c 1069
c378eb4e 1070 /* The general symbol info required for all types of symbols. */
c906108c 1071
17c5ed2c 1072 struct general_symbol_info ginfo;
c906108c 1073
17c5ed2c 1074 /* Data type of value */
c906108c 1075
17c5ed2c 1076 struct type *type;
c906108c 1077
1994afbf 1078 /* The owner of this symbol.
e2ada9cb 1079 Which one to use is defined by symbol.is_objfile_owned. */
1994afbf
DE
1080
1081 union
1082 {
1083 /* The symbol table containing this symbol. This is the file associated
1084 with LINE. It can be NULL during symbols read-in but it is never NULL
1085 during normal operation. */
1086 struct symtab *symtab;
1087
1088 /* For types defined by the architecture. */
1089 struct gdbarch *arch;
1090 } owner;
cb1df416 1091
176620f1 1092 /* Domain code. */
c906108c 1093
c01feb36 1094 ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
c906108c 1095
f1e6e072
TT
1096 /* Address class. This holds an index into the 'symbol_impls'
1097 table. The actual enum address_class value is stored there,
1098 alongside any per-class ops vectors. */
c906108c 1099
f1e6e072 1100 unsigned int aclass_index : SYMBOL_ACLASS_BITS;
c906108c 1101
1994afbf
DE
1102 /* If non-zero then symbol is objfile-owned, use owner.symtab.
1103 Otherwise symbol is arch-owned, use owner.arch. */
1104
1105 unsigned int is_objfile_owned : 1;
1106
2a2d4dc3
AS
1107 /* Whether this is an argument. */
1108
1109 unsigned is_argument : 1;
1110
edb3359d
DJ
1111 /* Whether this is an inlined function (class LOC_BLOCK only). */
1112 unsigned is_inlined : 1;
1113
cf724bc9 1114 /* The concrete type of this symbol. */
71a3c369 1115
cf724bc9 1116 ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
71a3c369 1117
edb3359d
DJ
1118 /* Line number of this symbol's definition, except for inlined
1119 functions. For an inlined function (class LOC_BLOCK and
1120 SYMBOL_INLINED set) this is the line number of the function's call
1121 site. Inlined function symbols are not definitions, and they are
1122 never found by symbol table lookup.
1994afbf 1123 If this symbol is arch-owned, LINE shall be zero.
edb3359d
DJ
1124
1125 FIXME: Should we really make the assumption that nobody will try
1126 to debug files longer than 64K lines? What about machine
1127 generated programs? */
c906108c 1128
17c5ed2c 1129 unsigned short line;
c906108c 1130
10f4ecb8
UW
1131 /* An arbitrary data pointer, allowing symbol readers to record
1132 additional information on a per-symbol basis. Note that this data
1133 must be allocated using the same obstack as the symbol itself. */
1cd36e54
DE
1134 /* So far it is only used by:
1135 LOC_COMPUTED: to find the location information
1136 LOC_BLOCK (DWARF2 function): information used internally by the
1137 DWARF 2 code --- specifically, the location expression for the frame
10f4ecb8
UW
1138 base for this function. */
1139 /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
1140 to add a magic symbol to the block containing this information,
1141 or to have a generic debug info annotation slot for symbols. */
1142
1143 void *aux_value;
c906108c 1144
17c5ed2c
DC
1145 struct symbol *hash_next;
1146};
c906108c 1147
d12307c1
PMR
1148/* Several lookup functions return both a symbol and the block in which the
1149 symbol is found. This structure is used in these cases. */
1150
1151struct block_symbol
1152{
1153 /* The symbol that was found, or NULL if no symbol was found. */
1154 struct symbol *symbol;
1155
1156 /* If SYMBOL is not NULL, then this is the block in which the symbol is
1157 defined. */
1158 const struct block *block;
1159};
1160
f1e6e072 1161extern const struct symbol_impl *symbol_impls;
c906108c 1162
b6b80672
PA
1163/* For convenience. All fields are NULL. This means "there is no
1164 symbol". */
1165extern const struct block_symbol null_block_symbol;
1166
1994afbf
DE
1167/* Note: There is no accessor macro for symbol.owner because it is
1168 "private". */
1169
176620f1 1170#define SYMBOL_DOMAIN(symbol) (symbol)->domain
f1e6e072
TT
1171#define SYMBOL_IMPL(symbol) (symbol_impls[(symbol)->aclass_index])
1172#define SYMBOL_ACLASS_INDEX(symbol) (symbol)->aclass_index
1173#define SYMBOL_CLASS(symbol) (SYMBOL_IMPL (symbol).aclass)
1994afbf 1174#define SYMBOL_OBJFILE_OWNED(symbol) ((symbol)->is_objfile_owned)
2a2d4dc3 1175#define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
edb3359d 1176#define SYMBOL_INLINED(symbol) (symbol)->is_inlined
34eaf542 1177#define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
cf724bc9 1178 (((symbol)->subclass) == SYMBOL_TEMPLATE)
c906108c
SS
1179#define SYMBOL_TYPE(symbol) (symbol)->type
1180#define SYMBOL_LINE(symbol) (symbol)->line
f1e6e072
TT
1181#define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
1182#define SYMBOL_BLOCK_OPS(symbol) (SYMBOL_IMPL (symbol).ops_block)
1183#define SYMBOL_REGISTER_OPS(symbol) (SYMBOL_IMPL (symbol).ops_register)
10f4ecb8 1184#define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
34eaf542 1185
f1e6e072
TT
1186extern int register_symbol_computed_impl (enum address_class,
1187 const struct symbol_computed_ops *);
1188
1189extern int register_symbol_block_impl (enum address_class aclass,
1190 const struct symbol_block_ops *ops);
1191
1192extern int register_symbol_register_impl (enum address_class,
1193 const struct symbol_register_ops *);
1194
08be3fe3
DE
1195/* Return the OBJFILE of SYMBOL.
1196 It is an error to call this if symbol.is_objfile_owned is false, which
1197 only happens for architecture-provided types. */
1198
1199extern struct objfile *symbol_objfile (const struct symbol *symbol);
1200
1201/* Return the ARCH of SYMBOL. */
1202
1203extern struct gdbarch *symbol_arch (const struct symbol *symbol);
1204
1205/* Return the SYMTAB of SYMBOL.
1206 It is an error to call this if symbol.is_objfile_owned is false, which
1207 only happens for architecture-provided types. */
1208
1209extern struct symtab *symbol_symtab (const struct symbol *symbol);
1210
1211/* Set the symtab of SYMBOL to SYMTAB.
1212 It is an error to call this if symbol.is_objfile_owned is false, which
1213 only happens for architecture-provided types. */
1214
1215extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
1216
34eaf542 1217/* An instance of this type is used to represent a C++ template
68e745e3
TT
1218 function. A symbol is really of this type iff
1219 SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true. */
34eaf542 1220
68e745e3 1221struct template_symbol : public symbol
34eaf542 1222{
34eaf542
TT
1223 /* The number of template arguments. */
1224 int n_template_arguments;
1225
1226 /* The template arguments. This is an array with
1227 N_TEMPLATE_ARGUMENTS elements. */
1228 struct symbol **template_arguments;
1229};
1230
71a3c369
TT
1231/* A symbol that represents a Rust virtual table object. */
1232
1233struct rust_vtable_symbol : public symbol
1234{
1235 /* The concrete type for which this vtable was created; that is, in
1236 "impl Trait for Type", this is "Type". */
1237 struct type *concrete_type;
1238};
1239
c906108c 1240\f
c906108c
SS
1241/* Each item represents a line-->pc (or the reverse) mapping. This is
1242 somewhat more wasteful of space than one might wish, but since only
1243 the files which are actually debugged are read in to core, we don't
1244 waste much space. */
1245
1246struct linetable_entry
17c5ed2c
DC
1247{
1248 int line;
1249 CORE_ADDR pc;
1250};
c906108c
SS
1251
1252/* The order of entries in the linetable is significant. They should
1253 be sorted by increasing values of the pc field. If there is more than
1254 one entry for a given pc, then I'm not sure what should happen (and
1255 I not sure whether we currently handle it the best way).
1256
1257 Example: a C for statement generally looks like this
1258
c5aa993b
JM
1259 10 0x100 - for the init/test part of a for stmt.
1260 20 0x200
1261 30 0x300
1262 10 0x400 - for the increment part of a for stmt.
c906108c 1263
e8717518
FF
1264 If an entry has a line number of zero, it marks the start of a PC
1265 range for which no line number information is available. It is
1266 acceptable, though wasteful of table space, for such a range to be
1267 zero length. */
c906108c
SS
1268
1269struct linetable
17c5ed2c
DC
1270{
1271 int nitems;
c906108c 1272
17c5ed2c
DC
1273 /* Actually NITEMS elements. If you don't like this use of the
1274 `struct hack', you can shove it up your ANSI (seriously, if the
1275 committee tells us how to do it, we can probably go along). */
1276 struct linetable_entry item[1];
1277};
c906108c 1278
c906108c
SS
1279/* How to relocate the symbols from each section in a symbol file.
1280 Each struct contains an array of offsets.
1281 The ordering and meaning of the offsets is file-type-dependent;
1282 typically it is indexed by section numbers or symbol types or
1283 something like that.
1284
1285 To give us flexibility in changing the internal representation
1286 of these offsets, the ANOFFSET macro must be used to insert and
1287 extract offset values in the struct. */
1288
1289struct section_offsets
17c5ed2c 1290{
c378eb4e 1291 CORE_ADDR offsets[1]; /* As many as needed. */
17c5ed2c 1292};
c906108c 1293
a4c8257b 1294#define ANOFFSET(secoff, whichone) \
3e43a32a
MS
1295 ((whichone == -1) \
1296 ? (internal_error (__FILE__, __LINE__, \
1297 _("Section index is uninitialized")), -1) \
1298 : secoff->offsets[whichone])
c906108c 1299
b29c9944
JB
1300/* The size of a section_offsets table for N sections. */
1301#define SIZEOF_N_SECTION_OFFSETS(n) \
c906108c 1302 (sizeof (struct section_offsets) \
b29c9944
JB
1303 + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
1304
c378eb4e 1305/* Each source file or header is represented by a struct symtab.
43f3e411 1306 The name "symtab" is historical, another name for it is "filetab".
c906108c
SS
1307 These objects are chained through the `next' field. */
1308
1309struct symtab
17c5ed2c 1310{
b7236fbe
DE
1311 /* Unordered chain of all filetabs in the compunit, with the exception
1312 that the "main" source file is the first entry in the list. */
c906108c 1313
17c5ed2c 1314 struct symtab *next;
c906108c 1315
43f3e411 1316 /* Backlink to containing compunit symtab. */
c906108c 1317
43f3e411 1318 struct compunit_symtab *compunit_symtab;
c906108c 1319
17c5ed2c
DC
1320 /* Table mapping core addresses to line numbers for this file.
1321 Can be NULL if none. Never shared between different symtabs. */
c906108c 1322
17c5ed2c 1323 struct linetable *linetable;
c906108c 1324
4e04028d 1325 /* Name of this source file. This pointer is never NULL. */
c906108c 1326
21ea9eec 1327 const char *filename;
c906108c 1328
17c5ed2c 1329 /* Total number of lines found in source file. */
c906108c 1330
17c5ed2c 1331 int nlines;
c906108c 1332
17c5ed2c
DC
1333 /* line_charpos[N] is the position of the (N-1)th line of the
1334 source file. "position" means something we can lseek() to; it
1335 is not guaranteed to be useful any other way. */
c906108c 1336
17c5ed2c 1337 int *line_charpos;
c906108c 1338
17c5ed2c 1339 /* Language of this source file. */
c906108c 1340
17c5ed2c 1341 enum language language;
c906108c 1342
43f3e411
DE
1343 /* Full name of file as found by searching the source path.
1344 NULL if not yet known. */
1345
1346 char *fullname;
1347};
1348
1349#define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1350#define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1351#define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1352#define SYMTAB_BLOCKVECTOR(symtab) \
1353 COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1354#define SYMTAB_OBJFILE(symtab) \
1355 COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1356#define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1357#define SYMTAB_DIRNAME(symtab) \
1358 COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1359
1360typedef struct symtab *symtab_ptr;
1361DEF_VEC_P (symtab_ptr);
1362
1363/* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1364 as the list of all source files (what gdb has historically associated with
1365 the term "symtab").
1366 Additional information is recorded here that is common to all symtabs in a
1367 compilation unit (DWARF or otherwise).
1368
1369 Example:
1370 For the case of a program built out of these files:
1371
1372 foo.c
1373 foo1.h
1374 foo2.h
1375 bar.c
1376 foo1.h
1377 bar.h
1378
1379 This is recorded as:
1380
1381 objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1382 | |
1383 v v
1384 foo.c bar.c
1385 | |
1386 v v
1387 foo1.h foo1.h
1388 | |
1389 v v
1390 foo2.h bar.h
1391 | |
1392 v v
1393 NULL NULL
1394
1395 where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1396 and the files foo.c, etc. are struct symtab objects. */
1397
1398struct compunit_symtab
1399{
1400 /* Unordered chain of all compunit symtabs of this objfile. */
1401 struct compunit_symtab *next;
1402
1403 /* Object file from which this symtab information was read. */
1404 struct objfile *objfile;
1405
1406 /* Name of the symtab.
1407 This is *not* intended to be a usable filename, and is
1408 for debugging purposes only. */
1409 const char *name;
1410
1411 /* Unordered list of file symtabs, except that by convention the "main"
1412 source file (e.g., .c, .cc) is guaranteed to be first.
1413 Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1414 or header (e.g., .h). */
1415 struct symtab *filetabs;
1416
1417 /* Last entry in FILETABS list.
1418 Subfiles are added to the end of the list so they accumulate in order,
1419 with the main source subfile living at the front.
1420 The main reason is so that the main source file symtab is at the head
1421 of the list, and the rest appear in order for debugging convenience. */
1422 struct symtab *last_filetab;
1423
1424 /* Non-NULL string that identifies the format of the debugging information,
1425 such as "stabs", "dwarf 1", "dwarf 2", "coff", etc. This is mostly useful
17c5ed2c 1426 for automated testing of gdb but may also be information that is
c378eb4e 1427 useful to the user. */
554d387d 1428 const char *debugformat;
c906108c 1429
43f3e411 1430 /* String of producer version information, or NULL if we don't know. */
554d387d 1431 const char *producer;
c906108c 1432
43f3e411
DE
1433 /* Directory in which it was compiled, or NULL if we don't know. */
1434 const char *dirname;
c906108c 1435
43f3e411
DE
1436 /* List of all symbol scope blocks for this symtab. It is shared among
1437 all symtabs in a given compilation unit. */
1438 const struct blockvector *blockvector;
c906108c 1439
43f3e411
DE
1440 /* Section in objfile->section_offsets for the blockvector and
1441 the linetable. Probably always SECT_OFF_TEXT. */
1442 int block_line_section;
c906108c 1443
43f3e411
DE
1444 /* Symtab has been compiled with both optimizations and debug info so that
1445 GDB may stop skipping prologues as variables locations are valid already
1446 at function entry points. */
1447 unsigned int locations_valid : 1;
c906108c 1448
43f3e411
DE
1449 /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1450 instruction). This is supported by GCC since 4.5.0. */
1451 unsigned int epilogue_unwind_valid : 1;
8e3b41a9 1452
43f3e411 1453 /* struct call_site entries for this compilation unit or NULL. */
8e3b41a9 1454 htab_t call_site_htab;
b5b04b5b 1455
43f3e411
DE
1456 /* The macro table for this symtab. Like the blockvector, this
1457 is shared between different symtabs in a given compilation unit.
1458 It's debatable whether it *should* be shared among all the symtabs in
1459 the given compilation unit, but it currently is. */
1460 struct macro_table *macro_table;
1461
b5b04b5b 1462 /* If non-NULL, then this points to a NULL-terminated vector of
43f3e411
DE
1463 included compunits. When searching the static or global
1464 block of this compunit, the corresponding block of all
1465 included compunits will also be searched. Note that this
b5b04b5b
TT
1466 list must be flattened -- the symbol reader is responsible for
1467 ensuring that this vector contains the transitive closure of all
43f3e411
DE
1468 included compunits. */
1469 struct compunit_symtab **includes;
b5b04b5b 1470
43f3e411
DE
1471 /* If this is an included compunit, this points to one includer
1472 of the table. This user is considered the canonical compunit
1473 containing this one. An included compunit may itself be
b5b04b5b 1474 included by another. */
43f3e411 1475 struct compunit_symtab *user;
17c5ed2c 1476};
c906108c 1477
43f3e411
DE
1478#define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1479#define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1480#define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1481#define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1482#define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1483#define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1484#define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1485#define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1486#define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1487#define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1488#define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
ec94af83 1489
43f3e411 1490/* Iterate over all file tables (struct symtab) within a compunit. */
db0fec5c 1491
43f3e411
DE
1492#define ALL_COMPUNIT_FILETABS(cu, s) \
1493 for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next)
1494
1495/* Return the primary symtab of CUST. */
1496
1497extern struct symtab *
1498 compunit_primary_filetab (const struct compunit_symtab *cust);
1499
1500/* Return the language of CUST. */
1501
1502extern enum language compunit_language (const struct compunit_symtab *cust);
1503
1504typedef struct compunit_symtab *compunit_symtab_ptr;
1505DEF_VEC_P (compunit_symtab_ptr);
ec94af83 1506
c906108c 1507\f
c5aa993b 1508
c906108c 1509/* The virtual function table is now an array of structures which have the
a960f249 1510 form { int16 offset, delta; void *pfn; }.
c906108c
SS
1511
1512 In normal virtual function tables, OFFSET is unused.
1513 DELTA is the amount which is added to the apparent object's base
1514 address in order to point to the actual object to which the
1515 virtual function should be applied.
1516 PFN is a pointer to the virtual function.
1517
c378eb4e 1518 Note that this macro is g++ specific (FIXME). */
c5aa993b 1519
c906108c
SS
1520#define VTBL_FNADDR_OFFSET 2
1521
c378eb4e 1522/* External variables and functions for the objects described above. */
c906108c 1523
c378eb4e 1524/* True if we are nested inside psymtab_to_symtab. */
c906108c
SS
1525
1526extern int currently_reading_symtab;
1527
c906108c
SS
1528/* symtab.c lookup functions */
1529
7fc830e2
MK
1530extern const char multiple_symbols_ask[];
1531extern const char multiple_symbols_all[];
1532extern const char multiple_symbols_cancel[];
717d2f5a
JB
1533
1534const char *multiple_symbols_select_mode (void);
1535
4186eb54
KS
1536int symbol_matches_domain (enum language symbol_language,
1537 domain_enum symbol_domain,
1538 domain_enum domain);
1539
c378eb4e 1540/* lookup a symbol table by source file name. */
c906108c 1541
1f8cc6db 1542extern struct symtab *lookup_symtab (const char *);
c906108c 1543
1993b719
TT
1544/* An object of this type is passed as the 'is_a_field_of_this'
1545 argument to lookup_symbol and lookup_symbol_in_language. */
1546
1547struct field_of_this_result
1548{
1549 /* The type in which the field was found. If this is NULL then the
1550 symbol was not found in 'this'. If non-NULL, then one of the
1551 other fields will be non-NULL as well. */
1552
1553 struct type *type;
1554
1555 /* If the symbol was found as an ordinary field of 'this', then this
1556 is non-NULL and points to the particular field. */
1557
1558 struct field *field;
1559
cf901d3b 1560 /* If the symbol was found as a function field of 'this', then this
1993b719
TT
1561 is non-NULL and points to the particular field. */
1562
1563 struct fn_fieldlist *fn_field;
1564};
1565
cf901d3b
DE
1566/* Find the definition for a specified symbol name NAME
1567 in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1568 if non-NULL or from global/static blocks if BLOCK is NULL.
1569 Returns the struct symbol pointer, or NULL if no symbol is found.
1570 C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1571 NAME is a field of the current implied argument `this'. If so fill in the
1572 fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
cf901d3b 1573 The symbol's section is fixed up if necessary. */
53c5240f 1574
d12307c1
PMR
1575extern struct block_symbol
1576 lookup_symbol_in_language (const char *,
1577 const struct block *,
1578 const domain_enum,
1579 enum language,
1580 struct field_of_this_result *);
53c5240f 1581
cf901d3b 1582/* Same as lookup_symbol_in_language, but using the current language. */
c906108c 1583
d12307c1
PMR
1584extern struct block_symbol lookup_symbol (const char *,
1585 const struct block *,
1586 const domain_enum,
1587 struct field_of_this_result *);
c906108c 1588
de63c46b
PA
1589/* Find the definition for a specified symbol search name in domain
1590 DOMAIN, visible from lexical block BLOCK if non-NULL or from
1591 global/static blocks if BLOCK is NULL. The passed-in search name
1592 should not come from the user; instead it should already be a
1593 search name as retrieved from a
1594 SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call. See definition of
1595 symbol_name_match_type::SEARCH_NAME. Returns the struct symbol
1596 pointer, or NULL if no symbol is found. The symbol's section is
1597 fixed up if necessary. */
1598
1599extern struct block_symbol lookup_symbol_search_name (const char *search_name,
1600 const struct block *block,
1601 domain_enum domain);
1602
5f9a71c3 1603/* A default version of lookup_symbol_nonlocal for use by languages
cf901d3b
DE
1604 that can't think of anything better to do.
1605 This implements the C lookup rules. */
5f9a71c3 1606
d12307c1 1607extern struct block_symbol
f606139a
DE
1608 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
1609 const char *,
1610 const struct block *,
1611 const domain_enum);
5f9a71c3
DC
1612
1613/* Some helper functions for languages that need to write their own
1614 lookup_symbol_nonlocal functions. */
1615
1616/* Lookup a symbol in the static block associated to BLOCK, if there
cf901d3b 1617 is one; do nothing if BLOCK is NULL or a global block.
d12307c1 1618 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1619
d12307c1
PMR
1620extern struct block_symbol
1621 lookup_symbol_in_static_block (const char *name,
1622 const struct block *block,
1623 const domain_enum domain);
5f9a71c3 1624
08724ab7 1625/* Search all static file-level symbols for NAME from DOMAIN.
d12307c1 1626 Upon success fixes up the symbol's section if necessary. */
08724ab7 1627
d12307c1
PMR
1628extern struct block_symbol lookup_static_symbol (const char *name,
1629 const domain_enum domain);
08724ab7 1630
cf901d3b 1631/* Lookup a symbol in all files' global blocks.
67be31e5
DE
1632
1633 If BLOCK is non-NULL then it is used for two things:
1634 1) If a target-specific lookup routine for libraries exists, then use the
1635 routine for the objfile of BLOCK, and
1636 2) The objfile of BLOCK is used to assist in determining the search order
1637 if the target requires it.
1638 See gdbarch_iterate_over_objfiles_in_search_order.
1639
d12307c1 1640 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1641
d12307c1
PMR
1642extern struct block_symbol
1643 lookup_global_symbol (const char *name,
1644 const struct block *block,
1645 const domain_enum domain);
5f9a71c3 1646
d1a2d36d 1647/* Lookup a symbol in block BLOCK.
d12307c1 1648 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1649
d12307c1
PMR
1650extern struct symbol *
1651 lookup_symbol_in_block (const char *name,
de63c46b 1652 symbol_name_match_type match_type,
d12307c1
PMR
1653 const struct block *block,
1654 const domain_enum domain);
5f9a71c3 1655
cf901d3b
DE
1656/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1657 found, or NULL if not found. */
1658
d12307c1
PMR
1659extern struct block_symbol
1660 lookup_language_this (const struct language_defn *lang,
1661 const struct block *block);
66a17cb6 1662
cf901d3b 1663/* Lookup a [struct, union, enum] by name, within a specified block. */
c906108c 1664
270140bd 1665extern struct type *lookup_struct (const char *, const struct block *);
c906108c 1666
270140bd 1667extern struct type *lookup_union (const char *, const struct block *);
c906108c 1668
270140bd 1669extern struct type *lookup_enum (const char *, const struct block *);
c906108c 1670
c906108c
SS
1671/* from blockframe.c: */
1672
c378eb4e 1673/* lookup the function symbol corresponding to the address. */
c906108c 1674
a14ed312 1675extern struct symbol *find_pc_function (CORE_ADDR);
c906108c 1676
c378eb4e 1677/* lookup the function corresponding to the address and section. */
c906108c 1678
714835d5 1679extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
c5aa993b 1680
71a3c369
TT
1681/* Find the symbol at the given address. Returns NULL if no symbol
1682 found. Only exact matches for ADDRESS are considered. */
1683
1684extern struct symbol *find_symbol_at_address (CORE_ADDR);
1685
c378eb4e 1686/* lookup function from address, return name, start addr and end addr. */
c906108c 1687
2c02bd72 1688extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *,
570b8f7c 1689 CORE_ADDR *);
c906108c 1690
8388016d
PA
1691/* Return the type of a function with its first instruction exactly at
1692 the PC address. Return NULL otherwise. */
1693
1694extern struct type *find_function_type (CORE_ADDR pc);
1695
1696/* See if we can figure out the function's actual type from the type
1697 that the resolver returns. RESOLVER_FUNADDR is the address of the
1698 ifunc resolver. */
1699
1700extern struct type *find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr);
1701
ca31ab1d
PA
1702/* Find the GNU ifunc minimal symbol that matches SYM. */
1703extern bound_minimal_symbol find_gnu_ifunc (const symbol *sym);
1704
a14ed312 1705extern void clear_pc_function_cache (void);
c906108c 1706
2097ae25 1707/* Expand symtab containing PC, SECTION if not already expanded. */
c906108c 1708
2097ae25 1709extern void expand_symtab_containing_pc (CORE_ADDR, struct obj_section *);
c906108c 1710
c378eb4e 1711/* lookup full symbol table by address. */
c906108c 1712
43f3e411 1713extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
c906108c 1714
c378eb4e 1715/* lookup full symbol table by address and section. */
c906108c 1716
43f3e411
DE
1717extern struct compunit_symtab *
1718 find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
c906108c 1719
a14ed312 1720extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
c906108c 1721
a14ed312 1722extern void reread_symbols (void);
c906108c 1723
cf901d3b
DE
1724/* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1725 The type returned must not be opaque -- i.e., must have at least one field
1726 defined. */
1727
a14ed312 1728extern struct type *lookup_transparent_type (const char *);
c906108c 1729
cf901d3b 1730extern struct type *basic_lookup_transparent_type (const char *);
c906108c 1731
c378eb4e 1732/* Macro for name of symbol to indicate a file compiled with gcc. */
c906108c
SS
1733#ifndef GCC_COMPILED_FLAG_SYMBOL
1734#define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1735#endif
1736
c378eb4e 1737/* Macro for name of symbol to indicate a file compiled with gcc2. */
c906108c
SS
1738#ifndef GCC2_COMPILED_FLAG_SYMBOL
1739#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1740#endif
1741
0875794a
JK
1742extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1743
07be84bf
JK
1744/* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1745 for ELF symbol files. */
1746
1747struct gnu_ifunc_fns
1748{
1749 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
1750 CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1751
1752 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
1753 int (*gnu_ifunc_resolve_name) (const char *function_name,
1754 CORE_ADDR *function_address_p);
0e30163f
JK
1755
1756 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
1757 void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1758
1759 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
1760 void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
07be84bf
JK
1761};
1762
1763#define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1764#define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
0e30163f
JK
1765#define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1766#define gnu_ifunc_resolver_return_stop \
1767 gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
07be84bf
JK
1768
1769extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1770
52f729a7 1771extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
c906108c 1772
c906108c 1773struct symtab_and_line
17c5ed2c 1774{
6c95b8df 1775 /* The program space of this sal. */
51abb421 1776 struct program_space *pspace = NULL;
6c95b8df 1777
51abb421 1778 struct symtab *symtab = NULL;
06871ae8 1779 struct symbol *symbol = NULL;
51abb421 1780 struct obj_section *section = NULL;
3467ec66 1781 struct minimal_symbol *msymbol = NULL;
17c5ed2c
DC
1782 /* Line number. Line numbers start at 1 and proceed through symtab->nlines.
1783 0 is never a valid line number; it is used to indicate that line number
1784 information is not available. */
51abb421 1785 int line = 0;
17c5ed2c 1786
51abb421
PA
1787 CORE_ADDR pc = 0;
1788 CORE_ADDR end = 0;
1789 bool explicit_pc = false;
1790 bool explicit_line = false;
55aa24fb
SDJ
1791
1792 /* The probe associated with this symtab_and_line. */
935676c9 1793 probe *prob = NULL;
729662a5
TT
1794 /* If PROBE is not NULL, then this is the objfile in which the probe
1795 originated. */
51abb421 1796 struct objfile *objfile = NULL;
17c5ed2c 1797};
c906108c 1798
c5aa993b 1799\f
c906108c 1800
c906108c
SS
1801/* Given a pc value, return line number it is in. Second arg nonzero means
1802 if pc is on the boundary use the previous statement's line number. */
1803
a14ed312 1804extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
c906108c 1805
c378eb4e 1806/* Same function, but specify a section as well as an address. */
c906108c 1807
714835d5
UW
1808extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1809 struct obj_section *, int);
c906108c 1810
34248c3a
DE
1811/* Wrapper around find_pc_line to just return the symtab. */
1812
1813extern struct symtab *find_pc_line_symtab (CORE_ADDR);
1814
c906108c
SS
1815/* Given a symtab and line number, return the pc there. */
1816
a14ed312 1817extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
c906108c 1818
570b8f7c
AC
1819extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1820 CORE_ADDR *);
c906108c 1821
a14ed312 1822extern void resolve_sal_pc (struct symtab_and_line *);
c906108c 1823
f176c4b5 1824/* solib.c */
c906108c 1825
a14ed312 1826extern void clear_solib (void);
c906108c 1827
c906108c
SS
1828/* source.c */
1829
a14ed312 1830extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
c906108c 1831
dfaae886
MM
1832/* Flags passed as 4th argument to print_source_lines. */
1833
8d297bbf 1834enum print_source_lines_flag
dfaae886
MM
1835 {
1836 /* Do not print an error message. */
4cd29721
MM
1837 PRINT_SOURCE_LINES_NOERROR = (1 << 0),
1838
1839 /* Print the filename in front of the source lines. */
1840 PRINT_SOURCE_LINES_FILENAME = (1 << 1)
dfaae886 1841 };
8d297bbf 1842DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags);
dfaae886
MM
1843
1844extern void print_source_lines (struct symtab *, int, int,
8d297bbf 1845 print_source_lines_flags);
c906108c 1846
00174a86 1847extern void forget_cached_source_info_for_objfile (struct objfile *);
a14ed312 1848extern void forget_cached_source_info (void);
c906108c 1849
a14ed312 1850extern void select_source_symtab (struct symtab *);
c906108c 1851
c6756f62
PA
1852/* The reason we're calling into a completion match list collector
1853 function. */
1854enum class complete_symbol_mode
1855 {
1856 /* Completing an expression. */
1857 EXPRESSION,
1858
1859 /* Completing a linespec. */
1860 LINESPEC,
1861 };
1862
eb3ff9a5
PA
1863extern void default_collect_symbol_completion_matches_break_on
1864 (completion_tracker &tracker,
c6756f62 1865 complete_symbol_mode mode,
b5ec771e 1866 symbol_name_match_type name_match_type,
eb3ff9a5 1867 const char *text, const char *word, const char *break_on,
2f68a895 1868 enum type_code code);
eb3ff9a5
PA
1869extern void default_collect_symbol_completion_matches
1870 (completion_tracker &tracker,
c6756f62 1871 complete_symbol_mode,
b5ec771e 1872 symbol_name_match_type name_match_type,
eb3ff9a5
PA
1873 const char *,
1874 const char *,
1875 enum type_code);
b5ec771e
PA
1876extern void collect_symbol_completion_matches
1877 (completion_tracker &tracker,
1878 complete_symbol_mode mode,
1879 symbol_name_match_type name_match_type,
1880 const char *, const char *);
eb3ff9a5
PA
1881extern void collect_symbol_completion_matches_type (completion_tracker &tracker,
1882 const char *, const char *,
2f68a895 1883 enum type_code);
c906108c 1884
b5ec771e
PA
1885extern void collect_file_symbol_completion_matches
1886 (completion_tracker &tracker,
1887 complete_symbol_mode,
1888 symbol_name_match_type name_match_type,
1889 const char *, const char *, const char *);
c94fdfd0 1890
eb3ff9a5
PA
1891extern completion_list
1892 make_source_files_completion_list (const char *, const char *);
c94fdfd0 1893
f9d67a22
PA
1894/* Return whether SYM is a function/method, as opposed to a data symbol. */
1895
1896extern bool symbol_is_function_or_method (symbol *sym);
1897
1898/* Return whether MSYMBOL is a function/method, as opposed to a data
1899 symbol */
1900
1901extern bool symbol_is_function_or_method (minimal_symbol *msymbol);
1902
1903/* Return whether SYM should be skipped in completion mode MODE. In
1904 linespec mode, we're only interested in functions/methods. */
1905
1906template<typename Symbol>
1907static bool
1908completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
1909{
1910 return (mode == complete_symbol_mode::LINESPEC
1911 && !symbol_is_function_or_method (sym));
1912}
1913
c906108c
SS
1914/* symtab.c */
1915
714835d5 1916int matching_obj_sections (struct obj_section *, struct obj_section *);
94277a38 1917
50641945
FN
1918extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1919
42ddae10
PA
1920/* Given a function symbol SYM, find the symtab and line for the start
1921 of the function. If FUNFIRSTLINE is true, we want the first line
1922 of real code inside the function. */
1923extern symtab_and_line find_function_start_sal (symbol *sym, bool
1924 funfirstline);
1925
1926/* Same, but start with a function address/section instead of a
1927 symbol. */
1928extern symtab_and_line find_function_start_sal (CORE_ADDR func_addr,
1929 obj_section *section,
1930 bool funfirstline);
50641945 1931
059acae7
UW
1932extern void skip_prologue_sal (struct symtab_and_line *);
1933
c906108c
SS
1934/* symtab.c */
1935
d80b854b
UW
1936extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1937 CORE_ADDR func_addr);
634aa483 1938
a14ed312
KB
1939extern struct symbol *fixup_symbol_section (struct symbol *,
1940 struct objfile *);
c906108c 1941
bf223d3e
PA
1942/* If MSYMBOL is an text symbol, look for a function debug symbol with
1943 the same address. Returns NULL if not found. This is necessary in
1944 case a function is an alias to some other function, because debug
1945 information is only emitted for the alias target function's
1946 definition, not for the alias. */
1947extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
1948
c906108c 1949/* Symbol searching */
5c04624b
DE
1950/* Note: struct symbol_search, search_symbols, et.al. are declared here,
1951 instead of making them local to symtab.c, for gdbtk's sake. */
c906108c 1952
b9c04fb2
TT
1953/* When using search_symbols, a vector of the following structs is
1954 returned. */
c906108c 1955struct symbol_search
17c5ed2c 1956{
b9c04fb2
TT
1957 symbol_search (int block_, struct symbol *symbol_)
1958 : block (block_),
1959 symbol (symbol_)
1960 {
1961 msymbol.minsym = nullptr;
1962 msymbol.objfile = nullptr;
1963 }
1964
1965 symbol_search (int block_, struct minimal_symbol *minsym,
1966 struct objfile *objfile)
1967 : block (block_),
1968 symbol (nullptr)
1969 {
1970 msymbol.minsym = minsym;
1971 msymbol.objfile = objfile;
1972 }
1973
1974 bool operator< (const symbol_search &other) const
1975 {
1976 return compare_search_syms (*this, other) < 0;
1977 }
1978
1979 bool operator== (const symbol_search &other) const
1980 {
1981 return compare_search_syms (*this, other) == 0;
1982 }
1983
c378eb4e
MS
1984 /* The block in which the match was found. Could be, for example,
1985 STATIC_BLOCK or GLOBAL_BLOCK. */
17c5ed2c 1986 int block;
c906108c 1987
17c5ed2c 1988 /* Information describing what was found.
c906108c 1989
d01060f0 1990 If symbol is NOT NULL, then information was found for this match. */
17c5ed2c 1991 struct symbol *symbol;
c906108c 1992
17c5ed2c 1993 /* If msymbol is non-null, then a match was made on something for
c378eb4e 1994 which only minimal_symbols exist. */
7c7b6655 1995 struct bound_minimal_symbol msymbol;
c906108c 1996
b9c04fb2
TT
1997private:
1998
1999 static int compare_search_syms (const symbol_search &sym_a,
2000 const symbol_search &sym_b);
17c5ed2c 2001};
c906108c 2002
b9c04fb2
TT
2003extern std::vector<symbol_search> search_symbols (const char *,
2004 enum search_domain, int,
2005 const char **);
c906108c 2006
51cc5b07
AC
2007/* The name of the ``main'' function.
2008 FIXME: cagney/2001-03-20: Can't make main_name() const since some
2009 of the calling code currently assumes that the string isn't
c378eb4e 2010 const. */
17c5ed2c 2011extern /*const */ char *main_name (void);
9e6c82ad 2012extern enum language main_language (void);
51cc5b07 2013
cf901d3b
DE
2014/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
2015 This searches MAIN_OBJFILE as well as any associated separate debug info
2016 objfiles of MAIN_OBJFILE.
d12307c1 2017 Upon success fixes up the symbol's section if necessary. */
cf901d3b 2018
d12307c1 2019extern struct block_symbol
efad9b6a 2020 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
cf901d3b
DE
2021 const char *name,
2022 const domain_enum domain);
3a40aaa0 2023
a6c727b2
DJ
2024/* Return 1 if the supplied producer string matches the ARM RealView
2025 compiler (armcc). */
2026int producer_is_realview (const char *producer);
3a40aaa0 2027
ccefe4c4
TT
2028void fixup_section (struct general_symbol_info *ginfo,
2029 CORE_ADDR addr, struct objfile *objfile);
2030
cf901d3b
DE
2031/* Look up objfile containing BLOCK. */
2032
c0201579
JK
2033struct objfile *lookup_objfile_from_block (const struct block *block);
2034
db0fec5c 2035extern unsigned int symtab_create_debug;
45cfd468 2036
cc485e62
DE
2037extern unsigned int symbol_lookup_debug;
2038
c011a4f4
DE
2039extern int basenames_may_differ;
2040
4aac40c8 2041int compare_filenames_for_search (const char *filename,
b57a636e 2042 const char *search_name);
4aac40c8 2043
cce0e923
DE
2044int compare_glob_filenames_for_search (const char *filename,
2045 const char *search_name);
2046
14bc53a8
PA
2047bool iterate_over_some_symtabs (const char *name,
2048 const char *real_path,
2049 struct compunit_symtab *first,
2050 struct compunit_symtab *after_last,
2051 gdb::function_view<bool (symtab *)> callback);
f8eba3c6
TT
2052
2053void iterate_over_symtabs (const char *name,
14bc53a8
PA
2054 gdb::function_view<bool (symtab *)> callback);
2055
f8eba3c6 2056
67d89901
TT
2057std::vector<CORE_ADDR> find_pcs_for_symtab_line
2058 (struct symtab *symtab, int line, struct linetable_entry **best_entry);
f8eba3c6 2059
14bc53a8
PA
2060/* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
2061 is called once per matching symbol SYM. The callback should return
2062 true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
2063 iterating, or false to indicate that the iteration should end. */
8e704927 2064
14bc53a8 2065typedef bool (symbol_found_callback_ftype) (symbol *sym);
8e704927 2066
b5ec771e
PA
2067void iterate_over_symbols (const struct block *block,
2068 const lookup_name_info &name,
f8eba3c6 2069 const domain_enum domain,
14bc53a8 2070 gdb::function_view<symbol_found_callback_ftype> callback);
f8eba3c6 2071
2f408ecb
PA
2072/* Storage type used by demangle_for_lookup. demangle_for_lookup
2073 either returns a const char * pointer that points to either of the
2074 fields of this type, or a pointer to the input NAME. This is done
2075 this way because the underlying functions that demangle_for_lookup
2076 calls either return a std::string (e.g., cp_canonicalize_string) or
2077 a malloc'ed buffer (libiberty's demangled), and we want to avoid
2078 unnecessary reallocation/string copying. */
2079class demangle_result_storage
2080{
2081public:
2082
2083 /* Swap the std::string storage with STR, and return a pointer to
2084 the beginning of the new string. */
2085 const char *swap_string (std::string &str)
2086 {
2087 std::swap (m_string, str);
2088 return m_string.c_str ();
2089 }
2090
2091 /* Set the malloc storage to now point at PTR. Any previous malloc
2092 storage is released. */
2093 const char *set_malloc_ptr (char *ptr)
2094 {
2095 m_malloc.reset (ptr);
2096 return ptr;
2097 }
2098
2099private:
2100
2101 /* The storage. */
2102 std::string m_string;
2103 gdb::unique_xmalloc_ptr<char> m_malloc;
2104};
2105
2106const char *
2107 demangle_for_lookup (const char *name, enum language lang,
2108 demangle_result_storage &storage);
f8eba3c6 2109
e623cf5d
TT
2110struct symbol *allocate_symbol (struct objfile *);
2111
38bf1463 2112void initialize_objfile_symbol (struct symbol *);
e623cf5d
TT
2113
2114struct template_symbol *allocate_template_symbol (struct objfile *);
2115
b5ec771e
PA
2116/* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
2117 SYMNAME (which is already demangled for C++ symbols) matches
2118 SYM_TEXT in the first SYM_TEXT_LEN characters. If so, add it to
2119 the current completion list. */
2120void completion_list_add_name (completion_tracker &tracker,
2121 language symbol_language,
2122 const char *symname,
2123 const lookup_name_info &lookup_name,
b5ec771e
PA
2124 const char *text, const char *word);
2125
c906108c 2126#endif /* !defined(SYMTAB_H) */
This page took 2.056602 seconds and 4 git commands to generate.