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