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