gdb/
[deliverable/binutils-gdb.git] / gdb / symtab.h
CommitLineData
c906108c 1/* Symbol table definitions for GDB.
1bac305b 2
6aba47ca 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
7b6bb8da
JB
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010,
5 2011 Free Software Foundation, Inc.
c906108c 6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
c5aa993b 12 (at your option) any later version.
c906108c 13
c5aa993b
JM
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b 19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
21
22#if !defined (SYMTAB_H)
23#define SYMTAB_H 1
24
5f8a3188 25/* Opaque declarations. */
da3331ec
AC
26struct ui_file;
27struct frame_info;
28struct symbol;
5f8a3188 29struct obstack;
6a2f5abf 30struct objfile;
fe898f56
DC
31struct block;
32struct blockvector;
4c2df51b
DJ
33struct axs_value;
34struct agent_expr;
6c95b8df 35struct program_space;
c906108c 36
a7f19c79
MC
37/* Some of the structures in this file are space critical.
38 The space-critical structures are:
39
40 struct general_symbol_info
41 struct symbol
42 struct partial_symbol
43
5bccb4d1 44 These structures are laid out to encourage good packing.
a7f19c79
MC
45 They use ENUM_BITFIELD and short int fields, and they order the
46 structure members so that fields less than a word are next
c378eb4e 47 to each other so they can be packed together. */
a7f19c79
MC
48
49/* Rearranged: used ENUM_BITFIELD and rearranged field order in
50 all the space critical structures (plus struct minimal_symbol).
51 Memory usage dropped from 99360768 bytes to 90001408 bytes.
52 I measured this with before-and-after tests of
53 "HEAD-old-gdb -readnow HEAD-old-gdb" and
54 "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
55 red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
56 typing "maint space 1" at the first command prompt.
57
58 Here is another measurement (from andrew c):
59 # no /usr/lib/debug, just plain glibc, like a normal user
60 gdb HEAD-old-gdb
61 (gdb) break internal_error
62 (gdb) run
63 (gdb) maint internal-error
64 (gdb) backtrace
65 (gdb) maint space 1
66
67 gdb gdb_6_0_branch 2003-08-19 space used: 8896512
68 gdb HEAD 2003-08-19 space used: 8904704
69 gdb HEAD 2003-08-21 space used: 8396800 (+symtab.h)
70 gdb HEAD 2003-08-21 space used: 8265728 (+gdbtypes.h)
71
72 The third line shows the savings from the optimizations in symtab.h.
73 The fourth line shows the savings from the optimizations in
74 gdbtypes.h. Both optimizations are in gdb HEAD now.
75
76 --chastain 2003-08-21 */
77
29df156d 78/* Struct for storing C++ specific information. Allocated when needed. */
a7f19c79 79
29df156d
SW
80struct cplus_specific
81{
82 char *demangled_name;
83};
a7f19c79 84
c906108c
SS
85/* Define a structure for the information that is common to all symbol types,
86 including minimal symbols, partial symbols, and full symbols. In a
87 multilanguage environment, some language specific information may need to
c378eb4e 88 be recorded along with each symbol. */
c906108c 89
c378eb4e 90/* This structure is space critical. See space comments at the top. */
c906108c
SS
91
92struct general_symbol_info
17c5ed2c 93{
22abf04a 94 /* Name of the symbol. This is a required field. Storage for the
4a146b47
EZ
95 name is allocated on the objfile_obstack for the associated
96 objfile. For languages like C++ that make a distinction between
97 the mangled name and demangled name, this is the mangled
98 name. */
c906108c 99
17c5ed2c 100 char *name;
c906108c 101
17c5ed2c
DC
102 /* Value of the symbol. Which member of this union to use, and what
103 it means, depends on what kind of symbol this is and its
104 SYMBOL_CLASS. See comments there for more details. All of these
105 are in host byte order (though what they point to might be in
106 target byte order, e.g. LOC_CONST_BYTES). */
c906108c 107
17c5ed2c
DC
108 union
109 {
110 /* The fact that this is a long not a LONGEST mainly limits the
111 range of a LOC_CONST. Since LOC_CONST_BYTES exists, I'm not
112 sure that is a big deal. */
113 long ivalue;
c906108c 114
17c5ed2c 115 struct block *block;
c906108c 116
4e38b386 117 gdb_byte *bytes;
c906108c 118
17c5ed2c 119 CORE_ADDR address;
c906108c 120
c378eb4e 121 /* For opaque typedef struct chain. */
c906108c 122
17c5ed2c
DC
123 struct symbol *chain;
124 }
125 value;
c906108c 126
17c5ed2c 127 /* Since one and only one language can apply, wrap the language specific
29df156d 128 information inside a union. */
c906108c 129
17c5ed2c
DC
130 union
131 {
afa16725 132 /* This is used by languages which wish to store a demangled name.
c378eb4e 133 currently used by Ada, Java, and Objective C. */
afa16725 134 struct mangled_lang
17c5ed2c
DC
135 {
136 char *demangled_name;
137 }
afa16725 138 mangled_lang;
29df156d
SW
139
140 struct cplus_specific *cplus_specific;
17c5ed2c
DC
141 }
142 language_specific;
c5aa993b 143
17c5ed2c
DC
144 /* Record the source code language that applies to this symbol.
145 This is used to select one of the fields from the language specific
c378eb4e 146 union above. */
c5aa993b 147
87193939 148 ENUM_BITFIELD(language) language : 8;
c5aa993b 149
17c5ed2c
DC
150 /* Which section is this symbol in? This is an index into
151 section_offsets for this objfile. Negative means that the symbol
152 does not get relocated relative to a section.
153 Disclaimer: currently this is just used for xcoff, so don't
154 expect all symbol-reading code to set it correctly (the ELF code
155 also tries to set it correctly). */
c5aa993b 156
17c5ed2c 157 short section;
c5aa993b 158
c0201579 159 /* The section associated with this symbol. It can be NULL. */
c5aa993b 160
714835d5 161 struct obj_section *obj_section;
17c5ed2c 162};
c906108c 163
29df156d
SW
164extern void symbol_set_demangled_name (struct general_symbol_info *, char *,
165 struct objfile *);
b250c185
SW
166
167extern char *symbol_get_demangled_name (const struct general_symbol_info *);
168
714835d5 169extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
c906108c 170
88cda038
EZ
171/* Note that all the following SYMBOL_* macros are used with the
172 SYMBOL argument being either a partial symbol, a minimal symbol or
173 a full symbol. All three types have a ginfo field. In particular
33e5013e 174 the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
d6350901 175 macros cannot be entirely substituted by
88cda038
EZ
176 functions, unless the callers are changed to pass in the ginfo
177 field only, instead of the SYMBOL parameter. */
178
c906108c
SS
179#define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.ivalue
180#define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address
181#define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes
182#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block
183#define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain
184#define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.language
185#define SYMBOL_SECTION(symbol) (symbol)->ginfo.section
714835d5 186#define SYMBOL_OBJ_SECTION(symbol) (symbol)->ginfo.obj_section
c906108c 187
89aad1f9 188/* Initializes the language dependent portion of a symbol
c378eb4e 189 depending upon the language for the symbol. */
33e5013e
SW
190#define SYMBOL_SET_LANGUAGE(symbol,language) \
191 (symbol_set_language (&(symbol)->ginfo, (language)))
192extern void symbol_set_language (struct general_symbol_info *symbol,
193 enum language language);
c906108c 194
3567439c
DJ
195/* Set just the linkage name of a symbol; do not try to demangle
196 it. Used for constructs which do not have a mangled name,
197 e.g. struct tags. Unlike SYMBOL_SET_NAMES, linkage_name must
1c9e8358
TT
198 be terminated and either already on the objfile's obstack or
199 permanently allocated. */
3567439c
DJ
200#define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
201 (symbol)->ginfo.name = (linkage_name)
202
203/* Set the linkage and natural names of a symbol, by demangling
204 the linkage name. */
04a679b8
TT
205#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \
206 symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
2de7ced7 207extern void symbol_set_names (struct general_symbol_info *symbol,
04a679b8 208 const char *linkage_name, int len, int copy_name,
2de7ced7
DJ
209 struct objfile *objfile);
210
22abf04a
DC
211/* Now come lots of name accessor macros. Short version as to when to
212 use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
213 symbol in the original source code. Use SYMBOL_LINKAGE_NAME if you
214 want to know what the linker thinks the symbol's name is. Use
215 SYMBOL_PRINT_NAME for output. Use SYMBOL_DEMANGLED_NAME if you
216 specifically need to know whether SYMBOL_NATURAL_NAME and
3567439c 217 SYMBOL_LINKAGE_NAME are different. */
22abf04a
DC
218
219/* Return SYMBOL's "natural" name, i.e. the name that it was called in
220 the original source code. In languages like C++ where symbols may
221 be mangled for ease of manipulation by the linker, this is the
222 demangled name. */
223
224#define SYMBOL_NATURAL_NAME(symbol) \
225 (symbol_natural_name (&(symbol)->ginfo))
226extern char *symbol_natural_name (const struct general_symbol_info *symbol);
227
228/* Return SYMBOL's name from the point of view of the linker. In
229 languages like C++ where symbols may be mangled for ease of
230 manipulation by the linker, this is the mangled name; otherwise,
3567439c 231 it's the same as SYMBOL_NATURAL_NAME. */
22abf04a
DC
232
233#define SYMBOL_LINKAGE_NAME(symbol) (symbol)->ginfo.name
234
9cc0d196 235/* Return the demangled name for a symbol based on the language for
c378eb4e 236 that symbol. If no demangled name exists, return NULL. */
9cc0d196
EZ
237#define SYMBOL_DEMANGLED_NAME(symbol) \
238 (symbol_demangled_name (&(symbol)->ginfo))
df8a16a1 239extern char *symbol_demangled_name (const struct general_symbol_info *symbol);
c906108c 240
de5ad195
DC
241/* Macro that returns a version of the name of a symbol that is
242 suitable for output. In C++ this is the "demangled" form of the
243 name if demangle is on and the "mangled" form of the name if
244 demangle is off. In other languages this is just the symbol name.
245 The result should never be NULL. Don't use this for internal
246 purposes (e.g. storing in a hashtable): it's only suitable for
247 output. */
248
249#define SYMBOL_PRINT_NAME(symbol) \
22abf04a 250 (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
c906108c 251
c906108c
SS
252/* Macro that tests a symbol for a match against a specified name string.
253 First test the unencoded name, then looks for and test a C++ encoded
254 name if it exists. Note that whitespace is ignored while attempting to
255 match a C++ encoded name, so that "foo::bar(int,long)" is the same as
256 "foo :: bar (int, long)".
c378eb4e 257 Evaluates to zero if the match fails, or nonzero if it succeeds. */
c906108c 258
8e437497
DC
259/* Macro that tests a symbol for a match against a specified name
260 string. It tests against SYMBOL_NATURAL_NAME, and it ignores
261 whitespace and trailing parentheses. (See strcmp_iw for details
262 about its behavior.) */
263
264#define SYMBOL_MATCHES_NATURAL_NAME(symbol, name) \
265 (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
266
c378eb4e 267/* Macro that returns the name to be used when sorting and searching symbols.
4725b721
PH
268 In C++, Chill, and Java, we search for the demangled form of a name,
269 and so sort symbols accordingly. In Ada, however, we search by mangled
270 name. If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
c378eb4e 271 returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
4725b721
PH
272#define SYMBOL_SEARCH_NAME(symbol) \
273 (symbol_search_name (&(symbol)->ginfo))
274extern char *symbol_search_name (const struct general_symbol_info *);
275
276/* Analogous to SYMBOL_MATCHES_NATURAL_NAME, but uses the search
277 name. */
278#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name) \
279 (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
280
87193939
MC
281/* Classification types for a minimal symbol. These should be taken as
282 "advisory only", since if gdb can't easily figure out a
283 classification it simply selects mst_unknown. It may also have to
284 guess when it can't figure out which is a better match between two
285 types (mst_data versus mst_bss) for example. Since the minimal
286 symbol info is sometimes derived from the BFD library's view of a
c378eb4e 287 file, we need to live with what information bfd supplies. */
87193939
MC
288
289enum minimal_symbol_type
290{
291 mst_unknown = 0, /* Unknown type, the default */
292 mst_text, /* Generally executable instructions */
0875794a
JK
293 mst_text_gnu_ifunc, /* Executable code returning address
294 of executable code */
295 mst_slot_got_plt, /* GOT entries for .plt sections */
87193939
MC
296 mst_data, /* Generally initialized data */
297 mst_bss, /* Generally uninitialized data */
298 mst_abs, /* Generally absolute (nonrelocatable) */
299 /* GDB uses mst_solib_trampoline for the start address of a shared
300 library trampoline entry. Breakpoints for shared library functions
301 are put there if the shared library is not yet loaded.
302 After the shared library is loaded, lookup_minimal_symbol will
303 prefer the minimal symbol from the shared library (usually
304 a mst_text symbol) over the mst_solib_trampoline symbol, and the
305 breakpoints will be moved to their true address in the shared
306 library via breakpoint_re_set. */
307 mst_solib_trampoline, /* Shared library trampoline code */
308 /* For the mst_file* types, the names are only guaranteed to be unique
309 within a given .o file. */
310 mst_file_text, /* Static version of mst_text */
311 mst_file_data, /* Static version of mst_data */
312 mst_file_bss /* Static version of mst_bss */
313};
314
c906108c
SS
315/* Define a simple structure used to hold some very basic information about
316 all defined global symbols (text, data, bss, abs, etc). The only required
317 information is the general_symbol_info.
318
319 In many cases, even if a file was compiled with no special options for
320 debugging at all, as long as was not stripped it will contain sufficient
321 information to build a useful minimal symbol table using this structure.
322 Even when a file contains enough debugging information to build a full
323 symbol table, these minimal symbols are still useful for quickly mapping
324 between names and addresses, and vice versa. They are also sometimes
c378eb4e 325 used to figure out what full symbol table entries need to be read in. */
c906108c
SS
326
327struct minimal_symbol
17c5ed2c 328{
c906108c 329
17c5ed2c 330 /* The general symbol info required for all types of symbols.
c906108c 331
17c5ed2c
DC
332 The SYMBOL_VALUE_ADDRESS contains the address that this symbol
333 corresponds to. */
c906108c 334
17c5ed2c 335 struct general_symbol_info ginfo;
c906108c 336
f594e5e9
MC
337 /* Size of this symbol. end_psymtab in dbxread.c uses this
338 information to calculate the end of the partial symtab based on the
339 address of the last symbol plus the size of the last symbol. */
340
341 unsigned long size;
342
17c5ed2c
DC
343 /* Which source file is this symbol in? Only relevant for mst_file_*. */
344 char *filename;
c906108c 345
87193939 346 /* Classification type for this minimal symbol. */
17c5ed2c 347
87193939 348 ENUM_BITFIELD(minimal_symbol_type) type : 8;
17c5ed2c 349
b887350f
TT
350 /* Two flag bits provided for the use of the target. */
351 unsigned int target_flag_1 : 1;
352 unsigned int target_flag_2 : 1;
353
17c5ed2c
DC
354 /* Minimal symbols with the same hash key are kept on a linked
355 list. This is the link. */
356
357 struct minimal_symbol *hash_next;
358
359 /* Minimal symbols are stored in two different hash tables. This is
360 the `next' pointer for the demangled hash table. */
361
362 struct minimal_symbol *demangled_hash_next;
363};
c906108c 364
b887350f
TT
365#define MSYMBOL_TARGET_FLAG_1(msymbol) (msymbol)->target_flag_1
366#define MSYMBOL_TARGET_FLAG_2(msymbol) (msymbol)->target_flag_2
f594e5e9 367#define MSYMBOL_SIZE(msymbol) (msymbol)->size
c906108c 368#define MSYMBOL_TYPE(msymbol) (msymbol)->type
c906108c 369
c906108c 370\f
c5aa993b 371
c906108c
SS
372/* Represent one symbol name; a variable, constant, function or typedef. */
373
176620f1 374/* Different name domains for symbols. Looking up a symbol specifies a
c378eb4e 375 domain and ignores symbol definitions in other name domains. */
c906108c 376
87193939 377typedef enum domain_enum_tag
17c5ed2c 378{
176620f1 379 /* UNDEF_DOMAIN is used when a domain has not been discovered or
17c5ed2c 380 none of the following apply. This usually indicates an error either
c378eb4e 381 in the symbol information or in gdb's handling of symbols. */
c906108c 382
176620f1 383 UNDEF_DOMAIN,
c906108c 384
176620f1 385 /* VAR_DOMAIN is the usual domain. In C, this contains variables,
c378eb4e 386 function names, typedef names and enum type values. */
c906108c 387
176620f1 388 VAR_DOMAIN,
c906108c 389
176620f1 390 /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
17c5ed2c 391 Thus, if `struct foo' is used in a C program, it produces a symbol named
c378eb4e 392 `foo' in the STRUCT_DOMAIN. */
c906108c 393
176620f1 394 STRUCT_DOMAIN,
c906108c 395
0f5238ed 396 /* LABEL_DOMAIN may be used for names of labels (for gotos). */
c906108c 397
176620f1 398 LABEL_DOMAIN,
c906108c 399
c378eb4e
MS
400 /* Searching domains. These overlap with VAR_DOMAIN, providing
401 some granularity with the search_symbols function. */
c906108c 402
bd2e94ce
TT
403 /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
404 TYPES_DOMAIN. */
176620f1 405 VARIABLES_DOMAIN,
c906108c 406
c378eb4e 407 /* All functions -- for some reason not methods, though. */
176620f1 408 FUNCTIONS_DOMAIN,
c906108c 409
17c5ed2c 410 /* All defined types */
bd2e94ce 411 TYPES_DOMAIN
17c5ed2c 412}
176620f1 413domain_enum;
c906108c
SS
414
415/* An address-class says where to find the value of a symbol. */
416
417enum address_class
17c5ed2c 418{
c378eb4e 419 /* Not used; catches errors. */
c5aa993b 420
17c5ed2c 421 LOC_UNDEF,
c906108c 422
c378eb4e 423 /* Value is constant int SYMBOL_VALUE, host byteorder. */
c906108c 424
17c5ed2c 425 LOC_CONST,
c906108c 426
c378eb4e 427 /* Value is at fixed address SYMBOL_VALUE_ADDRESS. */
c906108c 428
17c5ed2c 429 LOC_STATIC,
c906108c 430
768a979c
UW
431 /* Value is in register. SYMBOL_VALUE is the register number
432 in the original debug format. SYMBOL_REGISTER_OPS holds a
433 function that can be called to transform this into the
434 actual register number this represents in a specific target
435 architecture (gdbarch).
2a2d4dc3
AS
436
437 For some symbol formats (stabs, for some compilers at least),
438 the compiler generates two symbols, an argument and a register.
439 In some cases we combine them to a single LOC_REGISTER in symbol
440 reading, but currently not for all cases (e.g. it's passed on the
441 stack and then loaded into a register). */
c906108c 442
17c5ed2c 443 LOC_REGISTER,
c906108c 444
17c5ed2c 445 /* It's an argument; the value is at SYMBOL_VALUE offset in arglist. */
c906108c 446
17c5ed2c 447 LOC_ARG,
c906108c 448
17c5ed2c 449 /* Value address is at SYMBOL_VALUE offset in arglist. */
c906108c 450
17c5ed2c 451 LOC_REF_ARG,
c906108c 452
2a2d4dc3 453 /* Value is in specified register. Just like LOC_REGISTER except the
17c5ed2c 454 register holds the address of the argument instead of the argument
c378eb4e 455 itself. This is currently used for the passing of structs and unions
17c5ed2c
DC
456 on sparc and hppa. It is also used for call by reference where the
457 address is in a register, at least by mipsread.c. */
c906108c 458
17c5ed2c 459 LOC_REGPARM_ADDR,
c906108c 460
17c5ed2c 461 /* Value is a local variable at SYMBOL_VALUE offset in stack frame. */
c906108c 462
17c5ed2c 463 LOC_LOCAL,
c906108c 464
176620f1
EZ
465 /* Value not used; definition in SYMBOL_TYPE. Symbols in the domain
466 STRUCT_DOMAIN all have this class. */
c906108c 467
17c5ed2c 468 LOC_TYPEDEF,
c906108c 469
c378eb4e 470 /* Value is address SYMBOL_VALUE_ADDRESS in the code. */
c906108c 471
17c5ed2c 472 LOC_LABEL,
c906108c 473
17c5ed2c
DC
474 /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
475 In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
c378eb4e 476 of the block. Function names have this class. */
c906108c 477
17c5ed2c 478 LOC_BLOCK,
c906108c 479
17c5ed2c
DC
480 /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
481 target byte order. */
c906108c 482
17c5ed2c 483 LOC_CONST_BYTES,
c906108c 484
17c5ed2c
DC
485 /* Value is at fixed address, but the address of the variable has
486 to be determined from the minimal symbol table whenever the
487 variable is referenced.
488 This happens if debugging information for a global symbol is
489 emitted and the corresponding minimal symbol is defined
490 in another object file or runtime common storage.
491 The linker might even remove the minimal symbol if the global
492 symbol is never referenced, in which case the symbol remains
de40b933
JK
493 unresolved.
494
495 GDB would normally find the symbol in the minimal symbol table if it will
496 not find it in the full symbol table. But a reference to an external
497 symbol in a local block shadowing other definition requires full symbol
498 without possibly having its address available for LOC_STATIC. Testcase
499 is provided as `gdb.dwarf2/dw2-unresolved.exp'. */
c906108c 500
17c5ed2c 501 LOC_UNRESOLVED,
c906108c 502
17c5ed2c
DC
503 /* The variable does not actually exist in the program.
504 The value is ignored. */
c906108c 505
17c5ed2c 506 LOC_OPTIMIZED_OUT,
c906108c 507
4c2df51b 508 /* The variable's address is computed by a set of location
768a979c 509 functions (see "struct symbol_computed_ops" below). */
4c2df51b 510 LOC_COMPUTED,
4c2df51b
DJ
511};
512
768a979c 513/* The methods needed to implement LOC_COMPUTED. These methods can
a67af2b9
AC
514 use the symbol's .aux_value for additional per-symbol information.
515
516 At present this is only used to implement location expressions. */
517
768a979c 518struct symbol_computed_ops
4c2df51b
DJ
519{
520
521 /* Return the value of the variable SYMBOL, relative to the stack
522 frame FRAME. If the variable has been optimized out, return
523 zero.
524
525 Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero. */
526
527 struct value *(*read_variable) (struct symbol * symbol,
528 struct frame_info * frame);
529
530 /* Return non-zero if we need a frame to find the value of the SYMBOL. */
531 int (*read_needs_frame) (struct symbol * symbol);
532
533 /* Write to STREAM a natural-language description of the location of
08922a10
SS
534 SYMBOL, in the context of ADDR. */
535 void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
536 struct ui_file * stream);
4c2df51b
DJ
537
538 /* Tracepoint support. Append bytecodes to the tracepoint agent
539 expression AX that push the address of the object SYMBOL. Set
540 VALUE appropriately. Note --- for objects in registers, this
541 needn't emit any code; as long as it sets VALUE properly, then
542 the caller will generate the right code in the process of
543 treating this as an lvalue or rvalue. */
544
505e835d
UW
545 void (*tracepoint_var_ref) (struct symbol *symbol, struct gdbarch *gdbarch,
546 struct agent_expr *ax, struct axs_value *value);
17c5ed2c 547};
c906108c 548
768a979c
UW
549/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
550
551struct symbol_register_ops
552{
553 int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
554};
555
c378eb4e 556/* This structure is space critical. See space comments at the top. */
a7f19c79 557
c906108c 558struct symbol
17c5ed2c 559{
c906108c 560
c378eb4e 561 /* The general symbol info required for all types of symbols. */
c906108c 562
17c5ed2c 563 struct general_symbol_info ginfo;
c906108c 564
17c5ed2c 565 /* Data type of value */
c906108c 566
17c5ed2c 567 struct type *type;
c906108c 568
cb1df416 569 /* The symbol table containing this symbol. This is the file
cd55e50f
JK
570 associated with LINE. It can be NULL during symbols read-in but it is
571 never NULL during normal operation. */
cb1df416
DJ
572 struct symtab *symtab;
573
176620f1 574 /* Domain code. */
c906108c 575
87193939 576 ENUM_BITFIELD(domain_enum_tag) domain : 6;
c906108c 577
17c5ed2c 578 /* Address class */
a67af2b9
AC
579 /* NOTE: cagney/2003-11-02: The fields "aclass" and "ops" contain
580 overlapping information. By creating a per-aclass ops vector, or
581 using the aclass as an index into an ops table, the aclass and
582 ops fields can be merged. The latter, for instance, would shave
583 32-bits from each symbol (relative to a symbol lookup, any table
584 index overhead would be in the noise). */
c906108c 585
87193939 586 ENUM_BITFIELD(address_class) aclass : 6;
c906108c 587
2a2d4dc3
AS
588 /* Whether this is an argument. */
589
590 unsigned is_argument : 1;
591
edb3359d
DJ
592 /* Whether this is an inlined function (class LOC_BLOCK only). */
593 unsigned is_inlined : 1;
594
34eaf542
TT
595 /* True if this is a C++ function symbol with template arguments.
596 In this case the symbol is really a "struct template_symbol". */
597 unsigned is_cplus_template_function : 1;
598
edb3359d
DJ
599 /* Line number of this symbol's definition, except for inlined
600 functions. For an inlined function (class LOC_BLOCK and
601 SYMBOL_INLINED set) this is the line number of the function's call
602 site. Inlined function symbols are not definitions, and they are
603 never found by symbol table lookup.
604
605 FIXME: Should we really make the assumption that nobody will try
606 to debug files longer than 64K lines? What about machine
607 generated programs? */
c906108c 608
17c5ed2c 609 unsigned short line;
c906108c 610
a67af2b9
AC
611 /* Method's for symbol's of this class. */
612 /* NOTE: cagney/2003-11-02: See comment above attached to "aclass". */
613
768a979c
UW
614 union
615 {
616 /* Used with LOC_COMPUTED. */
617 const struct symbol_computed_ops *ops_computed;
618
619 /* Used with LOC_REGISTER and LOC_REGPARM_ADDR. */
620 const struct symbol_register_ops *ops_register;
621 } ops;
a67af2b9 622
10f4ecb8
UW
623 /* An arbitrary data pointer, allowing symbol readers to record
624 additional information on a per-symbol basis. Note that this data
625 must be allocated using the same obstack as the symbol itself. */
2a2d4dc3 626 /* So far it is only used by LOC_COMPUTED to
10f4ecb8
UW
627 find the location information. For a LOC_BLOCK symbol
628 for a function in a compilation unit compiled with DWARF 2
629 information, this is information used internally by the DWARF 2
630 code --- specifically, the location expression for the frame
631 base for this function. */
632 /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
633 to add a magic symbol to the block containing this information,
634 or to have a generic debug info annotation slot for symbols. */
635
636 void *aux_value;
c906108c 637
17c5ed2c
DC
638 struct symbol *hash_next;
639};
c906108c
SS
640
641
176620f1 642#define SYMBOL_DOMAIN(symbol) (symbol)->domain
c906108c 643#define SYMBOL_CLASS(symbol) (symbol)->aclass
2a2d4dc3 644#define SYMBOL_IS_ARGUMENT(symbol) (symbol)->is_argument
edb3359d 645#define SYMBOL_INLINED(symbol) (symbol)->is_inlined
34eaf542
TT
646#define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
647 (symbol)->is_cplus_template_function
c906108c
SS
648#define SYMBOL_TYPE(symbol) (symbol)->type
649#define SYMBOL_LINE(symbol) (symbol)->line
cb1df416 650#define SYMBOL_SYMTAB(symbol) (symbol)->symtab
768a979c
UW
651#define SYMBOL_COMPUTED_OPS(symbol) (symbol)->ops.ops_computed
652#define SYMBOL_REGISTER_OPS(symbol) (symbol)->ops.ops_register
10f4ecb8 653#define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
34eaf542
TT
654
655/* An instance of this type is used to represent a C++ template
656 function. It includes a "struct symbol" as a kind of base class;
657 users downcast to "struct template_symbol *" when needed. A symbol
658 is really of this type iff SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is
659 true. */
660
661struct template_symbol
662{
663 /* The base class. */
664 struct symbol base;
665
666 /* The number of template arguments. */
667 int n_template_arguments;
668
669 /* The template arguments. This is an array with
670 N_TEMPLATE_ARGUMENTS elements. */
671 struct symbol **template_arguments;
672};
673
c906108c 674\f
c906108c
SS
675/* Each item represents a line-->pc (or the reverse) mapping. This is
676 somewhat more wasteful of space than one might wish, but since only
677 the files which are actually debugged are read in to core, we don't
678 waste much space. */
679
680struct linetable_entry
17c5ed2c
DC
681{
682 int line;
683 CORE_ADDR pc;
684};
c906108c
SS
685
686/* The order of entries in the linetable is significant. They should
687 be sorted by increasing values of the pc field. If there is more than
688 one entry for a given pc, then I'm not sure what should happen (and
689 I not sure whether we currently handle it the best way).
690
691 Example: a C for statement generally looks like this
692
c5aa993b
JM
693 10 0x100 - for the init/test part of a for stmt.
694 20 0x200
695 30 0x300
696 10 0x400 - for the increment part of a for stmt.
c906108c 697
e8717518
FF
698 If an entry has a line number of zero, it marks the start of a PC
699 range for which no line number information is available. It is
700 acceptable, though wasteful of table space, for such a range to be
701 zero length. */
c906108c
SS
702
703struct linetable
17c5ed2c
DC
704{
705 int nitems;
c906108c 706
17c5ed2c
DC
707 /* Actually NITEMS elements. If you don't like this use of the
708 `struct hack', you can shove it up your ANSI (seriously, if the
709 committee tells us how to do it, we can probably go along). */
710 struct linetable_entry item[1];
711};
c906108c 712
c906108c
SS
713/* How to relocate the symbols from each section in a symbol file.
714 Each struct contains an array of offsets.
715 The ordering and meaning of the offsets is file-type-dependent;
716 typically it is indexed by section numbers or symbol types or
717 something like that.
718
719 To give us flexibility in changing the internal representation
720 of these offsets, the ANOFFSET macro must be used to insert and
721 extract offset values in the struct. */
722
723struct section_offsets
17c5ed2c 724{
c378eb4e 725 CORE_ADDR offsets[1]; /* As many as needed. */
17c5ed2c 726};
c906108c 727
a4c8257b 728#define ANOFFSET(secoff, whichone) \
3e43a32a
MS
729 ((whichone == -1) \
730 ? (internal_error (__FILE__, __LINE__, \
731 _("Section index is uninitialized")), -1) \
732 : secoff->offsets[whichone])
c906108c 733
b29c9944
JB
734/* The size of a section_offsets table for N sections. */
735#define SIZEOF_N_SECTION_OFFSETS(n) \
c906108c 736 (sizeof (struct section_offsets) \
b29c9944
JB
737 + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
738
c378eb4e 739/* Each source file or header is represented by a struct symtab.
c906108c
SS
740 These objects are chained through the `next' field. */
741
742struct symtab
17c5ed2c 743{
93b55aa1 744 /* Unordered chain of all existing symtabs of this objfile. */
c906108c 745
17c5ed2c 746 struct symtab *next;
c906108c 747
17c5ed2c
DC
748 /* List of all symbol scope blocks for this symtab. May be shared
749 between different symtabs (and normally is for all the symtabs
750 in a given compilation unit). */
c906108c 751
17c5ed2c 752 struct blockvector *blockvector;
c906108c 753
17c5ed2c
DC
754 /* Table mapping core addresses to line numbers for this file.
755 Can be NULL if none. Never shared between different symtabs. */
c906108c 756
17c5ed2c 757 struct linetable *linetable;
c906108c 758
17c5ed2c
DC
759 /* Section in objfile->section_offsets for the blockvector and
760 the linetable. Probably always SECT_OFF_TEXT. */
c906108c 761
17c5ed2c 762 int block_line_section;
c906108c 763
17c5ed2c
DC
764 /* If several symtabs share a blockvector, exactly one of them
765 should be designated the primary, so that the blockvector
766 is relocated exactly once by objfile_relocate. */
c906108c 767
17c5ed2c 768 int primary;
c906108c 769
17c5ed2c
DC
770 /* The macro table for this symtab. Like the blockvector, this
771 may be shared between different symtabs --- and normally is for
772 all the symtabs in a given compilation unit. */
773 struct macro_table *macro_table;
99d9066e 774
17c5ed2c 775 /* Name of this source file. */
c906108c 776
17c5ed2c 777 char *filename;
c906108c 778
17c5ed2c 779 /* Directory in which it was compiled, or NULL if we don't know. */
c906108c 780
17c5ed2c 781 char *dirname;
c906108c 782
17c5ed2c 783 /* This component says how to free the data we point to:
17c5ed2c
DC
784 free_nothing => do nothing; some other symtab will free
785 the data this one uses.
786 free_linetable => free just the linetable. FIXME: Is this redundant
787 with the primary field? */
c906108c 788
17c5ed2c
DC
789 enum free_code
790 {
f73634e5 791 free_nothing, free_linetable
17c5ed2c
DC
792 }
793 free_code;
c906108c 794
de4f826b
DC
795 /* A function to call to free space, if necessary. This is IN
796 ADDITION to the action indicated by free_code. */
c5aa993b 797
de4f826b 798 void (*free_func)(struct symtab *symtab);
c906108c 799
17c5ed2c 800 /* Total number of lines found in source file. */
c906108c 801
17c5ed2c 802 int nlines;
c906108c 803
17c5ed2c
DC
804 /* line_charpos[N] is the position of the (N-1)th line of the
805 source file. "position" means something we can lseek() to; it
806 is not guaranteed to be useful any other way. */
c906108c 807
17c5ed2c 808 int *line_charpos;
c906108c 809
17c5ed2c 810 /* Language of this source file. */
c906108c 811
17c5ed2c 812 enum language language;
c906108c 813
17c5ed2c
DC
814 /* String that identifies the format of the debugging information, such
815 as "stabs", "dwarf 1", "dwarf 2", "coff", etc. This is mostly useful
816 for automated testing of gdb but may also be information that is
c378eb4e 817 useful to the user. */
c906108c 818
17c5ed2c 819 char *debugformat;
c906108c 820
303b6f5d 821 /* String of producer version information. May be zero. */
c906108c 822
303b6f5d 823 char *producer;
c906108c 824
17c5ed2c
DC
825 /* Full name of file as found by searching the source path.
826 NULL if not yet known. */
c906108c 827
17c5ed2c 828 char *fullname;
c906108c 829
17c5ed2c 830 /* Object file from which this symbol information was read. */
c906108c 831
17c5ed2c 832 struct objfile *objfile;
c906108c 833
17c5ed2c 834};
c906108c
SS
835
836#define BLOCKVECTOR(symtab) (symtab)->blockvector
837#define LINETABLE(symtab) (symtab)->linetable
6c95b8df 838#define SYMTAB_PSPACE(symtab) (symtab)->objfile->pspace
c906108c 839\f
c5aa993b 840
c906108c 841/* The virtual function table is now an array of structures which have the
a960f249 842 form { int16 offset, delta; void *pfn; }.
c906108c
SS
843
844 In normal virtual function tables, OFFSET is unused.
845 DELTA is the amount which is added to the apparent object's base
846 address in order to point to the actual object to which the
847 virtual function should be applied.
848 PFN is a pointer to the virtual function.
849
c378eb4e 850 Note that this macro is g++ specific (FIXME). */
c5aa993b 851
c906108c
SS
852#define VTBL_FNADDR_OFFSET 2
853
c378eb4e 854/* External variables and functions for the objects described above. */
c906108c 855
c378eb4e 856/* See the comment in symfile.c about how current_objfile is used. */
c906108c
SS
857
858extern struct objfile *current_objfile;
859
c378eb4e 860/* True if we are nested inside psymtab_to_symtab. */
c906108c
SS
861
862extern int currently_reading_symtab;
863
864/* From utils.c. */
865extern int demangle;
866extern int asm_demangle;
867
868/* symtab.c lookup functions */
869
7fc830e2
MK
870extern const char multiple_symbols_ask[];
871extern const char multiple_symbols_all[];
872extern const char multiple_symbols_cancel[];
717d2f5a
JB
873
874const char *multiple_symbols_select_mode (void);
875
5eeb2539
AR
876int symbol_matches_domain (enum language symbol_language,
877 domain_enum symbol_domain,
878 domain_enum domain);
879
c378eb4e 880/* lookup a symbol table by source file name. */
c906108c 881
1f8cc6db 882extern struct symtab *lookup_symtab (const char *);
c906108c 883
6c9353d3 884/* lookup a symbol by name (optional block) in language. */
53c5240f
PA
885
886extern struct symbol *lookup_symbol_in_language (const char *,
887 const struct block *,
888 const domain_enum,
889 enum language,
2570f2b7 890 int *);
53c5240f
PA
891
892/* lookup a symbol by name (optional block, optional symtab)
c378eb4e 893 in the current language. */
c906108c 894
a14ed312 895extern struct symbol *lookup_symbol (const char *, const struct block *,
2570f2b7 896 const domain_enum, int *);
c906108c 897
5f9a71c3
DC
898/* A default version of lookup_symbol_nonlocal for use by languages
899 that can't think of anything better to do. */
900
901extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
5f9a71c3 902 const struct block *,
21b556f4 903 const domain_enum);
5f9a71c3
DC
904
905/* Some helper functions for languages that need to write their own
906 lookup_symbol_nonlocal functions. */
907
908/* Lookup a symbol in the static block associated to BLOCK, if there
909 is one; do nothing if BLOCK is NULL or a global block. */
910
911extern struct symbol *lookup_symbol_static (const char *name,
5f9a71c3 912 const struct block *block,
21b556f4 913 const domain_enum domain);
5f9a71c3
DC
914
915/* Lookup a symbol in all files' global blocks (searching psymtabs if
916 necessary). */
917
918extern struct symbol *lookup_symbol_global (const char *name,
3a40aaa0 919 const struct block *block,
21b556f4 920 const domain_enum domain);
5f9a71c3
DC
921
922/* Lookup a symbol within the block BLOCK. This, unlike
923 lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
924 will fix up the symbol if necessary. */
925
926extern struct symbol *lookup_symbol_aux_block (const char *name,
5f9a71c3 927 const struct block *block,
21b556f4 928 const domain_enum domain);
5f9a71c3 929
41f62f39
JK
930/* Lookup a symbol only in the file static scope of all the objfiles. */
931
932struct symbol *lookup_static_symbol_aux (const char *name,
933 const domain_enum domain);
934
935
c378eb4e 936/* lookup a symbol by name, within a specified block. */
c5aa993b 937
a14ed312 938extern struct symbol *lookup_block_symbol (const struct block *, const char *,
176620f1 939 const domain_enum);
c906108c 940
c378eb4e 941/* lookup a [struct, union, enum] by name, within a specified block. */
c906108c 942
a14ed312 943extern struct type *lookup_struct (char *, struct block *);
c906108c 944
a14ed312 945extern struct type *lookup_union (char *, struct block *);
c906108c 946
a14ed312 947extern struct type *lookup_enum (char *, struct block *);
c906108c 948
c906108c
SS
949/* from blockframe.c: */
950
c378eb4e 951/* lookup the function symbol corresponding to the address. */
c906108c 952
a14ed312 953extern struct symbol *find_pc_function (CORE_ADDR);
c906108c 954
c378eb4e 955/* lookup the function corresponding to the address and section. */
c906108c 956
714835d5 957extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
c5aa993b 958
c378eb4e 959/* lookup function from address, return name, start addr and end addr. */
c906108c 960
570b8f7c
AC
961extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
962 CORE_ADDR *);
c906108c 963
a14ed312 964extern void clear_pc_function_cache (void);
c906108c 965
c378eb4e 966/* lookup partial symbol table by address and section. */
c906108c 967
ccefe4c4
TT
968extern struct symtab *find_pc_sect_symtab_via_partial (CORE_ADDR,
969 struct obj_section *);
c906108c 970
c378eb4e 971/* lookup full symbol table by address. */
c906108c 972
a14ed312 973extern struct symtab *find_pc_symtab (CORE_ADDR);
c906108c 974
c378eb4e 975/* lookup full symbol table by address and section. */
c906108c 976
714835d5 977extern struct symtab *find_pc_sect_symtab (CORE_ADDR, struct obj_section *);
c906108c 978
a14ed312 979extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
c906108c 980
a14ed312 981extern void reread_symbols (void);
c906108c 982
a14ed312 983extern struct type *lookup_transparent_type (const char *);
b368761e 984extern struct type *basic_lookup_transparent_type (const char *);
c906108c
SS
985
986
c378eb4e 987/* Macro for name of symbol to indicate a file compiled with gcc. */
c906108c
SS
988#ifndef GCC_COMPILED_FLAG_SYMBOL
989#define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
990#endif
991
c378eb4e 992/* Macro for name of symbol to indicate a file compiled with gcc2. */
c906108c
SS
993#ifndef GCC2_COMPILED_FLAG_SYMBOL
994#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
995#endif
996
997/* Functions for dealing with the minimal symbol table, really a misc
998 address<->symbol mapping for things we don't have debug symbols for. */
999
a14ed312
KB
1000extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1001 enum minimal_symbol_type,
1002 struct objfile *);
c906108c 1003
04a679b8
TT
1004extern struct minimal_symbol *prim_record_minimal_symbol_full
1005 (const char *, int, int, CORE_ADDR,
1006 enum minimal_symbol_type,
1007 int section, asection * bfd_section, struct objfile *);
1008
c906108c 1009extern struct minimal_symbol *prim_record_minimal_symbol_and_info
a14ed312
KB
1010 (const char *, CORE_ADDR,
1011 enum minimal_symbol_type,
b887350f 1012 int section, asection * bfd_section, struct objfile *);
c906108c 1013
a14ed312 1014extern unsigned int msymbol_hash_iw (const char *);
9227b5eb 1015
a14ed312 1016extern unsigned int msymbol_hash (const char *);
9227b5eb 1017
bccdca4a
UW
1018extern struct objfile * msymbol_objfile (struct minimal_symbol *sym);
1019
9227b5eb
JB
1020extern void
1021add_minsym_to_hash_table (struct minimal_symbol *sym,
1022 struct minimal_symbol **table);
1023
a14ed312
KB
1024extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1025 const char *,
1026 struct objfile *);
c906108c 1027
a14ed312 1028extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
a14ed312 1029 struct objfile *);
c906108c 1030
a14ed312 1031struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
a14ed312
KB
1032 struct objfile
1033 *);
c906108c 1034
907fc202
UW
1035extern struct minimal_symbol *lookup_minimal_symbol_by_pc_name
1036 (CORE_ADDR, const char *, struct objfile *);
1037
a14ed312 1038extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
c906108c 1039
0875794a
JK
1040extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1041
0d5392b8
TT
1042extern struct minimal_symbol *
1043 lookup_minimal_symbol_and_objfile (const char *,
1044 struct objfile **);
1045
714835d5
UW
1046extern struct minimal_symbol
1047 *lookup_minimal_symbol_by_pc_section (CORE_ADDR, struct obj_section *);
c906108c 1048
a14ed312
KB
1049extern struct minimal_symbol
1050 *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
c906108c 1051
52f729a7 1052extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
c906108c 1053
a14ed312 1054extern void init_minimal_symbol_collection (void);
c906108c 1055
56e290f4 1056extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
c906108c 1057
a14ed312 1058extern void install_minimal_symbols (struct objfile *);
c906108c
SS
1059
1060/* Sort all the minimal symbols in OBJFILE. */
1061
a14ed312 1062extern void msymbols_sort (struct objfile *objfile);
c906108c
SS
1063
1064struct symtab_and_line
17c5ed2c 1065{
6c95b8df
PA
1066 /* The program space of this sal. */
1067 struct program_space *pspace;
1068
17c5ed2c 1069 struct symtab *symtab;
714835d5 1070 struct obj_section *section;
17c5ed2c
DC
1071 /* Line number. Line numbers start at 1 and proceed through symtab->nlines.
1072 0 is never a valid line number; it is used to indicate that line number
1073 information is not available. */
1074 int line;
1075
1076 CORE_ADDR pc;
1077 CORE_ADDR end;
ed0616c6
VP
1078 int explicit_pc;
1079 int explicit_line;
17c5ed2c 1080};
c906108c 1081
fe39c653 1082extern void init_sal (struct symtab_and_line *sal);
c906108c
SS
1083
1084struct symtabs_and_lines
17c5ed2c
DC
1085{
1086 struct symtab_and_line *sals;
1087 int nelts;
1088};
c5aa993b 1089\f
c906108c
SS
1090
1091
c906108c
SS
1092/* Some types and macros needed for exception catchpoints.
1093 Can't put these in target.h because symtab_and_line isn't
c378eb4e
MS
1094 known there. This file will be included by breakpoint.c,
1095 hppa-tdep.c, etc. */
c906108c 1096
c378eb4e 1097/* Enums for exception-handling support. */
c5aa993b 1098enum exception_event_kind
17c5ed2c
DC
1099{
1100 EX_EVENT_THROW,
1101 EX_EVENT_CATCH
1102};
c906108c 1103
c906108c
SS
1104\f
1105
1106/* Given a pc value, return line number it is in. Second arg nonzero means
1107 if pc is on the boundary use the previous statement's line number. */
1108
a14ed312 1109extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
c906108c 1110
c378eb4e 1111/* Same function, but specify a section as well as an address. */
c906108c 1112
714835d5
UW
1113extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1114 struct obj_section *, int);
c906108c 1115
c906108c
SS
1116/* Given a symtab and line number, return the pc there. */
1117
a14ed312 1118extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
c906108c 1119
570b8f7c
AC
1120extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1121 CORE_ADDR *);
c906108c 1122
a14ed312 1123extern void resolve_sal_pc (struct symtab_and_line *);
c906108c
SS
1124
1125/* Given a string, return the line specified by it. For commands like "list"
1126 and "breakpoint". */
1127
a14ed312 1128extern struct symtabs_and_lines decode_line_spec (char *, int);
c906108c 1129
a14ed312 1130extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
c906108c 1131
c906108c
SS
1132/* Symmisc.c */
1133
a14ed312 1134void maintenance_print_symbols (char *, int);
c906108c 1135
a14ed312 1136void maintenance_print_psymbols (char *, int);
c906108c 1137
a14ed312 1138void maintenance_print_msymbols (char *, int);
c906108c 1139
a14ed312 1140void maintenance_print_objfiles (char *, int);
c906108c 1141
5e7b2f39 1142void maintenance_info_symtabs (char *, int);
44ea7b70 1143
5e7b2f39 1144void maintenance_info_psymtabs (char *, int);
44ea7b70 1145
a14ed312 1146void maintenance_check_symtabs (char *, int);
c906108c
SS
1147
1148/* maint.c */
1149
a14ed312 1150void maintenance_print_statistics (char *, int);
c906108c 1151
a14ed312 1152extern void free_symtab (struct symtab *);
c906108c
SS
1153
1154/* Symbol-reading stuff in symfile.c and solib.c. */
1155
a14ed312 1156extern void clear_solib (void);
c906108c 1157
c906108c
SS
1158/* source.c */
1159
a14ed312 1160extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
c906108c 1161
a14ed312 1162extern void print_source_lines (struct symtab *, int, int, int);
c906108c 1163
a14ed312 1164extern void forget_cached_source_info (void);
c906108c 1165
a14ed312 1166extern void select_source_symtab (struct symtab *);
c906108c 1167
f55ee35c
JK
1168extern char **default_make_symbol_completion_list_break_on
1169 (char *text, char *word, const char *break_on);
41d27058 1170extern char **default_make_symbol_completion_list (char *, char *);
a14ed312 1171extern char **make_symbol_completion_list (char *, char *);
d8906c6f
TJB
1172extern char **make_symbol_completion_list_fn (struct cmd_list_element *,
1173 char *, char *);
c906108c 1174
c94fdfd0
EZ
1175extern char **make_file_symbol_completion_list (char *, char *, char *);
1176
c94fdfd0
EZ
1177extern char **make_source_files_completion_list (char *, char *);
1178
c906108c
SS
1179/* symtab.c */
1180
714835d5 1181int matching_obj_sections (struct obj_section *, struct obj_section *);
94277a38 1182
dd786858 1183extern const char *find_main_filename (void);
c906108c 1184
50641945
FN
1185extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1186
17c5ed2c
DC
1187extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1188 int);
50641945 1189
059acae7
UW
1190extern void skip_prologue_sal (struct symtab_and_line *);
1191
c906108c
SS
1192/* symfile.c */
1193
c1e56572 1194extern void clear_symtab_users (int add_flags);
c906108c 1195
dd786858 1196extern enum language deduce_language_from_filename (const char *);
c906108c
SS
1197
1198/* symtab.c */
1199
d80b854b
UW
1200extern int in_prologue (struct gdbarch *gdbarch,
1201 CORE_ADDR pc, CORE_ADDR func_start);
c906108c 1202
d80b854b
UW
1203extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1204 CORE_ADDR func_addr);
634aa483 1205
a14ed312
KB
1206extern struct symbol *fixup_symbol_section (struct symbol *,
1207 struct objfile *);
c906108c
SS
1208
1209/* Symbol searching */
1210
1211/* When using search_symbols, a list of the following structs is returned.
c378eb4e 1212 Callers must free the search list using free_search_symbols! */
c906108c 1213struct symbol_search
17c5ed2c 1214{
c378eb4e
MS
1215 /* The block in which the match was found. Could be, for example,
1216 STATIC_BLOCK or GLOBAL_BLOCK. */
17c5ed2c 1217 int block;
c906108c 1218
17c5ed2c 1219 /* Information describing what was found.
c906108c 1220
17c5ed2c 1221 If symtab abd symbol are NOT NULL, then information was found
c378eb4e 1222 for this match. */
17c5ed2c
DC
1223 struct symtab *symtab;
1224 struct symbol *symbol;
c906108c 1225
17c5ed2c 1226 /* If msymbol is non-null, then a match was made on something for
c378eb4e 1227 which only minimal_symbols exist. */
17c5ed2c 1228 struct minimal_symbol *msymbol;
c906108c 1229
c378eb4e 1230 /* A link to the next match, or NULL for the end. */
17c5ed2c
DC
1231 struct symbol_search *next;
1232};
c906108c 1233
176620f1 1234extern void search_symbols (char *, domain_enum, int, char **,
a14ed312
KB
1235 struct symbol_search **);
1236extern void free_search_symbols (struct symbol_search *);
17c5ed2c
DC
1237extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1238 *);
c906108c 1239
51cc5b07
AC
1240/* The name of the ``main'' function.
1241 FIXME: cagney/2001-03-20: Can't make main_name() const since some
1242 of the calling code currently assumes that the string isn't
c378eb4e 1243 const. */
51cc5b07 1244extern void set_main_name (const char *name);
17c5ed2c 1245extern /*const */ char *main_name (void);
01f8c46d 1246extern enum language language_of_main;
51cc5b07 1247
3a40aaa0 1248/* Check global symbols in objfile. */
3e43a32a 1249struct symbol *lookup_global_symbol_from_objfile (const struct objfile *,
3a40aaa0 1250 const char *name,
21b556f4 1251 const domain_enum domain);
3a40aaa0 1252
a6c727b2
DJ
1253extern struct symtabs_and_lines expand_line_sal (struct symtab_and_line sal);
1254
1255/* Return 1 if the supplied producer string matches the ARM RealView
1256 compiler (armcc). */
1257int producer_is_realview (const char *producer);
3a40aaa0 1258
ccefe4c4
TT
1259void fixup_section (struct general_symbol_info *ginfo,
1260 CORE_ADDR addr, struct objfile *objfile);
1261
c0201579
JK
1262struct objfile *lookup_objfile_from_block (const struct block *block);
1263
c906108c 1264#endif /* !defined(SYMTAB_H) */
This page took 1.137021 seconds and 4 git commands to generate.