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