gdb/symtab.h

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