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