gdb/symtab.h

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