gdb/symtab.h

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