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
  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
  29 /* Define a structure for the information that is common to all symbol types,
  30    including minimal symbols, partial symbols, and full symbols. */
  31
  32 struct general_symbol_info
  33 {
  34   /* Name of the symbol.  This is a required field.  Storage for the name is
  35      allocated on the psymbol_obstack or symbol_obstack for the associated
  36      objfile. */
  37
  38   char *name;
  39
  40   /* Constant value, or address if static, or register number,
  41      or offset in arguments, or offset in stack frame.  All of
  42      these are in host byte order (though what they point to might
  43      be in target byte order, e.g. LOC_CONST_BYTES).
  44
  45      Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst)
  46      in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st))
  47      in a symbol table.  */
  48
  49   union
  50     {
  51       /* for LOC_CONST, LOC_REGISTER, LOC_ARG, LOC_REF_ARG, LOC_REGPARM,
  52          LOC_LOCAL */
  53
  54       long value;
  55
  56       /* for LOC_BLOCK */
  57
  58       struct block *block;
  59
  60       /* for LOC_CONST_BYTES */
  61
  62       char *bytes;
  63
  64       /* for LOC_STATIC, LOC_LABEL */
  65
  66       CORE_ADDR address;
  67
  68       /* for opaque typedef struct chain */
  69
  70       struct symbol *chain;
  71     }
  72   value;
  73
  74   /* In a multilanguage environment, some language specific information may
  75      need to be recorded along with each symbol. */
  76
  77   struct language_dependent_info
  78     {
  79
  80       /* Record the language that this information applies to. */
  81
  82       enum language language;
  83
  84       /* Since one and only one language can apply, wrap the information inside
  85          a union. */
  86
  87       union lang_specific
  88         {
  89           /* For C++ */
  90           struct cplus_specific
  91             {
  92               char *demangled_name;
  93             } cplus_specific;
  94           /* start-sanitize-chill */
  95           /* For Chill */
  96           struct chill_specific
  97             {
  98               char *demangled_name;
  99             } chill_specific;
 100           /* end-sanitize-chill */
 101         } lang_u;
 102     } lang_specific;
 103 };
 104
 105 #define SYMBOL_NAME(symbol)             (symbol)->ginfo.name
 106 #define SYMBOL_VALUE(symbol)            (symbol)->ginfo.value.value
 107 #define SYMBOL_VALUE_ADDRESS(symbol)    (symbol)->ginfo.value.address
 108 #define SYMBOL_VALUE_BYTES(symbol)      (symbol)->ginfo.value.bytes
 109 #define SYMBOL_BLOCK_VALUE(symbol)      (symbol)->ginfo.value.block
 110 #define SYMBOL_VALUE_CHAIN(symbol)      (symbol)->ginfo.value.chain
 111 #define SYMBOL_LANGUAGE(symbol)         (symbol)->ginfo.lang_specific.language
 112
 113 #define SYMBOL_CPLUS_DEMANGLED_NAME(symbol)     \
 114   (symbol)->ginfo.lang_specific.lang_u.cplus_specific.demangled_name
 115
 116
 117 extern int demangle;    /* We reference it, so go ahead and declare it. */
 118
 119 /* Macro that initializes the language dependent portion of a symbol
 120    depending upon the language for the symbol. */
 121
 122 #define SYMBOL_INIT_LANGUAGE_SPECIFIC(symbol,language)                  \
 123   do {                                                                  \
 124     SYMBOL_LANGUAGE (symbol) = language;                                \
 125     if (SYMBOL_LANGUAGE (symbol) == language_cplus)                     \
 126       {                                                                 \
 127         SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL;                    \
 128       }                                                                 \
 129     /* start-sanitize-chill */                                          \
 130     else if (SYMBOL_LANGUAGE (symbol) == language_chill)                \
 131       {                                                                 \
 132         SYMBOL_CHILL_DEMANGLED_NAME (symbol) = NULL;                    \
 133       }                                                                 \
 134     /* end-sanitize-chill */                                            \
 135     else                                                                \
 136       {                                                                 \
 137         memset (&(symbol)->ginfo.lang_specific.lang_u, 0,               \
 138                 sizeof ((symbol)->ginfo.lang_specific.lang_u));         \
 139       }                                                                 \
 140   } while (0)
 141
 142 /* Macro that attempts to initialize the demangled name for a symbol,
 143    based on the language of that symbol.  If the language is set to
 144    language_auto, it will attempt to find any demangling algorithm
 145    that works and then set the language appropriately.  If no demangling
 146    of any kind is found, the language is set back to language_unknown,
 147    so we can avoid doing this work again the next time we encounter
 148    the symbol.  Any required space to store the name is obtained from the
 149    specified obstack. */
 150
 151 #define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack)                      \
 152   do {                                                                  \
 153     char *demangled = NULL;                                             \
 154     if (SYMBOL_LANGUAGE (symbol) == language_cplus                      \
 155         || SYMBOL_LANGUAGE (symbol) == language_auto)                   \
 156       {                                                                 \
 157         demangled =                                                     \
 158           cplus_demangle (SYMBOL_NAME (symbol), DMGL_PARAMS | DMGL_ANSI);\
 159         if (demangled != NULL)                                          \
 160           {                                                             \
 161             SYMBOL_LANGUAGE (symbol) = language_cplus;                  \
 162             SYMBOL_CPLUS_DEMANGLED_NAME (symbol) =                      \
 163               obsavestring (demangled, strlen (demangled), (obstack));  \
 164             free (demangled);                                           \
 165           }                                                             \
 166         else                                                            \
 167           {                                                             \
 168             SYMBOL_CPLUS_DEMANGLED_NAME (symbol) = NULL;                \
 169           }                                                             \
 170       }                                                                 \
 171     /* start-sanitize-chill */                                          \
 172     if (demangled == NULL                                               \
 173         && (SYMBOL_LANGUAGE (symbol) == language_chill                  \
 174             || SYMBOL_LANGUAGE (symbol) == language_auto))              \
 175       {                                                                 \
 176         demangled =                                                     \
 177           chill_demangle (SYMBOL_NAME (symbol));                        \
 178         if (demangled != NULL)                                          \
 179           {                                                             \
 180             SYMBOL_LANGUAGE (symbol) = language_chill;                  \
 181             SYMBOL_CHILL_DEMANGLED_NAME (symbol) =                      \
 182               obsavestring (demangled, strlen (demangled), (obstack));  \
 183             free (demangled);                                           \
 184           }                                                             \
 185         else                                                            \
 186           {                                                             \
 187             SYMBOL_CHILL_DEMANGLED_NAME (symbol) = NULL;                \
 188           }                                                             \
 189       }                                                                 \
 190     /* end-sanitize-chill */                                            \
 191     if (SYMBOL_LANGUAGE (symbol) == language_auto)                      \
 192       {                                                                 \
 193         SYMBOL_LANGUAGE (symbol) = language_unknown;                    \
 194       }                                                                 \
 195   } while (0)
 196
 197 /* Macro that returns the demangled name for a symbol based on the language
 198    for that symbol.  If no demangled name exists, returns NULL. */
 199
 200 #define SYMBOL_DEMANGLED_NAME(symbol)                                   \
 201   (SYMBOL_LANGUAGE (symbol) == language_cplus                           \
 202    ? SYMBOL_CPLUS_DEMANGLED_NAME (symbol)                               \
 203    : NULL)
 204
 205 /* start-sanitize-chill */
 206
 207 #define SYMBOL_CHILL_DEMANGLED_NAME(symbol)                             \
 208   (symbol)->ginfo.lang_specific.lang_u.chill_specific.demangled_name
 209
 210 /* Redefine SYMBOL_DEMANGLED_NAME.  This is simplier than trying to
 211    devise a macro for which part of it can be cleanly sanitized away. */
 212
 213 #undef SYMBOL_DEMANGLED_NAME
 214 #define SYMBOL_DEMANGLED_NAME(symbol)                                   \
 215   (SYMBOL_LANGUAGE (symbol) == language_cplus                           \
 216    ? SYMBOL_CPLUS_DEMANGLED_NAME (symbol)                               \
 217    : (SYMBOL_LANGUAGE (symbol) == language_chill                        \
 218       ? SYMBOL_CHILL_DEMANGLED_NAME (symbol)                            \
 219       : NULL))
 220
 221 /* end-sanitize-chill */
 222
 223 /* Macro that returns the "natural source name" of a symbol.  In C++ this is
 224    the "demangled" form of the name if demangle is on and the "mangled" form
 225    of the name if demangle is off.  In other languages this is just the
 226    symbol name.  The result should never be NULL. */
 227
 228 #define SYMBOL_SOURCE_NAME(symbol)                                      \
 229   (demangle && SYMBOL_DEMANGLED_NAME (symbol) != NULL                   \
 230    ? SYMBOL_DEMANGLED_NAME (symbol)                                     \
 231    : SYMBOL_NAME (symbol))
 232
 233 /* Macro that returns the "natural assembly name" of a symbol.  In C++ this is
 234    the "mangled" form of the name if demangle is off, or if demangle is on and
 235    asm_demangle is off.  Otherwise if asm_demangle is on it is the "demangled"
 236    form.  In other languages this is just the symbol name.  The result should
 237    never be NULL. */
 238
 239 #define SYMBOL_LINKAGE_NAME(symbol)                                     \
 240   (demangle && asm_demangle && SYMBOL_DEMANGLED_NAME (symbol) != NULL   \
 241    ? SYMBOL_DEMANGLED_NAME (symbol)                                     \
 242    : SYMBOL_NAME (symbol))
 243
 244 /* Macro that tests a symbol for a match against a specified name string.
 245    First test the unencoded name, then looks for and test a C++ encoded
 246    name if it exists.  Note that whitespace is ignored while attempting to
 247    match a C++ encoded name, so that "foo::bar(int,long)" is the same as
 248    "foo :: bar (int, long)".
 249    Evaluates to zero if the match fails, or nonzero if it succeeds. */
 250
 251 #define SYMBOL_MATCHES_NAME(symbol, name)                               \
 252   (STREQ (SYMBOL_NAME (symbol), (name))                                 \
 253    || (SYMBOL_DEMANGLED_NAME (symbol) != NULL                           \
 254        && strcmp_iw (SYMBOL_DEMANGLED_NAME (symbol), (name)) == 0))
 255
 256 /* Macro that tests a symbol for an re-match against the last compiled regular
 257    expression.  First test the unencoded name, then look for and test a C++
 258    encoded name if it exists.
 259    Evaluates to zero if the match fails, or nonzero if it succeeds. */
 260
 261 #define SYMBOL_MATCHES_REGEXP(symbol)                                   \
 262   (re_exec (SYMBOL_NAME (symbol)) != 0                                  \
 263    || (SYMBOL_DEMANGLED_NAME (symbol) != NULL                           \
 264        && re_exec (SYMBOL_DEMANGLED_NAME (symbol)) != 0))
 265
 266 /* Define a simple structure used to hold some very basic information about
 267    all defined global symbols (text, data, bss, abs, etc).  The only required
 268    information is the general_symbol_info.
 269
 270    In many cases, even if a file was compiled with no special options for
 271    debugging at all, as long as was not stripped it will contain sufficient
 272    information to build a useful minimal symbol table using this structure.
 273    Even when a file contains enough debugging information to build a full
 274    symbol table, these minimal symbols are still useful for quickly mapping
 275    between names and addresses, and vice versa.  They are also sometimes
 276    used to figure out what full symbol table entries need to be read in. */
 277
 278 struct minimal_symbol
 279 {
 280
 281   /* The general symbol info required for all types of symbols. */
 282
 283   struct general_symbol_info ginfo;
 284
 285   /* The info field is available for caching machine-specific information that
 286      The AMD 29000 tdep.c uses it to remember things it has decoded from the
 287      instructions in the function header, so it doesn't have to rederive the
 288      info constantly (over a serial line).  It is initialized to zero and
 289      stays that way until target-dependent code sets it.  Storage for any data
 290      pointed to by this field should be allocated on the symbol_obstack for
 291      the associated objfile.  The type would be "void *" except for reasons
 292      of compatibility with older compilers.  This field is optional. */
 293
 294   char *info;
 295
 296   /* Classification types for this symbol.  These should be taken as "advisory
 297      only", since if gdb can't easily figure out a classification it simply
 298      selects mst_unknown.  It may also have to guess when it can't figure out
 299      which is a better match between two types (mst_data versus mst_bss) for
 300      example.  Since the minimal symbol info is sometimes derived from the
 301      BFD library's view of a file, we need to live with what information bfd
 302      supplies. */
 303
 304   enum minimal_symbol_type
 305     {
 306       mst_unknown = 0,          /* Unknown type, the default */
 307       mst_text,                 /* Generally executable instructions */
 308       mst_data,                 /* Generally initialized data */
 309       mst_bss,                  /* Generally uninitialized data */
 310       mst_abs                   /* Generally absolute (nonrelocatable) */
 311     } type;
 312
 313 };
 314
 315 #define MSYMBOL_INFO(msymbol)           (msymbol)->info
 316 #define MSYMBOL_TYPE(msymbol)           (msymbol)->type
 317
 318 \f
 319 /* All of the name-scope contours of the program
 320    are represented by `struct block' objects.
 321    All of these objects are pointed to by the blockvector.
 322
 323    Each block represents one name scope.
 324    Each lexical context has its own block.
 325
 326    The first two blocks in the blockvector are special.
 327    The first one contains all the symbols defined in this compilation
 328    whose scope is the entire program linked together.
 329    The second one contains all the symbols whose scope is the
 330    entire compilation excluding other separate compilations.
 331    In C, these correspond to global symbols and static symbols.
 332
 333    Each block records a range of core addresses for the code that
 334    is in the scope of the block.  The first two special blocks
 335    give, for the range of code, the entire range of code produced
 336    by the compilation that the symbol segment belongs to.
 337
 338    The blocks appear in the blockvector
 339    in order of increasing starting-address,
 340    and, within that, in order of decreasing ending-address.
 341
 342    This implies that within the body of one function
 343    the blocks appear in the order of a depth-first tree walk.  */
 344
 345 struct blockvector
 346 {
 347   /* Number of blocks in the list.  */
 348   int nblocks;
 349   /* The blocks themselves.  */
 350   struct block *block[1];
 351 };
 352
 353 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
 354 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
 355
 356 /* Special block numbers */
 357
 358 #define GLOBAL_BLOCK            0
 359 #define STATIC_BLOCK            1
 360 #define FIRST_LOCAL_BLOCK       2
 361
 362 struct block
 363 {
 364
 365   /* Addresses in the executable code that are in this block.
 366      Note: in an unrelocated symbol segment in a file,
 367      these are always zero.  They can be filled in from the
 368      N_LBRAC and N_RBRAC symbols in the loader symbol table.  */
 369
 370   CORE_ADDR startaddr;
 371   CORE_ADDR endaddr;
 372
 373   /* The symbol that names this block,
 374      if the block is the body of a function;
 375      otherwise, zero.
 376      Note: In an unrelocated symbol segment in an object file,
 377      this field may be zero even when the block has a name.
 378      That is because the block is output before the name
 379      (since the name resides in a higher block).
 380      Since the symbol does point to the block (as its value),
 381      it is possible to find the block and set its name properly.  */
 382
 383   struct symbol *function;
 384
 385   /* The `struct block' for the containing block, or 0 if none.
 386      Note that in an unrelocated symbol segment in an object file
 387      this pointer may be zero when the correct value should be
 388      the second special block (for symbols whose scope is one compilation).
 389      This is because the compiler outputs the special blocks at the
 390      very end, after the other blocks.   */
 391
 392   struct block *superblock;
 393
 394   /* A flag indicating whether or not the function corresponding
 395      to this block was compiled with gcc or not.  If there is no
 396      function corresponding to this block, this meaning of this flag
 397      is undefined.  (In practice it will be 1 if the block was created
 398      while processing a file compiled with gcc and 0 when not). */
 399
 400   unsigned char gcc_compile_flag;
 401
 402   /* Number of local symbols.  */
 403
 404   int nsyms;
 405
 406   /* The symbols.  */
 407
 408   struct symbol *sym[1];
 409 };
 410
 411 #define BLOCK_START(bl)         (bl)->startaddr
 412 #define BLOCK_END(bl)           (bl)->endaddr
 413 #define BLOCK_NSYMS(bl)         (bl)->nsyms
 414 #define BLOCK_SYM(bl, n)        (bl)->sym[n]
 415 #define BLOCK_FUNCTION(bl)      (bl)->function
 416 #define BLOCK_SUPERBLOCK(bl)    (bl)->superblock
 417 #define BLOCK_GCC_COMPILED(bl)  (bl)->gcc_compile_flag
 418
 419 /* Nonzero if symbols of block BL should be sorted alphabetically.  */
 420
 421 #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40)
 422
 423 \f
 424 /* Represent one symbol name; a variable, constant, function or typedef.  */
 425
 426 /* For a non-global symbol allocated statically,
 427    the correct core address cannot be determined by the compiler.
 428    The compiler puts an index number into the symbol's value field.
 429    This index number can be matched with the "desc" field of
 430    an entry in the loader symbol table.  */
 431
 432 /* Different name spaces for symbols.  Looking up a symbol specifies a
 433    namespace and ignores symbol definitions in other name spaces. */
 434
 435 enum namespace
 436 {
 437   /* UNDEF_NAMESPACE is used when a namespace has not been discovered or
 438      none of the following apply.  This usually indicates an error either
 439      in the symbol information or in gdb's handling of symbols. */
 440
 441   UNDEF_NAMESPACE,
 442
 443   /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
 444      function names, typedef names and enum type values. */
 445
 446   VAR_NAMESPACE,
 447
 448   /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
 449      Thus, if `struct foo' is used in a C program, it produces a symbol named
 450      `foo' in the STRUCT_NAMESPACE. */
 451
 452   STRUCT_NAMESPACE,
 453
 454   /* LABEL_NAMESPACE may be used for names of labels (for gotos);
 455      currently it is not used and labels are not recorded at all.  */
 456
 457   LABEL_NAMESPACE
 458 };
 459
 460 /* An address-class says where to find the value of a symbol.  */
 461
 462 enum address_class
 463 {
 464   /* Not used; catches errors */
 465
 466   LOC_UNDEF,
 467
 468   /* Value is constant int SYMBOL_VALUE, host byteorder */
 469
 470   LOC_CONST,
 471
 472   /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 473
 474   LOC_STATIC,
 475
 476   /* Value is in register */
 477
 478   LOC_REGISTER,
 479
 480   /* Value is at spec'd offset in arglist */
 481
 482   LOC_ARG,
 483
 484   /* Value address is at spec'd offset in arglist. */
 485
 486   LOC_REF_ARG,
 487
 488   /* Value is at spec'd offset in register window */
 489
 490   LOC_REGPARM,
 491
 492   /* Value is at spec'd offset in stack frame */
 493
 494   LOC_LOCAL,
 495
 496   /* Value not used; definition in SYMBOL_TYPE.  Symbols in the namespace
 497      STRUCT_NAMESPACE all have this class.  */
 498
 499   LOC_TYPEDEF,
 500
 501   /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 502
 503   LOC_LABEL,
 504
 505   /* Value is address SYMBOL_VALUE_BLOCK of a `struct block'.  Function names
 506      have this class. */
 507
 508   LOC_BLOCK,
 509
 510   /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_ADDRESS, in
 511      target byte order.  */
 512
 513   LOC_CONST_BYTES,
 514
 515   /* Value is arg at spec'd offset in stack frame. Differs from LOC_LOCAL in
 516      that symbol is an argument; differs from LOC_ARG in that we find it
 517      in the frame (FRAME_LOCALS_ADDRESS), not in the arglist
 518      (FRAME_ARGS_ADDRESS).  Added for i960, which passes args in regs then
 519      copies to frame.  */
 520
 521   LOC_LOCAL_ARG
 522
 523 };
 524
 525 struct symbol
 526 {
 527
 528   /* The general symbol info required for all types of symbols. */
 529
 530   struct general_symbol_info ginfo;
 531
 532   /* Name space code.  */
 533
 534   enum namespace namespace;
 535
 536   /* Address class */
 537
 538   enum address_class class;
 539
 540   /* Data type of value */
 541
 542   struct type *type;
 543
 544   /* Line number of definition.  FIXME:  Should we really make the assumption
 545      that nobody will try to debug files longer than 64K lines?  What about
 546      machine generated programs? */
 547
 548   unsigned short line;
 549
 550   /* Some symbols require an additional value to be recorded on a per-
 551      symbol basis.  Stash those values here. */
 552
 553   union
 554     {
 555       /* for OP_BASEREG in DWARF location specs */
 556       struct
 557         {
 558           short regno_valid;    /* 0 == regno invalid; !0 == regno valid */
 559           short regno;          /* base register number {0, 1, 2, ...} */
 560         } basereg;
 561     }
 562   aux_value;
 563
 564 };
 565
 566 #define SYMBOL_NAMESPACE(symbol)        (symbol)->namespace
 567 #define SYMBOL_CLASS(symbol)            (symbol)->class
 568 #define SYMBOL_TYPE(symbol)             (symbol)->type
 569 #define SYMBOL_LINE(symbol)             (symbol)->line
 570 #define SYMBOL_BASEREG(symbol)          (symbol)->aux_value.basereg.regno
 571
 572 /* This currently fails because some symbols are not being initialized
 573    to zero on allocation, and no code is currently setting this value.
 574    Basereg handling will probably change significantly in the next release.
 575    FIXME -fnf */
 576
 577 #if 0
 578 #define SYMBOL_BASEREG_VALID(symbol) (symbol)->aux_value.basereg.regno_valid
 579 #else
 580 #define SYMBOL_BASEREG_VALID(symbol) 0
 581 #endif
 582
 583 \f
 584 /* A partial_symbol records the name, namespace, and address class of
 585    symbols whose types we have not parsed yet.  For functions, it also
 586    contains their memory address, so we can find them from a PC value.
 587    Each partial_symbol sits in a partial_symtab, all of which are chained
 588    on a  partial symtab list and which points to the corresponding
 589    normal symtab once the partial_symtab has been referenced.  */
 590
 591 struct partial_symbol
 592 {
 593
 594   /* The general symbol info required for all types of symbols. */
 595
 596   struct general_symbol_info ginfo;
 597
 598   /* Name space code.  */
 599
 600   enum namespace namespace;
 601
 602   /* Address class (for info_symbols) */
 603
 604   enum address_class class;
 605
 606 };
 607
 608 #define PSYMBOL_NAMESPACE(psymbol)      (psymbol)->namespace
 609 #define PSYMBOL_CLASS(psymbol)          (psymbol)->class
 610
 611 \f
 612 /* Source-file information.  This describes the relation between source files,
 613    ine numbers and addresses in the program text.  */
 614
 615 struct sourcevector
 616 {
 617   int length;                   /* Number of source files described */
 618   struct source *source[1];     /* Descriptions of the files */
 619 };
 620
 621 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 622    somewhat more wasteful of space than one might wish, but since only
 623    the files which are actually debugged are read in to core, we don't
 624    waste much space.  */
 625
 626 struct linetable_entry
 627 {
 628   int line;
 629   CORE_ADDR pc;
 630 };
 631
 632 struct linetable
 633 {
 634   int nitems;
 635   struct linetable_entry item[1];
 636 };
 637
 638 /* All the information on one source file.  */
 639
 640 struct source
 641 {
 642   char *name;                   /* Name of file */
 643   struct linetable contents;
 644 };
 645
 646 /* How to relocate the symbols from each section in a symbol file.
 647    Each struct contains an array of offsets.
 648    The ordering and meaning of the offsets is file-type-dependent;
 649    typically it is indexed by section numbers or symbol types or
 650    something like that.
 651
 652    To give us flexibility in changing the internal representation
 653    of these offsets, the ANOFFSET macro must be used to insert and
 654    extract offset values in the struct.  */
 655
 656 struct section_offsets
 657   {
 658     CORE_ADDR offsets[1];               /* As many as needed. */
 659   };
 660
 661 #define ANOFFSET(secoff, whichone)      (secoff->offsets[whichone])
 662
 663 /* Each source file is represented by a struct symtab.
 664    These objects are chained through the `next' field.  */
 665
 666 struct symtab
 667   {
 668
 669     /* Chain of all existing symtabs.  */
 670
 671     struct symtab *next;
 672
 673     /* List of all symbol scope blocks for this symtab.  */
 674
 675     struct blockvector *blockvector;
 676
 677     /* Table mapping core addresses to line numbers for this file.
 678        Can be NULL if none.  */
 679
 680     struct linetable *linetable;
 681
 682     /* Name of this source file.  */
 683
 684     char *filename;
 685
 686     /* Directory in which it was compiled, or NULL if we don't know.  */
 687
 688     char *dirname;
 689
 690     /* This component says how to free the data we point to:
 691        free_contents => do a tree walk and free each object.
 692        free_nothing => do nothing; some other symtab will free
 693          the data this one uses.
 694       free_linetable => free just the linetable.  */
 695
 696     enum free_code
 697       {
 698         free_nothing, free_contents, free_linetable
 699         }
 700     free_code;
 701
 702     /* Pointer to one block of storage to be freed, if nonzero.  */
 703     /* This is IN ADDITION to the action indicated by free_code.  */
 704
 705     char *free_ptr;
 706
 707     /* Total number of lines found in source file.  */
 708
 709     int nlines;
 710
 711     /* Array mapping line number to character position.  */
 712
 713     int *line_charpos;
 714
 715     /* Language of this source file.  */
 716
 717     enum language language;
 718
 719     /* String of version information.  May be zero.  */
 720
 721     char *version;
 722
 723     /* Full name of file as found by searching the source path.
 724        NULL if not yet known.  */
 725
 726     char *fullname;
 727
 728     /* Object file from which this symbol information was read.  */
 729
 730     struct objfile *objfile;
 731
 732     /* Anything extra for this symtab.  This is for target machines
 733        with special debugging info of some sort (which cannot just
 734        be represented in a normal symtab).  */
 735
 736 #if defined (EXTRA_SYMTAB_INFO)
 737     EXTRA_SYMTAB_INFO
 738 #endif
 739
 740   };
 741
 742 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 743 #define LINETABLE(symtab)       (symtab)->linetable
 744
 745 \f
 746 /* Each source file that has not been fully read in is represented by
 747    a partial_symtab.  This contains the information on where in the
 748    executable the debugging symbols for a specific file are, and a
 749    list of names of global symbols which are located in this file.
 750    They are all chained on partial symtab lists.
 751
 752    Even after the source file has been read into a symtab, the
 753    partial_symtab remains around.  They are allocated on an obstack,
 754    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 755    style execution of a bunch of .o's.  */
 756
 757 struct partial_symtab
 758 {
 759
 760   /* Chain of all existing partial symtabs.  */
 761
 762   struct partial_symtab *next;
 763
 764   /* Name of the source file which this partial_symtab defines */
 765
 766   char *filename;
 767
 768   /* Information about the object file from which symbols should be read.  */
 769
 770   struct objfile *objfile;
 771
 772   /* Set of relocation offsets to apply to each section.  */
 773
 774   struct section_offsets *section_offsets;
 775
 776   /* Range of text addresses covered by this file; texthigh is the
 777      beginning of the next section. */
 778
 779   CORE_ADDR textlow;
 780   CORE_ADDR texthigh;
 781
 782   /* Array of pointers to all of the partial_symtab's which this one
 783      depends on.  Since this array can only be set to previous or
 784      the current (?) psymtab, this dependency tree is guaranteed not
 785      to have any loops. */
 786
 787   struct partial_symtab **dependencies;
 788
 789   int number_of_dependencies;
 790
 791   /* Global symbol list.  This list will be sorted after readin to
 792      improve access.  Binary search will be the usual method of
 793      finding a symbol within it. globals_offset is an integer offset
 794      within global_psymbols[].  */
 795
 796   int globals_offset;
 797   int n_global_syms;
 798
 799   /* Static symbol list.  This list will *not* be sorted after readin;
 800      to find a symbol in it, exhaustive search must be used.  This is
 801      reasonable because searches through this list will eventually
 802      lead to either the read in of a files symbols for real (assumed
 803      to take a *lot* of time; check) or an error (and we don't care
 804      how long errors take).  This is an offset and size within
 805      static_psymbols[].  */
 806
 807   int statics_offset;
 808   int n_static_syms;
 809
 810   /* Pointer to symtab eventually allocated for this source file, 0 if
 811      !readin or if we haven't looked for the symtab after it was readin.  */
 812
 813   struct symtab *symtab;
 814
 815   /* Pointer to function which will read in the symtab corresponding to
 816      this psymtab.  */
 817
 818   void (*read_symtab) PARAMS ((struct partial_symtab *));
 819
 820   /* Information that lets read_symtab() locate the part of the symbol table
 821      that this psymtab corresponds to.  This information is private to the
 822      format-dependent symbol reading routines.  For further detail examine
 823      the various symbol reading modules.  Should really be (void *) but is
 824      (char *) as with other such gdb variables.  (FIXME) */
 825
 826   char *read_symtab_private;
 827
 828   /* Non-zero if the symtab corresponding to this psymtab has been readin */
 829
 830   unsigned char readin;
 831 };
 832
 833 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 834 #define PSYMTAB_TO_SYMTAB(pst)  \
 835     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
 836
 837 \f
 838 /* The virtual function table is now an array of structures which have the
 839    form { int16 offset, delta; void *pfn; }.
 840
 841    In normal virtual function tables, OFFSET is unused.
 842    DELTA is the amount which is added to the apparent object's base
 843    address in order to point to the actual object to which the
 844    virtual function should be applied.
 845    PFN is a pointer to the virtual function.  */
 846
 847 #define VTBL_FNADDR_OFFSET 2
 848
 849 /* Macro that yields non-zero value iff NAME is the prefix for C++ operator
 850    names.  If you leave out the parenthesis here you will lose!
 851    Currently 'o' 'p' CPLUS_MARKER is used for both the symbol in the
 852    symbol-file and the names in gdb's symbol table.  */
 853
 854 #define OPNAME_PREFIX_P(NAME) \
 855   ((NAME)[0] == 'o' && (NAME)[1] == 'p' && (NAME)[2] == CPLUS_MARKER)
 856
 857 #define VTBL_PREFIX_P(NAME) \
 858   ((NAME)[3] == CPLUS_MARKER && !strncmp ((NAME), "_vt", 3))
 859
 860 \f
 861 /* External variables and functions for the objects described above. */
 862
 863 /* This symtab variable specifies the current file for printing source lines */
 864
 865 extern struct symtab *current_source_symtab;
 866
 867 /* This is the next line to print for listing source lines.  */
 868
 869 extern int current_source_line;
 870
 871 /* See the comment in symfile.c about how current_objfile is used. */
 872
 873 extern struct objfile *current_objfile;
 874
 875 extern struct symtab *
 876 lookup_symtab PARAMS ((char *));
 877
 878 extern struct symbol *
 879 lookup_symbol PARAMS ((const char *, const struct block *,
 880                        const enum namespace, int *, struct symtab **));
 881
 882 extern struct symbol *
 883 lookup_block_symbol PARAMS ((const struct block *, const char *,
 884                              const enum namespace));
 885
 886 extern struct type *
 887 lookup_struct PARAMS ((char *, struct block *));
 888
 889 extern struct type *
 890 lookup_union PARAMS ((char *, struct block *));
 891
 892 extern struct type *
 893 lookup_enum PARAMS ((char *, struct block *));
 894
 895 extern struct symbol *
 896 block_function PARAMS ((struct block *));
 897
 898 extern struct symbol *
 899 find_pc_function PARAMS ((CORE_ADDR));
 900
 901 extern int
 902 find_pc_partial_function PARAMS ((CORE_ADDR, char **, CORE_ADDR *));
 903
 904 extern void
 905 clear_pc_function_cache PARAMS ((void));
 906
 907 extern struct partial_symtab *
 908 lookup_partial_symtab PARAMS ((char *));
 909
 910 extern struct partial_symtab *
 911 find_pc_psymtab PARAMS ((CORE_ADDR));
 912
 913 extern struct symtab *
 914 find_pc_symtab PARAMS ((CORE_ADDR));
 915
 916 extern struct partial_symbol *
 917 find_pc_psymbol PARAMS ((struct partial_symtab *, CORE_ADDR));
 918
 919 extern int
 920 find_pc_line_pc_range PARAMS ((CORE_ADDR, CORE_ADDR *, CORE_ADDR *));
 921
 922 extern int
 923 contained_in PARAMS ((struct block *, struct block *));
 924
 925 extern void
 926 reread_symbols PARAMS ((void));
 927
 928 /* Functions for dealing with the minimal symbol table, really a misc
 929    address<->symbol mapping for things we don't have debug symbols for.  */
 930
 931 extern void
 932 prim_record_minimal_symbol PARAMS ((const char *, CORE_ADDR,
 933                                     enum minimal_symbol_type));
 934
 935 extern void
 936 prim_record_minimal_symbol_and_info PARAMS ((const char *, CORE_ADDR,
 937                                              enum minimal_symbol_type,
 938                                              char *info));
 939
 940 extern struct minimal_symbol *
 941 lookup_minimal_symbol PARAMS ((const char *, struct objfile *));
 942
 943 extern struct minimal_symbol *
 944 lookup_minimal_symbol_by_pc PARAMS ((CORE_ADDR));
 945
 946 extern void
 947 init_minimal_symbol_collection PARAMS ((void));
 948
 949 extern void
 950 discard_minimal_symbols PARAMS ((int));
 951
 952 extern void
 953 install_minimal_symbols PARAMS ((struct objfile *));
 954
 955 struct symtab_and_line
 956 {
 957   struct symtab *symtab;
 958   int line;
 959   CORE_ADDR pc;
 960   CORE_ADDR end;
 961 };
 962
 963 struct symtabs_and_lines
 964 {
 965   struct symtab_and_line *sals;
 966   int nelts;
 967 };
 968
 969 /* Given a pc value, return line number it is in.  Second arg nonzero means
 970    if pc is on the boundary use the previous statement's line number.  */
 971
 972 extern struct symtab_and_line
 973 find_pc_line PARAMS ((CORE_ADDR, int));
 974
 975 /* Given a symtab and line number, return the pc there.  */
 976
 977 extern CORE_ADDR
 978 find_line_pc PARAMS ((struct symtab *, int));
 979
 980 extern int
 981 find_line_pc_range PARAMS ((struct symtab *, int, CORE_ADDR *, CORE_ADDR *));
 982
 983 extern void
 984 resolve_sal_pc PARAMS ((struct symtab_and_line *));
 985
 986 /* Given a string, return the line specified by it.  For commands like "list"
 987    and "breakpoint".  */
 988
 989 extern struct symtabs_and_lines
 990 decode_line_spec PARAMS ((char *, int));
 991
 992 extern struct symtabs_and_lines
 993 decode_line_spec_1 PARAMS ((char *, int));
 994
 995 extern struct symtabs_and_lines
 996 decode_line_1 PARAMS ((char **, int, struct symtab *, int));
 997
 998 /* Symmisc.c */
 999
