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