gdb/symtab.h

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