1000 #if MAINTENANCE_CMDS
1001
1002 void
1003 maintenance_print_symbols PARAMS ((char *, int));
1004
1005 void
1006 maintenance_print_psymbols PARAMS ((char *, int));
1007
1008 void
1009 maintenance_print_msymbols PARAMS ((char *, int));
1010
1011 void
1012 maintenance_print_objfiles PARAMS ((char *, int));
1013
1014 #endif
1015
1016 extern void
1017 free_symtab PARAMS ((struct symtab *));
1018
1019 /* Symbol-reading stuff in symfile.c and solib.c.  */
1020
1021 extern struct symtab *
1022 psymtab_to_symtab PARAMS ((struct partial_symtab *));
1023
1024 extern void
1025 clear_solib PARAMS ((void));
1026
1027 extern struct objfile *
1028 symbol_file_add PARAMS ((char *, int, CORE_ADDR, int, int, int));
1029
1030 /* source.c */
1031
1032 extern int
1033 identify_source_line PARAMS ((struct symtab *, int, int));
1034
1035 extern void
1036 print_source_lines PARAMS ((struct symtab *, int, int, int));
1037
1038 extern void
1039 forget_cached_source_info PARAMS ((void));
1040
1041 extern void
1042 select_source_symtab PARAMS ((struct symtab *));
1043
1044 extern char **
1045 make_symbol_completion_list PARAMS ((char *));
1046
1047 /* symtab.c */
1048
1049 extern void
1050 clear_symtab_users_once PARAMS ((void));
1051
1052 extern struct partial_symtab *
1053 find_main_psymtab PARAMS ((void));
1054
1055 /* blockframe.c */
1056
1057 extern struct blockvector *
1058 blockvector_for_pc PARAMS ((CORE_ADDR, int *));
1059
1060 /* symfile.c */
1061
1062 extern enum language
1063 deduce_language_from_filename PARAMS ((char *));
1064
1065 #endif /* !defined(SYMTAB_H) */