Commit | Line | Data |
---|---|---|
bd5635a1 | 1 | /* Symbol table definitions for GDB. |
b0246b3b | 2 | Copyright (C) 1986, 1989, 1991, 1992 Free Software Foundation, Inc. |
bd5635a1 RP |
3 | |
4 | This file is part of GDB. | |
5 | ||
4a35d6e9 | 6 | This program is free software; you can redistribute it and/or modify |
bd5635a1 | 7 | it under the terms of the GNU General Public License as published by |
4a35d6e9 FF |
8 | the Free Software Foundation; either version 2 of the License, or |
9 | (at your option) any later version. | |
bd5635a1 | 10 | |
4a35d6e9 | 11 | This program is distributed in the hope that it will be useful, |
bd5635a1 RP |
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. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
4a35d6e9 FF |
17 | along with this program; if not, write to the Free Software |
18 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
bd5635a1 RP |
19 | |
20 | #if !defined (SYMTAB_H) | |
21 | #define SYMTAB_H 1 | |
bd5635a1 RP |
22 | |
23 | /* Some definitions and declarations to go with use of obstacks. */ | |
2e4964ad FF |
24 | |
25 | #include "obstack.h" | |
bd5635a1 RP |
26 | #define obstack_chunk_alloc xmalloc |
27 | #define obstack_chunk_free free | |
bd5635a1 | 28 | |
2e4964ad FF |
29 | /* Define a structure for the information that is common to all symbol types, |
30 | including minimal symbols, partial symbols, and full symbols. */ | |
31 | ||
32 | struct general_symbol_info | |
33 | { | |
34 | /* Name of the symbol. This is a required field. Storage for the name is | |
35 | allocated on the psymbol_obstack or symbol_obstack for the associated | |
36 | objfile. */ | |
37 | ||
38 | char *name; | |
39 | ||
40 | /* Constant value, or address if static, or register number, | |
41 | or offset in arguments, or offset in stack frame. All of | |
42 | these are in host byte order (though what they point to might | |
43 | be in target byte order, e.g. LOC_CONST_BYTES). | |
44 | ||
45 | Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst) | |
46 | in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st)) | |
47 | in a symbol table. */ | |
48 | ||
49 | union | |
50 | { | |
51 | /* for LOC_CONST, LOC_REGISTER, LOC_ARG, LOC_REF_ARG, LOC_REGPARM, | |
52 | LOC_LOCAL */ | |
53 | ||
54 | long value; | |
55 | ||
56 | /* for LOC_BLOCK */ | |
57 | ||
58 | struct block *block; | |
59 | ||
60 | /* for LOC_CONST_BYTES */ | |
61 | ||
62 | char *bytes; | |
63 | ||
64 | /* for LOC_STATIC, LOC_LABEL */ | |
65 | ||
66 | CORE_ADDR address; | |
67 | ||
68 | /* for opaque typedef struct chain */ | |
bd5635a1 | 69 | |
2e4964ad FF |
70 | struct symbol *chain; |
71 | } | |
72 | value; | |
73 | ||
74 | /* In a multilanguage environment, some language specific information may | |
75 | need to be recorded along with each symbol. */ | |
76 | ||
77 | struct language_dependent_info | |
78 | { | |
79 | ||
80 | /* Record the language that this information applies to. */ | |
81 | ||
82 | enum language language; | |
83 | ||
84 | /* Since one and only one language can apply, wrap the information inside | |
85 | a union. */ | |
bd5635a1 | 86 | |
2e4964ad FF |
87 | union |
88 | { | |
89 | /* For C++ */ | |
90 | struct | |
91 | { | |
92 | char *demangled_name; | |
93 | } cplus_specific; | |
94 | } lang_u; | |
95 | } lang_specific; | |
96 | }; | |
97 | ||
98 | #define SYMBOL_NAME(symbol) (symbol)->ginfo.name | |
99 | #define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.value | |
100 | #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address | |
101 | #define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes | |
102 | #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->ginfo.value.block | |
103 | #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->ginfo.value.chain | |
104 | #define SYMBOL_LANGUAGE(symbol) (symbol)->ginfo.lang_specific.language | |
105 | #define SYMBOL_DEMANGLED_NAME(symbol) \ | |
106 | (symbol)->ginfo.lang_specific.lang_u.cplus_specific.demangled_name | |
107 | ||
108 | extern int demangle; /* We reference it, so go ahead and declare it. */ | |
109 | ||
110 | /* Macro that returns the "natural source name" of a symbol. In C++ this is | |
111 | the "demangled" form of the name if demangle is on and the "mangled" form | |
112 | of the name if demangle is off. In other languages this is just the | |
113 | symbol name. */ | |
114 | ||
115 | #define SYMBOL_SOURCE_NAME(symbol) \ | |
116 | ((demangle && (SYMBOL_LANGUAGE(symbol) == language_cplus) && \ | |
117 | (SYMBOL_DEMANGLED_NAME(symbol) != NULL)) ? \ | |
118 | SYMBOL_DEMANGLED_NAME (symbol) : SYMBOL_NAME (symbol)) | |
119 | ||
120 | /* Macro that returns the "natural assembly name" of a symbol. In C++ this is | |
121 | the "mangled" form of the name if demangle is off, or if demangle is on and | |
122 | asm_demangle is off. Otherwise if asm_demangle is on it is the "demangled" | |
123 | form. In other languages this is just the symbol name. */ | |
124 | ||
125 | #define SYMBOL_LINKAGE_NAME(symbol) \ | |
126 | ((demangle && asm_demangle && (SYMBOL_LANGUAGE(symbol) == language_cplus) &&\ | |
127 | (SYMBOL_DEMANGLED_NAME(symbol) != NULL)) ? \ | |
128 | SYMBOL_DEMANGLED_NAME (symbol) : SYMBOL_NAME (symbol)) | |
129 | ||
130 | /* Macro that tests a symbol for a match against a specified name string. | |
131 | First test the unencoded name, then looks for and test a C++ encoded | |
132 | name if it exists. Note that whitespace is ignored while attempting to | |
133 | match a C++ encoded name, so that "foo::bar(int,long)" is the same as | |
134 | "foo :: bar (int, long)". | |
135 | Evaluates to zero if the match fails, or nonzero if it succeeds. */ | |
136 | ||
137 | #define SYMBOL_MATCHES_NAME(symbol, name) \ | |
138 | (STREQ (SYMBOL_NAME (symbol), (name)) || \ | |
139 | (SYMBOL_LANGUAGE (symbol) == language_cplus && \ | |
140 | SYMBOL_DEMANGLED_NAME (symbol) != NULL && \ | |
141 | strcmp_iw (SYMBOL_DEMANGLED_NAME (symbol), (name)) == 0)) | |
142 | ||
143 | /* Macro that tests a symbol for an re-match against the last compiled regular | |
144 | expression. First test the unencoded name, then look for and test a C++ | |
145 | encoded name if it exists. | |
146 | Evaluates to zero if the match fails, or nonzero if it succeeds. */ | |
147 | ||
148 | #define SYMBOL_MATCHES_REGEXP(symbol) \ | |
149 | (re_exec (SYMBOL_NAME (symbol)) != 0 || \ | |
150 | (SYMBOL_LANGUAGE (symbol) == language_cplus && \ | |
151 | SYMBOL_DEMANGLED_NAME (symbol) != NULL && \ | |
152 | re_exec (SYMBOL_DEMANGLED_NAME (symbol)) != 0)) | |
153 | ||
b0246b3b | 154 | /* Define a simple structure used to hold some very basic information about |
2e4964ad FF |
155 | all defined global symbols (text, data, bss, abs, etc). The only required |
156 | information is the general_symbol_info. | |
157 | ||
158 | In many cases, even if a file was compiled with no special options for | |
159 | debugging at all, as long as was not stripped it will contain sufficient | |
160 | information to build a useful minimal symbol table using this structure. | |
161 | Even when a file contains enough debugging information to build a full | |
162 | symbol table, these minimal symbols are still useful for quickly mapping | |
163 | between names and addresses, and vice versa. They are also sometimes | |
164 | used to figure out what full symbol table entries need to be read in. */ | |
bd5635a1 | 165 | |
b0246b3b FF |
166 | struct minimal_symbol |
167 | { | |
bd5635a1 | 168 | |
2e4964ad | 169 | /* The general symbol info required for all types of symbols. */ |
bd5635a1 | 170 | |
2e4964ad | 171 | struct general_symbol_info ginfo; |
bd5635a1 | 172 | |
b0246b3b FF |
173 | /* The info field is available for caching machine-specific information that |
174 | The AMD 29000 tdep.c uses it to remember things it has decoded from the | |
175 | instructions in the function header, so it doesn't have to rederive the | |
176 | info constantly (over a serial line). It is initialized to zero and | |
177 | stays that way until target-dependent code sets it. Storage for any data | |
178 | pointed to by this field should be allocated on the symbol_obstack for | |
179 | the associated objfile. The type would be "void *" except for reasons | |
180 | of compatibility with older compilers. This field is optional. */ | |
181 | ||
182 | char *info; | |
183 | ||
184 | /* Classification types for this symbol. These should be taken as "advisory | |
185 | only", since if gdb can't easily figure out a classification it simply | |
186 | selects mst_unknown. It may also have to guess when it can't figure out | |
187 | which is a better match between two types (mst_data versus mst_bss) for | |
188 | example. Since the minimal symbol info is sometimes derived from the | |
189 | BFD library's view of a file, we need to live with what information bfd | |
190 | supplies. */ | |
191 | ||
192 | enum minimal_symbol_type | |
bd5635a1 | 193 | { |
b0246b3b FF |
194 | mst_unknown = 0, /* Unknown type, the default */ |
195 | mst_text, /* Generally executable instructions */ | |
196 | mst_data, /* Generally initialized data */ | |
197 | mst_bss, /* Generally uninitialized data */ | |
198 | mst_abs /* Generally absolute (nonrelocatable) */ | |
199 | } type; | |
d018c8a6 | 200 | |
bd5635a1 | 201 | }; |
7e258d18 | 202 | |
2e4964ad FF |
203 | #define MSYMBOL_INFO(msymbol) (msymbol)->info |
204 | #define MSYMBOL_TYPE(msymbol) (msymbol)->type | |
205 | ||
bd5635a1 RP |
206 | \f |
207 | /* All of the name-scope contours of the program | |
208 | are represented by `struct block' objects. | |
209 | All of these objects are pointed to by the blockvector. | |
210 | ||
211 | Each block represents one name scope. | |
212 | Each lexical context has its own block. | |
213 | ||
214 | The first two blocks in the blockvector are special. | |
215 | The first one contains all the symbols defined in this compilation | |
216 | whose scope is the entire program linked together. | |
217 | The second one contains all the symbols whose scope is the | |
218 | entire compilation excluding other separate compilations. | |
219 | In C, these correspond to global symbols and static symbols. | |
220 | ||
221 | Each block records a range of core addresses for the code that | |
222 | is in the scope of the block. The first two special blocks | |
223 | give, for the range of code, the entire range of code produced | |
224 | by the compilation that the symbol segment belongs to. | |
225 | ||
226 | The blocks appear in the blockvector | |
227 | in order of increasing starting-address, | |
228 | and, within that, in order of decreasing ending-address. | |
229 | ||
230 | This implies that within the body of one function | |
231 | the blocks appear in the order of a depth-first tree walk. */ | |
232 | ||
233 | struct blockvector | |
234 | { | |
235 | /* Number of blocks in the list. */ | |
236 | int nblocks; | |
237 | /* The blocks themselves. */ | |
238 | struct block *block[1]; | |
239 | }; | |
240 | ||
2e4964ad FF |
241 | #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks |
242 | #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n] | |
243 | ||
92a29b47 | 244 | /* Special block numbers */ |
2e4964ad FF |
245 | |
246 | #define GLOBAL_BLOCK 0 | |
247 | #define STATIC_BLOCK 1 | |
92a29b47 JG |
248 | #define FIRST_LOCAL_BLOCK 2 |
249 | ||
bd5635a1 RP |
250 | struct block |
251 | { | |
2e4964ad | 252 | |
bd5635a1 RP |
253 | /* Addresses in the executable code that are in this block. |
254 | Note: in an unrelocated symbol segment in a file, | |
255 | these are always zero. They can be filled in from the | |
256 | N_LBRAC and N_RBRAC symbols in the loader symbol table. */ | |
2e4964ad FF |
257 | |
258 | CORE_ADDR startaddr; | |
259 | CORE_ADDR endaddr; | |
260 | ||
bd5635a1 RP |
261 | /* The symbol that names this block, |
262 | if the block is the body of a function; | |
263 | otherwise, zero. | |
264 | Note: In an unrelocated symbol segment in an object file, | |
265 | this field may be zero even when the block has a name. | |
266 | That is because the block is output before the name | |
267 | (since the name resides in a higher block). | |
268 | Since the symbol does point to the block (as its value), | |
269 | it is possible to find the block and set its name properly. */ | |
2e4964ad | 270 | |
bd5635a1 | 271 | struct symbol *function; |
2e4964ad FF |
272 | |
273 | /* The `struct block' for the containing block, or 0 if none. | |
274 | Note that in an unrelocated symbol segment in an object file | |
bd5635a1 RP |
275 | this pointer may be zero when the correct value should be |
276 | the second special block (for symbols whose scope is one compilation). | |
252f6c65 | 277 | This is because the compiler outputs the special blocks at the |
bd5635a1 | 278 | very end, after the other blocks. */ |
2e4964ad | 279 | |
bd5635a1 | 280 | struct block *superblock; |
2e4964ad | 281 | |
252f6c65 | 282 | /* A flag indicating whether or not the function corresponding |
bd5635a1 RP |
283 | to this block was compiled with gcc or not. If there is no |
284 | function corresponding to this block, this meaning of this flag | |
285 | is undefined. (In practice it will be 1 if the block was created | |
286 | while processing a file compiled with gcc and 0 when not). */ | |
2e4964ad | 287 | |
bd5635a1 | 288 | unsigned char gcc_compile_flag; |
2e4964ad | 289 | |
bd5635a1 | 290 | /* Number of local symbols. */ |
2e4964ad | 291 | |
bd5635a1 | 292 | int nsyms; |
2e4964ad | 293 | |
bd5635a1 | 294 | /* The symbols. */ |
2e4964ad | 295 | |
bd5635a1 RP |
296 | struct symbol *sym[1]; |
297 | }; | |
bd5635a1 | 298 | |
2e4964ad FF |
299 | #define BLOCK_START(bl) (bl)->startaddr |
300 | #define BLOCK_END(bl) (bl)->endaddr | |
301 | #define BLOCK_NSYMS(bl) (bl)->nsyms | |
302 | #define BLOCK_SYM(bl, n) (bl)->sym[n] | |
303 | #define BLOCK_FUNCTION(bl) (bl)->function | |
304 | #define BLOCK_SUPERBLOCK(bl) (bl)->superblock | |
305 | #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag | |
bd5635a1 | 306 | |
2e4964ad | 307 | /* Nonzero if symbols of block BL should be sorted alphabetically. */ |
bd5635a1 | 308 | |
2e4964ad | 309 | #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40) |
bd5635a1 | 310 | |
2e4964ad FF |
311 | \f |
312 | /* Represent one symbol name; a variable, constant, function or typedef. */ | |
bd5635a1 RP |
313 | |
314 | /* For a non-global symbol allocated statically, | |
315 | the correct core address cannot be determined by the compiler. | |
316 | The compiler puts an index number into the symbol's value field. | |
317 | This index number can be matched with the "desc" field of | |
318 | an entry in the loader symbol table. */ | |
319 | ||
2e4964ad FF |
320 | /* Different name spaces for symbols. Looking up a symbol specifies a |
321 | namespace and ignores symbol definitions in other name spaces. */ | |
322 | ||
bd5635a1 RP |
323 | enum namespace |
324 | { | |
2e4964ad FF |
325 | /* UNDEF_NAMESPACE is used when a namespace has not been discovered or |
326 | none of the following apply. This usually indicates an error either | |
327 | in the symbol information or in gdb's handling of symbols. */ | |
328 | ||
329 | UNDEF_NAMESPACE, | |
330 | ||
331 | /* VAR_NAMESPACE is the usual namespace. In C, this contains variables, | |
332 | function names, typedef names and enum type values. */ | |
333 | ||
334 | VAR_NAMESPACE, | |
335 | ||
336 | /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names. | |
337 | Thus, if `struct foo' is used in a C program, it produces a symbol named | |
338 | `foo' in the STRUCT_NAMESPACE. */ | |
339 | ||
340 | STRUCT_NAMESPACE, | |
341 | ||
342 | /* LABEL_NAMESPACE may be used for names of labels (for gotos); | |
343 | currently it is not used and labels are not recorded at all. */ | |
344 | ||
345 | LABEL_NAMESPACE | |
bd5635a1 RP |
346 | }; |
347 | ||
348 | /* An address-class says where to find the value of a symbol. */ | |
349 | ||
350 | enum address_class | |
351 | { | |
2e4964ad FF |
352 | /* Not used; catches errors */ |
353 | ||
354 | LOC_UNDEF, | |
355 | ||
356 | /* Value is constant int SYMBOL_VALUE, host byteorder */ | |
357 | ||
358 | LOC_CONST, | |
359 | ||
360 | /* Value is at fixed address SYMBOL_VALUE_ADDRESS */ | |
361 | ||
362 | LOC_STATIC, | |
363 | ||
364 | /* Value is in register */ | |
365 | ||
366 | LOC_REGISTER, | |
367 | ||
368 | /* Value is at spec'd offset in arglist */ | |
369 | ||
370 | LOC_ARG, | |
371 | ||
372 | /* Value address is at spec'd offset in arglist. */ | |
373 | ||
374 | LOC_REF_ARG, | |
375 | ||
376 | /* Value is at spec'd offset in register window */ | |
377 | ||
378 | LOC_REGPARM, | |
379 | ||
380 | /* Value is at spec'd offset in stack frame */ | |
381 | ||
382 | LOC_LOCAL, | |
383 | ||
384 | /* Value not used; definition in SYMBOL_TYPE. Symbols in the namespace | |
385 | STRUCT_NAMESPACE all have this class. */ | |
386 | ||
387 | LOC_TYPEDEF, | |
388 | ||
389 | /* Value is address SYMBOL_VALUE_ADDRESS in the code */ | |
390 | ||
391 | LOC_LABEL, | |
392 | ||
393 | /* Value is address SYMBOL_VALUE_BLOCK of a `struct block'. Function names | |
394 | have this class. */ | |
395 | ||
396 | LOC_BLOCK, | |
397 | ||
398 | /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_ADDRESS, in | |
399 | target byte order. */ | |
400 | ||
401 | LOC_CONST_BYTES, | |
402 | ||
403 | /* Value is arg at spec'd offset in stack frame. Differs from LOC_LOCAL in | |
404 | that symbol is an argument; differs from LOC_ARG in that we find it | |
405 | in the frame (FRAME_LOCALS_ADDRESS), not in the arglist | |
406 | (FRAME_ARGS_ADDRESS). Added for i960, which passes args in regs then | |
407 | copies to frame. */ | |
408 | ||
409 | LOC_LOCAL_ARG | |
410 | ||
bd5635a1 RP |
411 | }; |
412 | ||
413 | struct symbol | |
414 | { | |
2e4964ad FF |
415 | |
416 | /* The general symbol info required for all types of symbols. */ | |
417 | ||
418 | struct general_symbol_info ginfo; | |
419 | ||
bd5635a1 | 420 | /* Name space code. */ |
2e4964ad | 421 | |
bd5635a1 | 422 | enum namespace namespace; |
2e4964ad | 423 | |
bd5635a1 | 424 | /* Address class */ |
2e4964ad | 425 | |
bd5635a1 | 426 | enum address_class class; |
2e4964ad | 427 | |
bd5635a1 | 428 | /* Data type of value */ |
2e4964ad | 429 | |
bd5635a1 RP |
430 | struct type *type; |
431 | ||
2e4964ad FF |
432 | /* Line number of definition. FIXME: Should we really make the assumption |
433 | that nobody will try to debug files longer than 64K lines? What about | |
434 | machine generated programs? */ | |
435 | ||
bd5635a1 RP |
436 | unsigned short line; |
437 | ||
252f6c65 FF |
438 | /* Some symbols require an additional value to be recorded on a per- |
439 | symbol basis. Stash those values here. */ | |
2e4964ad | 440 | |
252f6c65 FF |
441 | union |
442 | { | |
2e4964ad FF |
443 | /* for OP_BASEREG in DWARF location specs */ |
444 | struct | |
252f6c65 FF |
445 | { |
446 | short regno_valid; /* 0 == regno invalid; !0 == regno valid */ | |
447 | short regno; /* base register number {0, 1, 2, ...} */ | |
448 | } basereg; | |
449 | } | |
450 | aux_value; | |
2e4964ad | 451 | |
bd5635a1 RP |
452 | }; |
453 | ||
2e4964ad FF |
454 | #define SYMBOL_NAMESPACE(symbol) (symbol)->namespace |
455 | #define SYMBOL_CLASS(symbol) (symbol)->class | |
456 | #define SYMBOL_TYPE(symbol) (symbol)->type | |
457 | #define SYMBOL_LINE(symbol) (symbol)->line | |
458 | #define SYMBOL_BASEREG(symbol) (symbol)->aux_value.basereg.regno | |
bd5635a1 | 459 | |
2e4964ad FF |
460 | /* This currently fails because some symbols are not being initialized |
461 | to zero on allocation, and no code is currently setting this value. | |
462 | Basereg handling will probably change significantly in the next release. | |
463 | FIXME -fnf */ | |
464 | ||
465 | #if 0 | |
466 | #define SYMBOL_BASEREG_VALID(symbol) (symbol)->aux_value.basereg.regno_valid | |
467 | #else | |
468 | #define SYMBOL_BASEREG_VALID(symbol) 0 | |
469 | #endif | |
470 | ||
471 | \f | |
bd5635a1 RP |
472 | /* A partial_symbol records the name, namespace, and address class of |
473 | symbols whose types we have not parsed yet. For functions, it also | |
474 | contains their memory address, so we can find them from a PC value. | |
475 | Each partial_symbol sits in a partial_symtab, all of which are chained | |
b0246b3b | 476 | on a partial symtab list and which points to the corresponding |
bd5635a1 RP |
477 | normal symtab once the partial_symtab has been referenced. */ |
478 | ||
479 | struct partial_symbol | |
480 | { | |
2e4964ad FF |
481 | |
482 | /* The general symbol info required for all types of symbols. */ | |
483 | ||
484 | struct general_symbol_info ginfo; | |
485 | ||
bd5635a1 | 486 | /* Name space code. */ |
2e4964ad | 487 | |
bd5635a1 | 488 | enum namespace namespace; |
2e4964ad | 489 | |
bd5635a1 | 490 | /* Address class (for info_symbols) */ |
2e4964ad | 491 | |
bd5635a1 | 492 | enum address_class class; |
2e4964ad | 493 | |
bd5635a1 | 494 | }; |
2e4964ad FF |
495 | |
496 | #define PSYMBOL_NAMESPACE(psymbol) (psymbol)->namespace | |
497 | #define PSYMBOL_CLASS(psymbol) (psymbol)->class | |
498 | ||
bd5635a1 | 499 | \f |
2e4964ad FF |
500 | /* Source-file information. This describes the relation between source files, |
501 | ine numbers and addresses in the program text. */ | |
bd5635a1 RP |
502 | |
503 | struct sourcevector | |
504 | { | |
505 | int length; /* Number of source files described */ | |
506 | struct source *source[1]; /* Descriptions of the files */ | |
507 | }; | |
508 | ||
509 | /* Each item represents a line-->pc (or the reverse) mapping. This is | |
510 | somewhat more wasteful of space than one might wish, but since only | |
511 | the files which are actually debugged are read in to core, we don't | |
512 | waste much space. | |
513 | ||
514 | Each item used to be an int; either minus a line number, or a | |
515 | program counter. If it represents a line number, that is the line | |
516 | described by the next program counter value. If it is positive, it | |
517 | is the program counter at which the code for the next line starts. */ | |
518 | ||
519 | struct linetable_entry | |
520 | { | |
521 | int line; | |
522 | CORE_ADDR pc; | |
523 | }; | |
524 | ||
525 | struct linetable | |
526 | { | |
527 | int nitems; | |
528 | struct linetable_entry item[1]; | |
529 | }; | |
530 | ||
531 | /* All the information on one source file. */ | |
532 | ||
533 | struct source | |
534 | { | |
535 | char *name; /* Name of file */ | |
536 | struct linetable contents; | |
537 | }; | |
538 | ||
2670f34d JG |
539 | /* How to relocate the symbols from each section in a symbol file. |
540 | Each struct contains an array of offsets. | |
541 | The ordering and meaning of the offsets is file-type-dependent; | |
542 | typically it is indexed by section numbers or symbol types or | |
543 | something like that. | |
544 | ||
545 | To give us flexibility in changing the internal representation | |
546 | of these offsets, the ANOFFSET macro must be used to insert and | |
547 | extract offset values in the struct. */ | |
548 | ||
549 | struct section_offsets | |
550 | { | |
551 | CORE_ADDR offsets[1]; /* As many as needed. */ | |
552 | }; | |
553 | ||
554 | #define ANOFFSET(secoff, whichone) (secoff->offsets[whichone]) | |
555 | ||
bd5635a1 RP |
556 | /* Each source file is represented by a struct symtab. |
557 | These objects are chained through the `next' field. */ | |
558 | ||
559 | struct symtab | |
560 | { | |
2e4964ad | 561 | |
bd5635a1 | 562 | /* Chain of all existing symtabs. */ |
2e4964ad | 563 | |
bd5635a1 | 564 | struct symtab *next; |
2e4964ad | 565 | |
bd5635a1 | 566 | /* List of all symbol scope blocks for this symtab. */ |
2e4964ad | 567 | |
bd5635a1 | 568 | struct blockvector *blockvector; |
2e4964ad | 569 | |
4137c5fc JG |
570 | /* Table mapping core addresses to line numbers for this file. |
571 | Can be NULL if none. */ | |
2e4964ad | 572 | |
bd5635a1 | 573 | struct linetable *linetable; |
2e4964ad | 574 | |
bd5635a1 | 575 | /* Name of this source file. */ |
2e4964ad | 576 | |
bd5635a1 | 577 | char *filename; |
2e4964ad | 578 | |
bd5635a1 | 579 | /* Directory in which it was compiled, or NULL if we don't know. */ |
2e4964ad | 580 | |
bd5635a1 | 581 | char *dirname; |
2e4964ad | 582 | |
bd5635a1 RP |
583 | /* This component says how to free the data we point to: |
584 | free_contents => do a tree walk and free each object. | |
585 | free_nothing => do nothing; some other symtab will free | |
586 | the data this one uses. | |
2e4964ad FF |
587 | free_linetable => free just the linetable. */ |
588 | ||
589 | enum free_code | |
590 | { | |
591 | free_nothing, free_contents, free_linetable | |
592 | } | |
593 | free_code; | |
594 | ||
bd5635a1 RP |
595 | /* Pointer to one block of storage to be freed, if nonzero. */ |
596 | /* This is IN ADDITION to the action indicated by free_code. */ | |
2e4964ad | 597 | |
bd5635a1 | 598 | char *free_ptr; |
2e4964ad | 599 | |
bd5635a1 | 600 | /* Total number of lines found in source file. */ |
2e4964ad | 601 | |
bd5635a1 | 602 | int nlines; |
2e4964ad | 603 | |
bd5635a1 | 604 | /* Array mapping line number to character position. */ |
2e4964ad | 605 | |
bd5635a1 | 606 | int *line_charpos; |
2e4964ad | 607 | |
bd5635a1 | 608 | /* Language of this source file. */ |
2e4964ad | 609 | |
bd5635a1 | 610 | enum language language; |
2e4964ad | 611 | |
bd5635a1 | 612 | /* String of version information. May be zero. */ |
2e4964ad | 613 | |
bd5635a1 | 614 | char *version; |
2e4964ad | 615 | |
bd5635a1 | 616 | /* Full name of file as found by searching the source path. |
2e4964ad FF |
617 | NULL if not yet known. */ |
618 | ||
bd5635a1 | 619 | char *fullname; |
8aa13b87 | 620 | |
a048c8f5 | 621 | /* Object file from which this symbol information was read. */ |
2e4964ad | 622 | |
a048c8f5 | 623 | struct objfile *objfile; |
a048c8f5 | 624 | |
8aa13b87 JK |
625 | /* Anything extra for this symtab. This is for target machines |
626 | with special debugging info of some sort (which cannot just | |
627 | be represented in a normal symtab). */ | |
2e4964ad | 628 | |
8aa13b87 JK |
629 | #if defined (EXTRA_SYMTAB_INFO) |
630 | EXTRA_SYMTAB_INFO | |
631 | #endif | |
2e4964ad | 632 | |
bd5635a1 RP |
633 | }; |
634 | ||
2e4964ad FF |
635 | #define BLOCKVECTOR(symtab) (symtab)->blockvector |
636 | #define LINETABLE(symtab) (symtab)->linetable | |
637 | ||
638 | \f | |
bd5635a1 RP |
639 | /* Each source file that has not been fully read in is represented by |
640 | a partial_symtab. This contains the information on where in the | |
641 | executable the debugging symbols for a specific file are, and a | |
642 | list of names of global symbols which are located in this file. | |
b0246b3b | 643 | They are all chained on partial symtab lists. |
bd5635a1 RP |
644 | |
645 | Even after the source file has been read into a symtab, the | |
646 | partial_symtab remains around. They are allocated on an obstack, | |
647 | psymbol_obstack. FIXME, this is bad for dynamic linking or VxWorks- | |
648 | style execution of a bunch of .o's. */ | |
b0246b3b | 649 | |
bd5635a1 RP |
650 | struct partial_symtab |
651 | { | |
2e4964ad | 652 | |
bd5635a1 | 653 | /* Chain of all existing partial symtabs. */ |
2e4964ad | 654 | |
bd5635a1 | 655 | struct partial_symtab *next; |
2e4964ad | 656 | |
bd5635a1 | 657 | /* Name of the source file which this partial_symtab defines */ |
2e4964ad | 658 | |
bd5635a1 RP |
659 | char *filename; |
660 | ||
a048c8f5 | 661 | /* Information about the object file from which symbols should be read. */ |
2e4964ad | 662 | |
a048c8f5 | 663 | struct objfile *objfile; |
a048c8f5 | 664 | |
2670f34d | 665 | /* Set of relocation offsets to apply to each section. */ |
2e4964ad | 666 | |
2670f34d JG |
667 | struct section_offsets *section_offsets; |
668 | ||
bd5635a1 RP |
669 | /* Range of text addresses covered by this file; texthigh is the |
670 | beginning of the next section. */ | |
2e4964ad FF |
671 | |
672 | CORE_ADDR textlow; | |
673 | CORE_ADDR texthigh; | |
674 | ||
bd5635a1 RP |
675 | /* Array of pointers to all of the partial_symtab's which this one |
676 | depends on. Since this array can only be set to previous or | |
677 | the current (?) psymtab, this dependency tree is guaranteed not | |
678 | to have any loops. */ | |
2e4964ad | 679 | |
bd5635a1 | 680 | struct partial_symtab **dependencies; |
2e4964ad | 681 | |
bd5635a1 | 682 | int number_of_dependencies; |
2e4964ad | 683 | |
bd5635a1 RP |
684 | /* Global symbol list. This list will be sorted after readin to |
685 | improve access. Binary search will be the usual method of | |
686 | finding a symbol within it. globals_offset is an integer offset | |
4a35d6e9 | 687 | within global_psymbols[]. */ |
2e4964ad FF |
688 | |
689 | int globals_offset; | |
690 | int n_global_syms; | |
691 | ||
bd5635a1 RP |
692 | /* Static symbol list. This list will *not* be sorted after readin; |
693 | to find a symbol in it, exhaustive search must be used. This is | |
694 | reasonable because searches through this list will eventually | |
695 | lead to either the read in of a files symbols for real (assumed | |
696 | to take a *lot* of time; check) or an error (and we don't care | |
4a35d6e9 FF |
697 | how long errors take). This is an offset and size within |
698 | static_psymbols[]. */ | |
2e4964ad FF |
699 | |
700 | int statics_offset; | |
701 | int n_static_syms; | |
702 | ||
bd5635a1 RP |
703 | /* Pointer to symtab eventually allocated for this source file, 0 if |
704 | !readin or if we haven't looked for the symtab after it was readin. */ | |
2e4964ad | 705 | |
bd5635a1 | 706 | struct symtab *symtab; |
2e4964ad | 707 | |
bd5635a1 RP |
708 | /* Pointer to function which will read in the symtab corresponding to |
709 | this psymtab. */ | |
2e4964ad | 710 | |
b0246b3b | 711 | void (*read_symtab) PARAMS ((struct partial_symtab *)); |
2e4964ad | 712 | |
4a35d6e9 FF |
713 | /* Information that lets read_symtab() locate the part of the symbol table |
714 | that this psymtab corresponds to. This information is private to the | |
715 | format-dependent symbol reading routines. For further detail examine | |
716 | the various symbol reading modules. Should really be (void *) but is | |
717 | (char *) as with other such gdb variables. (FIXME) */ | |
2e4964ad | 718 | |
4a35d6e9 | 719 | char *read_symtab_private; |
2e4964ad FF |
720 | |
721 | /* Non-zero if the symtab corresponding to this psymtab has been readin */ | |
722 | ||
bd5635a1 RP |
723 | unsigned char readin; |
724 | }; | |
725 | ||
726 | /* A fast way to get from a psymtab to its symtab (after the first time). */ | |
2e4964ad FF |
727 | #define PSYMTAB_TO_SYMTAB(pst) \ |
728 | ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst)) | |
bd5635a1 | 729 | |
bd5635a1 | 730 | \f |
2e4964ad FF |
731 | /* The virtual function table is now an array of structures which have the |
732 | form { int16 offset, delta; void *pfn; }. | |
aec4cb91 | 733 | |
ea9cdf62 JK |
734 | In normal virtual function tables, OFFSET is unused. |
735 | DELTA is the amount which is added to the apparent object's base | |
736 | address in order to point to the actual object to which the | |
737 | virtual function should be applied. | |
738 | PFN is a pointer to the virtual function. */ | |
bd5635a1 RP |
739 | |
740 | #define VTBL_FNADDR_OFFSET 2 | |
ea9cdf62 | 741 | |
2e4964ad FF |
742 | /* Macro that yields non-zero value iff NAME is the prefix for C++ operator |
743 | names. If you leave out the parenthesis here you will lose! | |
ea9cdf62 JK |
744 | Currently 'o' 'p' CPLUS_MARKER is used for both the symbol in the |
745 | symbol-file and the names in gdb's symbol table. */ | |
ea9cdf62 | 746 | |
2e4964ad FF |
747 | #define OPNAME_PREFIX_P(NAME) \ |
748 | ((NAME)[0] == 'o' && (NAME)[1] == 'p' && (NAME)[2] == CPLUS_MARKER) | |
749 | ||
750 | #define VTBL_PREFIX_P(NAME) \ | |
751 | ((NAME)[3] == CPLUS_MARKER && !strncmp ((NAME), "_vt", 3)) | |
752 | ||
bd5635a1 | 753 | \f |
2e4964ad FF |
754 | /* External variables and functions for the objects described above. */ |
755 | ||
756 | /* This symtab variable specifies the current file for printing source lines */ | |
757 | ||
758 | extern struct symtab *current_source_symtab; | |
759 | ||
760 | /* This is the next line to print for listing source lines. */ | |
761 | ||
762 | extern int current_source_line; | |
763 | ||
764 | /* See the comment in symfile.c about how current_objfile is used. */ | |
765 | ||
766 | extern struct objfile *current_objfile; | |
bd5635a1 | 767 | |
b0246b3b FF |
768 | extern struct symtab * |
769 | lookup_symtab PARAMS ((char *)); | |
770 | ||
771 | extern struct symbol * | |
772 | lookup_symbol PARAMS ((const char *, const struct block *, | |
773 | const enum namespace, int *, struct symtab **)); | |
774 | ||
775 | extern struct symbol * | |
776 | lookup_block_symbol PARAMS ((const struct block *, const char *, | |
777 | const enum namespace)); | |
778 | ||
779 | extern struct type * | |
780 | lookup_struct PARAMS ((char *, struct block *)); | |
781 | ||
782 | extern struct type * | |
783 | lookup_union PARAMS ((char *, struct block *)); | |
784 | ||
785 | extern struct type * | |
786 | lookup_enum PARAMS ((char *, struct block *)); | |
787 | ||
788 | extern struct symbol * | |
789 | block_function PARAMS ((struct block *)); | |
790 | ||
791 | extern struct symbol * | |
792 | find_pc_function PARAMS ((CORE_ADDR)); | |
793 | ||
794 | extern int | |
795 | find_pc_partial_function PARAMS ((CORE_ADDR, char **, CORE_ADDR *)); | |
796 | ||
797 | extern void | |
798 | clear_pc_function_cache PARAMS ((void)); | |
799 | ||
800 | extern struct partial_symtab * | |
801 | lookup_partial_symtab PARAMS ((char *)); | |
802 | ||
803 | extern struct partial_symtab * | |
804 | find_pc_psymtab PARAMS ((CORE_ADDR)); | |
805 | ||
806 | extern struct symtab * | |
807 | find_pc_symtab PARAMS ((CORE_ADDR)); | |
808 | ||
809 | extern struct partial_symbol * | |
810 | find_pc_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR)); | |
811 | ||
812 | extern int | |
813 | find_pc_line_pc_range PARAMS ((CORE_ADDR, CORE_ADDR *, CORE_ADDR *)); | |
814 | ||
815 | extern int | |
816 | contained_in PARAMS ((struct block *, struct block *)); | |
817 | ||
818 | extern void | |
819 | reread_symbols PARAMS ((void)); | |
820 | ||
b0246b3b FF |
821 | /* Functions for dealing with the minimal symbol table, really a misc |
822 | address<->symbol mapping for things we don't have debug symbols for. */ | |
823 | ||
b0246b3b FF |
824 | extern void |
825 | prim_record_minimal_symbol PARAMS ((const char *, CORE_ADDR, | |
826 | enum minimal_symbol_type)); | |
827 | ||
51b57ded FF |
828 | extern void |
829 | prim_record_minimal_symbol_and_info PARAMS ((const char *, CORE_ADDR, | |
830 | enum minimal_symbol_type, | |
831 | char *info)); | |
832 | ||
b0246b3b FF |
833 | extern struct minimal_symbol * |
834 | lookup_minimal_symbol PARAMS ((const char *, struct objfile *)); | |
835 | ||
836 | extern struct minimal_symbol * | |
837 | lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR)); | |
838 | ||
b0246b3b FF |
839 | extern void |
840 | init_minimal_symbol_collection PARAMS ((void)); | |
841 | ||
842 | extern void | |
843 | discard_minimal_symbols PARAMS ((int)); | |
844 | ||
845 | extern void | |
846 | install_minimal_symbols PARAMS ((struct objfile *)); | |
bd5635a1 RP |
847 | |
848 | struct symtab_and_line | |
849 | { | |
850 | struct symtab *symtab; | |
851 | int line; | |
852 | CORE_ADDR pc; | |
853 | CORE_ADDR end; | |
854 | }; | |
855 | ||
856 | struct symtabs_and_lines | |
857 | { | |
858 | struct symtab_and_line *sals; | |
859 | int nelts; | |
860 | }; | |
861 | ||
2e4964ad FF |
862 | /* Given a pc value, return line number it is in. Second arg nonzero means |
863 | if pc is on the boundary use the previous statement's line number. */ | |
bd5635a1 | 864 | |
b0246b3b FF |
865 | extern struct symtab_and_line |
866 | find_pc_line PARAMS ((CORE_ADDR, int)); | |
bd5635a1 RP |
867 | |
868 | /* Given a symtab and line number, return the pc there. */ | |
b0246b3b FF |
869 | |
870 | extern CORE_ADDR | |
871 | find_line_pc PARAMS ((struct symtab *, int)); | |
872 | ||
873 | extern int | |
874 | find_line_pc_range PARAMS ((struct symtab *, int, CORE_ADDR *, CORE_ADDR *)); | |
875 | ||
876 | extern void | |
877 | resolve_sal_pc PARAMS ((struct symtab_and_line *)); | |
bd5635a1 | 878 | |
2e4964ad FF |
879 | /* Given a string, return the line specified by it. For commands like "list" |
880 | and "breakpoint". */ | |
bd5635a1 | 881 | |
b0246b3b FF |
882 | extern struct symtabs_and_lines |
883 | decode_line_spec PARAMS ((char *, int)); | |
884 | ||
885 | extern struct symtabs_and_lines | |
886 | decode_line_spec_1 PARAMS ((char *, int)); | |
887 | ||
888 | extern struct symtabs_and_lines | |
889 | decode_line_1 PARAMS ((char **, int, struct symtab *, int)); | |
bd5635a1 | 890 | |
5c43db6b | 891 | /* Symmisc.c */ |
b0246b3b | 892 | |
35fcebce PB |
893 | #if MAINTENANCE_CMDS |
894 | ||
895 | void | |
896 | maintenance_print_symbols PARAMS ((char *, int)); | |
897 | ||
898 | void | |
899 | maintenance_print_psymbols PARAMS ((char *, int)); | |
900 | ||
901 | void | |
902 | maintenance_print_msymbols PARAMS ((char *, int)); | |
903 | ||
904 | void | |
905 | maintenance_print_objfiles PARAMS ((char *, int)); | |
906 | ||
907 | #endif | |
908 | ||
b0246b3b FF |
909 | extern void |
910 | free_symtab PARAMS ((struct symtab *)); | |
5c43db6b | 911 | |
bd5635a1 | 912 | /* Symbol-reading stuff in symfile.c and solib.c. */ |
b0246b3b FF |
913 | |
914 | extern struct symtab * | |
915 | psymtab_to_symtab PARAMS ((struct partial_symtab *)); | |
916 | ||
917 | extern void | |
918 | clear_solib PARAMS ((void)); | |
919 | ||
920 | extern struct objfile * | |
921 | symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int)); | |
bd5635a1 RP |
922 | |
923 | /* source.c */ | |
bd5635a1 | 924 | |
b0246b3b FF |
925 | extern int |
926 | identify_source_line PARAMS ((struct symtab *, int, int)); | |
927 | ||
928 | extern void | |
929 | print_source_lines PARAMS ((struct symtab *, int, int, int)); | |
930 | ||
931 | extern void | |
932 | forget_cached_source_info PARAMS ((void)); | |
933 | ||
934 | extern void | |
935 | select_source_symtab PARAMS ((struct symtab *)); | |
936 | ||
937 | extern char ** | |
938 | make_symbol_completion_list PARAMS ((char *)); | |
939 | ||
940 | /* symtab.c */ | |
941 | ||
51b57ded FF |
942 | extern void |
943 | clear_symtab_users_once PARAMS ((void)); | |
944 | ||
b0246b3b FF |
945 | extern struct partial_symtab * |
946 | find_main_psymtab PARAMS ((void)); | |
947 | ||
948 | /* blockframe.c */ | |
949 | ||
950 | extern struct blockvector * | |
951 | blockvector_for_pc PARAMS ((CORE_ADDR, int *)); | |
bd5635a1 | 952 | |
b0246b3b | 953 | /* symfile.c */ |
4a35d6e9 | 954 | |
b0246b3b FF |
955 | extern enum language |
956 | deduce_language_from_filename PARAMS ((char *)); | |
4a35d6e9 | 957 | |
b0246b3b | 958 | #endif /* !defined(SYMTAB_H) */ |