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