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. This is used only by hppa.  */
 629
 630   LOC_HP_THREAD_LOCAL_STATIC,
 631
 632   /* Value is at a thread-specific location calculated by a
 633      target-specific method.  SYMBOL_OBJFILE gives the object file
 634      in which the symbol is defined; the symbol's value is the
 635      offset into that objfile's thread-local storage for the current
 636      thread.  */
 637
 638   LOC_THREAD_LOCAL_STATIC,
 639
 640   /* The variable does not actually exist in the program.
 641      The value is ignored.  */
 642
 643   LOC_OPTIMIZED_OUT,
 644
 645   /* The variable is static, but actually lives at * (address).
 646    * I.e. do an extra indirection to get to it.
 647    * This is used on HP-UX to get at globals that are allocated
 648    * in shared libraries, where references from images other
 649    * than the one where the global was allocated are done
 650    * with a level of indirection.
 651    */
 652
 653   LOC_INDIRECT
 654 };
 655
 656 /* Linked list of symbol's live ranges. */
 657
 658 struct range_list
 659 {
 660   CORE_ADDR start;
 661   CORE_ADDR end;
 662   struct range_list *next;
 663 };
 664
 665 /* Linked list of aliases for a particular main/primary symbol.  */
 666 struct alias_list
 667 {
 668   struct symbol *sym;
 669   struct alias_list *next;
 670 };
 671
 672 struct symbol
 673 {
 674
 675   /* The general symbol info required for all types of symbols. */
 676
 677   struct general_symbol_info ginfo;
 678
 679   /* Data type of value */
 680
 681   struct type *type;
 682
 683   /* Name space code.  */
 684
 685 #ifdef __MFC4__
 686   /* FIXME: don't conflict with C++'s namespace */
 687   /* would be safer to do a global change for all namespace identifiers. */
 688 #define namespace _namespace
 689 #endif
 690   namespace_enum namespace BYTE_BITFIELD;
 691
 692   /* Address class */
 693
 694   enum address_class aclass BYTE_BITFIELD;
 695
 696   /* Line number of definition.  FIXME:  Should we really make the assumption
 697      that nobody will try to debug files longer than 64K lines?  What about
 698      machine generated programs? */
 699
 700   unsigned short line;
 701
 702   /* Some symbols require an additional value to be recorded on a per-
 703      symbol basis.  Stash those values here. */
 704
 705   union
 706   {
 707     /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
 708     short basereg;
 709
 710     /* Used by LOC_THREAD_LOCAL_STATIC.  The objfile in which this
 711        symbol is defined.  To find a thread-local variable (e.g., a
 712        variable declared with the `__thread' storage class), we may
 713        need to know which object file it's in.  */
 714     struct objfile *objfile;
 715   }
 716   aux_value;
 717
 718
 719   /* Link to a list of aliases for this symbol.
 720      Only a "primary/main symbol may have aliases.  */
 721   struct alias_list *aliases;
 722
 723   /* List of ranges where this symbol is active.  This is only
 724      used by alias symbols at the current time.  */
 725   struct range_list *ranges;
 726
 727   struct symbol *hash_next;
 728 };
 729
 730
 731 #define SYMBOL_NAMESPACE(symbol)        (symbol)->namespace
 732 #define SYMBOL_CLASS(symbol)            (symbol)->aclass
 733 #define SYMBOL_TYPE(symbol)             (symbol)->type
 734 #define SYMBOL_LINE(symbol)             (symbol)->line
 735 #define SYMBOL_BASEREG(symbol)          (symbol)->aux_value.basereg
 736 #define SYMBOL_OBJFILE(symbol)          (symbol)->aux_value.objfile
 737 #define SYMBOL_ALIASES(symbol)          (symbol)->aliases
 738 #define SYMBOL_RANGES(symbol)           (symbol)->ranges
 739 \f
 740 /* A partial_symbol records the name, namespace, and address class of
 741    symbols whose types we have not parsed yet.  For functions, it also
 742    contains their memory address, so we can find them from a PC value.
 743    Each partial_symbol sits in a partial_symtab, all of which are chained
 744    on a  partial symtab list and which points to the corresponding
 745    normal symtab once the partial_symtab has been referenced.  */
 746
 747 struct partial_symbol
 748 {
 749
 750   /* The general symbol info required for all types of symbols. */
 751
 752   struct general_symbol_info ginfo;
 753
 754   /* Name space code.  */
 755
 756   namespace_enum namespace BYTE_BITFIELD;
 757
 758   /* Address class (for info_symbols) */
 759
 760   enum address_class aclass BYTE_BITFIELD;
 761
 762 };
 763
 764 #define PSYMBOL_NAMESPACE(psymbol)      (psymbol)->namespace
 765 #define PSYMBOL_CLASS(psymbol)          (psymbol)->aclass
 766 \f
 767
 768 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 769    somewhat more wasteful of space than one might wish, but since only
 770    the files which are actually debugged are read in to core, we don't
 771    waste much space.  */
 772
 773 struct linetable_entry
 774 {
 775   int line;
 776   CORE_ADDR pc;
 777 };
 778
 779 /* The order of entries in the linetable is significant.  They should
 780    be sorted by increasing values of the pc field.  If there is more than
 781    one entry for a given pc, then I'm not sure what should happen (and
 782    I not sure whether we currently handle it the best way).
 783
 784    Example: a C for statement generally looks like this
 785
 786    10   0x100   - for the init/test part of a for stmt.
 787    20   0x200
 788    30   0x300
 789    10   0x400   - for the increment part of a for stmt.
 790
 791    If an entry has a line number of zero, it marks the start of a PC
 792    range for which no line number information is available.  It is
 793    acceptable, though wasteful of table space, for such a range to be
 794    zero length.  */
 795
 796 struct linetable
 797 {
 798   int nitems;
 799
 800   /* Actually NITEMS elements.  If you don't like this use of the
 801      `struct hack', you can shove it up your ANSI (seriously, if the
 802      committee tells us how to do it, we can probably go along).  */
 803   struct linetable_entry item[1];
 804 };
 805
 806 /* How to relocate the symbols from each section in a symbol file.
 807    Each struct contains an array of offsets.
 808    The ordering and meaning of the offsets is file-type-dependent;
 809    typically it is indexed by section numbers or symbol types or
 810    something like that.
 811
 812    To give us flexibility in changing the internal representation
 813    of these offsets, the ANOFFSET macro must be used to insert and
 814    extract offset values in the struct.  */
 815
 816 struct section_offsets
 817 {
 818   CORE_ADDR offsets[1];         /* As many as needed. */
 819 };
 820
 821 #define ANOFFSET(secoff, whichone) \
 822    ((whichone == -1) \
 823     ? (internal_error (__FILE__, __LINE__, "Section index is uninitialized"), -1) \
 824     : secoff->offsets[whichone])
 825
 826 /* The maximum possible size of a section_offsets table.  */
 827
 828 #define SIZEOF_SECTION_OFFSETS \
 829   (sizeof (struct section_offsets) \
 830    + sizeof (((struct section_offsets *) 0)->offsets) * (SECT_OFF_MAX-1))
 831
 832 /* Each source file or header is represented by a struct symtab.
 833    These objects are chained through the `next' field.  */
 834
 835 struct symtab
 836 {
 837
 838   /* Chain of all existing symtabs.  */
 839
 840   struct symtab *next;
 841
 842   /* List of all symbol scope blocks for this symtab.  May be shared
 843      between different symtabs (and normally is for all the symtabs
 844      in a given compilation unit).  */
 845
 846   struct blockvector *blockvector;
 847
 848   /* Table mapping core addresses to line numbers for this file.
 849      Can be NULL if none.  Never shared between different symtabs.  */
 850
 851   struct linetable *linetable;
 852
 853   /* Section in objfile->section_offsets for the blockvector and
 854      the linetable.  Probably always SECT_OFF_TEXT.  */
 855
 856   int block_line_section;
 857
 858   /* If several symtabs share a blockvector, exactly one of them
 859      should be designated the primary, so that the blockvector
 860      is relocated exactly once by objfile_relocate.  */
 861
 862   int primary;
 863
 864   /* The macro table for this symtab.  Like the blockvector, this
 865      may be shared between different symtabs --- and normally is for
 866      all the symtabs in a given compilation unit.  */
 867   struct macro_table *macro_table;
 868
 869   /* Name of this source file.  */
 870
 871   char *filename;
 872
 873   /* Directory in which it was compiled, or NULL if we don't know.  */
 874
 875   char *dirname;
 876
 877   /* This component says how to free the data we point to:
 878      free_contents => do a tree walk and free each object.
 879      free_nothing => do nothing; some other symtab will free
 880      the data this one uses.
 881      free_linetable => free just the linetable.  FIXME: Is this redundant
 882      with the primary field?  */
 883
 884   enum free_code
 885   {
 886     free_nothing, free_contents, free_linetable
 887   }
 888   free_code;
 889
 890   /* Pointer to one block of storage to be freed, if nonzero.  */
 891   /* This is IN ADDITION to the action indicated by free_code.  */
 892
 893   char *free_ptr;
 894
 895   /* Total number of lines found in source file.  */
 896
 897   int nlines;
 898
 899   /* line_charpos[N] is the position of the (N-1)th line of the
 900      source file.  "position" means something we can lseek() to; it
 901      is not guaranteed to be useful any other way.  */
 902
 903   int *line_charpos;
 904
 905   /* Language of this source file.  */
 906
 907   enum language language;
 908
 909   /* String that identifies the format of the debugging information, such
 910      as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 911      for automated testing of gdb but may also be information that is
 912      useful to the user. */
 913
 914   char *debugformat;
 915
 916   /* String of version information.  May be zero.  */
 917
 918   char *version;
 919
 920   /* Full name of file as found by searching the source path.
 921      NULL if not yet known.  */
 922
 923   char *fullname;
 924
 925   /* Object file from which this symbol information was read.  */
 926
 927   struct objfile *objfile;
 928
 929 };
 930
 931 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 932 #define LINETABLE(symtab)       (symtab)->linetable
 933 \f
 934
 935 /* Each source file that has not been fully read in is represented by
 936    a partial_symtab.  This contains the information on where in the
 937    executable the debugging symbols for a specific file are, and a
 938    list of names of global symbols which are located in this file.
 939    They are all chained on partial symtab lists.
 940
 941    Even after the source file has been read into a symtab, the
 942    partial_symtab remains around.  They are allocated on an obstack,
 943    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 944    style execution of a bunch of .o's.  */
 945
 946 struct partial_symtab
 947 {
 948
 949   /* Chain of all existing partial symtabs.  */
 950
 951   struct partial_symtab *next;
 952
 953   /* Name of the source file which this partial_symtab defines */
 954
 955   char *filename;
 956
 957   /* Full path of the source file.  NULL if not known.  */
 958
 959   char *fullname;
 960
 961   /* Information about the object file from which symbols should be read.  */
 962
 963   struct objfile *objfile;
 964
 965   /* Set of relocation offsets to apply to each section.  */
 966
 967   struct section_offsets *section_offsets;
 968
 969   /* Range of text addresses covered by this file; texthigh is the
 970      beginning of the next section. */
 971
 972   CORE_ADDR textlow;
 973   CORE_ADDR texthigh;
 974
 975   /* Array of pointers to all of the partial_symtab's which this one
 976      depends on.  Since this array can only be set to previous or
 977      the current (?) psymtab, this dependency tree is guaranteed not
 978      to have any loops.  "depends on" means that symbols must be read
 979      for the dependencies before being read for this psymtab; this is
 980      for type references in stabs, where if foo.c includes foo.h, declarations
 981      in foo.h may use type numbers defined in foo.c.  For other debugging
 982      formats there may be no need to use dependencies.  */
 983
 984   struct partial_symtab **dependencies;
 985
 986   int number_of_dependencies;
 987
 988   /* Global symbol list.  This list will be sorted after readin to
 989      improve access.  Binary search will be the usual method of
 990      finding a symbol within it. globals_offset is an integer offset
 991      within global_psymbols[].  */
 992
 993   int globals_offset;
 994   int n_global_syms;
 995
 996   /* Static symbol list.  This list will *not* be sorted after readin;
 997      to find a symbol in it, exhaustive search must be used.  This is
 998      reasonable because searches through this list will eventually
 999      lead to either the read in of a files symbols for real (assumed
1000      to take a *lot* of time; check) or an error (and we don't care
1001      how long errors take).  This is an offset and size within
1002      static_psymbols[].  */
1003
1004   int statics_offset;
1005   int n_static_syms;
1006
1007   /* Pointer to symtab eventually allocated for this source file, 0 if
1008      !readin or if we haven't looked for the symtab after it was readin.  */
1009
1010   struct symtab *symtab;
1011
1012   /* Pointer to function which will read in the symtab corresponding to
1013      this psymtab.  */
1014
1015   void (*read_symtab) (struct partial_symtab *);
1016
1017   /* Information that lets read_symtab() locate the part of the symbol table
1018      that this psymtab corresponds to.  This information is private to the
1019      format-dependent symbol reading routines.  For further detail examine
1020      the various symbol reading modules.  Should really be (void *) but is
1021      (char *) as with other such gdb variables.  (FIXME) */
1022
1023   char *read_symtab_private;
1024
1025   /* Non-zero if the symtab corresponding to this psymtab has been readin */
1026
1027   unsigned char readin;
1028 };
1029
1030 /* A fast way to get from a psymtab to its symtab (after the first time).  */
1031 #define PSYMTAB_TO_SYMTAB(pst)  \
1032     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
1033 \f
1034
1035 /* The virtual function table is now an array of structures which have the
1036    form { int16 offset, delta; void *pfn; }.
1037
1038    In normal virtual function tables, OFFSET is unused.
1039    DELTA is the amount which is added to the apparent object's base
1040    address in order to point to the actual object to which the
1041    virtual function should be applied.
1042    PFN is a pointer to the virtual function.
1043
1044    Note that this macro is g++ specific (FIXME). */
1045
1046 #define VTBL_FNADDR_OFFSET 2
1047
1048 /* External variables and functions for the objects described above. */
1049
1050 /* See the comment in symfile.c about how current_objfile is used. */
1051
1052 extern struct objfile *current_objfile;
1053
1054 /* True if we are nested inside psymtab_to_symtab. */
1055
1056 extern int currently_reading_symtab;
1057
1058 /* From utils.c.  */
1059 extern int demangle;
1060 extern int asm_demangle;
1061
1062 /* symtab.c lookup functions */
1063
1064 /* lookup a symbol table by source file name */
1065
1066 extern struct symtab *lookup_symtab (const char *);
1067
1068 /* lookup a symbol by name (optional block, optional symtab) */
1069
1070 extern struct symbol *lookup_symbol (const char *, const struct block *,
1071                                      const namespace_enum, int *,
1072                                      struct symtab **);
1073
1074 /* lookup a symbol by name, within a specified block */
1075
1076 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
1077                                            const char *,
1078                                            const namespace_enum);
1079
1080 /* lookup a [struct, union, enum] by name, within a specified block */
1081
1082 extern struct type *lookup_struct (char *, struct block *);
1083
1084 extern struct type *lookup_union (char *, struct block *);
1085
1086 extern struct type *lookup_enum (char *, struct block *);
1087
1088 /* lookup the function corresponding to the block */
1089
1090 extern struct symbol *block_function (struct block *);
1091
1092 /* from blockframe.c: */
1093
1094 /* lookup the function symbol corresponding to the address */
1095
1096 extern struct symbol *find_pc_function (CORE_ADDR);
1097
1098 /* lookup the function corresponding to the address and section */
1099
1100 extern struct symbol *find_pc_sect_function (CORE_ADDR, asection *);
1101
1102 /* lookup function from address, return name, start addr and end addr */
1103
1104 extern int
1105 find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *, CORE_ADDR *);
1106
1107 extern void clear_pc_function_cache (void);
1108
1109 extern int find_pc_sect_partial_function (CORE_ADDR, asection *,
1110                                           char **, CORE_ADDR *, CORE_ADDR *);
1111
1112 /* from symtab.c: */
1113
1114 /* lookup partial symbol table by filename */
1115
1116 extern struct partial_symtab *lookup_partial_symtab (const char *);
1117
1118 /* lookup partial symbol table by address */
1119
1120 extern struct partial_symtab *find_pc_psymtab (CORE_ADDR);
1121
1122 /* lookup partial symbol table by address and section */
1123
1124 extern struct partial_symtab *find_pc_sect_psymtab (CORE_ADDR, asection *);
1125
1126 /* lookup full symbol table by address */
1127
1128 extern struct symtab *find_pc_symtab (CORE_ADDR);
1129
1130 /* lookup full symbol table by address and section */
1131
1132 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, asection *);
1133
1134 /* lookup partial symbol by address */
1135
1136 extern struct partial_symbol *find_pc_psymbol (struct partial_symtab *,
1137                                                CORE_ADDR);
1138
1139 /* lookup partial symbol by address and section */
1140
1141 extern struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
1142                                                     CORE_ADDR, asection *);
1143
1144 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1145
1146 extern int contained_in (struct block *, struct block *);
1147
1148 extern void reread_symbols (void);
1149
1150 extern struct type *lookup_transparent_type (const char *);
1151
1152
1153 /* Macro for name of symbol to indicate a file compiled with gcc. */
1154 #ifndef GCC_COMPILED_FLAG_SYMBOL
1155 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1156 #endif
1157
1158 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1159 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1160 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1161 #endif
1162
1163 /* Functions for dealing with the minimal symbol table, really a misc
1164    address<->symbol mapping for things we don't have debug symbols for.  */
1165
1166 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1167                                         enum minimal_symbol_type,
1168                                         struct objfile *);
1169
1170 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1171   (const char *, CORE_ADDR,
1172    enum minimal_symbol_type,
1173    char *info, int section, asection * bfd_section, struct objfile *);
1174
1175 extern unsigned int msymbol_hash_iw (const char *);
1176
1177 extern unsigned int msymbol_hash (const char *);
1178
1179 extern void
1180 add_minsym_to_hash_table (struct minimal_symbol *sym,
1181                           struct minimal_symbol **table);
1182
1183 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1184                                                      const char *,
1185                                                      struct objfile *);
1186
1187 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1188                                                           const char *,
1189                                                           struct objfile *);
1190
1191 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1192                                                                const char *,
1193                                                                struct objfile
1194                                                                *);
1195
1196 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1197
1198 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_section (CORE_ADDR,
1199                                                                    asection
1200                                                                    *);
1201
1202 extern struct minimal_symbol
1203   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1204
1205 extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR);
1206
1207 extern void init_minimal_symbol_collection (void);
1208
1209 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1210
1211 extern void install_minimal_symbols (struct objfile *);
1212
1213 /* Sort all the minimal symbols in OBJFILE.  */
1214
1215 extern void msymbols_sort (struct objfile *objfile);
1216
1217 struct symtab_and_line
1218 {
1219   struct symtab *symtab;
1220   asection *section;
1221   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1222      0 is never a valid line number; it is used to indicate that line number
1223      information is not available.  */
1224   int line;
1225
1226   CORE_ADDR pc;
1227   CORE_ADDR end;
1228 };
1229
1230 #define INIT_SAL(sal) { \
1231   (sal)->symtab  = 0;   \
1232   (sal)->section = 0;   \
1233   (sal)->line    = 0;   \
1234   (sal)->pc      = 0;   \
1235   (sal)->end     = 0;   \
1236 }
1237
1238 struct symtabs_and_lines
1239 {
1240   struct symtab_and_line *sals;
1241   int nelts;
1242 };
1243 \f
1244
1245
1246 /* Some types and macros needed for exception catchpoints.
1247    Can't put these in target.h because symtab_and_line isn't
1248    known there. This file will be included by breakpoint.c,
1249    hppa-tdep.c, etc. */
1250
1251 /* Enums for exception-handling support */
1252 enum exception_event_kind
1253 {
1254   EX_EVENT_THROW,
1255   EX_EVENT_CATCH
1256 };
1257
1258 /* Type for returning info about an exception */
1259 struct exception_event_record
1260 {
1261   enum exception_event_kind kind;
1262   struct symtab_and_line throw_sal;
1263   struct symtab_and_line catch_sal;
1264   /* This may need to be extended in the future, if
1265      some platforms allow reporting more information,
1266      such as point of rethrow, type of exception object,
1267      type expected by catch clause, etc. */
1268 };
1269
1270 #define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
1271 #define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
1272 #define CURRENT_EXCEPTION_CATCH_LINE (current_exception_event->catch_sal.line)
1273 #define CURRENT_EXCEPTION_CATCH_FILE (current_exception_event->catch_sal.symtab->filename)
1274 #define CURRENT_EXCEPTION_CATCH_PC   (current_exception_event->catch_sal.pc)
1275 #define CURRENT_EXCEPTION_THROW_SAL  (current_exception_event->throw_sal)
1276 #define CURRENT_EXCEPTION_THROW_LINE (current_exception_event->throw_sal.line)
1277 #define CURRENT_EXCEPTION_THROW_FILE (current_exception_event->throw_sal.symtab->filename)
1278 #define CURRENT_EXCEPTION_THROW_PC   (current_exception_event->throw_sal.pc)
1279 \f
1280
1281 /* Given a pc value, return line number it is in.  Second arg nonzero means
1282    if pc is on the boundary use the previous statement's line number.  */
1283
1284 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1285
1286 /* Same function, but specify a section as well as an address */
1287
1288 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR, asection *, int);
1289
1290 /* Given an address, return the nearest symbol at or below it in memory.
1291    Optionally return the symtab it's from through 2nd arg, and the
1292    address in inferior memory of the symbol through 3rd arg.  */
1293
1294 extern struct symbol *find_addr_symbol (CORE_ADDR, struct symtab **,
1295                                         CORE_ADDR *);
1296
1297 /* Given a symtab and line number, return the pc there.  */
1298
1299 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1300
1301 extern int
1302 find_line_pc_range (struct symtab_and_line, CORE_ADDR *, CORE_ADDR *);
1303
1304 extern void resolve_sal_pc (struct symtab_and_line *);
1305
1306 /* Given a string, return the line specified by it.  For commands like "list"
1307    and "breakpoint".  */
1308
1309 extern struct symtabs_and_lines decode_line_spec (char *, int);
1310
1311 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1312
1313 /* Symmisc.c */
1314
1315 void maintenance_print_symbols (char *, int);
1316
1317 void maintenance_print_psymbols (char *, int);
1318
1319 void maintenance_print_msymbols (char *, int);
1320
1321 void maintenance_print_objfiles (char *, int);
1322
1323 void maintenance_check_symtabs (char *, int);
1324
1325 /* maint.c */
1326
1327 void maintenance_print_statistics (char *, int);
1328
1329 extern void free_symtab (struct symtab *);
1330
1331 /* Symbol-reading stuff in symfile.c and solib.c.  */
1332
1333 extern struct symtab *psymtab_to_symtab (struct partial_symtab *);
1334
1335 extern void clear_solib (void);
1336
1337 /* source.c */
1338
1339 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1340
1341 extern void print_source_lines (struct symtab *, int, int, int);
1342
1343 extern void forget_cached_source_info (void);
1344
1345 extern void select_source_symtab (struct symtab *);
1346
1347 extern char **make_symbol_completion_list (char *, char *);
1348
1349 extern char **make_file_symbol_completion_list (char *, char *, char *);
1350
1351 extern struct symbol **make_symbol_overload_list (struct symbol *);
1352
1353 extern char **make_source_files_completion_list (char *, char *);
1354
1355 /* symtab.c */
1356
1357 extern struct partial_symtab *find_main_psymtab (void);
1358
1359 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1360
1361 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1362                                                        int);
1363
1364 /* blockframe.c */
1365
1366 extern struct blockvector *blockvector_for_pc (CORE_ADDR, int *);
1367
1368 extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, asection *,
1369                                                     int *, struct symtab *);
1370
1371 /* symfile.c */
1372
1373 extern void clear_symtab_users (void);
1374
1375 extern enum language deduce_language_from_filename (char *);
1376
1377 /* symtab.c */
1378
1379 extern int in_prologue (CORE_ADDR pc, CORE_ADDR func_start);
1380
1381 extern struct symbol *fixup_symbol_section (struct symbol *,
1382                                             struct objfile *);
1383
1384 extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
1385                                                      *psym,
1386                                                      struct objfile *objfile);
1387
1388 /* Symbol searching */
1389
1390 /* When using search_symbols, a list of the following structs is returned.
1391    Callers must free the search list using free_search_symbols! */
1392 struct symbol_search
1393 {
1394   /* The block in which the match was found. Could be, for example,
1395      STATIC_BLOCK or GLOBAL_BLOCK. */
1396   int block;
1397
1398   /* Information describing what was found.
1399
1400      If symtab abd symbol are NOT NULL, then information was found
1401      for this match. */
1402   struct symtab *symtab;
1403   struct symbol *symbol;
1404
1405   /* If msymbol is non-null, then a match was made on something for
1406      which only minimal_symbols exist. */
1407   struct minimal_symbol *msymbol;
1408
1409   /* A link to the next match, or NULL for the end. */
1410   struct symbol_search *next;
1411 };
1412
1413 extern void search_symbols (char *, namespace_enum, int, char **,
1414                             struct symbol_search **);
1415 extern void free_search_symbols (struct symbol_search *);
1416 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1417                                                          *);
1418
1419 /* The name of the ``main'' function.
1420    FIXME: cagney/2001-03-20: Can't make main_name() const since some
1421    of the calling code currently assumes that the string isn't
1422    const. */
1423 extern void set_main_name (const char *name);
1424 extern /*const */ char *main_name (void);
1425
1426 #endif /* !defined(SYMTAB_H) */