1 /* Symbol table definitions for GDB.
2 Copyright (C) 1986, 1989, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 #if !defined (SYMTAB_H)
24 /* See the comment in symfile.c about how current_objfile is used. */
26 extern struct objfile
*current_objfile
;
28 /* Some definitions and declarations to go with use of obstacks. */
29 #define obstack_chunk_alloc xmalloc
30 #define obstack_chunk_free free
32 /* Some macros for char-based bitfields. */
33 #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7)))
34 #define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7)))
35 #define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7)))
36 #define B_TYPE unsigned char
37 #define B_BYTES(x) ( 1 + ((x)>>3) )
38 #define B_CLRALL(a,x) (void) memset ((a), 0, B_BYTES(x))
41 /* Define a simple structure used to hold some very basic information about
42 all defined global symbols (text, data, bss, abs, etc). The only two
43 required pieces of information are the symbol's name and the address
44 associated with that symbol. In many cases, even if a file was compiled
45 with no special options for debugging at all, as long as was not stripped
46 it will contain sufficient information to build a useful minimal symbol
47 table using this structure. Even when a file contains enough debugging
48 information to build a full symbol table, these minimal symbols are still
49 useful for quickly mapping between names and addresses, and vice versa.
50 They are also sometimes used to figure out what full symbol table entries
51 need to be read in. */
56 /* Name of the symbol. This is a required field. Storage for the name is
57 allocated on the symbol_obstack for the associated objfile. */
61 /* Address of the symbol. This is a required field. */
65 /* The info field is available for caching machine-specific information that
66 The AMD 29000 tdep.c uses it to remember things it has decoded from the
67 instructions in the function header, so it doesn't have to rederive the
68 info constantly (over a serial line). It is initialized to zero and
69 stays that way until target-dependent code sets it. Storage for any data
70 pointed to by this field should be allocated on the symbol_obstack for
71 the associated objfile. The type would be "void *" except for reasons
72 of compatibility with older compilers. This field is optional. */
76 /* Classification types for this symbol. These should be taken as "advisory
77 only", since if gdb can't easily figure out a classification it simply
78 selects mst_unknown. It may also have to guess when it can't figure out
79 which is a better match between two types (mst_data versus mst_bss) for
80 example. Since the minimal symbol info is sometimes derived from the
81 BFD library's view of a file, we need to live with what information bfd
84 enum minimal_symbol_type
86 mst_unknown
= 0, /* Unknown type, the default */
87 mst_text
, /* Generally executable instructions */
88 mst_data
, /* Generally initialized data */
89 mst_bss
, /* Generally uninitialized data */
90 mst_abs
/* Generally absolute (nonrelocatable) */
96 /* All of the name-scope contours of the program
97 are represented by `struct block' objects.
98 All of these objects are pointed to by the blockvector.
100 Each block represents one name scope.
101 Each lexical context has its own block.
103 The first two blocks in the blockvector are special.
104 The first one contains all the symbols defined in this compilation
105 whose scope is the entire program linked together.
106 The second one contains all the symbols whose scope is the
107 entire compilation excluding other separate compilations.
108 In C, these correspond to global symbols and static symbols.
110 Each block records a range of core addresses for the code that
111 is in the scope of the block. The first two special blocks
112 give, for the range of code, the entire range of code produced
113 by the compilation that the symbol segment belongs to.
115 The blocks appear in the blockvector
116 in order of increasing starting-address,
117 and, within that, in order of decreasing ending-address.
119 This implies that within the body of one function
120 the blocks appear in the order of a depth-first tree walk. */
124 /* Number of blocks in the list. */
126 /* The blocks themselves. */
127 struct block
*block
[1];
130 /* Special block numbers */
131 #define GLOBAL_BLOCK 0
132 #define STATIC_BLOCK 1
133 #define FIRST_LOCAL_BLOCK 2
137 /* Addresses in the executable code that are in this block.
138 Note: in an unrelocated symbol segment in a file,
139 these are always zero. They can be filled in from the
140 N_LBRAC and N_RBRAC symbols in the loader symbol table. */
141 CORE_ADDR startaddr
, endaddr
;
142 /* The symbol that names this block,
143 if the block is the body of a function;
145 Note: In an unrelocated symbol segment in an object file,
146 this field may be zero even when the block has a name.
147 That is because the block is output before the name
148 (since the name resides in a higher block).
149 Since the symbol does point to the block (as its value),
150 it is possible to find the block and set its name properly. */
151 struct symbol
*function
;
152 /* The `struct block' for the containing block, or 0 if none. */
153 /* Note that in an unrelocated symbol segment in an object file
154 this pointer may be zero when the correct value should be
155 the second special block (for symbols whose scope is one compilation).
156 This is because the compiler outputs the special blocks at the
157 very end, after the other blocks. */
158 struct block
*superblock
;
159 /* A flag indicating whether or not the function corresponding
160 to this block was compiled with gcc or not. If there is no
161 function corresponding to this block, this meaning of this flag
162 is undefined. (In practice it will be 1 if the block was created
163 while processing a file compiled with gcc and 0 when not). */
164 unsigned char gcc_compile_flag
;
165 /* Number of local symbols. */
168 struct symbol
*sym
[1];
171 /* Represent one symbol name; a variable, constant, function or typedef. */
173 /* Different name spaces for symbols. Looking up a symbol specifies
174 a namespace and ignores symbol definitions in other name spaces.
176 VAR_NAMESPACE is the usual namespace.
177 In C, this contains variables, function names, typedef names
178 and enum type values.
180 STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
181 Thus, if `struct foo' is used in a C program,
182 it produces a symbol named `foo' in the STRUCT_NAMESPACE.
184 LABEL_NAMESPACE may be used for names of labels (for gotos);
185 currently it is not used and labels are not recorded at all. */
187 /* For a non-global symbol allocated statically,
188 the correct core address cannot be determined by the compiler.
189 The compiler puts an index number into the symbol's value field.
190 This index number can be matched with the "desc" field of
191 an entry in the loader symbol table. */
195 UNDEF_NAMESPACE
, VAR_NAMESPACE
, STRUCT_NAMESPACE
, LABEL_NAMESPACE
198 /* An address-class says where to find the value of a symbol. */
202 LOC_UNDEF
, /* Not used; catches errors */
203 LOC_CONST
, /* Value is constant int SYMBOL_VALUE, host byteorder */
204 LOC_STATIC
, /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
205 LOC_REGISTER
, /* Value is in register */
206 LOC_ARG
, /* Value is at spec'd offset in arglist */
207 LOC_REF_ARG
, /* Value address is at spec'd offset in arglist. */
208 LOC_REGPARM
, /* Value is at spec'd offset in register window */
209 LOC_LOCAL
, /* Value is at spec'd offset in stack frame */
210 LOC_TYPEDEF
, /* Value not used; definition in SYMBOL_TYPE
211 Symbols in the namespace STRUCT_NAMESPACE
212 all have this class. */
213 LOC_LABEL
, /* Value is address SYMBOL_VALUE_ADDRESS in the code */
214 LOC_BLOCK
, /* Value is address SYMBOL_VALUE_BLOCK of a
215 `struct block'. Function names have this class. */
216 LOC_CONST_BYTES
, /* Value is a constant byte-sequence pointed to by
217 SYMBOL_VALUE_ADDRESS, in target byte order. */
218 LOC_LOCAL_ARG
/* Value is arg at spec'd offset in stack frame.
219 Differs from LOC_LOCAL in that symbol is an
220 argument; differs from LOC_ARG in that we find it
221 in the frame (FRAME_LOCALS_ADDRESS), not in the
222 arglist (FRAME_ARGS_ADDRESS). Added for i960,
223 which passes args in regs then copies to frame. */
230 /* Name space code. */
231 enum namespace namespace;
233 enum address_class
class;
234 /* Data type of value */
237 /* Line number of definition. */
240 /* constant value, or address if static, or register number,
241 or offset in arguments, or offset in stack frame. All of
242 these are in host byte order (though what they point to might
243 be in target byte order, e.g. LOC_CONST_BYTES). */
246 long value
; /* for LOC_CONST, LOC_REGISTER, LOC_ARG,
247 LOC_REF_ARG, LOC_REGPARM, LOC_LOCAL */
248 struct block
*block
; /* for LOC_BLOCK */
249 char *bytes
; /* for LOC_CONST_BYTES */
250 CORE_ADDR address
; /* for LOC_STATIC, LOC_LABEL */
251 struct symbol
*chain
; /* for opaque typedef struct chain */
255 /* Some symbols require an additional value to be recorded on a per-
256 symbol basis. Stash those values here. */
259 struct /* for OP_BASEREG in DWARF location specs */
261 short regno_valid
; /* 0 == regno invalid; !0 == regno valid */
262 short regno
; /* base register number {0, 1, 2, ...} */
269 /* A partial_symbol records the name, namespace, and address class of
270 symbols whose types we have not parsed yet. For functions, it also
271 contains their memory address, so we can find them from a PC value.
272 Each partial_symbol sits in a partial_symtab, all of which are chained
273 on a partial symtab list and which points to the corresponding
274 normal symtab once the partial_symtab has been referenced. */
276 struct partial_symbol
280 /* Name space code. */
281 enum namespace namespace;
282 /* Address class (for info_symbols) */
283 enum address_class
class;
284 /* Value (only used for static functions currently). Done this
285 way so that we can use the struct symbol macros.
286 Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst)
287 in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st))
288 in a symbol table. */
297 /* Source-file information.
298 This describes the relation between source files and line numbers
299 and addresses in the program text. */
303 int length
; /* Number of source files described */
304 struct source
*source
[1]; /* Descriptions of the files */
307 /* Each item represents a line-->pc (or the reverse) mapping. This is
308 somewhat more wasteful of space than one might wish, but since only
309 the files which are actually debugged are read in to core, we don't
312 Each item used to be an int; either minus a line number, or a
313 program counter. If it represents a line number, that is the line
314 described by the next program counter value. If it is positive, it
315 is the program counter at which the code for the next line starts. */
317 struct linetable_entry
326 struct linetable_entry item
[1];
329 /* All the information on one source file. */
333 char *name
; /* Name of file */
334 struct linetable contents
;
337 /* Each source file is represented by a struct symtab.
338 These objects are chained through the `next' field. */
342 /* Chain of all existing symtabs. */
344 /* List of all symbol scope blocks for this symtab. */
345 struct blockvector
*blockvector
;
346 /* Table mapping core addresses to line numbers for this file.
347 Can be NULL if none. */
348 struct linetable
*linetable
;
349 /* Name of this source file. */
351 /* Directory in which it was compiled, or NULL if we don't know. */
353 /* This component says how to free the data we point to:
354 free_contents => do a tree walk and free each object.
355 free_nothing => do nothing; some other symtab will free
356 the data this one uses.
357 free_linetable => free just the linetable. */
358 enum free_code
{free_nothing
, free_contents
, free_linetable
}
360 /* Pointer to one block of storage to be freed, if nonzero. */
361 /* This is IN ADDITION to the action indicated by free_code. */
363 /* Total number of lines found in source file. */
365 /* Array mapping line number to character position. */
367 /* Language of this source file. */
368 enum language language
;
369 /* String of version information. May be zero. */
371 /* Full name of file as found by searching the source path.
372 0 if not yet known. */
375 /* Object file from which this symbol information was read. */
376 struct objfile
*objfile
;
378 /* Anything extra for this symtab. This is for target machines
379 with special debugging info of some sort (which cannot just
380 be represented in a normal symtab). */
381 #if defined (EXTRA_SYMTAB_INFO)
386 /* Each source file that has not been fully read in is represented by
387 a partial_symtab. This contains the information on where in the
388 executable the debugging symbols for a specific file are, and a
389 list of names of global symbols which are located in this file.
390 They are all chained on partial symtab lists.
392 Even after the source file has been read into a symtab, the
393 partial_symtab remains around. They are allocated on an obstack,
394 psymbol_obstack. FIXME, this is bad for dynamic linking or VxWorks-
395 style execution of a bunch of .o's. */
397 struct partial_symtab
399 /* Chain of all existing partial symtabs. */
400 struct partial_symtab
*next
;
401 /* Name of the source file which this partial_symtab defines */
404 /* Information about the object file from which symbols should be read. */
405 struct objfile
*objfile
;
407 /* Address relative to which the symbols in this file are. Need to
408 relocate by this amount when reading in symbols from the symbol
411 /* Range of text addresses covered by this file; texthigh is the
412 beginning of the next section. */
413 CORE_ADDR textlow
, texthigh
;
414 /* Array of pointers to all of the partial_symtab's which this one
415 depends on. Since this array can only be set to previous or
416 the current (?) psymtab, this dependency tree is guaranteed not
417 to have any loops. */
418 struct partial_symtab
**dependencies
;
419 int number_of_dependencies
;
420 /* Global symbol list. This list will be sorted after readin to
421 improve access. Binary search will be the usual method of
422 finding a symbol within it. globals_offset is an integer offset
423 within global_psymbols[]. */
424 int globals_offset
, n_global_syms
;
425 /* Static symbol list. This list will *not* be sorted after readin;
426 to find a symbol in it, exhaustive search must be used. This is
427 reasonable because searches through this list will eventually
428 lead to either the read in of a files symbols for real (assumed
429 to take a *lot* of time; check) or an error (and we don't care
430 how long errors take). This is an offset and size within
431 static_psymbols[]. */
432 int statics_offset
, n_static_syms
;
433 /* Pointer to symtab eventually allocated for this source file, 0 if
434 !readin or if we haven't looked for the symtab after it was readin. */
435 struct symtab
*symtab
;
436 /* Pointer to function which will read in the symtab corresponding to
438 void (*read_symtab
) PARAMS ((struct partial_symtab
*));
439 /* Information that lets read_symtab() locate the part of the symbol table
440 that this psymtab corresponds to. This information is private to the
441 format-dependent symbol reading routines. For further detail examine
442 the various symbol reading modules. Should really be (void *) but is
443 (char *) as with other such gdb variables. (FIXME) */
444 char *read_symtab_private
;
445 /* Non-zero if the symtab corresponding to this psymtab has been
447 unsigned char readin
;
450 /* A fast way to get from a psymtab to its symtab (after the first time). */
451 #define PSYMTAB_TO_SYMTAB(pst) ((pst)->symtab? \
453 psymtab_to_symtab (pst) )
455 /* This symtab variable specifies the current file for printing source lines */
457 extern struct symtab
*current_source_symtab
;
459 /* This is the next line to print for listing source lines. */
461 extern int current_source_line
;
463 #define BLOCKVECTOR(symtab) (symtab)->blockvector
465 #define LINETABLE(symtab) (symtab)->linetable
467 /* Macros normally used to access components of symbol table structures. */
469 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
470 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
472 #define BLOCK_START(bl) (bl)->startaddr
473 #define BLOCK_END(bl) (bl)->endaddr
474 #define BLOCK_NSYMS(bl) (bl)->nsyms
475 #define BLOCK_SYM(bl, n) (bl)->sym[n]
476 #define BLOCK_FUNCTION(bl) (bl)->function
477 #define BLOCK_SUPERBLOCK(bl) (bl)->superblock
478 #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag
480 /* Nonzero if symbols of block BL should be sorted alphabetically. */
481 #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40)
483 #define SYMBOL_NAME(symbol) (symbol)->name
484 #define SYMBOL_NAMESPACE(symbol) (symbol)->namespace
485 #define SYMBOL_CLASS(symbol) (symbol)->class
486 #define SYMBOL_VALUE(symbol) (symbol)->value.value
487 #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->value.address
488 #define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
489 #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
490 #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
491 #define SYMBOL_TYPE(symbol) (symbol)->type
492 #define SYMBOL_LINE(symbol) (symbol)->line
494 /* This currently fails because some symbols are not being initialized
495 to zero on allocation, and no code is currently setting this value.
496 Basereg handling will probably change significantly in the next release.
498 #define SYMBOL_BASEREG_VALID(symbol) (symbol)->aux_value.basereg.regno_valid
500 #define SYMBOL_BASEREG_VALID(symbol) 0
502 #define SYMBOL_BASEREG(symbol) (symbol)->aux_value.basereg.regno
504 /* The virtual function table is now an array of structures
505 which have the form { int16 offset, delta; void *pfn; }.
507 In normal virtual function tables, OFFSET is unused.
508 DELTA is the amount which is added to the apparent object's base
509 address in order to point to the actual object to which the
510 virtual function should be applied.
511 PFN is a pointer to the virtual function. */
513 #define VTBL_FNADDR_OFFSET 2
515 /* Macro that yields non-zero value iff NAME is the prefix
516 for C++ operator names. If you leave out the parenthesis
519 Currently 'o' 'p' CPLUS_MARKER is used for both the symbol in the
520 symbol-file and the names in gdb's symbol table. */
521 #define OPNAME_PREFIX_P(NAME) ((NAME)[0] == 'o' && (NAME)[1] == 'p' \
522 && (NAME)[2] == CPLUS_MARKER)
524 #define VTBL_PREFIX_P(NAME) ((NAME)[3] == CPLUS_MARKER \
525 && !strncmp ((NAME), "_vt", 3))
527 /* Functions that work on the objects described above */
529 extern struct symtab
*
530 lookup_symtab
PARAMS ((char *));
532 extern struct symbol
*
533 lookup_symbol
PARAMS ((const char *, const struct block
*,
534 const enum namespace, int *, struct symtab
**));
536 extern struct symbol
*
537 lookup_block_symbol
PARAMS ((const struct block
*, const char *,
538 const enum namespace));
541 lookup_struct
PARAMS ((char *, struct block
*));
544 lookup_union
PARAMS ((char *, struct block
*));
547 lookup_enum
PARAMS ((char *, struct block
*));
549 extern struct symbol
*
550 block_function
PARAMS ((struct block
*));
552 extern struct symbol
*
553 find_pc_function
PARAMS ((CORE_ADDR
));
556 find_pc_partial_function
PARAMS ((CORE_ADDR
, char **, CORE_ADDR
*));
559 clear_pc_function_cache
PARAMS ((void));
561 extern struct partial_symtab
*
562 lookup_partial_symtab
PARAMS ((char *));
564 extern struct partial_symtab
*
565 find_pc_psymtab
PARAMS ((CORE_ADDR
));
567 extern struct symtab
*
568 find_pc_symtab
PARAMS ((CORE_ADDR
));
570 extern struct partial_symbol
*
571 find_pc_psymbol
PARAMS ((struct partial_symtab
*, CORE_ADDR
));
574 find_pc_line_pc_range
PARAMS ((CORE_ADDR
, CORE_ADDR
*, CORE_ADDR
*));
577 contained_in
PARAMS ((struct block
*, struct block
*));
580 reread_symbols
PARAMS ((void));
582 /* Functions for dealing with the minimal symbol table, really a misc
583 address<->symbol mapping for things we don't have debug symbols for. */
586 prim_record_minimal_symbol
PARAMS ((const char *, CORE_ADDR
,
587 enum minimal_symbol_type
));
590 prim_record_minimal_symbol_and_info
PARAMS ((const char *, CORE_ADDR
,
591 enum minimal_symbol_type
,
594 extern struct minimal_symbol
*
595 lookup_minimal_symbol
PARAMS ((const char *, struct objfile
*));
597 extern struct minimal_symbol
*
598 lookup_minimal_symbol_by_pc
PARAMS ((CORE_ADDR
));
601 init_minimal_symbol_collection
PARAMS ((void));
604 discard_minimal_symbols
PARAMS ((int));
607 install_minimal_symbols
PARAMS ((struct objfile
*));
609 struct symtab_and_line
611 struct symtab
*symtab
;
617 struct symtabs_and_lines
619 struct symtab_and_line
*sals
;
623 /* Given a pc value, return line number it is in.
624 Second arg nonzero means if pc is on the boundary
625 use the previous statement's line number. */
627 extern struct symtab_and_line
628 find_pc_line
PARAMS ((CORE_ADDR
, int));
630 /* Given a symtab and line number, return the pc there. */
633 find_line_pc
PARAMS ((struct symtab
*, int));
636 find_line_pc_range
PARAMS ((struct symtab
*, int, CORE_ADDR
*, CORE_ADDR
*));
639 resolve_sal_pc
PARAMS ((struct symtab_and_line
*));
641 /* Given a string, return the line specified by it.
642 For commands like "list" and "breakpoint". */
644 extern struct symtabs_and_lines
645 decode_line_spec
PARAMS ((char *, int));
647 extern struct symtabs_and_lines
648 decode_line_spec_1
PARAMS ((char *, int));
650 extern struct symtabs_and_lines
651 decode_line_1
PARAMS ((char **, int, struct symtab
*, int));
656 free_symtab
PARAMS ((struct symtab
*));
658 /* Symbol-reading stuff in symfile.c and solib.c. */
660 extern struct symtab
*
661 psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
664 clear_solib
PARAMS ((void));
666 extern struct objfile
*
667 symbol_file_add
PARAMS ((char *, int, CORE_ADDR
, int, int, int));
672 identify_source_line
PARAMS ((struct symtab
*, int, int));
675 print_source_lines
PARAMS ((struct symtab
*, int, int, int));
678 forget_cached_source_info
PARAMS ((void));
681 select_source_symtab
PARAMS ((struct symtab
*));
684 make_symbol_completion_list
PARAMS ((char *));
689 clear_symtab_users_once
PARAMS ((void));
691 extern struct partial_symtab
*
692 find_main_psymtab
PARAMS ((void));
696 extern struct blockvector
*
697 blockvector_for_pc
PARAMS ((CORE_ADDR
, int *));
702 deduce_language_from_filename
PARAMS ((char *));
704 #endif /* !defined(SYMTAB_H) */