ax-gdb: Remove two unused agent_expr *ax parameters
[deliverable/binutils-gdb.git] / gdb / symtab.h
CommitLineData
c906108c 1/* Symbol table definitions for GDB.
1bac305b 2
61baf725 3 Copyright (C) 1986-2017 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
67d89901 23#include <vector>
49c4e619 24#include "gdb_vecs.h"
2f68a895 25#include "gdbtypes.h"
8d297bbf 26#include "common/enum-flags.h"
14bc53a8 27#include "common/function-view.h"
f8eba3c6 28
5f8a3188 29/* Opaque declarations. */
da3331ec
AC
30struct ui_file;
31struct frame_info;
32struct symbol;
5f8a3188 33struct obstack;
6a2f5abf 34struct objfile;
fe898f56
DC
35struct block;
36struct blockvector;
4c2df51b
DJ
37struct axs_value;
38struct agent_expr;
6c95b8df 39struct program_space;
66a17cb6 40struct language_defn;
55aa24fb 41struct probe;
4357ac6c 42struct common_block;
06096720
AB
43struct obj_section;
44struct cmd_list_element;
c906108c 45
a7f19c79
MC
46/* Some of the structures in this file are space critical.
47 The space-critical structures are:
48
49 struct general_symbol_info
50 struct symbol
51 struct partial_symbol
52
5bccb4d1 53 These structures are laid out to encourage good packing.
a7f19c79
MC
54 They use ENUM_BITFIELD and short int fields, and they order the
55 structure members so that fields less than a word are next
c378eb4e 56 to each other so they can be packed together. */
a7f19c79
MC
57
58/* Rearranged: used ENUM_BITFIELD and rearranged field order in
59 all the space critical structures (plus struct minimal_symbol).
60 Memory usage dropped from 99360768 bytes to 90001408 bytes.
61 I measured this with before-and-after tests of
62 "HEAD-old-gdb -readnow HEAD-old-gdb" and
63 "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
64 red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
65 typing "maint space 1" at the first command prompt.
66
67 Here is another measurement (from andrew c):
68 # no /usr/lib/debug, just plain glibc, like a normal user
69 gdb HEAD-old-gdb
70 (gdb) break internal_error
71 (gdb) run
72 (gdb) maint internal-error
73 (gdb) backtrace
74 (gdb) maint space 1
75
76 gdb gdb_6_0_branch 2003-08-19 space used: 8896512
77 gdb HEAD 2003-08-19 space used: 8904704
78 gdb HEAD 2003-08-21 space used: 8396800 (+symtab.h)
79 gdb HEAD 2003-08-21 space used: 8265728 (+gdbtypes.h)
80
81 The third line shows the savings from the optimizations in symtab.h.
82 The fourth line shows the savings from the optimizations in
83 gdbtypes.h. Both optimizations are in gdb HEAD now.
84
85 --chastain 2003-08-21 */
86
c906108c
SS
87/* Define a structure for the information that is common to all symbol types,
88 including minimal symbols, partial symbols, and full symbols. In a
89 multilanguage environment, some language specific information may need to
c378eb4e 90 be recorded along with each symbol. */
c906108c 91
c378eb4e 92/* This structure is space critical. See space comments at the top. */
c906108c
SS
93
94struct general_symbol_info
17c5ed2c 95{
22abf04a 96 /* Name of the symbol. This is a required field. Storage for the
4a146b47
EZ
97 name is allocated on the objfile_obstack for the associated
98 objfile. For languages like C++ that make a distinction between
99 the mangled name and demangled name, this is the mangled
100 name. */
c906108c 101
0d5cff50 102 const char *name;
c906108c 103
17c5ed2c
DC
104 /* Value of the symbol. Which member of this union to use, and what
105 it means, depends on what kind of symbol this is and its
106 SYMBOL_CLASS. See comments there for more details. All of these
107 are in host byte order (though what they point to might be in
108 target byte order, e.g. LOC_CONST_BYTES). */
c906108c 109
17c5ed2c
DC
110 union
111 {
12df843f 112 LONGEST ivalue;
c906108c 113
3977b71f 114 const struct block *block;
c906108c 115
d47a1bc1 116 const gdb_byte *bytes;
c906108c 117
17c5ed2c 118 CORE_ADDR address;
c906108c 119
5a352474 120 /* A common block. Used with LOC_COMMON_BLOCK. */
4357ac6c 121
17a40b44 122 const struct common_block *common_block;
4357ac6c 123
c378eb4e 124 /* For opaque typedef struct chain. */
c906108c 125
17c5ed2c
DC
126 struct symbol *chain;
127 }
128 value;
c906108c 129
17c5ed2c 130 /* Since one and only one language can apply, wrap the language specific
29df156d 131 information inside a union. */
c906108c 132
17c5ed2c
DC
133 union
134 {
f85f34ed
TT
135 /* A pointer to an obstack that can be used for storage associated
136 with this symbol. This is only used by Ada, and only when the
137 'ada_mangled' field is zero. */
138 struct obstack *obstack;
139
afa16725 140 /* This is used by languages which wish to store a demangled name.
9c37b5ae 141 currently used by Ada, C++, and Objective C. */
615b3f62 142 const char *demangled_name;
17c5ed2c
DC
143 }
144 language_specific;
c5aa993b 145
17c5ed2c
DC
146 /* Record the source code language that applies to this symbol.
147 This is used to select one of the fields from the language specific
c378eb4e 148 union above. */
c5aa993b 149
51cdc993 150 ENUM_BITFIELD(language) language : LANGUAGE_BITS;
c5aa993b 151
a04a15f5 152 /* This is only used by Ada. If set, then the 'demangled_name' field
f85f34ed
TT
153 of language_specific is valid. Otherwise, the 'obstack' field is
154 valid. */
155 unsigned int ada_mangled : 1;
156
17c5ed2c
DC
157 /* Which section is this symbol in? This is an index into
158 section_offsets for this objfile. Negative means that the symbol
e27d198c 159 does not get relocated relative to a section. */
c5aa993b 160
17c5ed2c 161 short section;
17c5ed2c 162};
c906108c 163
cfc594ee
TT
164extern void symbol_set_demangled_name (struct general_symbol_info *,
165 const char *,
ccde22c0 166 struct obstack *);
b250c185 167
0d5cff50
DE
168extern const char *symbol_get_demangled_name
169 (const struct general_symbol_info *);
b250c185 170
714835d5 171extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
c906108c 172
88cda038 173/* Note that all the following SYMBOL_* macros are used with the
efd66ac6
TT
174 SYMBOL argument being either a partial symbol or
175 a full symbol. Both types have a ginfo field. In particular
33e5013e 176 the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
d6350901 177 macros cannot be entirely substituted by
88cda038
EZ
178 functions, unless the callers are changed to pass in the ginfo
179 field only, instead of the SYMBOL parameter. */
180
c906108c
SS
181#define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.ivalue
182#define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address
183#define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes
4357ac6c 184#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
c906108c
SS
185#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block
186#define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain
187#define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.language
188#define SYMBOL_SECTION(symbol) (symbol)->ginfo.section
e27d198c
TT
189#define SYMBOL_OBJ_SECTION(objfile, symbol) \
190 (((symbol)->ginfo.section >= 0) \
191 ? (&(((objfile)->sections)[(symbol)->ginfo.section])) \
192 : NULL)
c906108c 193
89aad1f9 194/* Initializes the language dependent portion of a symbol
c378eb4e 195 depending upon the language for the symbol. */
f85f34ed
TT
196#define SYMBOL_SET_LANGUAGE(symbol,language,obstack) \
197 (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
33e5013e 198extern void symbol_set_language (struct general_symbol_info *symbol,
f85f34ed
TT
199 enum language language,
200 struct obstack *obstack);
c906108c 201
3567439c
DJ
202/* Set just the linkage name of a symbol; do not try to demangle
203 it. Used for constructs which do not have a mangled name,
204 e.g. struct tags. Unlike SYMBOL_SET_NAMES, linkage_name must
1c9e8358
TT
205 be terminated and either already on the objfile's obstack or
206 permanently allocated. */
3567439c
DJ
207#define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
208 (symbol)->ginfo.name = (linkage_name)
209
210/* Set the linkage and natural names of a symbol, by demangling
211 the linkage name. */
04a679b8
TT
212#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
213 symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
2de7ced7 214extern void symbol_set_names (struct general_symbol_info *symbol,
04a679b8 215 const char *linkage_name, int len, int copy_name,
2de7ced7
DJ
216 struct objfile *objfile);
217
22abf04a
DC
218/* Now come lots of name accessor macros. Short version as to when to
219 use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
220 symbol in the original source code. Use SYMBOL_LINKAGE_NAME if you
221 want to know what the linker thinks the symbol's name is. Use
222 SYMBOL_PRINT_NAME for output. Use SYMBOL_DEMANGLED_NAME if you
223 specifically need to know whether SYMBOL_NATURAL_NAME and
3567439c 224 SYMBOL_LINKAGE_NAME are different. */
22abf04a
DC
225
226/* Return SYMBOL's "natural" name, i.e. the name that it was called in
227 the original source code. In languages like C++ where symbols may
228 be mangled for ease of manipulation by the linker, this is the
229 demangled name. */
230
231#define SYMBOL_NATURAL_NAME(symbol) \
232 (symbol_natural_name (&(symbol)->ginfo))
0d5cff50
DE
233extern const char *symbol_natural_name
234 (const struct general_symbol_info *symbol);
22abf04a
DC
235
236/* Return SYMBOL's name from the point of view of the linker. In
237 languages like C++ where symbols may be mangled for ease of
238 manipulation by the linker, this is the mangled name; otherwise,
3567439c 239 it's the same as SYMBOL_NATURAL_NAME. */
22abf04a
DC
240
241#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
242
9cc0d196 243/* Return the demangled name for a symbol based on the language for
c378eb4e 244 that symbol. If no demangled name exists, return NULL. */
9cc0d196
EZ
245#define SYMBOL_DEMANGLED_NAME(symbol) \
246 (symbol_demangled_name (&(symbol)->ginfo))
0d5cff50
DE
247extern const char *symbol_demangled_name
248 (const struct general_symbol_info *symbol);
c906108c 249
de5ad195
DC
250/* Macro that returns a version of the name of a symbol that is
251 suitable for output. In C++ this is the "demangled" form of the
252 name if demangle is on and the "mangled" form of the name if
253 demangle is off. In other languages this is just the symbol name.
254 The result should never be NULL. Don't use this for internal
50f182aa
DE
255 purposes (e.g. storing in a hashtable): it's only suitable for output.
256
257 N.B. symbol may be anything with a ginfo member,
258 e.g., struct symbol or struct minimal_symbol. */
de5ad195
DC
259
260#define SYMBOL_PRINT_NAME(symbol) \
22abf04a 261 (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
50f182aa 262extern int demangle;
c906108c 263
c378eb4e 264/* Macro that returns the name to be used when sorting and searching symbols.
9c37b5ae 265 In C++, we search for the demangled form of a name,
4725b721
PH
266 and so sort symbols accordingly. In Ada, however, we search by mangled
267 name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
c378eb4e 268 returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
4725b721
PH
269#define SYMBOL_SEARCH_NAME(symbol) \
270 (symbol_search_name (&(symbol)->ginfo))
0d5cff50 271extern const char *symbol_search_name (const struct general_symbol_info *);
4725b721 272
e9111bf7
DE
273/* Return non-zero if NAME matches the "search" name of SYMBOL.
274 Whitespace and trailing parentheses are ignored.
275 See strcmp_iw for details about its behavior. */
4725b721
PH
276#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
277 (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
278
87193939
MC
279/* Classification types for a minimal symbol. These should be taken as
280 "advisory only", since if gdb can't easily figure out a
281 classification it simply selects mst_unknown. It may also have to
282 guess when it can't figure out which is a better match between two
283 types (mst_data versus mst_bss) for example. Since the minimal
284 symbol info is sometimes derived from the BFD library's view of a
c378eb4e 285 file, we need to live with what information bfd supplies. */
87193939
MC
286
287enum minimal_symbol_type
288{
289 mst_unknown = 0, /* Unknown type, the default */
290 mst_text, /* Generally executable instructions */
0875794a
JK
291 mst_text_gnu_ifunc, /* Executable code returning address
292 of executable code */
293 mst_slot_got_plt, /* GOT entries for .plt sections */
87193939
MC
294 mst_data, /* Generally initialized data */
295 mst_bss, /* Generally uninitialized data */
296 mst_abs, /* Generally absolute (nonrelocatable) */
297 /* GDB uses mst_solib_trampoline for the start address of a shared
298 library trampoline entry. Breakpoints for shared library functions
299 are put there if the shared library is not yet loaded.
300 After the shared library is loaded, lookup_minimal_symbol will
301 prefer the minimal symbol from the shared library (usually
302 a mst_text symbol) over the mst_solib_trampoline symbol, and the
303 breakpoints will be moved to their true address in the shared
304 library via breakpoint_re_set. */
305 mst_solib_trampoline, /* Shared library trampoline code */
306 /* For the mst_file* types, the names are only guaranteed to be unique
307 within a given .o file. */
308 mst_file_text, /* Static version of mst_text */
309 mst_file_data, /* Static version of mst_data */
51cdc993
DE
310 mst_file_bss, /* Static version of mst_bss */
311 nr_minsym_types
87193939
MC
312};
313
51cdc993
DE
314/* The number of enum minimal_symbol_type values, with some padding for
315 reasonable growth. */
316#define MINSYM_TYPE_BITS 4
317gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
318
c906108c
SS
319/* Define a simple structure used to hold some very basic information about
320 all defined global symbols (text, data, bss, abs, etc). The only required
321 information is the general_symbol_info.
322
323 In many cases, even if a file was compiled with no special options for
324 debugging at all, as long as was not stripped it will contain sufficient
325 information to build a useful minimal symbol table using this structure.
326 Even when a file contains enough debugging information to build a full
327 symbol table, these minimal symbols are still useful for quickly mapping
328 between names and addresses, and vice versa. They are also sometimes
c378eb4e 329 used to figure out what full symbol table entries need to be read in. */
c906108c
SS
330
331struct minimal_symbol
17c5ed2c 332{
c906108c 333
17c5ed2c 334 /* The general symbol info required for all types of symbols.
c906108c 335
17c5ed2c
DC
336 The SYMBOL_VALUE_ADDRESS contains the address that this symbol
337 corresponds to. */
c906108c 338
efd66ac6 339 struct general_symbol_info mginfo;
c906108c 340
8763cede 341 /* Size of this symbol. dbx_end_psymtab in dbxread.c uses this
f594e5e9
MC
342 information to calculate the end of the partial symtab based on the
343 address of the last symbol plus the size of the last symbol. */
344
345 unsigned long size;
346
17c5ed2c 347 /* Which source file is this symbol in? Only relevant for mst_file_*. */
04aba065 348 const char *filename;
c906108c 349
87193939 350 /* Classification type for this minimal symbol. */
17c5ed2c 351
51cdc993 352 ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
17c5ed2c 353
422d65e7
DE
354 /* Non-zero if this symbol was created by gdb.
355 Such symbols do not appear in the output of "info var|fun". */
356 unsigned int created_by_gdb : 1;
357
b887350f
TT
358 /* Two flag bits provided for the use of the target. */
359 unsigned int target_flag_1 : 1;
360 unsigned int target_flag_2 : 1;
361
d9eaeb59
JB
362 /* Nonzero iff the size of the minimal symbol has been set.
363 Symbol size information can sometimes not be determined, because
364 the object file format may not carry that piece of information. */
365 unsigned int has_size : 1;
366
17c5ed2c
DC
367 /* Minimal symbols with the same hash key are kept on a linked
368 list. This is the link. */
369
370 struct minimal_symbol *hash_next;
371
372 /* Minimal symbols are stored in two different hash tables. This is
373 the `next' pointer for the demangled hash table. */
374
375 struct minimal_symbol *demangled_hash_next;
376};
c906108c 377
b887350f
TT
378#define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
379#define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
d9eaeb59
JB
380#define MSYMBOL_SIZE(msymbol) ((msymbol)->size + 0)
381#define SET_MSYMBOL_SIZE(msymbol, sz) \
382 do \
383 { \
384 (msymbol)->size = sz; \
385 (msymbol)->has_size = 1; \
386 } while (0)
387#define MSYMBOL_HAS_SIZE(msymbol) ((msymbol)->has_size + 0)
c906108c 388#define MSYMBOL_TYPE(msymbol) (msymbol)->type
c906108c 389
efd66ac6 390#define MSYMBOL_VALUE(symbol) (symbol)->mginfo.value.ivalue
77e371c0
TT
391/* The unrelocated address of the minimal symbol. */
392#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
2273f0ac
TT
393/* The relocated address of the minimal symbol, using the section
394 offsets from OBJFILE. */
77e371c0
TT
395#define MSYMBOL_VALUE_ADDRESS(objfile, symbol) \
396 ((symbol)->mginfo.value.address \
2273f0ac 397 + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
77e371c0
TT
398/* For a bound minsym, we can easily compute the address directly. */
399#define BMSYMBOL_VALUE_ADDRESS(symbol) \
400 MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
401#define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value) \
40c1a007 402 ((symbol)->mginfo.value.address = (new_value))
efd66ac6
TT
403#define MSYMBOL_VALUE_BYTES(symbol) (symbol)->mginfo.value.bytes
404#define MSYMBOL_BLOCK_VALUE(symbol) (symbol)->mginfo.value.block
405#define MSYMBOL_VALUE_CHAIN(symbol) (symbol)->mginfo.value.chain
406#define MSYMBOL_LANGUAGE(symbol) (symbol)->mginfo.language
407#define MSYMBOL_SECTION(symbol) (symbol)->mginfo.section
408#define MSYMBOL_OBJ_SECTION(objfile, symbol) \
409 (((symbol)->mginfo.section >= 0) \
410 ? (&(((objfile)->sections)[(symbol)->mginfo.section])) \
411 : NULL)
412
413#define MSYMBOL_NATURAL_NAME(symbol) \
414 (symbol_natural_name (&(symbol)->mginfo))
415#define MSYMBOL_LINKAGE_NAME(symbol) (symbol)->mginfo.name
416#define MSYMBOL_PRINT_NAME(symbol) \
417 (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
418#define MSYMBOL_DEMANGLED_NAME(symbol) \
419 (symbol_demangled_name (&(symbol)->mginfo))
420#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack) \
421 (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
422#define MSYMBOL_SEARCH_NAME(symbol) \
423 (symbol_search_name (&(symbol)->mginfo))
424#define MSYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
425 (strcmp_iw (MSYMBOL_SEARCH_NAME (symbol), (name)) == 0)
426#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
427 symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
428
c35384fb
TT
429#include "minsyms.h"
430
c906108c 431\f
c5aa993b 432
c906108c
SS
433/* Represent one symbol name; a variable, constant, function or typedef. */
434
176620f1 435/* Different name domains for symbols. Looking up a symbol specifies a
c378eb4e 436 domain and ignores symbol definitions in other name domains. */
c906108c 437
87193939 438typedef enum domain_enum_tag
17c5ed2c 439{
176620f1 440 /* UNDEF_DOMAIN is used when a domain has not been discovered or
17c5ed2c 441 none of the following apply. This usually indicates an error either
c378eb4e 442 in the symbol information or in gdb's handling of symbols. */
c906108c 443
176620f1 444 UNDEF_DOMAIN,
c906108c 445
176620f1 446 /* VAR_DOMAIN is the usual domain. In C, this contains variables,
c378eb4e 447 function names, typedef names and enum type values. */
c906108c 448
176620f1 449 VAR_DOMAIN,
c906108c 450
176620f1 451 /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
17c5ed2c 452 Thus, if `struct foo' is used in a C program, it produces a symbol named
c378eb4e 453 `foo' in the STRUCT_DOMAIN. */
c906108c 454
176620f1 455 STRUCT_DOMAIN,
c906108c 456
530e8392
KB
457 /* MODULE_DOMAIN is used in Fortran to hold module type names. */
458
459 MODULE_DOMAIN,
460
0f5238ed 461 /* LABEL_DOMAIN may be used for names of labels (for gotos). */
c906108c 462
4357ac6c
TT
463 LABEL_DOMAIN,
464
5a352474
JK
465 /* Fortran common blocks. Their naming must be separate from VAR_DOMAIN.
466 They also always use LOC_COMMON_BLOCK. */
51cdc993
DE
467 COMMON_BLOCK_DOMAIN,
468
469 /* This must remain last. */
470 NR_DOMAINS
8903c50d 471} domain_enum;
c906108c 472
c01feb36
DE
473/* The number of bits in a symbol used to represent the domain. */
474
51cdc993
DE
475#define SYMBOL_DOMAIN_BITS 3
476gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
c01feb36 477
20c681d1
DE
478extern const char *domain_name (domain_enum);
479
e8930875
JK
480/* Searching domains, used for `search_symbols'. Element numbers are
481 hardcoded in GDB, check all enum uses before changing it. */
c906108c 482
8903c50d
TT
483enum search_domain
484{
bd2e94ce
TT
485 /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
486 TYPES_DOMAIN. */
e8930875 487 VARIABLES_DOMAIN = 0,
c906108c 488
c378eb4e 489 /* All functions -- for some reason not methods, though. */
e8930875 490 FUNCTIONS_DOMAIN = 1,
c906108c 491
17c5ed2c 492 /* All defined types */
e8930875 493 TYPES_DOMAIN = 2,
7b08b9eb
JK
494
495 /* Any type. */
496 ALL_DOMAIN = 3
8903c50d 497};
c906108c 498
20c681d1
DE
499extern const char *search_domain_name (enum search_domain);
500
c906108c
SS
501/* An address-class says where to find the value of a symbol. */
502
503enum address_class
17c5ed2c 504{
c378eb4e 505 /* Not used; catches errors. */
c5aa993b 506
17c5ed2c 507 LOC_UNDEF,
c906108c 508
c378eb4e 509 /* Value is constant int SYMBOL_VALUE, host byteorder. */
c906108c 510
17c5ed2c 511 LOC_CONST,
c906108c 512
c378eb4e 513 /* Value is at fixed address SYMBOL_VALUE_ADDRESS. */
c906108c 514
17c5ed2c 515 LOC_STATIC,
c906108c 516
768a979c
UW
517 /* Value is in register. SYMBOL_VALUE is the register number
518 in the original debug format. SYMBOL_REGISTER_OPS holds a
519 function that can be called to transform this into the
520 actual register number this represents in a specific target
521 architecture (gdbarch).
2a2d4dc3
AS
522
523 For some symbol formats (stabs, for some compilers at least),
524 the compiler generates two symbols, an argument and a register.
525 In some cases we combine them to a single LOC_REGISTER in symbol
526 reading, but currently not for all cases (e.g. it's passed on the
527 stack and then loaded into a register). */
c906108c 528
17c5ed2c 529 LOC_REGISTER,
c906108c 530
17c5ed2c 531 /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */
c906108c 532
17c5ed2c 533 LOC_ARG,
c906108c 534
17c5ed2c 535 /* Value address is at SYMBOL_VALUE offset in arglist. */
c906108c 536
17c5ed2c 537 LOC_REF_ARG,
c906108c 538
2a2d4dc3 539 /* Value is in specified register. Just like LOC_REGISTER except the
17c5ed2c 540 register holds the address of the argument instead of the argument
c378eb4e 541 itself. This is currently used for the passing of structs and unions
17c5ed2c
DC
542 on sparc and hppa. It is also used for call by reference where the
543 address is in a register, at least by mipsread.c. */
c906108c 544
17c5ed2c 545 LOC_REGPARM_ADDR,
c906108c 546
17c5ed2c 547 /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */
c906108c 548
17c5ed2c 549 LOC_LOCAL,
c906108c 550
176620f1
EZ
551 /* Value not used; definition in SYMBOL_TYPE. Symbols in the domain
552 STRUCT_DOMAIN all have this class. */
c906108c 553
17c5ed2c 554 LOC_TYPEDEF,
c906108c 555
c378eb4e 556 /* Value is address SYMBOL_VALUE_ADDRESS in the code. */
c906108c 557
17c5ed2c 558 LOC_LABEL,
c906108c 559
17c5ed2c
DC
560 /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
561 In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
c378eb4e 562 of the block. Function names have this class. */
c906108c 563
17c5ed2c 564 LOC_BLOCK,
c906108c 565
17c5ed2c
DC
566 /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
567 target byte order. */
c906108c 568
17c5ed2c 569 LOC_CONST_BYTES,
c906108c 570
17c5ed2c
DC
571 /* Value is at fixed address, but the address of the variable has
572 to be determined from the minimal symbol table whenever the
573 variable is referenced.
574 This happens if debugging information for a global symbol is
575 emitted and the corresponding minimal symbol is defined
576 in another object file or runtime common storage.
577 The linker might even remove the minimal symbol if the global
578 symbol is never referenced, in which case the symbol remains
de40b933
JK
579 unresolved.
580
581 GDB would normally find the symbol in the minimal symbol table if it will
582 not find it in the full symbol table. But a reference to an external
583 symbol in a local block shadowing other definition requires full symbol
584 without possibly having its address available for LOC_STATIC. Testcase
5382cfab
PW
585 is provided as `gdb.dwarf2/dw2-unresolved.exp'.
586
587 This is also used for thread local storage (TLS) variables. In this case,
588 the address of the TLS variable must be determined when the variable is
589 referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
590 of the TLS variable in the thread local storage of the shared
591 library/object. */
c906108c 592
17c5ed2c 593 LOC_UNRESOLVED,
c906108c 594
17c5ed2c
DC
595 /* The variable does not actually exist in the program.
596 The value is ignored. */
c906108c 597
17c5ed2c 598 LOC_OPTIMIZED_OUT,
c906108c 599
4c2df51b 600 /* The variable's address is computed by a set of location
768a979c 601 functions (see "struct symbol_computed_ops" below). */
4c2df51b 602 LOC_COMPUTED,
5a352474
JK
603
604 /* The variable uses general_symbol_info->value->common_block field.
605 It also always uses COMMON_BLOCK_DOMAIN. */
606 LOC_COMMON_BLOCK,
f1e6e072
TT
607
608 /* Not used, just notes the boundary of the enum. */
609 LOC_FINAL_VALUE
4c2df51b
DJ
610};
611
51cdc993
DE
612/* The number of bits needed for values in enum address_class, with some
613 padding for reasonable growth, and room for run-time registered address
614 classes. See symtab.c:MAX_SYMBOL_IMPLS.
615 This is a #define so that we can have a assertion elsewhere to
616 verify that we have reserved enough space for synthetic address
617 classes. */
618#define SYMBOL_ACLASS_BITS 5
619gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
620
768a979c 621/* The methods needed to implement LOC_COMPUTED. These methods can
a67af2b9
AC
622 use the symbol's .aux_value for additional per-symbol information.
623
624 At present this is only used to implement location expressions. */
625
768a979c 626struct symbol_computed_ops
4c2df51b
DJ
627{
628
629 /* Return the value of the variable SYMBOL, relative to the stack
630 frame FRAME. If the variable has been optimized out, return
631 zero.
632
0b31a4bc
TT
633 Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
634 FRAME may be zero. */
4c2df51b
DJ
635
636 struct value *(*read_variable) (struct symbol * symbol,
637 struct frame_info * frame);
638
e18b2753
JK
639 /* Read variable SYMBOL like read_variable at (callee) FRAME's function
640 entry. SYMBOL should be a function parameter, otherwise
641 NO_ENTRY_VALUE_ERROR will be thrown. */
642 struct value *(*read_variable_at_entry) (struct symbol *symbol,
643 struct frame_info *frame);
644
0b31a4bc
TT
645 /* Find the "symbol_needs_kind" value for the given symbol. This
646 value determines whether reading the symbol needs memory (e.g., a
647 global variable), just registers (a thread-local), or a frame (a
648 local variable). */
649 enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
4c2df51b
DJ
650
651 /* Write to STREAM a natural-language description of the location of
08922a10
SS
652 SYMBOL, in the context of ADDR. */
653 void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
654 struct ui_file * stream);
4c2df51b 655
f1e6e072
TT
656 /* Non-zero if this symbol's address computation is dependent on PC. */
657 unsigned char location_has_loclist;
658
4c2df51b
DJ
659 /* Tracepoint support. Append bytecodes to the tracepoint agent
660 expression AX that push the address of the object SYMBOL. Set
661 VALUE appropriately. Note --- for objects in registers, this
662 needn't emit any code; as long as it sets VALUE properly, then
663 the caller will generate the right code in the process of
664 treating this as an lvalue or rvalue. */
665
505e835d
UW
666 void (*tracepoint_var_ref) (struct symbol *symbol, struct gdbarch *gdbarch,
667 struct agent_expr *ax, struct axs_value *value);
bb2ec1b3
TT
668
669 /* Generate C code to compute the location of SYMBOL. The C code is
670 emitted to STREAM. GDBARCH is the current architecture and PC is
671 the PC at which SYMBOL's location should be evaluated.
672 REGISTERS_USED is a vector indexed by register number; the
673 generator function should set an element in this vector if the
674 corresponding register is needed by the location computation.
675 The generated C code must assign the location to a local
676 variable; this variable's name is RESULT_NAME. */
677
d7e74731 678 void (*generate_c_location) (struct symbol *symbol, string_file &stream,
bb2ec1b3
TT
679 struct gdbarch *gdbarch,
680 unsigned char *registers_used,
681 CORE_ADDR pc, const char *result_name);
682
17c5ed2c 683};
c906108c 684
f1e6e072
TT
685/* The methods needed to implement LOC_BLOCK for inferior functions.
686 These methods can use the symbol's .aux_value for additional
687 per-symbol information. */
688
689struct symbol_block_ops
690{
691 /* Fill in *START and *LENGTH with DWARF block data of function
692 FRAMEFUNC valid for inferior context address PC. Set *LENGTH to
693 zero if such location is not valid for PC; *START is left
694 uninitialized in such case. */
695 void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
696 const gdb_byte **start, size_t *length);
63e43d3a
PMR
697
698 /* Return the frame base address. FRAME is the frame for which we want to
699 compute the base address while FRAMEFUNC is the symbol for the
700 corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
701 information we need).
702
703 This method is designed to work with static links (nested functions
704 handling). Static links are function properties whose evaluation returns
705 the frame base address for the enclosing frame. However, there are
706 multiple definitions for "frame base": the content of the frame base
707 register, the CFA as defined by DWARF unwinding information, ...
708
709 So this specific method is supposed to compute the frame base address such
710 as for nested fuctions, the static link computes the same address. For
711 instance, considering DWARF debugging information, the static link is
712 computed with DW_AT_static_link and this method must be used to compute
713 the corresponding DW_AT_frame_base attribute. */
714 CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
715 struct frame_info *frame);
f1e6e072
TT
716};
717
768a979c
UW
718/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
719
720struct symbol_register_ops
721{
722 int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
723};
724
f1e6e072
TT
725/* Objects of this type are used to find the address class and the
726 various computed ops vectors of a symbol. */
727
728struct symbol_impl
729{
730 enum address_class aclass;
731
732 /* Used with LOC_COMPUTED. */
733 const struct symbol_computed_ops *ops_computed;
734
735 /* Used with LOC_BLOCK. */
736 const struct symbol_block_ops *ops_block;
737
738 /* Used with LOC_REGISTER and LOC_REGPARM_ADDR. */
739 const struct symbol_register_ops *ops_register;
740};
741
c378eb4e 742/* This structure is space critical. See space comments at the top. */
a7f19c79 743
c906108c 744struct symbol
17c5ed2c 745{
c906108c 746
c378eb4e 747 /* The general symbol info required for all types of symbols. */
c906108c 748
17c5ed2c 749 struct general_symbol_info ginfo;
c906108c 750
17c5ed2c 751 /* Data type of value */
c906108c 752
17c5ed2c 753 struct type *type;
c906108c 754
1994afbf 755 /* The owner of this symbol.
e2ada9cb 756 Which one to use is defined by symbol.is_objfile_owned. */
1994afbf
DE
757
758 union
759 {
760 /* The symbol table containing this symbol. This is the file associated
761 with LINE. It can be NULL during symbols read-in but it is never NULL
762 during normal operation. */
763 struct symtab *symtab;
764
765 /* For types defined by the architecture. */
766 struct gdbarch *arch;
767 } owner;
cb1df416 768
176620f1 769 /* Domain code. */
c906108c 770
c01feb36 771 ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
c906108c 772
f1e6e072
TT
773 /* Address class. This holds an index into the 'symbol_impls'
774 table. The actual enum address_class value is stored there,
775 alongside any per-class ops vectors. */
c906108c 776
f1e6e072 777 unsigned int aclass_index : SYMBOL_ACLASS_BITS;
c906108c 778
1994afbf
DE
779 /* If non-zero then symbol is objfile-owned, use owner.symtab.
780 Otherwise symbol is arch-owned, use owner.arch. */
781
782 unsigned int is_objfile_owned : 1;
783
2a2d4dc3
AS
784 /* Whether this is an argument. */
785
786 unsigned is_argument : 1;
787
edb3359d
DJ
788 /* Whether this is an inlined function (class LOC_BLOCK only). */
789 unsigned is_inlined : 1;
790
34eaf542
TT
791 /* True if this is a C++ function symbol with template arguments.
792 In this case the symbol is really a "struct template_symbol". */
793 unsigned is_cplus_template_function : 1;
794
edb3359d
DJ
795 /* Line number of this symbol's definition, except for inlined
796 functions. For an inlined function (class LOC_BLOCK and
797 SYMBOL_INLINED set) this is the line number of the function's call
798 site. Inlined function symbols are not definitions, and they are
799 never found by symbol table lookup.
1994afbf 800 If this symbol is arch-owned, LINE shall be zero.
edb3359d
DJ
801
802 FIXME: Should we really make the assumption that nobody will try
803 to debug files longer than 64K lines? What about machine
804 generated programs? */
c906108c 805
17c5ed2c 806 unsigned short line;
c906108c 807
10f4ecb8
UW
808 /* An arbitrary data pointer, allowing symbol readers to record
809 additional information on a per-symbol basis. Note that this data
810 must be allocated using the same obstack as the symbol itself. */
1cd36e54
DE
811 /* So far it is only used by:
812 LOC_COMPUTED: to find the location information
813 LOC_BLOCK (DWARF2 function): information used internally by the
814 DWARF 2 code --- specifically, the location expression for the frame
10f4ecb8
UW
815 base for this function. */
816 /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
817 to add a magic symbol to the block containing this information,
818 or to have a generic debug info annotation slot for symbols. */
819
820 void *aux_value;
c906108c 821
17c5ed2c
DC
822 struct symbol *hash_next;
823};
c906108c 824
d12307c1
PMR
825/* Several lookup functions return both a symbol and the block in which the
826 symbol is found. This structure is used in these cases. */
827
828struct block_symbol
829{
830 /* The symbol that was found, or NULL if no symbol was found. */
831 struct symbol *symbol;
832
833 /* If SYMBOL is not NULL, then this is the block in which the symbol is
834 defined. */
835 const struct block *block;
836};
837
f1e6e072 838extern const struct symbol_impl *symbol_impls;
c906108c 839
b6b80672
PA
840/* For convenience. All fields are NULL. This means "there is no
841 symbol". */
842extern const struct block_symbol null_block_symbol;
843
1994afbf
DE
844/* Note: There is no accessor macro for symbol.owner because it is
845 "private". */
846
176620f1 847#define SYMBOL_DOMAIN(symbol) (symbol)->domain
f1e6e072
TT
848#define SYMBOL_IMPL(symbol) (symbol_impls[(symbol)->aclass_index])
849#define SYMBOL_ACLASS_INDEX(symbol) (symbol)->aclass_index
850#define SYMBOL_CLASS(symbol) (SYMBOL_IMPL (symbol).aclass)
1994afbf 851#define SYMBOL_OBJFILE_OWNED(symbol) ((symbol)->is_objfile_owned)
2a2d4dc3 852#define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
edb3359d 853#define SYMBOL_INLINED(symbol) (symbol)->is_inlined
34eaf542
TT
854#define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
855 (symbol)->is_cplus_template_function
c906108c
SS
856#define SYMBOL_TYPE(symbol) (symbol)->type
857#define SYMBOL_LINE(symbol) (symbol)->line
f1e6e072
TT
858#define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
859#define SYMBOL_BLOCK_OPS(symbol) (SYMBOL_IMPL (symbol).ops_block)
860#define SYMBOL_REGISTER_OPS(symbol) (SYMBOL_IMPL (symbol).ops_register)
10f4ecb8 861#define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
34eaf542 862
f1e6e072
TT
863extern int register_symbol_computed_impl (enum address_class,
864 const struct symbol_computed_ops *);
865
866extern int register_symbol_block_impl (enum address_class aclass,
867 const struct symbol_block_ops *ops);
868
869extern int register_symbol_register_impl (enum address_class,
870 const struct symbol_register_ops *);
871
08be3fe3
DE
872/* Return the OBJFILE of SYMBOL.
873 It is an error to call this if symbol.is_objfile_owned is false, which
874 only happens for architecture-provided types. */
875
876extern struct objfile *symbol_objfile (const struct symbol *symbol);
877
878/* Return the ARCH of SYMBOL. */
879
880extern struct gdbarch *symbol_arch (const struct symbol *symbol);
881
882/* Return the SYMTAB of SYMBOL.
883 It is an error to call this if symbol.is_objfile_owned is false, which
884 only happens for architecture-provided types. */
885
886extern struct symtab *symbol_symtab (const struct symbol *symbol);
887
888/* Set the symtab of SYMBOL to SYMTAB.
889 It is an error to call this if symbol.is_objfile_owned is false, which
890 only happens for architecture-provided types. */
891
892extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
893
34eaf542
TT
894/* An instance of this type is used to represent a C++ template
895 function. It includes a "struct symbol" as a kind of base class;
896 users downcast to "struct template_symbol *" when needed. A symbol
897 is really of this type iff SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is
898 true. */
899
900struct template_symbol
901{
902 /* The base class. */
903 struct symbol base;
904
905 /* The number of template arguments. */
906 int n_template_arguments;
907
908 /* The template arguments. This is an array with
909 N_TEMPLATE_ARGUMENTS elements. */
910 struct symbol **template_arguments;
911};
912
c906108c 913\f
c906108c
SS
914/* Each item represents a line-->pc (or the reverse) mapping. This is
915 somewhat more wasteful of space than one might wish, but since only
916 the files which are actually debugged are read in to core, we don't
917 waste much space. */
918
919struct linetable_entry
17c5ed2c
DC
920{
921 int line;
922 CORE_ADDR pc;
923};
c906108c
SS
924
925/* The order of entries in the linetable is significant. They should
926 be sorted by increasing values of the pc field. If there is more than
927 one entry for a given pc, then I'm not sure what should happen (and
928 I not sure whether we currently handle it the best way).
929
930 Example: a C for statement generally looks like this
931
c5aa993b
JM
932 10 0x100 - for the init/test part of a for stmt.
933 20 0x200
934 30 0x300
935 10 0x400 - for the increment part of a for stmt.
c906108c 936
e8717518
FF
937 If an entry has a line number of zero, it marks the start of a PC
938 range for which no line number information is available. It is
939 acceptable, though wasteful of table space, for such a range to be
940 zero length. */
c906108c
SS
941
942struct linetable
17c5ed2c
DC
943{
944 int nitems;
c906108c 945
17c5ed2c
DC
946 /* Actually NITEMS elements. If you don't like this use of the
947 `struct hack', you can shove it up your ANSI (seriously, if the
948 committee tells us how to do it, we can probably go along). */
949 struct linetable_entry item[1];
950};
c906108c 951
c906108c
SS
952/* How to relocate the symbols from each section in a symbol file.
953 Each struct contains an array of offsets.
954 The ordering and meaning of the offsets is file-type-dependent;
955 typically it is indexed by section numbers or symbol types or
956 something like that.
957
958 To give us flexibility in changing the internal representation
959 of these offsets, the ANOFFSET macro must be used to insert and
960 extract offset values in the struct. */
961
962struct section_offsets
17c5ed2c 963{
c378eb4e 964 CORE_ADDR offsets[1]; /* As many as needed. */
17c5ed2c 965};
c906108c 966
a4c8257b 967#define ANOFFSET(secoff, whichone) \
3e43a32a
MS
968 ((whichone == -1) \
969 ? (internal_error (__FILE__, __LINE__, \
970 _("Section index is uninitialized")), -1) \
971 : secoff->offsets[whichone])
c906108c 972
b29c9944
JB
973/* The size of a section_offsets table for N sections. */
974#define SIZEOF_N_SECTION_OFFSETS(n) \
c906108c 975 (sizeof (struct section_offsets) \
b29c9944
JB
976 + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
977
c378eb4e 978/* Each source file or header is represented by a struct symtab.
43f3e411 979 The name "symtab" is historical, another name for it is "filetab".
c906108c
SS
980 These objects are chained through the `next' field. */
981
982struct symtab
17c5ed2c 983{
b7236fbe
DE
984 /* Unordered chain of all filetabs in the compunit, with the exception
985 that the "main" source file is the first entry in the list. */
c906108c 986
17c5ed2c 987 struct symtab *next;
c906108c 988
43f3e411 989 /* Backlink to containing compunit symtab. */
c906108c 990
43f3e411 991 struct compunit_symtab *compunit_symtab;
c906108c 992
17c5ed2c
DC
993 /* Table mapping core addresses to line numbers for this file.
994 Can be NULL if none. Never shared between different symtabs. */
c906108c 995
17c5ed2c 996 struct linetable *linetable;
c906108c 997
4e04028d 998 /* Name of this source file. This pointer is never NULL. */
c906108c 999
21ea9eec 1000 const char *filename;
c906108c 1001
17c5ed2c 1002 /* Total number of lines found in source file. */
c906108c 1003
17c5ed2c 1004 int nlines;
c906108c 1005
17c5ed2c
DC
1006 /* line_charpos[N] is the position of the (N-1)th line of the
1007 source file. "position" means something we can lseek() to; it
1008 is not guaranteed to be useful any other way. */
c906108c 1009
17c5ed2c 1010 int *line_charpos;
c906108c 1011
17c5ed2c 1012 /* Language of this source file. */
c906108c 1013
17c5ed2c 1014 enum language language;
c906108c 1015
43f3e411
DE
1016 /* Full name of file as found by searching the source path.
1017 NULL if not yet known. */
1018
1019 char *fullname;
1020};
1021
1022#define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1023#define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1024#define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1025#define SYMTAB_BLOCKVECTOR(symtab) \
1026 COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1027#define SYMTAB_OBJFILE(symtab) \
1028 COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1029#define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1030#define SYMTAB_DIRNAME(symtab) \
1031 COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1032
1033typedef struct symtab *symtab_ptr;
1034DEF_VEC_P (symtab_ptr);
1035
1036/* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1037 as the list of all source files (what gdb has historically associated with
1038 the term "symtab").
1039 Additional information is recorded here that is common to all symtabs in a
1040 compilation unit (DWARF or otherwise).
1041
1042 Example:
1043 For the case of a program built out of these files:
1044
1045 foo.c
1046 foo1.h
1047 foo2.h
1048 bar.c
1049 foo1.h
1050 bar.h
1051
1052 This is recorded as:
1053
1054 objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1055 | |
1056 v v
1057 foo.c bar.c
1058 | |
1059 v v
1060 foo1.h foo1.h
1061 | |
1062 v v
1063 foo2.h bar.h
1064 | |
1065 v v
1066 NULL NULL
1067
1068 where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1069 and the files foo.c, etc. are struct symtab objects. */
1070
1071struct compunit_symtab
1072{
1073 /* Unordered chain of all compunit symtabs of this objfile. */
1074 struct compunit_symtab *next;
1075
1076 /* Object file from which this symtab information was read. */
1077 struct objfile *objfile;
1078
1079 /* Name of the symtab.
1080 This is *not* intended to be a usable filename, and is
1081 for debugging purposes only. */
1082 const char *name;
1083
1084 /* Unordered list of file symtabs, except that by convention the "main"
1085 source file (e.g., .c, .cc) is guaranteed to be first.
1086 Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1087 or header (e.g., .h). */
1088 struct symtab *filetabs;
1089
1090 /* Last entry in FILETABS list.
1091 Subfiles are added to the end of the list so they accumulate in order,
1092 with the main source subfile living at the front.
1093 The main reason is so that the main source file symtab is at the head
1094 of the list, and the rest appear in order for debugging convenience. */
1095 struct symtab *last_filetab;
1096
1097 /* Non-NULL string that identifies the format of the debugging information,
1098 such as "stabs", "dwarf 1", "dwarf 2", "coff", etc. This is mostly useful
17c5ed2c 1099 for automated testing of gdb but may also be information that is
c378eb4e 1100 useful to the user. */
554d387d 1101 const char *debugformat;
c906108c 1102
43f3e411 1103 /* String of producer version information, or NULL if we don't know. */
554d387d 1104 const char *producer;
c906108c 1105
43f3e411
DE
1106 /* Directory in which it was compiled, or NULL if we don't know. */
1107 const char *dirname;
c906108c 1108
43f3e411
DE
1109 /* List of all symbol scope blocks for this symtab. It is shared among
1110 all symtabs in a given compilation unit. */
1111 const struct blockvector *blockvector;
c906108c 1112
43f3e411
DE
1113 /* Section in objfile->section_offsets for the blockvector and
1114 the linetable. Probably always SECT_OFF_TEXT. */
1115 int block_line_section;
c906108c 1116
43f3e411
DE
1117 /* Symtab has been compiled with both optimizations and debug info so that
1118 GDB may stop skipping prologues as variables locations are valid already
1119 at function entry points. */
1120 unsigned int locations_valid : 1;
c906108c 1121
43f3e411
DE
1122 /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1123 instruction). This is supported by GCC since 4.5.0. */
1124 unsigned int epilogue_unwind_valid : 1;
8e3b41a9 1125
43f3e411 1126 /* struct call_site entries for this compilation unit or NULL. */
8e3b41a9 1127 htab_t call_site_htab;
b5b04b5b 1128
43f3e411
DE
1129 /* The macro table for this symtab. Like the blockvector, this
1130 is shared between different symtabs in a given compilation unit.
1131 It's debatable whether it *should* be shared among all the symtabs in
1132 the given compilation unit, but it currently is. */
1133 struct macro_table *macro_table;
1134
b5b04b5b 1135 /* If non-NULL, then this points to a NULL-terminated vector of
43f3e411
DE
1136 included compunits. When searching the static or global
1137 block of this compunit, the corresponding block of all
1138 included compunits will also be searched. Note that this
b5b04b5b
TT
1139 list must be flattened -- the symbol reader is responsible for
1140 ensuring that this vector contains the transitive closure of all
43f3e411
DE
1141 included compunits. */
1142 struct compunit_symtab **includes;
b5b04b5b 1143
43f3e411
DE
1144 /* If this is an included compunit, this points to one includer
1145 of the table. This user is considered the canonical compunit
1146 containing this one. An included compunit may itself be
b5b04b5b 1147 included by another. */
43f3e411 1148 struct compunit_symtab *user;
17c5ed2c 1149};
c906108c 1150
43f3e411
DE
1151#define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1152#define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1153#define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1154#define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1155#define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1156#define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1157#define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1158#define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1159#define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1160#define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1161#define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
ec94af83 1162
43f3e411 1163/* Iterate over all file tables (struct symtab) within a compunit. */
db0fec5c 1164
43f3e411
DE
1165#define ALL_COMPUNIT_FILETABS(cu, s) \
1166 for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next)
1167
1168/* Return the primary symtab of CUST. */
1169
1170extern struct symtab *
1171 compunit_primary_filetab (const struct compunit_symtab *cust);
1172
1173/* Return the language of CUST. */
1174
1175extern enum language compunit_language (const struct compunit_symtab *cust);
1176
1177typedef struct compunit_symtab *compunit_symtab_ptr;
1178DEF_VEC_P (compunit_symtab_ptr);
ec94af83 1179
c906108c 1180\f
c5aa993b 1181
c906108c 1182/* The virtual function table is now an array of structures which have the
a960f249 1183 form { int16 offset, delta; void *pfn; }.
c906108c
SS
1184
1185 In normal virtual function tables, OFFSET is unused.
1186 DELTA is the amount which is added to the apparent object's base
1187 address in order to point to the actual object to which the
1188 virtual function should be applied.
1189 PFN is a pointer to the virtual function.
1190
c378eb4e 1191 Note that this macro is g++ specific (FIXME). */
c5aa993b 1192
c906108c
SS
1193#define VTBL_FNADDR_OFFSET 2
1194
c378eb4e 1195/* External variables and functions for the objects described above. */
c906108c 1196
c378eb4e 1197/* True if we are nested inside psymtab_to_symtab. */
c906108c
SS
1198
1199extern int currently_reading_symtab;
1200
c906108c
SS
1201/* symtab.c lookup functions */
1202
7fc830e2
MK
1203extern const char multiple_symbols_ask[];
1204extern const char multiple_symbols_all[];
1205extern const char multiple_symbols_cancel[];
717d2f5a
JB
1206
1207const char *multiple_symbols_select_mode (void);
1208
4186eb54
KS
1209int symbol_matches_domain (enum language symbol_language,
1210 domain_enum symbol_domain,
1211 domain_enum domain);
1212
c378eb4e 1213/* lookup a symbol table by source file name. */
c906108c 1214
1f8cc6db 1215extern struct symtab *lookup_symtab (const char *);
c906108c 1216
1993b719
TT
1217/* An object of this type is passed as the 'is_a_field_of_this'
1218 argument to lookup_symbol and lookup_symbol_in_language. */
1219
1220struct field_of_this_result
1221{
1222 /* The type in which the field was found. If this is NULL then the
1223 symbol was not found in 'this'. If non-NULL, then one of the
1224 other fields will be non-NULL as well. */
1225
1226 struct type *type;
1227
1228 /* If the symbol was found as an ordinary field of 'this', then this
1229 is non-NULL and points to the particular field. */
1230
1231 struct field *field;
1232
cf901d3b 1233 /* If the symbol was found as a function field of 'this', then this
1993b719
TT
1234 is non-NULL and points to the particular field. */
1235
1236 struct fn_fieldlist *fn_field;
1237};
1238
cf901d3b
DE
1239/* Find the definition for a specified symbol name NAME
1240 in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1241 if non-NULL or from global/static blocks if BLOCK is NULL.
1242 Returns the struct symbol pointer, or NULL if no symbol is found.
1243 C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1244 NAME is a field of the current implied argument `this'. If so fill in the
1245 fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
cf901d3b 1246 The symbol's section is fixed up if necessary. */
53c5240f 1247
d12307c1
PMR
1248extern struct block_symbol
1249 lookup_symbol_in_language (const char *,
1250 const struct block *,
1251 const domain_enum,
1252 enum language,
1253 struct field_of_this_result *);
53c5240f 1254
cf901d3b 1255/* Same as lookup_symbol_in_language, but using the current language. */
c906108c 1256
d12307c1
PMR
1257extern struct block_symbol lookup_symbol (const char *,
1258 const struct block *,
1259 const domain_enum,
1260 struct field_of_this_result *);
c906108c 1261
5f9a71c3 1262/* A default version of lookup_symbol_nonlocal for use by languages
cf901d3b
DE
1263 that can't think of anything better to do.
1264 This implements the C lookup rules. */
5f9a71c3 1265
d12307c1 1266extern struct block_symbol
f606139a
DE
1267 basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
1268 const char *,
1269 const struct block *,
1270 const domain_enum);
5f9a71c3
DC
1271
1272/* Some helper functions for languages that need to write their own
1273 lookup_symbol_nonlocal functions. */
1274
1275/* Lookup a symbol in the static block associated to BLOCK, if there
cf901d3b 1276 is one; do nothing if BLOCK is NULL or a global block.
d12307c1 1277 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1278
d12307c1
PMR
1279extern struct block_symbol
1280 lookup_symbol_in_static_block (const char *name,
1281 const struct block *block,
1282 const domain_enum domain);
5f9a71c3 1283
08724ab7 1284/* Search all static file-level symbols for NAME from DOMAIN.
d12307c1 1285 Upon success fixes up the symbol's section if necessary. */
08724ab7 1286
d12307c1
PMR
1287extern struct block_symbol lookup_static_symbol (const char *name,
1288 const domain_enum domain);
08724ab7 1289
cf901d3b 1290/* Lookup a symbol in all files' global blocks.
67be31e5
DE
1291
1292 If BLOCK is non-NULL then it is used for two things:
1293 1) If a target-specific lookup routine for libraries exists, then use the
1294 routine for the objfile of BLOCK, and
1295 2) The objfile of BLOCK is used to assist in determining the search order
1296 if the target requires it.
1297 See gdbarch_iterate_over_objfiles_in_search_order.
1298
d12307c1 1299 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1300
d12307c1
PMR
1301extern struct block_symbol
1302 lookup_global_symbol (const char *name,
1303 const struct block *block,
1304 const domain_enum domain);
5f9a71c3 1305
d1a2d36d 1306/* Lookup a symbol in block BLOCK.
d12307c1 1307 Upon success fixes up the symbol's section if necessary. */
5f9a71c3 1308
d12307c1
PMR
1309extern struct symbol *
1310 lookup_symbol_in_block (const char *name,
1311 const struct block *block,
1312 const domain_enum domain);
5f9a71c3 1313
cf901d3b
DE
1314/* Look up the `this' symbol for LANG in BLOCK. Return the symbol if
1315 found, or NULL if not found. */
1316
d12307c1
PMR
1317extern struct block_symbol
1318 lookup_language_this (const struct language_defn *lang,
1319 const struct block *block);
66a17cb6 1320
cf901d3b 1321/* Lookup a [struct, union, enum] by name, within a specified block. */
c906108c 1322
270140bd 1323extern struct type *lookup_struct (const char *, const struct block *);
c906108c 1324
270140bd 1325extern struct type *lookup_union (const char *, const struct block *);
c906108c 1326
270140bd 1327extern struct type *lookup_enum (const char *, const struct block *);
c906108c 1328
c906108c
SS
1329/* from blockframe.c: */
1330
c378eb4e 1331/* lookup the function symbol corresponding to the address. */
c906108c 1332
a14ed312 1333extern struct symbol *find_pc_function (CORE_ADDR);
c906108c 1334
c378eb4e 1335/* lookup the function corresponding to the address and section. */
c906108c 1336
714835d5 1337extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
c5aa993b 1338
2c02bd72 1339extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
11c81455
JK
1340 CORE_ADDR *address,
1341 CORE_ADDR *endaddr,
1342 int *is_gnu_ifunc_p);
1343
c378eb4e 1344/* lookup function from address, return name, start addr and end addr. */
c906108c 1345
2c02bd72 1346extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *,
570b8f7c 1347 CORE_ADDR *);
c906108c 1348
a14ed312 1349extern void clear_pc_function_cache (void);
c906108c 1350
2097ae25 1351/* Expand symtab containing PC, SECTION if not already expanded. */
c906108c 1352
2097ae25 1353extern void expand_symtab_containing_pc (CORE_ADDR, struct obj_section *);
c906108c 1354
c378eb4e 1355/* lookup full symbol table by address. */
c906108c 1356
43f3e411 1357extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
c906108c 1358
c378eb4e 1359/* lookup full symbol table by address and section. */
c906108c 1360
43f3e411
DE
1361extern struct compunit_symtab *
1362 find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
c906108c 1363
a14ed312 1364extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
c906108c 1365
a14ed312 1366extern void reread_symbols (void);
c906108c 1367
cf901d3b
DE
1368/* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1369 The type returned must not be opaque -- i.e., must have at least one field
1370 defined. */
1371
a14ed312 1372extern struct type *lookup_transparent_type (const char *);
c906108c 1373
cf901d3b 1374extern struct type *basic_lookup_transparent_type (const char *);
c906108c 1375
c378eb4e 1376/* Macro for name of symbol to indicate a file compiled with gcc. */
c906108c
SS
1377#ifndef GCC_COMPILED_FLAG_SYMBOL
1378#define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1379#endif
1380
c378eb4e 1381/* Macro for name of symbol to indicate a file compiled with gcc2. */
c906108c
SS
1382#ifndef GCC2_COMPILED_FLAG_SYMBOL
1383#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1384#endif
1385
0875794a
JK
1386extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1387
07be84bf
JK
1388/* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1389 for ELF symbol files. */
1390
1391struct gnu_ifunc_fns
1392{
1393 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
1394 CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1395
1396 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
1397 int (*gnu_ifunc_resolve_name) (const char *function_name,
1398 CORE_ADDR *function_address_p);
0e30163f
JK
1399
1400 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
1401 void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1402
1403 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
1404 void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
07be84bf
JK
1405};
1406
1407#define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1408#define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
0e30163f
JK
1409#define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1410#define gnu_ifunc_resolver_return_stop \
1411 gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
07be84bf
JK
1412
1413extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1414
52f729a7 1415extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
c906108c 1416
c906108c 1417struct symtab_and_line
17c5ed2c 1418{
6c95b8df
PA
1419 /* The program space of this sal. */
1420 struct program_space *pspace;
1421
17c5ed2c 1422 struct symtab *symtab;
714835d5 1423 struct obj_section *section;
17c5ed2c
DC
1424 /* Line number. Line numbers start at 1 and proceed through symtab->nlines.
1425 0 is never a valid line number; it is used to indicate that line number
1426 information is not available. */
1427 int line;
1428
1429 CORE_ADDR pc;
1430 CORE_ADDR end;
ed0616c6
VP
1431 int explicit_pc;
1432 int explicit_line;
55aa24fb
SDJ
1433
1434 /* The probe associated with this symtab_and_line. */
1435 struct probe *probe;
729662a5
TT
1436 /* If PROBE is not NULL, then this is the objfile in which the probe
1437 originated. */
1438 struct objfile *objfile;
17c5ed2c 1439};
c906108c 1440
fe39c653 1441extern void init_sal (struct symtab_and_line *sal);
c906108c
SS
1442
1443struct symtabs_and_lines
17c5ed2c
DC
1444{
1445 struct symtab_and_line *sals;
1446 int nelts;
1447};
c5aa993b 1448\f
c906108c 1449
c906108c
SS
1450/* Given a pc value, return line number it is in. Second arg nonzero means
1451 if pc is on the boundary use the previous statement's line number. */
1452
a14ed312 1453extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
c906108c 1454
c378eb4e 1455/* Same function, but specify a section as well as an address. */
c906108c 1456
714835d5
UW
1457extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1458 struct obj_section *, int);
c906108c 1459
34248c3a
DE
1460/* Wrapper around find_pc_line to just return the symtab. */
1461
1462extern struct symtab *find_pc_line_symtab (CORE_ADDR);
1463
c906108c
SS
1464/* Given a symtab and line number, return the pc there. */
1465
a14ed312 1466extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
c906108c 1467
570b8f7c
AC
1468extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1469 CORE_ADDR *);
c906108c 1470
a14ed312 1471extern void resolve_sal_pc (struct symtab_and_line *);
c906108c 1472
f176c4b5 1473/* solib.c */
c906108c 1474
a14ed312 1475extern void clear_solib (void);
c906108c 1476
c906108c
SS
1477/* source.c */
1478
a14ed312 1479extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
c906108c 1480
dfaae886
MM
1481/* Flags passed as 4th argument to print_source_lines. */
1482
8d297bbf 1483enum print_source_lines_flag
dfaae886
MM
1484 {
1485 /* Do not print an error message. */
4cd29721
MM
1486 PRINT_SOURCE_LINES_NOERROR = (1 << 0),
1487
1488 /* Print the filename in front of the source lines. */
1489 PRINT_SOURCE_LINES_FILENAME = (1 << 1)
dfaae886 1490 };
8d297bbf 1491DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags);
dfaae886
MM
1492
1493extern void print_source_lines (struct symtab *, int, int,
8d297bbf 1494 print_source_lines_flags);
c906108c 1495
00174a86 1496extern void forget_cached_source_info_for_objfile (struct objfile *);
a14ed312 1497extern void forget_cached_source_info (void);
c906108c 1498
a14ed312 1499extern void select_source_symtab (struct symtab *);
c906108c 1500
49c4e619 1501extern VEC (char_ptr) *default_make_symbol_completion_list_break_on
6f937416 1502 (const char *text, const char *word, const char *break_on,
2f68a895 1503 enum type_code code);
6f937416
PA
1504extern VEC (char_ptr) *default_make_symbol_completion_list (const char *,
1505 const char *,
2f68a895 1506 enum type_code);
6f937416
PA
1507extern VEC (char_ptr) *make_symbol_completion_list (const char *, const char *);
1508extern VEC (char_ptr) *make_symbol_completion_type (const char *, const char *,
2f68a895 1509 enum type_code);
49c4e619 1510extern VEC (char_ptr) *make_symbol_completion_list_fn (struct cmd_list_element *,
6f937416
PA
1511 const char *,
1512 const char *);
c906108c 1513
6f937416
PA
1514extern VEC (char_ptr) *make_file_symbol_completion_list (const char *,
1515 const char *,
1516 const char *);
c94fdfd0 1517
6f937416
PA
1518extern VEC (char_ptr) *make_source_files_completion_list (const char *,
1519 const char *);
c94fdfd0 1520
c906108c
SS
1521/* symtab.c */
1522
714835d5 1523int matching_obj_sections (struct obj_section *, struct obj_section *);
94277a38 1524
50641945
FN
1525extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1526
17c5ed2c
DC
1527extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1528 int);
50641945 1529
059acae7
UW
1530extern void skip_prologue_sal (struct symtab_and_line *);
1531
c906108c
SS
1532/* symtab.c */
1533
d80b854b
UW
1534extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1535 CORE_ADDR func_addr);
634aa483 1536
a14ed312
KB
1537extern struct symbol *fixup_symbol_section (struct symbol *,
1538 struct objfile *);
c906108c
SS
1539
1540/* Symbol searching */
5c04624b
DE
1541/* Note: struct symbol_search, search_symbols, et.al. are declared here,
1542 instead of making them local to symtab.c, for gdbtk's sake. */
c906108c
SS
1543
1544/* When using search_symbols, a list of the following structs is returned.
c378eb4e 1545 Callers must free the search list using free_search_symbols! */
c906108c 1546struct symbol_search
17c5ed2c 1547{
c378eb4e
MS
1548 /* The block in which the match was found. Could be, for example,
1549 STATIC_BLOCK or GLOBAL_BLOCK. */
17c5ed2c 1550 int block;
c906108c 1551
17c5ed2c 1552 /* Information describing what was found.
c906108c 1553
d01060f0 1554 If symbol is NOT NULL, then information was found for this match. */
17c5ed2c 1555 struct symbol *symbol;
c906108c 1556
17c5ed2c 1557 /* If msymbol is non-null, then a match was made on something for
c378eb4e 1558 which only minimal_symbols exist. */
7c7b6655 1559 struct bound_minimal_symbol msymbol;
c906108c 1560
c378eb4e 1561 /* A link to the next match, or NULL for the end. */
17c5ed2c
DC
1562 struct symbol_search *next;
1563};
c906108c 1564
96142726
TT
1565extern void search_symbols (const char *, enum search_domain, int,
1566 const char **, struct symbol_search **);
a14ed312 1567extern void free_search_symbols (struct symbol_search *);
17c5ed2c 1568extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
b52109bc 1569 **);
c906108c 1570
51cc5b07
AC
1571/* The name of the ``main'' function.
1572 FIXME: cagney/2001-03-20: Can't make main_name() const since some
1573 of the calling code currently assumes that the string isn't
c378eb4e 1574 const. */
17c5ed2c 1575extern /*const */ char *main_name (void);
9e6c82ad 1576extern enum language main_language (void);
51cc5b07 1577
cf901d3b
DE
1578/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
1579 This searches MAIN_OBJFILE as well as any associated separate debug info
1580 objfiles of MAIN_OBJFILE.
d12307c1 1581 Upon success fixes up the symbol's section if necessary. */
cf901d3b 1582
d12307c1 1583extern struct block_symbol
efad9b6a 1584 lookup_global_symbol_from_objfile (struct objfile *main_objfile,
cf901d3b
DE
1585 const char *name,
1586 const domain_enum domain);
3a40aaa0 1587
a6c727b2
DJ
1588/* Return 1 if the supplied producer string matches the ARM RealView
1589 compiler (armcc). */
1590int producer_is_realview (const char *producer);
3a40aaa0 1591
ccefe4c4
TT
1592void fixup_section (struct general_symbol_info *ginfo,
1593 CORE_ADDR addr, struct objfile *objfile);
1594
cf901d3b
DE
1595/* Look up objfile containing BLOCK. */
1596
c0201579
JK
1597struct objfile *lookup_objfile_from_block (const struct block *block);
1598
db0fec5c 1599extern unsigned int symtab_create_debug;
45cfd468 1600
cc485e62
DE
1601extern unsigned int symbol_lookup_debug;
1602
c011a4f4
DE
1603extern int basenames_may_differ;
1604
4aac40c8 1605int compare_filenames_for_search (const char *filename,
b57a636e 1606 const char *search_name);
4aac40c8 1607
cce0e923
DE
1608int compare_glob_filenames_for_search (const char *filename,
1609 const char *search_name);
1610
14bc53a8
PA
1611bool iterate_over_some_symtabs (const char *name,
1612 const char *real_path,
1613 struct compunit_symtab *first,
1614 struct compunit_symtab *after_last,
1615 gdb::function_view<bool (symtab *)> callback);
f8eba3c6
TT
1616
1617void iterate_over_symtabs (const char *name,
14bc53a8
PA
1618 gdb::function_view<bool (symtab *)> callback);
1619
f8eba3c6 1620
67d89901
TT
1621std::vector<CORE_ADDR> find_pcs_for_symtab_line
1622 (struct symtab *symtab, int line, struct linetable_entry **best_entry);
f8eba3c6 1623
14bc53a8
PA
1624/* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS. The callback
1625 is called once per matching symbol SYM. The callback should return
1626 true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
1627 iterating, or false to indicate that the iteration should end. */
8e704927 1628
14bc53a8 1629typedef bool (symbol_found_callback_ftype) (symbol *sym);
8e704927 1630
f8eba3c6
TT
1631void iterate_over_symbols (const struct block *block, const char *name,
1632 const domain_enum domain,
14bc53a8 1633 gdb::function_view<symbol_found_callback_ftype> callback);
f8eba3c6 1634
2f408ecb
PA
1635/* Storage type used by demangle_for_lookup. demangle_for_lookup
1636 either returns a const char * pointer that points to either of the
1637 fields of this type, or a pointer to the input NAME. This is done
1638 this way because the underlying functions that demangle_for_lookup
1639 calls either return a std::string (e.g., cp_canonicalize_string) or
1640 a malloc'ed buffer (libiberty's demangled), and we want to avoid
1641 unnecessary reallocation/string copying. */
1642class demangle_result_storage
1643{
1644public:
1645
1646 /* Swap the std::string storage with STR, and return a pointer to
1647 the beginning of the new string. */
1648 const char *swap_string (std::string &str)
1649 {
1650 std::swap (m_string, str);
1651 return m_string.c_str ();
1652 }
1653
1654 /* Set the malloc storage to now point at PTR. Any previous malloc
1655 storage is released. */
1656 const char *set_malloc_ptr (char *ptr)
1657 {
1658 m_malloc.reset (ptr);
1659 return ptr;
1660 }
1661
1662private:
1663
1664 /* The storage. */
1665 std::string m_string;
1666 gdb::unique_xmalloc_ptr<char> m_malloc;
1667};
1668
1669const char *
1670 demangle_for_lookup (const char *name, enum language lang,
1671 demangle_result_storage &storage);
f8eba3c6 1672
e623cf5d
TT
1673struct symbol *allocate_symbol (struct objfile *);
1674
38bf1463 1675void initialize_objfile_symbol (struct symbol *);
e623cf5d
TT
1676
1677struct template_symbol *allocate_template_symbol (struct objfile *);
1678
c906108c 1679#endif /* !defined(SYMTAB_H) */
This page took 1.808413 seconds and 4 git commands to generate.