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 arg at SYMBOL_VALUE offset in stack frame. Differs from
 489      LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
 490      that we find it in the frame (get_frame_locals_address), not in
 491      the arglist (get_frame_args_address).  Added for i960, which
 492      passes args in regs then copies to frame.  */
 493
 494   LOC_LOCAL_ARG,
 495
 496   /* Value is at SYMBOL_VALUE offset from the current value of
 497      register number SYMBOL_BASEREG.  This exists mainly for the same
 498      things that LOC_LOCAL and LOC_ARG do; but we need to do this
 499      instead because on 88k DWARF gives us the offset from the
 500      frame/stack pointer, rather than the offset from the "canonical
 501      frame address" used by COFF, stabs, etc., and we don't know how
 502      to convert between these until we start examining prologues.
 503
 504      Note that LOC_BASEREG is much less general than a DWARF expression.
 505      We don't need the generality (at least not yet), and storing a general
 506      DWARF expression would presumably take up more space than the existing
 507      scheme.  */
 508
 509   LOC_BASEREG,
 510
 511   /* Same as LOC_BASEREG but it is an argument.  */
 512
 513   LOC_BASEREG_ARG,
 514
 515   /* Value is at fixed address, but the address of the variable has
 516      to be determined from the minimal symbol table whenever the
 517      variable is referenced.
 518      This happens if debugging information for a global symbol is
 519      emitted and the corresponding minimal symbol is defined
 520      in another object file or runtime common storage.
 521      The linker might even remove the minimal symbol if the global
 522      symbol is never referenced, in which case the symbol remains
 523      unresolved.  */
 524
 525   LOC_UNRESOLVED,
 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's address is computed by a set of location
 533      functions (see "struct symbol_ops" below).  */
 534   LOC_COMPUTED,
 535
 536   /* Same as LOC_COMPUTED, but for function arguments.  */
 537   LOC_COMPUTED_ARG
 538 };
 539
 540 /* The methods needed to implement a symbol class.  These methods can
 541    use the symbol's .aux_value for additional per-symbol information.
 542
 543    At present this is only used to implement location expressions.  */
 544
 545 struct symbol_ops
 546 {
 547
 548   /* Return the value of the variable SYMBOL, relative to the stack
 549      frame FRAME.  If the variable has been optimized out, return
 550      zero.
 551
 552      Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero.  */
 553
 554   struct value *(*read_variable) (struct symbol * symbol,
 555                                   struct frame_info * frame);
 556
 557   /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
 558   int (*read_needs_frame) (struct symbol * symbol);
 559
 560   /* Write to STREAM a natural-language description of the location of
 561      SYMBOL.  */
 562   int (*describe_location) (struct symbol * symbol, struct ui_file * stream);
 563
 564   /* Tracepoint support.  Append bytecodes to the tracepoint agent
 565      expression AX that push the address of the object SYMBOL.  Set
 566      VALUE appropriately.  Note --- for objects in registers, this
 567      needn't emit any code; as long as it sets VALUE properly, then
 568      the caller will generate the right code in the process of
 569      treating this as an lvalue or rvalue.  */
 570
 571   void (*tracepoint_var_ref) (struct symbol * symbol, struct agent_expr * ax,
 572                               struct axs_value * value);
 573 };
 574
 575 /* This structure is space critical.  See space comments at the top. */
 576
 577 struct symbol
 578 {
 579
 580   /* The general symbol info required for all types of symbols. */
 581
 582   struct general_symbol_info ginfo;
 583
 584   /* Data type of value */
 585
 586   struct type *type;
 587
 588   /* The symbol table containing this symbol.  This is the file
 589      associated with LINE.  */
 590   struct symtab *symtab;
 591
 592   /* Domain code.  */
 593
 594   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 595
 596   /* Address class */
 597   /* NOTE: cagney/2003-11-02: The fields "aclass" and "ops" contain
 598      overlapping information.  By creating a per-aclass ops vector, or
 599      using the aclass as an index into an ops table, the aclass and
 600      ops fields can be merged.  The latter, for instance, would shave
 601      32-bits from each symbol (relative to a symbol lookup, any table
 602      index overhead would be in the noise).  */
 603
 604   ENUM_BITFIELD(address_class) aclass : 6;
 605
 606   /* Line number of definition.  FIXME:  Should we really make the assumption
 607      that nobody will try to debug files longer than 64K lines?  What about
 608      machine generated programs? */
 609
 610   unsigned short line;
 611
 612   /* Method's for symbol's of this class.  */
 613   /* NOTE: cagney/2003-11-02: See comment above attached to "aclass".  */
 614
 615   const struct symbol_ops *ops;
 616
 617   /* Some symbols require additional information to be recorded on a
 618      per-symbol basis.  Stash those values here.  */
 619
 620   union
 621   {
 622     /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
 623     short basereg;
 624     /* An arbitrary data pointer.  Note that this data must be
 625        allocated using the same obstack as the symbol itself.  */
 626     /* So far it is only used by LOC_COMPUTED and LOC_COMPUTED_ARG to
 627        find the location information.  For a LOC_BLOCK symbol
 628        for a function in a compilation unit compiled with DWARF 2
 629        information, this is information used internally by the DWARF 2
 630        code --- specifically, the location expression for the frame
 631        base for this function.  */
 632     /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
 633        to add a magic symbol to the block containing this information,
 634        or to have a generic debug info annotation slot for symbols.  */
 635     void *ptr;
 636   }
 637   aux_value;
 638
 639   struct symbol *hash_next;
 640 };
 641
 642
 643 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
 644 #define SYMBOL_CLASS(symbol)            (symbol)->aclass
 645 #define SYMBOL_TYPE(symbol)             (symbol)->type
 646 #define SYMBOL_LINE(symbol)             (symbol)->line
 647 #define SYMBOL_SYMTAB(symbol)           (symbol)->symtab
 648 #define SYMBOL_BASEREG(symbol)          (symbol)->aux_value.basereg
 649 #define SYMBOL_OPS(symbol)              (symbol)->ops
 650 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value.ptr
 651 \f
 652 /* A partial_symbol records the name, domain, and address class of
 653    symbols whose types we have not parsed yet.  For functions, it also
 654    contains their memory address, so we can find them from a PC value.
 655    Each partial_symbol sits in a partial_symtab, all of which are chained
 656    on a  partial symtab list and which points to the corresponding
 657    normal symtab once the partial_symtab has been referenced.  */
 658
 659 /* This structure is space critical.  See space comments at the top. */
 660
 661 struct partial_symbol
 662 {
 663
 664   /* The general symbol info required for all types of symbols. */
 665
 666   struct general_symbol_info ginfo;
 667
 668   /* Name space code.  */
 669
 670   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 671
 672   /* Address class (for info_symbols) */
 673
 674   ENUM_BITFIELD(address_class) aclass : 6;
 675
 676 };
 677
 678 #define PSYMBOL_DOMAIN(psymbol) (psymbol)->domain
 679 #define PSYMBOL_CLASS(psymbol)          (psymbol)->aclass
 680 \f
 681
 682 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 683    somewhat more wasteful of space than one might wish, but since only
 684    the files which are actually debugged are read in to core, we don't
 685    waste much space.  */
 686
 687 struct linetable_entry
 688 {
 689   int line;
 690   CORE_ADDR pc;
 691 };
 692
 693 /* The order of entries in the linetable is significant.  They should
 694    be sorted by increasing values of the pc field.  If there is more than
 695    one entry for a given pc, then I'm not sure what should happen (and
 696    I not sure whether we currently handle it the best way).
 697
 698    Example: a C for statement generally looks like this
 699
 700    10   0x100   - for the init/test part of a for stmt.
 701    20   0x200
 702    30   0x300
 703    10   0x400   - for the increment part of a for stmt.
 704
 705    If an entry has a line number of zero, it marks the start of a PC
 706    range for which no line number information is available.  It is
 707    acceptable, though wasteful of table space, for such a range to be
 708    zero length.  */
 709
 710 struct linetable
 711 {
 712   int nitems;
 713
 714   /* Actually NITEMS elements.  If you don't like this use of the
 715      `struct hack', you can shove it up your ANSI (seriously, if the
 716      committee tells us how to do it, we can probably go along).  */
 717   struct linetable_entry item[1];
 718 };
 719
 720 /* How to relocate the symbols from each section in a symbol file.
 721    Each struct contains an array of offsets.
 722    The ordering and meaning of the offsets is file-type-dependent;
 723    typically it is indexed by section numbers or symbol types or
 724    something like that.
 725
 726    To give us flexibility in changing the internal representation
 727    of these offsets, the ANOFFSET macro must be used to insert and
 728    extract offset values in the struct.  */
 729
 730 struct section_offsets
 731 {
 732   CORE_ADDR offsets[1];         /* As many as needed. */
 733 };
 734
 735 #define ANOFFSET(secoff, whichone) \
 736    ((whichone == -1) \
 737     ? (internal_error (__FILE__, __LINE__, _("Section index is uninitialized")), -1) \
 738     : secoff->offsets[whichone])
 739
 740 /* The size of a section_offsets table for N sections.  */
 741 #define SIZEOF_N_SECTION_OFFSETS(n) \
 742   (sizeof (struct section_offsets) \
 743    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
 744
 745 /* Each source file or header is represented by a struct symtab.
 746    These objects are chained through the `next' field.  */
 747
 748 struct symtab
 749 {
 750
 751   /* Chain of all existing symtabs.  */
 752
 753   struct symtab *next;
 754
 755   /* List of all symbol scope blocks for this symtab.  May be shared
 756      between different symtabs (and normally is for all the symtabs
 757      in a given compilation unit).  */
 758
 759   struct blockvector *blockvector;
 760
 761   /* Table mapping core addresses to line numbers for this file.
 762      Can be NULL if none.  Never shared between different symtabs.  */
 763
 764   struct linetable *linetable;
 765
 766   /* Section in objfile->section_offsets for the blockvector and
 767      the linetable.  Probably always SECT_OFF_TEXT.  */
 768
 769   int block_line_section;
 770
 771   /* If several symtabs share a blockvector, exactly one of them
 772      should be designated the primary, so that the blockvector
 773      is relocated exactly once by objfile_relocate.  */
 774
 775   int primary;
 776
 777   /* The macro table for this symtab.  Like the blockvector, this
 778      may be shared between different symtabs --- and normally is for
 779      all the symtabs in a given compilation unit.  */
 780   struct macro_table *macro_table;
 781
 782   /* Name of this source file.  */
 783
 784   char *filename;
 785
 786   /* Directory in which it was compiled, or NULL if we don't know.  */
 787
 788   char *dirname;
 789
 790   /* This component says how to free the data we point to:
 791      free_nothing => do nothing; some other symtab will free
 792      the data this one uses.
 793      free_linetable => free just the linetable.  FIXME: Is this redundant
 794      with the primary field?  */
 795
 796   enum free_code
 797   {
 798     free_nothing, free_linetable
 799   }
 800   free_code;
 801
 802   /* A function to call to free space, if necessary.  This is IN
 803      ADDITION to the action indicated by free_code.  */
 804
 805   void (*free_func)(struct symtab *symtab);
 806
 807   /* Total number of lines found in source file.  */
 808
 809   int nlines;
 810
 811   /* line_charpos[N] is the position of the (N-1)th line of the
 812      source file.  "position" means something we can lseek() to; it
 813      is not guaranteed to be useful any other way.  */
 814
 815   int *line_charpos;
 816
 817   /* Language of this source file.  */
 818
 819   enum language language;
 820
 821   /* String that identifies the format of the debugging information, such
 822      as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 823      for automated testing of gdb but may also be information that is
 824      useful to the user. */
 825
 826   char *debugformat;
 827
 828   /* String of producer version information.  May be zero.  */
 829
 830   char *producer;
 831
 832   /* Full name of file as found by searching the source path.
 833      NULL if not yet known.  */
 834
 835   char *fullname;
 836
 837   /* Object file from which this symbol information was read.  */
 838
 839   struct objfile *objfile;
 840
 841 };
 842
 843 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 844 #define LINETABLE(symtab)       (symtab)->linetable
 845 \f
 846
 847 /* Each source file that has not been fully read in is represented by
 848    a partial_symtab.  This contains the information on where in the
 849    executable the debugging symbols for a specific file are, and a
 850    list of names of global symbols which are located in this file.
 851    They are all chained on partial symtab lists.
 852
 853    Even after the source file has been read into a symtab, the
 854    partial_symtab remains around.  They are allocated on an obstack,
 855    objfile_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 856    style execution of a bunch of .o's.  */
 857
 858 struct partial_symtab
 859 {
 860
 861   /* Chain of all existing partial symtabs.  */
 862
 863   struct partial_symtab *next;
 864
 865   /* Name of the source file which this partial_symtab defines */
 866
 867   char *filename;
 868
 869   /* Full path of the source file.  NULL if not known.  */
 870
 871   char *fullname;
 872
 873   /* Directory in which it was compiled, or NULL if we don't know.  */
 874
 875   char *dirname;
 876
 877   /* Information about the object file from which symbols should be read.  */
 878
 879   struct objfile *objfile;
 880
 881   /* Set of relocation offsets to apply to each section.  */
 882
 883   struct section_offsets *section_offsets;
 884
 885   /* Range of text addresses covered by this file; texthigh is the
 886      beginning of the next section. */
 887
 888   CORE_ADDR textlow;
 889   CORE_ADDR texthigh;
 890
 891   /* Array of pointers to all of the partial_symtab's which this one
 892      depends on.  Since this array can only be set to previous or
 893      the current (?) psymtab, this dependency tree is guaranteed not
 894      to have any loops.  "depends on" means that symbols must be read
 895      for the dependencies before being read for this psymtab; this is
 896      for type references in stabs, where if foo.c includes foo.h, declarations
 897      in foo.h may use type numbers defined in foo.c.  For other debugging
 898      formats there may be no need to use dependencies.  */
 899
 900   struct partial_symtab **dependencies;
 901
 902   int number_of_dependencies;
 903
 904   /* Global symbol list.  This list will be sorted after readin to
 905      improve access.  Binary search will be the usual method of
 906      finding a symbol within it. globals_offset is an integer offset
 907      within global_psymbols[].  */
 908
 909   int globals_offset;
 910   int n_global_syms;
 911
 912   /* Static symbol list.  This list will *not* be sorted after readin;
 913      to find a symbol in it, exhaustive search must be used.  This is
 914      reasonable because searches through this list will eventually
 915      lead to either the read in of a files symbols for real (assumed
 916      to take a *lot* of time; check) or an error (and we don't care
 917      how long errors take).  This is an offset and size within
 918      static_psymbols[].  */
 919
 920   int statics_offset;
 921   int n_static_syms;
 922
 923   /* Pointer to symtab eventually allocated for this source file, 0 if
 924      !readin or if we haven't looked for the symtab after it was readin.  */
 925
 926   struct symtab *symtab;
 927
 928   /* Pointer to function which will read in the symtab corresponding to
 929      this psymtab.  */
 930
 931   void (*read_symtab) (struct partial_symtab *);
 932
 933   /* Information that lets read_symtab() locate the part of the symbol table
 934      that this psymtab corresponds to.  This information is private to the
 935      format-dependent symbol reading routines.  For further detail examine
 936      the various symbol reading modules.  Should really be (void *) but is
 937      (char *) as with other such gdb variables.  (FIXME) */
 938
 939   char *read_symtab_private;
 940
 941   /* Non-zero if the symtab corresponding to this psymtab has been readin */
 942
 943   unsigned char readin;
 944 };
 945
 946 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 947 #define PSYMTAB_TO_SYMTAB(pst)  \
 948     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
 949 \f
 950
 951 /* The virtual function table is now an array of structures which have the
 952    form { int16 offset, delta; void *pfn; }.
 953
 954    In normal virtual function tables, OFFSET is unused.
 955    DELTA is the amount which is added to the apparent object's base
 956    address in order to point to the actual object to which the
 957    virtual function should be applied.
 958    PFN is a pointer to the virtual function.
 959
 960    Note that this macro is g++ specific (FIXME). */
 961
 962 #define VTBL_FNADDR_OFFSET 2
 963
 964 /* External variables and functions for the objects described above. */
 965
 966 /* See the comment in symfile.c about how current_objfile is used. */
 967
 968 extern struct objfile *current_objfile;
 969
 970 /* True if we are nested inside psymtab_to_symtab. */
 971
 972 extern int currently_reading_symtab;
 973
 974 /* From utils.c.  */
 975 extern int demangle;
 976 extern int asm_demangle;
 977
 978 /* symtab.c lookup functions */
 979
 980 extern const char multiple_symbols_ask[];
 981 extern const char multiple_symbols_all[];
 982 extern const char multiple_symbols_cancel[];
 983
 984 const char *multiple_symbols_select_mode (void);
 985
 986 int symbol_matches_domain (enum language symbol_language,
 987                            domain_enum symbol_domain,
 988                            domain_enum domain);
 989
 990 /* lookup a symbol table by source file name */
 991
 992 extern struct symtab *lookup_symtab (const char *);
 993
 994 /* lookup a symbol by name (optional block) in language.  */
 995
 996 extern struct symbol *lookup_symbol_in_language (const char *,
 997                                                  const struct block *,
 998                                                  const domain_enum,
 999                                                  enum language,
1000                                                  int *);
1001
1002 /* lookup a symbol by name (optional block, optional symtab)
1003    in the current language */
1004
1005 extern struct symbol *lookup_symbol (const char *, const struct block *,
1006                                      const domain_enum, int *);
1007
1008 /* A default version of lookup_symbol_nonlocal for use by languages
1009    that can't think of anything better to do.  */
1010
1011 extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
1012                                                     const char *,
1013                                                     const struct block *,
1014                                                     const domain_enum);
1015
1016 /* Some helper functions for languages that need to write their own
1017    lookup_symbol_nonlocal functions.  */
1018
1019 /* Lookup a symbol in the static block associated to BLOCK, if there
1020    is one; do nothing if BLOCK is NULL or a global block.  */
1021
1022 extern struct symbol *lookup_symbol_static (const char *name,
1023                                             const char *linkage_name,
1024                                             const struct block *block,
1025                                             const domain_enum domain);
1026
1027 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1028    necessary).  */
1029
1030 extern struct symbol *lookup_symbol_global (const char *name,
1031                                             const char *linkage_name,
1032                                             const struct block *block,
1033                                             const domain_enum domain);
1034
1035 /* Lookup a symbol within the block BLOCK.  This, unlike
1036    lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
1037    will fix up the symbol if necessary.  */
1038
1039 extern struct symbol *lookup_symbol_aux_block (const char *name,
1040                                                const char *linkage_name,
1041                                                const struct block *block,
1042                                                const domain_enum domain);
1043
1044 /* Lookup a partial symbol.  */
1045
1046 extern struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
1047                                                      const char *,
1048                                                      const char *, int,
1049                                                      domain_enum);
1050
1051 /* lookup a symbol by name, within a specified block */
1052
1053 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
1054                                            const char *,
1055                                            const domain_enum);
1056
1057 /* lookup a [struct, union, enum] by name, within a specified block */
1058
1059 extern struct type *lookup_struct (char *, struct block *);
1060
1061 extern struct type *lookup_union (char *, struct block *);
1062
1063 extern struct type *lookup_enum (char *, struct block *);
1064
1065 /* from blockframe.c: */
1066
1067 /* lookup the function symbol corresponding to the address */
1068
1069 extern struct symbol *find_pc_function (CORE_ADDR);
1070
1071 /* lookup the function corresponding to the address and section */
1072
1073 extern struct symbol *find_pc_sect_function (CORE_ADDR, asection *);
1074
1075 /* lookup function from address, return name, start addr and end addr */
1076
1077 extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
1078                                      CORE_ADDR *);
1079
1080 extern void clear_pc_function_cache (void);
1081
1082 /* from symtab.c: */
1083
1084 /* lookup partial symbol table by filename */
1085
1086 extern struct partial_symtab *lookup_partial_symtab (const char *);
1087
1088 /* lookup partial symbol table by address */
1089
1090 extern struct partial_symtab *find_pc_psymtab (CORE_ADDR);
1091
1092 /* lookup partial symbol table by address and section */
1093
1094 extern struct partial_symtab *find_pc_sect_psymtab (CORE_ADDR, asection *);
1095
1096 /* lookup full symbol table by address */
1097
1098 extern struct symtab *find_pc_symtab (CORE_ADDR);
1099
1100 /* lookup full symbol table by address and section */
1101
1102 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, asection *);
1103
1104 /* lookup partial symbol by address */
1105
1106 extern struct partial_symbol *find_pc_psymbol (struct partial_symtab *,
1107                                                CORE_ADDR);
1108
1109 /* lookup partial symbol by address and section */
1110
1111 extern struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
1112                                                     CORE_ADDR, asection *);
1113
1114 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1115
1116 extern void reread_symbols (void);
1117
1118 extern struct type *lookup_transparent_type (const char *);
1119 extern struct type *basic_lookup_transparent_type (const char *);
1120
1121
1122 /* Macro for name of symbol to indicate a file compiled with gcc. */
1123 #ifndef GCC_COMPILED_FLAG_SYMBOL
1124 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1125 #endif
1126
1127 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1128 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1129 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1130 #endif
1131
1132 /* Functions for dealing with the minimal symbol table, really a misc
1133    address<->symbol mapping for things we don't have debug symbols for.  */
1134
1135 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1136                                         enum minimal_symbol_type,
1137                                         struct objfile *);
1138
1139 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1140   (const char *, CORE_ADDR,
1141    enum minimal_symbol_type,
1142    char *info, int section, asection * bfd_section, struct objfile *);
1143
1144 extern unsigned int msymbol_hash_iw (const char *);
1145
1146 extern unsigned int msymbol_hash (const char *);
1147
1148 extern struct objfile * msymbol_objfile (struct minimal_symbol *sym);
1149
1150 extern void
1151 add_minsym_to_hash_table (struct minimal_symbol *sym,
1152                           struct minimal_symbol **table);
1153
1154 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1155                                                      const char *,
1156                                                      struct objfile *);
1157
1158 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1159                                                           struct objfile *);
1160
1161 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1162                                                                struct objfile
1163                                                                *);
1164
1165 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_name
1166                                 (CORE_ADDR, const char *, struct objfile *);
1167
1168 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1169
1170 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_section (CORE_ADDR,
1171                                                                    asection
1172                                                                    *);
1173
1174 extern struct minimal_symbol
1175   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1176
1177 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1178
1179 extern void init_minimal_symbol_collection (void);
1180
1181 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1182
1183 extern void install_minimal_symbols (struct objfile *);
1184
1185 /* Sort all the minimal symbols in OBJFILE.  */
1186
1187 extern void msymbols_sort (struct objfile *objfile);
1188
1189 struct symtab_and_line
1190 {
1191   struct symtab *symtab;
1192   asection *section;
1193   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1194      0 is never a valid line number; it is used to indicate that line number
1195      information is not available.  */
1196   int line;
1197
1198   CORE_ADDR pc;
1199   CORE_ADDR end;
1200   int explicit_pc;
1201   int explicit_line;
1202 };
1203
1204 extern void init_sal (struct symtab_and_line *sal);
1205
1206 struct symtabs_and_lines
1207 {
1208   struct symtab_and_line *sals;
1209   int nelts;
1210 };
1211 \f
1212
1213
1214 /* Some types and macros needed for exception catchpoints.
1215    Can't put these in target.h because symtab_and_line isn't
1216    known there. This file will be included by breakpoint.c,
1217    hppa-tdep.c, etc. */
1218
1219 /* Enums for exception-handling support */
1220 enum exception_event_kind
1221 {
1222   EX_EVENT_THROW,
1223   EX_EVENT_CATCH
1224 };
1225
1226 \f
1227
1228 /* Given a pc value, return line number it is in.  Second arg nonzero means
1229    if pc is on the boundary use the previous statement's line number.  */
1230
1231 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1232
1233 /* Same function, but specify a section as well as an address */
1234
1235 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR, asection *, int);
1236
1237 /* Given a symtab and line number, return the pc there.  */
1238
1239 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1240
1241 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1242                                CORE_ADDR *);
1243
1244 extern void resolve_sal_pc (struct symtab_and_line *);
1245
1246 /* Given a string, return the line specified by it.  For commands like "list"
1247    and "breakpoint".  */
1248
1249 extern struct symtabs_and_lines decode_line_spec (char *, int);
1250
1251 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1252
1253 /* Symmisc.c */
1254
1255 void maintenance_print_symbols (char *, int);
1256
1257 void maintenance_print_psymbols (char *, int);
1258
1259 void maintenance_print_msymbols (char *, int);
1260
1261 void maintenance_print_objfiles (char *, int);
1262
1263 void maintenance_info_symtabs (char *, int);
1264
1265 void maintenance_info_psymtabs (char *, int);
1266
1267 void maintenance_check_symtabs (char *, int);
1268
1269 /* maint.c */
1270
1271 void maintenance_print_statistics (char *, int);
1272
1273 extern void free_symtab (struct symtab *);
1274
1275 /* Symbol-reading stuff in symfile.c and solib.c.  */
1276
1277 extern struct symtab *psymtab_to_symtab (struct partial_symtab *);
1278
1279 extern void clear_solib (void);
1280
1281 /* source.c */
1282
1283 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1284
1285 extern void print_source_lines (struct symtab *, int, int, int);
1286
1287 extern void forget_cached_source_info (void);
1288
1289 extern void select_source_symtab (struct symtab *);
1290
1291 extern char **default_make_symbol_completion_list (char *, char *);
1292 extern char **make_symbol_completion_list (char *, char *);
1293
1294 extern char **make_file_symbol_completion_list (char *, char *, char *);
1295
1296 extern char **make_source_files_completion_list (char *, char *);
1297
1298 /* symtab.c */
1299
1300 int matching_bfd_sections (asection *, asection *);
1301
1302 extern struct partial_symtab *find_main_psymtab (void);
1303
1304 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1305
1306 extern CORE_ADDR find_function_start_pc (struct gdbarch *,
1307                                          CORE_ADDR, asection *);
1308
1309 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1310                                                        int);
1311
1312 /* symfile.c */
1313
1314 extern void clear_symtab_users (void);
1315
1316 extern enum language deduce_language_from_filename (char *);
1317
1318 /* symtab.c */
1319
1320 extern int in_prologue (CORE_ADDR pc, CORE_ADDR func_start);
1321
1322 extern CORE_ADDR skip_prologue_using_sal (CORE_ADDR func_addr);
1323
1324 extern struct symbol *fixup_symbol_section (struct symbol *,
1325                                             struct objfile *);
1326
1327 extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
1328                                                      *psym,
1329                                                      struct objfile *objfile);
1330
1331 /* Symbol searching */
1332
1333 /* When using search_symbols, a list of the following structs is returned.
1334    Callers must free the search list using free_search_symbols! */
1335 struct symbol_search
1336 {
1337   /* The block in which the match was found. Could be, for example,
1338      STATIC_BLOCK or GLOBAL_BLOCK. */
1339   int block;
1340
1341   /* Information describing what was found.
1342
1343      If symtab abd symbol are NOT NULL, then information was found
1344      for this match. */
1345   struct symtab *symtab;
1346   struct symbol *symbol;
1347
1348   /* If msymbol is non-null, then a match was made on something for
1349      which only minimal_symbols exist. */
1350   struct minimal_symbol *msymbol;
1351
1352   /* A link to the next match, or NULL for the end. */
1353   struct symbol_search *next;
1354 };
1355
1356 extern void search_symbols (char *, domain_enum, int, char **,
1357                             struct symbol_search **);
1358 extern void free_search_symbols (struct symbol_search *);
1359 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1360                                                          *);
1361
1362 /* The name of the ``main'' function.
1363    FIXME: cagney/2001-03-20: Can't make main_name() const since some
1364    of the calling code currently assumes that the string isn't
1365    const. */
1366 extern void set_main_name (const char *name);
1367 extern /*const */ char *main_name (void);
1368
1369 /* Check global symbols in objfile.  */
1370 struct symbol *lookup_global_symbol_from_objfile (const struct objfile *objfile,
1371                                                   const char *name,
1372                                                   const char *linkage_name,
1373                                                   const domain_enum domain);
1374
1375 extern struct symtabs_and_lines
1376 expand_line_sal (struct symtab_and_line sal);
1377
1378 #endif /* !defined(SYMTAB_H) */