gdb/symtab.h

   1 /* Symbol table definitions for GDB.
   2    Copyright 1986, 89, 91, 92, 93, 94, 95, 96, 1998
   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 free
  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             free (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             free (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             free (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 ("Section index is uninitialized"), -1) : secoff->offsets[whichone])
 833
 834 /* The maximum possible size of a section_offsets table.  */
 835
 836 #define SIZEOF_SECTION_OFFSETS \
 837   (sizeof (struct section_offsets) \
 838    + sizeof (((struct section_offsets *) 0)->offsets) * (SECT_OFF_MAX-1))
 839
 840 /* Each source file or header is represented by a struct symtab.
 841    These objects are chained through the `next' field.  */
 842
 843 struct symtab
 844   {
 845
 846     /* Chain of all existing symtabs.  */
 847
 848     struct symtab *next;
 849
 850     /* List of all symbol scope blocks for this symtab.  May be shared
 851        between different symtabs (and normally is for all the symtabs
 852        in a given compilation unit).  */
 853
 854     struct blockvector *blockvector;
 855
 856     /* Table mapping core addresses to line numbers for this file.
 857        Can be NULL if none.  Never shared between different symtabs.  */
 858
 859     struct linetable *linetable;
 860
 861     /* Section in objfile->section_offsets for the blockvector and
 862        the linetable.  Probably always SECT_OFF_TEXT.  */
 863
 864     int block_line_section;
 865
 866     /* If several symtabs share a blockvector, exactly one of them
 867        should be designated the primary, so that the blockvector
 868        is relocated exactly once by objfile_relocate.  */
 869
 870     int primary;
 871
 872     /* Name of this source file.  */
 873
 874     char *filename;
 875
 876     /* Directory in which it was compiled, or NULL if we don't know.  */
 877
 878     char *dirname;
 879
 880     /* This component says how to free the data we point to:
 881        free_contents => do a tree walk and free each object.
 882        free_nothing => do nothing; some other symtab will free
 883        the data this one uses.
 884        free_linetable => free just the linetable.  FIXME: Is this redundant
 885        with the primary field?  */
 886
 887     enum free_code
 888       {
 889         free_nothing, free_contents, free_linetable
 890       }
 891     free_code;
 892
 893     /* Pointer to one block of storage to be freed, if nonzero.  */
 894     /* This is IN ADDITION to the action indicated by free_code.  */
 895
 896     char *free_ptr;
 897
 898     /* Total number of lines found in source file.  */
 899
 900     int nlines;
 901
 902     /* line_charpos[N] is the position of the (N-1)th line of the
 903        source file.  "position" means something we can lseek() to; it
 904        is not guaranteed to be useful any other way.  */
 905
 906     int *line_charpos;
 907
 908     /* Language of this source file.  */
 909
 910     enum language language;
 911
 912     /* String that identifies the format of the debugging information, such
 913        as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 914        for automated testing of gdb but may also be information that is
 915        useful to the user. */
 916
 917     char *debugformat;
 918
 919     /* String of version information.  May be zero.  */
 920
 921     char *version;
 922
 923     /* Full name of file as found by searching the source path.
 924        NULL if not yet known.  */
 925
 926     char *fullname;
 927
 928     /* Object file from which this symbol information was read.  */
 929
 930     struct objfile *objfile;
 931
 932   };
 933
 934 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 935 #define LINETABLE(symtab)       (symtab)->linetable
 936 \f
 937
 938 /* Each source file that has not been fully read in is represented by
 939    a partial_symtab.  This contains the information on where in the
 940    executable the debugging symbols for a specific file are, and a
 941    list of names of global symbols which are located in this file.
 942    They are all chained on partial symtab lists.
 943
 944    Even after the source file has been read into a symtab, the
 945    partial_symtab remains around.  They are allocated on an obstack,
 946    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 947    style execution of a bunch of .o's.  */
 948
 949 struct partial_symtab
 950   {
 951
 952     /* Chain of all existing partial symtabs.  */
 953
 954     struct partial_symtab *next;
 955
 956     /* Name of the source file which this partial_symtab defines */
 957
 958     char *filename;
 959
 960     /* Information about the object file from which symbols should be read.  */
 961
 962     struct objfile *objfile;
 963
 964     /* Set of relocation offsets to apply to each section.  */
 965
 966     struct section_offsets *section_offsets;
 967
 968     /* Range of text addresses covered by this file; texthigh is the
 969        beginning of the next section. */
 970
 971     CORE_ADDR textlow;
 972     CORE_ADDR texthigh;
 973
 974     /* Array of pointers to all of the partial_symtab's which this one
 975        depends on.  Since this array can only be set to previous or
 976        the current (?) psymtab, this dependency tree is guaranteed not
 977        to have any loops.  "depends on" means that symbols must be read
 978        for the dependencies before being read for this psymtab; this is
 979        for type references in stabs, where if foo.c includes foo.h, declarations
 980        in foo.h may use type numbers defined in foo.c.  For other debugging
 981        formats there may be no need to use dependencies.  */
 982
 983     struct partial_symtab **dependencies;
 984
 985     int number_of_dependencies;
 986
 987     /* Global symbol list.  This list will be sorted after readin to
 988        improve access.  Binary search will be the usual method of
 989        finding a symbol within it. globals_offset is an integer offset
 990        within global_psymbols[].  */
 991
 992     int globals_offset;
 993     int n_global_syms;
 994
 995     /* Static symbol list.  This list will *not* be sorted after readin;
 996        to find a symbol in it, exhaustive search must be used.  This is
 997        reasonable because searches through this list will eventually
 998        lead to either the read in of a files symbols for real (assumed
 999        to take a *lot* of time; check) or an error (and we don't care
1000        how long errors take).  This is an offset and size within
1001        static_psymbols[].  */
1002
1003     int statics_offset;
1004     int n_static_syms;
1005
1006     /* Pointer to symtab eventually allocated for this source file, 0 if
1007        !readin or if we haven't looked for the symtab after it was readin.  */
1008
1009     struct symtab *symtab;
1010
1011     /* Pointer to function which will read in the symtab corresponding to
1012        this psymtab.  */
1013
1014     void (*read_symtab) (struct partial_symtab *);
1015
1016     /* Information that lets read_symtab() locate the part of the symbol table
1017        that this psymtab corresponds to.  This information is private to the
1018        format-dependent symbol reading routines.  For further detail examine
1019        the various symbol reading modules.  Should really be (void *) but is
1020        (char *) as with other such gdb variables.  (FIXME) */
1021
1022     char *read_symtab_private;
1023
1024     /* Non-zero if the symtab corresponding to this psymtab has been readin */
1025
1026     unsigned char readin;
1027   };
1028
1029 /* A fast way to get from a psymtab to its symtab (after the first time).  */
1030 #define PSYMTAB_TO_SYMTAB(pst)  \
1031     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
1032 \f
1033
1034 /* The virtual function table is now an array of structures which have the
1035    form { int16 offset, delta; void *pfn; }.
1036
1037    In normal virtual function tables, OFFSET is unused.
1038    DELTA is the amount which is added to the apparent object's base
1039    address in order to point to the actual object to which the
1040    virtual function should be applied.
1041    PFN is a pointer to the virtual function.
1042
1043    Note that this macro is g++ specific (FIXME). */
1044
1045 #define VTBL_FNADDR_OFFSET 2
1046
1047 /* Macro that yields non-zero value iff NAME is the prefix for C++ operator
1048    names.  If you leave out the parenthesis here you will lose!  */
1049 #define OPNAME_PREFIX_P(NAME) \
1050   (!strncmp (NAME, "operator", 8))
1051
1052 /* Macro that yields non-zero value iff NAME is the prefix for C++ vtbl
1053    names.  Note that this macro is g++ specific (FIXME).
1054    '_vt$' is the old cfront-style vtables; '_VT$' is the new
1055    style, using thunks (where '$' is really CPLUS_MARKER). */
1056
1057 #define VTBL_PREFIX_P(NAME) \
1058   (((NAME)[0] == '_' \
1059    && (((NAME)[1] == 'V' && (NAME)[2] == 'T') \
1060        || ((NAME)[1] == 'v' && (NAME)[2] == 't')) \
1061    && is_cplus_marker ((NAME)[3])) || ((NAME)[0]=='_' && (NAME)[1]=='_' \
1062    && (NAME)[2]=='v' && (NAME)[3]=='t' && (NAME)[4]=='_'))
1063
1064 /* Macro that yields non-zero value iff NAME is the prefix for C++ destructor
1065    names.  Note that this macro is g++ specific (FIXME).  */
1066
1067 #define DESTRUCTOR_PREFIX_P(NAME) \
1068   ((NAME)[0] == '_' && is_cplus_marker ((NAME)[1]) && (NAME)[2] == '_')
1069 \f
1070
1071 /* External variables and functions for the objects described above. */
1072
1073 /* This symtab variable specifies the current file for printing source lines */
1074
1075 extern struct symtab *current_source_symtab;
1076
1077 /* This is the next line to print for listing source lines.  */
1078
1079 extern int current_source_line;
1080
1081 /* See the comment in symfile.c about how current_objfile is used. */
1082
1083 extern struct objfile *current_objfile;
1084
1085 /* True if we are nested inside psymtab_to_symtab. */
1086
1087 extern int currently_reading_symtab;
1088
1089 /* From utils.c.  */
1090 extern int demangle;
1091 extern int asm_demangle;
1092
1093 /* symtab.c lookup functions */
1094
1095 /* lookup a symbol table by source file name */
1096
1097 extern struct symtab *lookup_symtab (char *);
1098
1099 /* lookup a symbol by name (optional block, optional symtab) */
1100
1101 extern struct symbol *lookup_symbol (const char *, const struct block *,
1102                                      const namespace_enum, int *,
1103                                      struct symtab **);
1104
1105 /* lookup a symbol by name, within a specified block */
1106
1107 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
1108                                            const namespace_enum);
1109
1110 /* lookup a [struct, union, enum] by name, within a specified block */
1111
1112 extern struct type *lookup_struct (char *, struct block *);
1113
1114 extern struct type *lookup_union (char *, struct block *);
1115
1116 extern struct type *lookup_enum (char *, struct block *);
1117
1118 /* lookup the function corresponding to the block */
1119
1120 extern struct symbol *block_function (struct block *);
1121
1122 /* from blockframe.c: */
1123
1124 /* lookup the function symbol corresponding to the address */
1125
1126 extern struct symbol *find_pc_function (CORE_ADDR);
1127
1128 /* lookup the function corresponding to the address and section */
1129
1130 extern struct symbol *find_pc_sect_function (CORE_ADDR, asection *);
1131
1132 /* lookup function from address, return name, start addr and end addr */
1133
1134 extern int
1135 find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *, CORE_ADDR *);
1136
1137 extern void clear_pc_function_cache (void);
1138
1139 extern int
1140 find_pc_sect_partial_function (CORE_ADDR, asection *,
1141                                char **, CORE_ADDR *, CORE_ADDR *);
1142
1143 /* from symtab.c: */
1144
1145 /* lookup partial symbol table by filename */
1146
1147 extern struct partial_symtab *lookup_partial_symtab (char *);
1148
1149 /* lookup partial symbol table by address */
1150
1151 extern struct partial_symtab *find_pc_psymtab (CORE_ADDR);
1152
1153 /* lookup partial symbol table by address and section */
1154
1155 extern struct partial_symtab *find_pc_sect_psymtab (CORE_ADDR, asection *);
1156
1157 /* lookup full symbol table by address */
1158
1159 extern struct symtab *find_pc_symtab (CORE_ADDR);
1160
1161 /* lookup full symbol table by address and section */
1162
1163 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, asection *);
1164
1165 /* lookup partial symbol by address */
1166
1167 extern struct partial_symbol *find_pc_psymbol (struct partial_symtab *,
1168                                                CORE_ADDR);
1169
1170 /* lookup partial symbol by address and section */
1171
1172 extern struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
1173                                                     CORE_ADDR, asection *);
1174
1175 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1176
1177 extern int contained_in (struct block *, struct block *);
1178
1179 extern void reread_symbols (void);
1180
1181 extern struct type *lookup_transparent_type (const char *);
1182
1183
1184 /* Macro for name of symbol to indicate a file compiled with gcc. */
1185 #ifndef GCC_COMPILED_FLAG_SYMBOL
1186 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1187 #endif
1188
1189 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1190 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1191 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1192 #endif
1193
1194 /* Functions for dealing with the minimal symbol table, really a misc
1195    address<->symbol mapping for things we don't have debug symbols for.  */
1196
1197 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1198                                         enum minimal_symbol_type,
1199                                         struct objfile *);
1200
1201 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1202   (const char *, CORE_ADDR,
1203    enum minimal_symbol_type,
1204    char *info, int section, asection * bfd_section, struct objfile *);
1205
1206 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1207 extern CORE_ADDR find_stab_function_addr (char *, char *, struct objfile *);
1208 #endif
1209
1210 extern unsigned int msymbol_hash_iw (const char *);
1211
1212 extern unsigned int msymbol_hash (const char *);
1213
1214 extern void
1215 add_minsym_to_hash_table (struct minimal_symbol *sym,
1216                           struct minimal_symbol **table);
1217
1218 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1219                                                      const char *,
1220                                                      struct objfile *);
1221
1222 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1223                                                           const char *,
1224                                                           struct objfile *);
1225
1226 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1227                                                                const char *,
1228                                                                struct objfile
1229                                                                *);
1230
1231 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1232
1233 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_section (CORE_ADDR,
1234                                                                    asection
1235                                                                    *);
1236
1237 extern struct minimal_symbol
1238   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1239
1240 extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR);
1241
1242 extern void init_minimal_symbol_collection (void);
1243
1244 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1245
1246 extern void install_minimal_symbols (struct objfile *);
1247
1248 /* Sort all the minimal symbols in OBJFILE.  */
1249
1250 extern void msymbols_sort (struct objfile *objfile);
1251
1252 struct symtab_and_line
1253   {
1254     struct symtab *symtab;
1255     asection *section;
1256     /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1257        0 is never a valid line number; it is used to indicate that line number
1258        information is not available.  */
1259     int line;
1260
1261     CORE_ADDR pc;
1262     CORE_ADDR end;
1263   };
1264
1265 #define INIT_SAL(sal) { \
1266   (sal)->symtab  = 0;   \
1267   (sal)->section = 0;   \
1268   (sal)->line    = 0;   \
1269   (sal)->pc      = 0;   \
1270   (sal)->end     = 0;   \
1271 }
1272
1273 struct symtabs_and_lines
1274   {
1275     struct symtab_and_line *sals;
1276     int nelts;
1277   };
1278 \f
1279
1280
1281 /* Some types and macros needed for exception catchpoints.
1282    Can't put these in target.h because symtab_and_line isn't
1283    known there. This file will be included by breakpoint.c,
1284    hppa-tdep.c, etc. */
1285
1286 /* Enums for exception-handling support */
1287 enum exception_event_kind
1288   {
1289     EX_EVENT_THROW,
1290     EX_EVENT_CATCH
1291   };
1292
1293 /* Type for returning info about an exception */
1294 struct exception_event_record
1295   {
1296     enum exception_event_kind kind;
1297     struct symtab_and_line throw_sal;
1298     struct symtab_and_line catch_sal;
1299     /* This may need to be extended in the future, if
1300        some platforms allow reporting more information,
1301        such as point of rethrow, type of exception object,
1302        type expected by catch clause, etc. */
1303   };
1304
1305 #define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
1306 #define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
1307 #define CURRENT_EXCEPTION_CATCH_LINE (current_exception_event->catch_sal.line)
1308 #define CURRENT_EXCEPTION_CATCH_FILE (current_exception_event->catch_sal.symtab->filename)
1309 #define CURRENT_EXCEPTION_CATCH_PC   (current_exception_event->catch_sal.pc)
1310 #define CURRENT_EXCEPTION_THROW_SAL  (current_exception_event->throw_sal)
1311 #define CURRENT_EXCEPTION_THROW_LINE (current_exception_event->throw_sal.line)
1312 #define CURRENT_EXCEPTION_THROW_FILE (current_exception_event->throw_sal.symtab->filename)
1313 #define CURRENT_EXCEPTION_THROW_PC   (current_exception_event->throw_sal.pc)
1314 \f
1315
1316 /* Given a pc value, return line number it is in.  Second arg nonzero means
1317    if pc is on the boundary use the previous statement's line number.  */
1318
1319 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1320
1321 /* Same function, but specify a section as well as an address */
1322
1323 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR, asection *, int);
1324
1325 /* Given an address, return the nearest symbol at or below it in memory.
1326    Optionally return the symtab it's from through 2nd arg, and the
1327    address in inferior memory of the symbol through 3rd arg.  */
1328
1329 extern struct symbol *find_addr_symbol (CORE_ADDR, struct symtab **,
1330                                         CORE_ADDR *);
1331
1332 /* Given a symtab and line number, return the pc there.  */
1333
1334 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1335
1336 extern int
1337 find_line_pc_range (struct symtab_and_line, CORE_ADDR *, CORE_ADDR *);
1338
1339 extern void resolve_sal_pc (struct symtab_and_line *);
1340
1341 /* Given a string, return the line specified by it.  For commands like "list"
1342    and "breakpoint".  */
1343
1344 extern struct symtabs_and_lines decode_line_spec (char *, int);
1345
1346 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1347
1348 extern struct symtabs_and_lines
1349 decode_line_1 (char **, int, struct symtab *, int, char ***);
1350
1351 /* Symmisc.c */
1352
1353 void maintenance_print_symbols (char *, int);
1354
1355 void maintenance_print_psymbols (char *, int);
1356
1357 void maintenance_print_msymbols (char *, int);
1358
1359 void maintenance_print_objfiles (char *, int);
1360
1361 void maintenance_check_symtabs (char *, int);
1362
1363 /* maint.c */
1364
1365 void maintenance_print_statistics (char *, int);
1366
1367 extern void free_symtab (struct symtab *);
1368
1369 /* Symbol-reading stuff in symfile.c and solib.c.  */
1370
1371 extern struct symtab *psymtab_to_symtab (struct partial_symtab *);
1372
1373 extern void clear_solib (void);
1374
1375 /* source.c */
1376
1377 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1378
1379 extern void print_source_lines (struct symtab *, int, int, int);
1380
1381 extern void forget_cached_source_info (void);
1382
1383 extern void select_source_symtab (struct symtab *);
1384
1385 extern char **make_symbol_completion_list (char *, char *);
1386
1387 extern struct symbol **make_symbol_overload_list (struct symbol *);
1388
1389 /* symtab.c */
1390
1391 extern struct partial_symtab *find_main_psymtab (void);
1392
1393 /* blockframe.c */
1394
1395 extern struct blockvector *blockvector_for_pc (CORE_ADDR, int *);
1396
1397 extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, asection *,
1398                                                     int *, struct symtab *);
1399
1400 /* symfile.c */
1401
1402 extern void clear_symtab_users (void);
1403
1404 extern enum language deduce_language_from_filename (char *);
1405
1406 /* symtab.c */
1407
1408 extern int in_prologue (CORE_ADDR pc, CORE_ADDR func_start);
1409
1410 extern struct symbol *fixup_symbol_section (struct symbol *,
1411                                             struct objfile *);
1412
1413 extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
1414                                                      *psym,
1415                                                      struct objfile *objfile);
1416
1417 /* Symbol searching */
1418
1419 /* When using search_symbols, a list of the following structs is returned.
1420    Callers must free the search list using free_search_symbols! */
1421 struct symbol_search
1422   {
1423     /* The block in which the match was found. Could be, for example,
1424        STATIC_BLOCK or GLOBAL_BLOCK. */
1425     int block;
1426
1427     /* Information describing what was found.
1428
1429        If symtab abd symbol are NOT NULL, then information was found
1430        for this match. */
1431     struct symtab *symtab;
1432     struct symbol *symbol;
1433
1434     /* If msymbol is non-null, then a match was made on something for
1435        which only minimal_symbols exist. */
1436     struct minimal_symbol *msymbol;
1437
1438     /* A link to the next match, or NULL for the end. */
1439     struct symbol_search *next;
1440   };
1441
1442 extern void search_symbols (char *, namespace_enum, int, char **,
1443                             struct symbol_search **);
1444 extern void free_search_symbols (struct symbol_search *);
1445 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search *);
1446
1447 #endif /* !defined(SYMTAB_H) */