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