gdb/symtab.h

   1 /* Symbol table definitions for GDB.
   2    Copyright (C) 1986, 1989, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #if !defined (SYMTAB_H)
  21 #define SYMTAB_H 1
  22 #include "obstack.h"
  23
  24 /* See the comment in symfile.c about how current_objfile is used. */
  25
  26 extern struct objfile *current_objfile;
  27
  28 /* Some definitions and declarations to go with use of obstacks.  */
  29 #define obstack_chunk_alloc xmalloc
  30 #define obstack_chunk_free free
  31
  32 /* Some macros for char-based bitfields.  */
  33 #define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7)))
  34 #define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7)))
  35 #define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7)))
  36 #define B_TYPE          unsigned char
  37 #define B_BYTES(x)      ( 1 + ((x)>>3) )
  38 #define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x))
  39
  40
  41 /* Define a simple structure used to hold some very basic information about
  42    all defined global symbols (text, data, bss, abs, etc).  The only two
  43    required pieces of information are the symbol's name and the address
  44    associated with that symbol.  In many cases, even if a file was compiled
  45    with no special options for debugging at all, as long as was not stripped
  46    it will contain sufficient information to build a useful minimal symbol
  47    table using this structure.  Even when a file contains enough debugging
  48    information to build a full symbol table, these minimal symbols are still
  49    useful for quickly mapping between names and addresses, and vice versa.
  50    They are also sometimes used to figure out what full symbol table entries
  51    need to be read in. */
  52
  53 struct minimal_symbol
  54 {
  55
  56   /* Name of the symbol.  This is a required field.  Storage for the name is
  57      allocated on the symbol_obstack for the associated objfile. */
  58
  59   char *name;
  60
  61   /* Address of the symbol.  This is a required field. */
  62
  63   CORE_ADDR address;
  64
  65   /* The info field is available for caching machine-specific information that
  66      The AMD 29000 tdep.c uses it to remember things it has decoded from the
  67      instructions in the function header, so it doesn't have to rederive the
  68      info constantly (over a serial line).  It is initialized to zero and
  69      stays that way until target-dependent code sets it.  Storage for any data
  70      pointed to by this field should be allocated on the symbol_obstack for
  71      the associated objfile.  The type would be "void *" except for reasons
  72      of compatibility with older compilers.  This field is optional. */
  73
  74   char *info;
  75
  76   /* Classification types for this symbol.  These should be taken as "advisory
  77      only", since if gdb can't easily figure out a classification it simply
  78      selects mst_unknown.  It may also have to guess when it can't figure out
  79      which is a better match between two types (mst_data versus mst_bss) for
  80      example.  Since the minimal symbol info is sometimes derived from the
  81      BFD library's view of a file, we need to live with what information bfd
  82      supplies. */
  83
  84   enum minimal_symbol_type
  85     {
  86       mst_unknown = 0,          /* Unknown type, the default */
  87       mst_text,                 /* Generally executable instructions */
  88       mst_data,                 /* Generally initialized data */
  89       mst_bss,                  /* Generally uninitialized data */
  90       mst_abs                   /* Generally absolute (nonrelocatable) */
  91     } type;
  92
  93 };
  94
  95 \f
  96 /* All of the name-scope contours of the program
  97    are represented by `struct block' objects.
  98    All of these objects are pointed to by the blockvector.
  99
 100    Each block represents one name scope.
 101    Each lexical context has its own block.
 102
 103    The first two blocks in the blockvector are special.
 104    The first one contains all the symbols defined in this compilation
 105    whose scope is the entire program linked together.
 106    The second one contains all the symbols whose scope is the
 107    entire compilation excluding other separate compilations.
 108    In C, these correspond to global symbols and static symbols.
 109
 110    Each block records a range of core addresses for the code that
 111    is in the scope of the block.  The first two special blocks
 112    give, for the range of code, the entire range of code produced
 113    by the compilation that the symbol segment belongs to.
 114
 115    The blocks appear in the blockvector
 116    in order of increasing starting-address,
 117    and, within that, in order of decreasing ending-address.
 118
 119    This implies that within the body of one function
 120    the blocks appear in the order of a depth-first tree walk.  */
 121
 122 struct blockvector
 123 {
 124   /* Number of blocks in the list.  */
 125   int nblocks;
 126   /* The blocks themselves.  */
 127   struct block *block[1];
 128 };
 129
 130 /* Special block numbers */
 131 #define GLOBAL_BLOCK    0
 132 #define STATIC_BLOCK    1
 133 #define FIRST_LOCAL_BLOCK       2
 134
 135 struct block
 136 {
 137   /* Addresses in the executable code that are in this block.
 138      Note: in an unrelocated symbol segment in a file,
 139      these are always zero.  They can be filled in from the
 140      N_LBRAC and N_RBRAC symbols in the loader symbol table.  */
 141   CORE_ADDR startaddr, endaddr;
 142   /* The symbol that names this block,
 143      if the block is the body of a function;
 144      otherwise, zero.
 145      Note: In an unrelocated symbol segment in an object file,
 146      this field may be zero even when the block has a name.
 147      That is because the block is output before the name
 148      (since the name resides in a higher block).
 149      Since the symbol does point to the block (as its value),
 150      it is possible to find the block and set its name properly.  */
 151   struct symbol *function;
 152   /* The `struct block' for the containing block, or 0 if none.  */
 153   /* Note that in an unrelocated symbol segment in an object file
 154      this pointer may be zero when the correct value should be
 155      the second special block (for symbols whose scope is one compilation).
 156      This is because the compiler outputs the special blocks at the
 157      very end, after the other blocks.   */
 158   struct block *superblock;
 159   /* A flag indicating whether or not the function corresponding
 160      to this block was compiled with gcc or not.  If there is no
 161      function corresponding to this block, this meaning of this flag
 162      is undefined.  (In practice it will be 1 if the block was created
 163      while processing a file compiled with gcc and 0 when not). */
 164   unsigned char gcc_compile_flag;
 165   /* Number of local symbols.  */
 166   int nsyms;
 167   /* The symbols.  */
 168   struct symbol *sym[1];
 169 };
 170 \f
 171 /* Represent one symbol name; a variable, constant, function or typedef.  */
 172
 173 /* Different name spaces for symbols.  Looking up a symbol specifies
 174    a namespace and ignores symbol definitions in other name spaces.
 175
 176    VAR_NAMESPACE is the usual namespace.
 177    In C, this contains variables, function names, typedef names
 178    and enum type values.
 179
 180    STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
 181    Thus, if `struct foo' is used in a C program,
 182    it produces a symbol named `foo' in the STRUCT_NAMESPACE.
 183
 184    LABEL_NAMESPACE may be used for names of labels (for gotos);
 185    currently it is not used and labels are not recorded at all.  */
 186
 187 /* For a non-global symbol allocated statically,
 188    the correct core address cannot be determined by the compiler.
 189    The compiler puts an index number into the symbol's value field.
 190    This index number can be matched with the "desc" field of
 191    an entry in the loader symbol table.  */
 192
 193 enum namespace
 194 {
 195   UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE
 196 };
 197
 198 /* An address-class says where to find the value of a symbol.  */
 199
 200 enum address_class
 201 {
 202   LOC_UNDEF,            /* Not used; catches errors */
 203   LOC_CONST,            /* Value is constant int SYMBOL_VALUE, host byteorder */
 204   LOC_STATIC,           /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 205   LOC_REGISTER,         /* Value is in register */
 206   LOC_ARG,              /* Value is at spec'd offset in arglist */
 207   LOC_REF_ARG,          /* Value address is at spec'd offset in arglist. */
 208   LOC_REGPARM,          /* Value is at spec'd offset in register window */
 209   LOC_LOCAL,            /* Value is at spec'd offset in stack frame */
 210   LOC_TYPEDEF,          /* Value not used; definition in SYMBOL_TYPE
 211                            Symbols in the namespace STRUCT_NAMESPACE
 212                            all have this class.  */
 213   LOC_LABEL,            /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 214   LOC_BLOCK,            /* Value is address SYMBOL_VALUE_BLOCK of a
 215                            `struct block'.  Function names have this class. */
 216   LOC_CONST_BYTES,      /* Value is a constant byte-sequence pointed to by
 217                            SYMBOL_VALUE_ADDRESS, in target byte order.  */
 218   LOC_LOCAL_ARG         /* Value is arg at spec'd offset in stack frame.
 219                            Differs from LOC_LOCAL in that symbol is an
 220                            argument; differs from LOC_ARG in that we find it
 221                            in the frame (FRAME_LOCALS_ADDRESS), not in the
 222                            arglist (FRAME_ARGS_ADDRESS).  Added for i960,
 223                            which passes args in regs then copies to frame.  */
 224 };
 225
 226 struct symbol
 227 {
 228   /* Symbol name */
 229   char *name;
 230   /* Name space code.  */
 231   enum namespace namespace;
 232   /* Address class */
 233   enum address_class class;
 234   /* Data type of value */
 235   struct type *type;
 236
 237   /* Line number of definition.  */
 238   unsigned short line;
 239
 240   /* constant value, or address if static, or register number,
 241      or offset in arguments, or offset in stack frame.  All of
 242      these are in host byte order (though what they point to might
 243      be in target byte order, e.g. LOC_CONST_BYTES).  */
 244   union
 245     {
 246       long value;               /* for LOC_CONST, LOC_REGISTER, LOC_ARG,
 247                                    LOC_REF_ARG, LOC_REGPARM, LOC_LOCAL */
 248       struct block *block;      /* for LOC_BLOCK */
 249       char *bytes;              /* for LOC_CONST_BYTES */
 250       CORE_ADDR address;        /* for LOC_STATIC, LOC_LABEL */
 251       struct symbol *chain;     /* for opaque typedef struct chain */
 252     }
 253   value;
 254
 255   /* Some symbols require an additional value to be recorded on a per-
 256      symbol basis.  Stash those values here. */
 257   union
 258     {
 259       struct                    /* for OP_BASEREG in DWARF location specs */
 260         {
 261           short regno_valid;    /* 0 == regno invalid; !0 == regno valid */
 262           short regno;          /* base register number {0, 1, 2, ...} */
 263         } basereg;
 264     }
 265   aux_value;
 266 };
 267
 268
 269 /* A partial_symbol records the name, namespace, and address class of
 270    symbols whose types we have not parsed yet.  For functions, it also
 271    contains their memory address, so we can find them from a PC value.
 272    Each partial_symbol sits in a partial_symtab, all of which are chained
 273    on a  partial symtab list and which points to the corresponding
 274    normal symtab once the partial_symtab has been referenced.  */
 275
 276 struct partial_symbol
 277 {
 278   /* Symbol name */
 279   char *name;
 280   /* Name space code.  */
 281   enum namespace namespace;
 282   /* Address class (for info_symbols) */
 283   enum address_class class;
 284   /* Value (only used for static functions currently).  Done this
 285      way so that we can use the struct symbol macros.
 286      Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst)
 287      in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st))
 288      in a symbol table.  */
 289   union
 290     {
 291       long value;
 292       CORE_ADDR address;
 293     }
 294   value;
 295 };
 296 \f
 297 /* Source-file information.
 298    This describes the relation between source files and line numbers
 299    and addresses in the program text.  */
 300
 301 struct sourcevector
 302 {
 303   int length;                   /* Number of source files described */
 304   struct source *source[1];     /* Descriptions of the files */
 305 };
 306
 307 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 308    somewhat more wasteful of space than one might wish, but since only
 309    the files which are actually debugged are read in to core, we don't
 310    waste much space.
 311
 312    Each item used to be an int; either minus a line number, or a
 313    program counter.  If it represents a line number, that is the line
 314    described by the next program counter value.  If it is positive, it
 315    is the program counter at which the code for the next line starts.  */
 316
 317 struct linetable_entry
 318 {
 319   int line;
 320   CORE_ADDR pc;
 321 };
 322
 323 struct linetable
 324 {
 325   int nitems;
 326   struct linetable_entry item[1];
 327 };
 328
 329 /* All the information on one source file.  */
 330
 331 struct source
 332 {
 333   char *name;                   /* Name of file */
 334   struct linetable contents;
 335 };
 336
 337 /* How to relocate the symbols from each section in a symbol file.
 338    Each struct contains an array of offsets.
 339    The ordering and meaning of the offsets is file-type-dependent;
 340    typically it is indexed by section numbers or symbol types or
 341    something like that.
 342
 343    To give us flexibility in changing the internal representation
 344    of these offsets, the ANOFFSET macro must be used to insert and
 345    extract offset values in the struct.  */
 346
 347 struct section_offsets
 348   {
 349     CORE_ADDR offsets[1];               /* As many as needed. */
 350   };
 351
 352 #define ANOFFSET(secoff, whichone)      (secoff->offsets[whichone])
 353
 354 /* Each source file is represented by a struct symtab.
 355    These objects are chained through the `next' field.  */
 356
 357 struct symtab
 358   {
 359     /* Chain of all existing symtabs.  */
 360     struct symtab *next;
 361     /* List of all symbol scope blocks for this symtab.  */
 362     struct blockvector *blockvector;
 363     /* Table mapping core addresses to line numbers for this file.
 364        Can be NULL if none.  */
 365     struct linetable *linetable;
 366     /* Name of this source file.  */
 367     char *filename;
 368     /* Directory in which it was compiled, or NULL if we don't know.  */
 369     char *dirname;
 370     /* This component says how to free the data we point to:
 371        free_contents => do a tree walk and free each object.
 372        free_nothing => do nothing; some other symtab will free
 373          the data this one uses.
 374        free_linetable => free just the linetable.  */
 375     enum free_code {free_nothing, free_contents, free_linetable}
 376       free_code;
 377     /* Pointer to one block of storage to be freed, if nonzero.  */
 378     /* This is IN ADDITION to the action indicated by free_code.  */
 379     char *free_ptr;
 380     /* Total number of lines found in source file.  */
 381     int nlines;
 382     /* Array mapping line number to character position.  */
 383     int *line_charpos;
 384     /* Language of this source file.  */
 385     enum language language;
 386     /* String of version information.  May be zero.  */
 387     char *version;
 388     /* Full name of file as found by searching the source path.
 389        0 if not yet known.  */
 390     char *fullname;
 391
 392     /* Object file from which this symbol information was read.  */
 393     struct objfile *objfile;
 394
 395     /* Anything extra for this symtab.  This is for target machines
 396        with special debugging info of some sort (which cannot just
 397        be represented in a normal symtab).  */
 398 #if defined (EXTRA_SYMTAB_INFO)
 399     EXTRA_SYMTAB_INFO
 400 #endif
 401   };
 402
 403 /* Each source file that has not been fully read in is represented by
 404    a partial_symtab.  This contains the information on where in the
 405    executable the debugging symbols for a specific file are, and a
 406    list of names of global symbols which are located in this file.
 407    They are all chained on partial symtab lists.
 408
 409    Even after the source file has been read into a symtab, the
 410    partial_symtab remains around.  They are allocated on an obstack,
 411    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 412    style execution of a bunch of .o's.  */
 413
 414 struct partial_symtab
 415 {
 416   /* Chain of all existing partial symtabs.  */
 417   struct partial_symtab *next;
 418   /* Name of the source file which this partial_symtab defines */
 419   char *filename;
 420
 421   /* Information about the object file from which symbols should be read.  */
 422   struct objfile *objfile;
 423
 424   /* Set of relocation offsets to apply to each section.  */
 425   struct section_offsets *section_offsets;
 426
 427   /* Range of text addresses covered by this file; texthigh is the
 428      beginning of the next section. */
 429   CORE_ADDR textlow, texthigh;
 430   /* Array of pointers to all of the partial_symtab's which this one
 431      depends on.  Since this array can only be set to previous or
 432      the current (?) psymtab, this dependency tree is guaranteed not
 433      to have any loops. */
 434   struct partial_symtab **dependencies;
 435   int number_of_dependencies;
 436   /* Global symbol list.  This list will be sorted after readin to
 437      improve access.  Binary search will be the usual method of
 438      finding a symbol within it. globals_offset is an integer offset
 439      within global_psymbols[].  */
 440   int globals_offset, n_global_syms;
 441   /* Static symbol list.  This list will *not* be sorted after readin;
 442      to find a symbol in it, exhaustive search must be used.  This is
 443      reasonable because searches through this list will eventually
 444      lead to either the read in of a files symbols for real (assumed
 445      to take a *lot* of time; check) or an error (and we don't care
 446      how long errors take).  This is an offset and size within
 447      static_psymbols[].  */
 448   int statics_offset, n_static_syms;
 449   /* Pointer to symtab eventually allocated for this source file, 0 if
 450      !readin or if we haven't looked for the symtab after it was readin.  */
 451   struct symtab *symtab;
 452   /* Pointer to function which will read in the symtab corresponding to
 453      this psymtab.  */
 454   void (*read_symtab) PARAMS ((struct partial_symtab *));
 455   /* Information that lets read_symtab() locate the part of the symbol table
 456      that this psymtab corresponds to.  This information is private to the
 457      format-dependent symbol reading routines.  For further detail examine
 458      the various symbol reading modules.  Should really be (void *) but is
 459      (char *) as with other such gdb variables.  (FIXME) */
 460   char *read_symtab_private;
 461   /* Non-zero if the symtab corresponding to this psymtab has been
 462      readin */
 463   unsigned char readin;
 464 };
 465
 466 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 467 #define PSYMTAB_TO_SYMTAB(pst)  ((pst)->symtab?                 \
 468                                  (pst)->symtab:                 \
 469                                  psymtab_to_symtab (pst) )
 470
 471 /* This symtab variable specifies the current file for printing source lines */
 472
 473 extern struct symtab *current_source_symtab;
 474
 475 /* This is the next line to print for listing source lines.  */
 476
 477 extern int current_source_line;
 478
 479 #define BLOCKVECTOR(symtab) (symtab)->blockvector
 480
 481 #define LINETABLE(symtab) (symtab)->linetable
 482 \f
 483 /* Macros normally used to access components of symbol table structures.  */
 484
 485 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
 486 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
 487
 488 #define BLOCK_START(bl) (bl)->startaddr
 489 #define BLOCK_END(bl) (bl)->endaddr
 490 #define BLOCK_NSYMS(bl) (bl)->nsyms
 491 #define BLOCK_SYM(bl, n) (bl)->sym[n]
 492 #define BLOCK_FUNCTION(bl) (bl)->function
 493 #define BLOCK_SUPERBLOCK(bl) (bl)->superblock
 494 #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag
 495
 496 /* Nonzero if symbols of block BL should be sorted alphabetically.  */
 497 #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40)
 498
 499 #define SYMBOL_NAME(symbol) (symbol)->name
 500 #define SYMBOL_NAMESPACE(symbol) (symbol)->namespace
 501 #define SYMBOL_CLASS(symbol) (symbol)->class
 502 #define SYMBOL_VALUE(symbol) (symbol)->value.value
 503 #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->value.address
 504 #define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
 505 #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
 506 #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
 507 #define SYMBOL_TYPE(symbol) (symbol)->type
 508 #define SYMBOL_LINE(symbol) (symbol)->line
 509 #if 0
 510 /* This currently fails because some symbols are not being initialized
 511    to zero on allocation, and no code is currently setting this value.
 512    Basereg handling will probably change significantly in the next release.
 513    FIXME -fnf */
 514 #define SYMBOL_BASEREG_VALID(symbol) (symbol)->aux_value.basereg.regno_valid
 515 #else
 516 #define SYMBOL_BASEREG_VALID(symbol) 0
 517 #endif
 518 #define SYMBOL_BASEREG(symbol) (symbol)->aux_value.basereg.regno
 519
 520 /* The virtual function table is now an array of structures
 521    which have the form { int16 offset, delta; void *pfn; }.
 522
 523    In normal virtual function tables, OFFSET is unused.
 524    DELTA is the amount which is added to the apparent object's base
 525    address in order to point to the actual object to which the
 526    virtual function should be applied.
 527    PFN is a pointer to the virtual function.  */
 528
 529 #define VTBL_FNADDR_OFFSET 2
 530
 531 /* Macro that yields non-zero value iff NAME is the prefix
 532    for C++ operator names.  If you leave out the parenthesis
 533    here you will lose!
 534
 535    Currently 'o' 'p' CPLUS_MARKER is used for both the symbol in the
 536    symbol-file and the names in gdb's symbol table.  */
 537 #define OPNAME_PREFIX_P(NAME) ((NAME)[0] == 'o' && (NAME)[1] == 'p' \
 538                                && (NAME)[2] == CPLUS_MARKER)
 539
 540 #define VTBL_PREFIX_P(NAME) ((NAME)[3] == CPLUS_MARKER  \
 541                              && !strncmp ((NAME), "_vt", 3))
 542 \f
 543 /* Functions that work on the objects described above */
 544
 545 extern struct symtab *
 546 lookup_symtab PARAMS ((char *));
 547
 548 extern struct symbol *
 549 lookup_symbol PARAMS ((const char *, const struct block *,
 550                        const enum namespace, int *, struct symtab **));
 551
 552 extern struct symbol *
 553 lookup_block_symbol PARAMS ((const struct block *, const char *,
 554                              const enum namespace));
 555
 556 extern struct type *
 557 lookup_struct PARAMS ((char *, struct block *));
 558
 559 extern struct type *
 560 lookup_union PARAMS ((char *, struct block *));
 561
 562 extern struct type *
 563 lookup_enum PARAMS ((char *, struct block *));
 564
 565 extern struct type *
 566 check_struct PARAMS ((struct type *));
 567
 568 extern struct type *
 569 check_union PARAMS ((struct type *));
 570
 571 extern struct type *
 572 check_enum PARAMS ((struct type *));
 573
 574 extern struct symbol *
 575 block_function PARAMS ((struct block *));
 576
 577 extern struct symbol *
 578 find_pc_function PARAMS ((CORE_ADDR));
 579
 580 extern int
 581 find_pc_partial_function PARAMS ((CORE_ADDR, char **, CORE_ADDR *));
 582
 583 extern void
 584 clear_pc_function_cache PARAMS ((void));
 585
 586 extern struct partial_symtab *
 587 lookup_partial_symtab PARAMS ((char *));
 588
 589 extern struct partial_symtab *
 590 find_pc_psymtab PARAMS ((CORE_ADDR));
 591
 592 extern struct symtab *
 593 find_pc_symtab PARAMS ((CORE_ADDR));
 594
 595 extern struct partial_symbol *
 596 find_pc_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR));
 597
 598 extern int
 599 find_pc_line_pc_range PARAMS ((CORE_ADDR, CORE_ADDR *, CORE_ADDR *));
 600
 601 extern int
 602 contained_in PARAMS ((struct block *, struct block *));
 603
 604 extern void
 605 reread_symbols PARAMS ((void));
 606
 607 /* Functions for dealing with the minimal symbol table, really a misc
 608    address<->symbol mapping for things we don't have debug symbols for.  */
 609
 610 extern void
 611 prim_record_minimal_symbol PARAMS ((const char *, CORE_ADDR,
 612                                     enum minimal_symbol_type));
 613
 614 extern void
 615 prim_record_minimal_symbol_and_info PARAMS ((const char *, CORE_ADDR,
 616                                              enum minimal_symbol_type,
 617                                              char *info));
 618
 619 extern struct minimal_symbol *
 620 lookup_minimal_symbol PARAMS ((const char *, struct objfile *));
 621
 622 extern struct minimal_symbol *
 623 lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR));
 624
 625 extern void
 626 init_minimal_symbol_collection PARAMS ((void));
 627
 628 extern void
 629 discard_minimal_symbols PARAMS ((int));
 630
 631 extern void
 632 install_minimal_symbols PARAMS ((struct objfile *));
 633
 634 struct symtab_and_line
 635 {
 636   struct symtab *symtab;
 637   int line;
 638   CORE_ADDR pc;
 639   CORE_ADDR end;
 640 };
 641
 642 struct symtabs_and_lines
 643 {
 644   struct symtab_and_line *sals;
 645   int nelts;
 646 };
 647
 648 /* Given a pc value, return line number it is in.
 649    Second arg nonzero means if pc is on the boundary
 650    use the previous statement's line number.  */
 651
 652 extern struct symtab_and_line
 653 find_pc_line PARAMS ((CORE_ADDR, int));
 654
 655 /* Given a symtab and line number, return the pc there.  */
 656
 657 extern CORE_ADDR
 658 find_line_pc PARAMS ((struct symtab *, int));
 659
 660 extern int
 661 find_line_pc_range PARAMS ((struct symtab *, int, CORE_ADDR *, CORE_ADDR *));
 662
 663 extern void
 664 resolve_sal_pc PARAMS ((struct symtab_and_line *));
 665
 666 /* Given a string, return the line specified by it.
 667    For commands like "list" and "breakpoint".  */
 668
 669 extern struct symtabs_and_lines
 670 decode_line_spec PARAMS ((char *, int));
 671
 672 extern struct symtabs_and_lines
 673 decode_line_spec_1 PARAMS ((char *, int));
 674
 675 extern struct symtabs_and_lines
 676 decode_line_1 PARAMS ((char **, int, struct symtab *, int));
 677
 678 /* Symmisc.c */
 679
 680 #if MAINTENANCE_CMDS
 681
 682 void
 683 maintenance_print_symbols PARAMS ((char *, int));
 684
 685 void
 686 maintenance_print_psymbols PARAMS ((char *, int));
 687
 688 void
 689 maintenance_print_msymbols PARAMS ((char *, int));
 690
 691 void
 692 maintenance_print_objfiles PARAMS ((char *, int));
 693
 694 #endif
 695
 696 extern void
 697 free_symtab PARAMS ((struct symtab *));
 698
 699 /* Symbol-reading stuff in symfile.c and solib.c.  */
 700
 701 extern struct symtab *
 702 psymtab_to_symtab PARAMS ((struct partial_symtab *));
 703
 704 extern void
 705 clear_solib PARAMS ((void));
 706
 707 extern struct objfile *
 708 symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int));
 709
 710 /* source.c */
 711
 712 extern int
 713 identify_source_line PARAMS ((struct symtab *, int, int));
 714
 715 extern void
 716 print_source_lines PARAMS ((struct symtab *, int, int, int));
 717
 718 extern void
 719 forget_cached_source_info PARAMS ((void));
 720
 721 extern void
 722 select_source_symtab PARAMS ((struct symtab *));
 723
 724 extern char **
 725 make_symbol_completion_list PARAMS ((char *));
 726
 727 /* symtab.c */
 728
 729 extern void
 730 clear_symtab_users_once PARAMS ((void));
 731
 732 extern struct partial_symtab *
 733 find_main_psymtab PARAMS ((void));
 734
 735 extern struct type *
 736 find_nested_type PARAMS ((struct type *, char*));
 737
 738 /* blockframe.c */
 739
 740 extern struct blockvector *
 741 blockvector_for_pc PARAMS ((CORE_ADDR, int *));
 742
 743 /* symfile.c */
 744
 745 extern enum language
 746 deduce_language_from_filename PARAMS ((char *));
 747
 748 #endif /* !defined(SYMTAB_H) */