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