gdb/symtab.h

   1 /* Symbol table definitions for GDB.
   2    Copyright (C) 1986, 1989, 1991 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 /* An obstack to hold objects that should be freed
  25    when we load a new symbol table.
  26    This includes the symbols made by dbxread
  27    and the types that are not permanent.  */
  28
  29 extern struct obstack *symbol_obstack;
  30 extern struct obstack *psymbol_obstack;
  31
  32 /* Some definitions and declarations to go with use of obstacks.  */
  33 #define obstack_chunk_alloc xmalloc
  34 #define obstack_chunk_free free
  35
  36 /* Some macros for char-based bitfields.  */
  37 #define B_SET(a,x) (a[x>>3] |= (1 << (x&7)))
  38 #define B_CLR(a,x) (a[x>>3] &= ~(1 << (x&7)))
  39 #define B_TST(a,x) (a[x>>3] & (1 << (x&7)))
  40 #define B_TYPE          unsigned char
  41 #define B_BYTES(x)      ( 1 + ((x)>>3) )
  42 #define B_CLRALL(a,x) bzero (a, B_BYTES(x))
  43
  44 /* gdb can know one or several symbol tables at the same time;
  45    the ultimate intent is to have one for each separately-compiled module.
  46    Each such symbol table is recorded by a struct symtab, and they
  47    are all chained together.  */
  48
  49 /* In addition, gdb can record any number of miscellaneous undebuggable
  50    functions' addresses.  In a system that appends _ to function names,
  51    the _'s are removed from the names stored in this table.  */
  52
  53 /* Actually, the misc function list is used to store *all* of the
  54    global symbols (text, data, bss, and abs).  It is sometimes used
  55    to figure out what symtabs to read in.  The "type" field is used
  56    occasionally.  Calling it the misc "function" vector is now a misnomer.
  57
  58    The misc_info field is available for machine-specific information
  59    that can be cached along with a misc function vector entry.  The
  60    AMD 29000 tdep.c uses it to remember things it has decoded from the
  61    instructions in the function header, so it doesn't have to rederive
  62    the info constantly (over a serial line).  It is initialized to zero
  63    and stays that way until target-dependent code sets it.  */
  64
  65 enum misc_function_type {mf_unknown = 0, mf_text, mf_data, mf_bss, mf_abs};
  66
  67 struct misc_function
  68 {
  69   char *name;
  70   CORE_ADDR address;
  71   char *misc_info;      /* Random pointer to misc info.  void * but for old C */
  72   enum misc_function_type type;
  73 };
  74
  75 /* Address and length of the vector recording all misc function names/addresses.  */
  76
  77 struct misc_function *misc_function_vector;
  78 int misc_function_count;
  79 \f
  80 /* Different kinds of data types are distinguished by the `code' field.  */
  81
  82 enum type_code
  83 {
  84   TYPE_CODE_UNDEF,              /* Not used; catches errors */
  85   TYPE_CODE_PTR,                /* Pointer type */
  86   TYPE_CODE_ARRAY,              /* Array type, lower bound zero */
  87   TYPE_CODE_STRUCT,             /* C struct or Pascal record */
  88   TYPE_CODE_UNION,              /* C union or Pascal variant part */
  89   TYPE_CODE_ENUM,               /* Enumeration type */
  90   TYPE_CODE_FUNC,               /* Function type */
  91   TYPE_CODE_INT,                /* Integer type */
  92   TYPE_CODE_FLT,                /* Floating type */
  93   TYPE_CODE_VOID,               /* Void type (values zero length) */
  94   TYPE_CODE_SET,                /* Pascal sets */
  95   TYPE_CODE_RANGE,              /* Range (integers within spec'd bounds) */
  96   TYPE_CODE_PASCAL_ARRAY,       /* Array with explicit type of index */
  97   TYPE_CODE_ERROR,              /* Unknown type */
  98
  99   /* C++ */
 100   TYPE_CODE_MEMBER,             /* Member type */
 101   TYPE_CODE_METHOD,             /* Method type */
 102   TYPE_CODE_REF,                /* C++ Reference types */
 103
 104   /* Modula-2 */
 105   TYPE_CODE_CHAR,               /* *real* character type */
 106   TYPE_CODE_BOOL                /* Builtin Modula-2 BOOLEAN */
 107 };
 108
 109 /* This appears in a type's flags word for an unsigned integer type.  */
 110 #define TYPE_FLAG_UNSIGNED 1
 111 /* This appears in a type's flags word
 112    if it is a (pointer to a|function returning a)* built in scalar type.
 113    These types are never freed.  */
 114 #define TYPE_FLAG_PERM 4
 115 /* This appears in a type's flags word if it is a stub type (eg. if
 116    someone referenced a type that wasn't definined in a source file
 117    via (struct sir_not_appearing_in_this_film *)).  */
 118 #define TYPE_FLAG_STUB 8
 119
 120 struct type
 121 {
 122   /* Code for kind of type */
 123   enum type_code code;
 124   /* Name of this type, or zero if none.
 125      This is used for printing only, except by poorly designed C++ code.
 126      Type names specified as input are defined by symbols.  */
 127   char *name;
 128   /* Length in bytes of storage for a value of this type */
 129   unsigned length;
 130   /* For a pointer type, describes the type of object pointed to.
 131      For an array type, describes the type of the elements.
 132      For a function or method type, describes the type of the value.
 133      For a range type, describes the type of the full range.
 134      Unused otherwise.  */
 135   struct type *target_type;
 136
 137   /* Type that is a pointer to this type.
 138      Zero if no such pointer-to type is known yet.
 139      The debugger may add the address of such a type
 140      if it has to construct one later.  */
 141   struct type *pointer_type;
 142   /* C++: also need a reference type.  */
 143   struct type *reference_type;
 144   /* Type that is a function returning this type.
 145      Zero if no such function type is known here.
 146      The debugger may add the address of such a type
 147      if it has to construct one later.  */
 148   struct type *function_type;
 149
 150   /* Flags about this type.  */
 151   short flags;
 152   /* Number of fields described for this type */
 153   short nfields;
 154   /* For structure and union types, a description of each field.
 155      For set and pascal array types, there is one "field",
 156      whose type is the domain type of the set or array.
 157      For range types, there are two "fields",
 158      the minimum and maximum values (both inclusive).
 159      For enum types, each possible value is described by one "field".
 160
 161      Using a pointer to a separate array of fields
 162      allows all types to have the same size, which is useful
 163      because we can allocate the space for a type before
 164      we know what to put in it.  */
 165   struct field
 166     {
 167       /* Position of this field, counting in bits from start of
 168          containing structure.  For a function type, this is the
 169          position in the argument list of this argument.
 170          For a range bound or enum value, this is the value itself.  */
 171       int bitpos;
 172       /* Size of this field, in bits, or zero if not packed.
 173          For an unpacked field, the field's type's length
 174          says how many bytes the field occupies.  */
 175       int bitsize;
 176       /* In a struct or enum type, type of this field.
 177          In a function type, type of this argument.
 178          In an array type, the domain-type of the array.  */
 179       struct type *type;
 180       /* Name of field, value or argument.
 181          Zero for range bounds and array domains.  */
 182       char *name;
 183     } *fields;
 184
 185   /* For types with virtual functions, VPTR_BASETYPE is the base class which
 186      defined the virtual function table pointer.  VPTR_FIELDNO is
 187      the field number of that pointer in the structure.
 188
 189      For types that are pointer to member types, VPTR_BASETYPE
 190      is the type that this pointer is a member of.
 191
 192      Unused otherwise.  */
 193   struct type *vptr_basetype;
 194
 195   int vptr_fieldno;
 196
 197   /* Slot to point to additional language-specific fields of this type.  */
 198   union type_specific
 199     {
 200       /* ARG_TYPES is for TYPE_CODE_METHOD and TYPE_CODE_FUNCTION.  */
 201       struct type **arg_types;
 202       /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  */
 203       struct cplus_struct_type *cplus_stuff;
 204     } type_specific;
 205 };
 206
 207 /* C++ language-specific information for TYPE_CODE_STRUCT and TYPE_CODE_UNION
 208    nodes.  */
 209 struct cplus_struct_type
 210 {
 211   B_TYPE *virtual_field_bits; /* if base class is virtual */
 212   B_TYPE *private_field_bits;
 213   B_TYPE *protected_field_bits;
 214
 215   /* Number of methods described for this type */
 216   short nfn_fields;
 217   /* Number of base classes this type derives from. */
 218   short n_baseclasses;
 219
 220   /* Number of methods described for this type plus all the
 221      methods that it derives from.  */
 222   int nfn_fields_total;
 223
 224   /* For classes, structures, and unions, a description of each field,
 225      which consists of an overloaded name, followed by the types of
 226      arguments that the method expects, and then the name after it
 227      has been renamed to make it distinct.  */
 228   struct fn_fieldlist
 229     {
 230       /* The overloaded name.  */
 231       char *name;
 232       /* The number of methods with this name.  */
 233       int length;
 234       /* The list of methods.  */
 235       struct fn_field
 236         {
 237           /* The return value of the method */
 238           struct type *type;
 239           /* The argument list */
 240           struct type **args;
 241           /* The name after it has been processed */
 242           char *physname;
 243
 244           /* For virtual functions.   */
 245           /* First baseclass that defines this virtual function.   */
 246           struct type *fcontext;
 247           unsigned int is_const : 1;
 248           unsigned int is_volatile : 1;
 249           unsigned int is_private : 1;
 250           unsigned int is_protected : 1;
 251           unsigned int is_stub : 1;
 252           unsigned int dummy : 3;
 253
 254           /* Index into that baseclass's virtual function table,
 255              minus 2; else if static: VOFFSET_STATIC; else: 0.  */
 256           unsigned voffset : 24;
 257 #         define VOFFSET_STATIC 1
 258         } *fn_fields;
 259
 260     } *fn_fieldlists;
 261
 262   unsigned char via_protected;
 263   unsigned char via_public;
 264 };
 265 \f
 266 /* All of the name-scope contours of the program
 267    are represented by `struct block' objects.
 268    All of these objects are pointed to by the blockvector.
 269
 270    Each block represents one name scope.
 271    Each lexical context has its own block.
 272
 273    The first two blocks in the blockvector are special.
 274    The first one contains all the symbols defined in this compilation
 275    whose scope is the entire program linked together.
 276    The second one contains all the symbols whose scope is the
 277    entire compilation excluding other separate compilations.
 278    In C, these correspond to global symbols and static symbols.
 279
 280    Each block records a range of core addresses for the code that
 281    is in the scope of the block.  The first two special blocks
 282    give, for the range of code, the entire range of code produced
 283    by the compilation that the symbol segment belongs to.
 284
 285    The blocks appear in the blockvector
 286    in order of increasing starting-address,
 287    and, within that, in order of decreasing ending-address.
 288
 289    This implies that within the body of one function
 290    the blocks appear in the order of a depth-first tree walk.  */
 291
 292 struct blockvector
 293 {
 294   /* Number of blocks in the list.  */
 295   int nblocks;
 296   /* The blocks themselves.  */
 297   struct block *block[1];
 298 };
 299
 300 /* Special block numbers */
 301 #define GLOBAL_BLOCK    0
 302 #define STATIC_BLOCK    1
 303 #define FIRST_LOCAL_BLOCK       2
 304
 305 struct block
 306 {
 307   /* Addresses in the executable code that are in this block.
 308      Note: in an unrelocated symbol segment in a file,
 309      these are always zero.  They can be filled in from the
 310      N_LBRAC and N_RBRAC symbols in the loader symbol table.  */
 311   CORE_ADDR startaddr, endaddr;
 312   /* The symbol that names this block,
 313      if the block is the body of a function;
 314      otherwise, zero.
 315      Note: In an unrelocated symbol segment in an object file,
 316      this field may be zero even when the block has a name.
 317      That is because the block is output before the name
 318      (since the name resides in a higher block).
 319      Since the symbol does point to the block (as its value),
 320      it is possible to find the block and set its name properly.  */
 321   struct symbol *function;
 322   /* The `struct block' for the containing block, or 0 if none.  */
 323   /* Note that in an unrelocated symbol segment in an object file
 324      this pointer may be zero when the correct value should be
 325      the second special block (for symbols whose scope is one compilation).
 326      This is because the compiler ouptuts the special blocks at the
 327      very end, after the other blocks.   */
 328   struct block *superblock;
 329   /* A flag indicating whether or not the fucntion corresponding
 330      to this block was compiled with gcc or not.  If there is no
 331      function corresponding to this block, this meaning of this flag
 332      is undefined.  (In practice it will be 1 if the block was created
 333      while processing a file compiled with gcc and 0 when not). */
 334   unsigned char gcc_compile_flag;
 335   /* Number of local symbols.  */
 336   int nsyms;
 337   /* The symbols.  */
 338   struct symbol *sym[1];
 339 };
 340 \f
 341 /* Represent one symbol name; a variable, constant, function or typedef.  */
 342
 343 /* Different name spaces for symbols.  Looking up a symbol specifies
 344    a namespace and ignores symbol definitions in other name spaces.
 345
 346    VAR_NAMESPACE is the usual namespace.
 347    In C, this contains variables, function names, typedef names
 348    and enum type values.
 349
 350    STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
 351    Thus, if `struct foo' is used in a C program,
 352    it produces a symbol named `foo' in the STRUCT_NAMESPACE.
 353
 354    LABEL_NAMESPACE may be used for names of labels (for gotos);
 355    currently it is not used and labels are not recorded at all.  */
 356
 357 /* For a non-global symbol allocated statically,
 358    the correct core address cannot be determined by the compiler.
 359    The compiler puts an index number into the symbol's value field.
 360    This index number can be matched with the "desc" field of
 361    an entry in the loader symbol table.  */
 362
 363 enum namespace
 364 {
 365   UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE
 366 };
 367
 368 /* An address-class says where to find the value of a symbol.  */
 369
 370 enum address_class
 371 {
 372   LOC_UNDEF,            /* Not used; catches errors */
 373   LOC_CONST,            /* Value is constant int SYMBOL_VALUE, host byteorder */
 374   LOC_STATIC,           /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 375   LOC_REGISTER,         /* Value is in register */
 376   LOC_ARG,              /* Value is at spec'd offset in arglist */
 377   LOC_REF_ARG,          /* Value address is at spec'd offset in arglist. */
 378   LOC_REGPARM,          /* Value is at spec'd offset in register window */
 379   LOC_LOCAL,            /* Value is at spec'd offset in stack frame */
 380   LOC_TYPEDEF,          /* Value not used; definition in SYMBOL_TYPE
 381                            Symbols in the namespace STRUCT_NAMESPACE
 382                            all have this class.  */
 383   LOC_LABEL,            /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 384   LOC_BLOCK,            /* Value is address SYMBOL_VALUE_BLOCK of a
 385                            `struct block'.  Function names have this class. */
 386   LOC_CONST_BYTES,      /* Value is a constant byte-sequence pointed to by
 387                            SYMBOL_VALUE_ADDRESS, in target byte order.  */
 388   LOC_LOCAL_ARG         /* Value is arg at spec'd offset in stack frame.
 389                            Differs from LOC_LOCAL in that symbol is an
 390                            argument; differs from LOC_ARG in that we find it
 391                            in the frame (FRAME_LOCALS_ADDRESS), not in the
 392                            arglist (FRAME_ARGS_ADDRESS).  Added for i960,
 393                            which passes args in regs then copies to frame.  */
 394 };
 395
 396 struct symbol
 397 {
 398   /* Symbol name */
 399   char *name;
 400   /* Name space code.  */
 401   enum namespace namespace;
 402   /* Address class */
 403   enum address_class class;
 404   /* Data type of value */
 405   struct type *type;
 406
 407   /* Line number of definition.  */
 408   unsigned short line;
 409
 410   /* constant value, or address if static, or register number,
 411      or offset in arguments, or offset in stack frame.  All of
 412      these are in host byte order (though what they point to might
 413      be in target byte order, e.g. LOC_CONST_BYTES).  */
 414   union
 415     {
 416       long value;               /* for LOC_CONST, LOC_REGISTER, LOC_ARG,
 417                                    LOC_REF_ARG, LOC_REGPARM, LOC_LOCAL */
 418       struct block *block;      /* for LOC_BLOCK */
 419       char *bytes;              /* for LOC_CONST_BYTES */
 420       CORE_ADDR address;        /* for LOC_STATIC, LOC_LABEL */
 421       struct symbol *chain;     /* for opaque typedef struct chain */
 422     }
 423   value;
 424 };
 425
 426
 427 /* A partial_symbol records the name, namespace, and address class of
 428    symbols whose types we have not parsed yet.  For functions, it also
 429    contains their memory address, so we can find them from a PC value.
 430    Each partial_symbol sits in a partial_symtab, all of which are chained
 431    on the partial_symtab_list and which points to the corresponding
 432    normal symtab once the partial_symtab has been referenced.  */
 433
 434 struct partial_symbol
 435 {
 436   /* Symbol name */
 437   char *name;
 438   /* Name space code.  */
 439   enum namespace namespace;
 440   /* Address class (for info_symbols) */
 441   enum address_class class;
 442   /* Value (only used for static functions currently).  Done this
 443      way so that we can use the struct symbol macros.
 444      Note that the address of a function is SYMBOL_VALUE_ADDRESS (pst)
 445      in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st))
 446      in a symbol table.  */
 447   union
 448     {
 449       long value;
 450       CORE_ADDR address;
 451     }
 452   value;
 453 };
 454 \f
 455 /* Source-file information.
 456    This describes the relation between source files and line numbers
 457    and addresses in the program text.  */
 458
 459 struct sourcevector
 460 {
 461   int length;                   /* Number of source files described */
 462   struct source *source[1];     /* Descriptions of the files */
 463 };
 464
 465 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 466    somewhat more wasteful of space than one might wish, but since only
 467    the files which are actually debugged are read in to core, we don't
 468    waste much space.
 469
 470    Each item used to be an int; either minus a line number, or a
 471    program counter.  If it represents a line number, that is the line
 472    described by the next program counter value.  If it is positive, it
 473    is the program counter at which the code for the next line starts.  */
 474
 475 struct linetable_entry
 476 {
 477   int line;
 478   CORE_ADDR pc;
 479 };
 480
 481 struct linetable
 482 {
 483   int nitems;
 484   struct linetable_entry item[1];
 485 };
 486
 487 /* All the information on one source file.  */
 488
 489 struct source
 490 {
 491   char *name;                   /* Name of file */
 492   struct linetable contents;
 493 };
 494
 495 /* Each source file is represented by a struct symtab.
 496    These objects are chained through the `next' field.  */
 497
 498 struct symtab
 499   {
 500     /* Chain of all existing symtabs.  */
 501     struct symtab *next;
 502     /* List of all symbol scope blocks for this symtab.  */
 503     struct blockvector *blockvector;
 504     /* Table mapping core addresses to line numbers for this file.
 505        Can be NULL if none.  */
 506     struct linetable *linetable;
 507     /* Name of this source file.  */
 508     char *filename;
 509     /* Directory in which it was compiled, or NULL if we don't know.  */
 510     char *dirname;
 511     /* This component says how to free the data we point to:
 512        free_contents => do a tree walk and free each object.
 513        free_nothing => do nothing; some other symtab will free
 514          the data this one uses.
 515        free_linetable => free just the linetable.  */
 516     enum free_code {free_nothing, free_contents, free_linetable}
 517       free_code;
 518     /* Pointer to one block of storage to be freed, if nonzero.  */
 519     /* This is IN ADDITION to the action indicated by free_code.  */
 520     char *free_ptr;
 521     /* Total number of lines found in source file.  */
 522     int nlines;
 523     /* Array mapping line number to character position.  */
 524     int *line_charpos;
 525     /* Language of this source file.  */
 526     enum language language;
 527     /* String of version information.  May be zero.  */
 528     char *version;
 529     /* Full name of file as found by searching the source path.
 530        0 if not yet known.  */
 531     char *fullname;
 532
 533     /* Object file from which this symbol information was read.  */
 534     struct objfile *objfile;
 535     /* Chain of all symtabs owned by that objfile.  */
 536     struct symtab *objfile_chain;
 537
 538     /* Anything extra for this symtab.  This is for target machines
 539        with special debugging info of some sort (which cannot just
 540        be represented in a normal symtab).  */
 541 #if defined (EXTRA_SYMTAB_INFO)
 542     EXTRA_SYMTAB_INFO
 543 #endif
 544   };
 545
 546 /* Each source file that has not been fully read in is represented by
 547    a partial_symtab.  This contains the information on where in the
 548    executable the debugging symbols for a specific file are, and a
 549    list of names of global symbols which are located in this file.
 550    They are all chained on partial_symtab_list.
 551
 552    Even after the source file has been read into a symtab, the
 553    partial_symtab remains around.  They are allocated on an obstack,
 554    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 555    style execution of a bunch of .o's.  */
 556 struct partial_symtab
 557 {
 558   /* Chain of all existing partial symtabs.  */
 559   struct partial_symtab *next;
 560   /* Name of the source file which this partial_symtab defines */
 561   char *filename;
 562
 563   /* Information about the object file from which symbols should be read.  */
 564   struct objfile *objfile;
 565   /* Chain of psymtabs owned by this objfile */
 566   struct partial_symtab *objfile_chain;
 567
 568   /* Address relative to which the symbols in this file are.  Need to
 569      relocate by this amount when reading in symbols from the symbol
 570      file.  */
 571   CORE_ADDR addr;
 572   /* Range of text addresses covered by this file; texthigh is the
 573      beginning of the next section. */
 574   CORE_ADDR textlow, texthigh;
 575   /* Array of pointers to all of the partial_symtab's which this one
 576      depends on.  Since this array can only be set to previous or
 577      the current (?) psymtab, this dependency tree is guaranteed not
 578      to have any loops. */
 579   struct partial_symtab **dependencies;
 580   int number_of_dependencies;
 581   /* Global symbol list.  This list will be sorted after readin to
 582      improve access.  Binary search will be the usual method of
 583      finding a symbol within it. globals_offset is an integer offset
 584      within global_psymbols[].  */
 585   int globals_offset, n_global_syms;
 586   /* Static symbol list.  This list will *not* be sorted after readin;
 587      to find a symbol in it, exhaustive search must be used.  This is
 588      reasonable because searches through this list will eventually
 589      lead to either the read in of a files symbols for real (assumed
 590      to take a *lot* of time; check) or an error (and we don't care
 591      how long errors take).  This is an offset and size within
 592      static_psymbols[].  */
 593   int statics_offset, n_static_syms;
 594   /* Pointer to symtab eventually allocated for this source file, 0 if
 595      !readin or if we haven't looked for the symtab after it was readin.  */
 596   struct symtab *symtab;
 597   /* Pointer to function which will read in the symtab corresponding to
 598      this psymtab.  */
 599   void (*read_symtab) ();
 600   /* Information that lets read_symtab() locate the part of the symbol table
 601      that this psymtab corresponds to.  This information is private to the
 602      format-dependent symbol reading routines.  For further detail examine
 603      the various symbol reading modules.  Should really be (void *) but is
 604      (char *) as with other such gdb variables.  (FIXME) */
 605   char *read_symtab_private;
 606   /* Non-zero if the symtab corresponding to this psymtab has been
 607      readin */
 608   unsigned char readin;
 609 };
 610
 611 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 612 #define PSYMTAB_TO_SYMTAB(pst)  ((pst)->symtab?                 \
 613                                  (pst)->symtab:                 \
 614                                  psymtab_to_symtab (pst) )
 615
 616 /* This is the list of struct symtab's that gdb considers current.  */
 617
 618 struct symtab *symtab_list;
 619
 620 /* This is the list of struct partial_symtab's that gdb may need to access */
 621
 622 struct partial_symtab *partial_symtab_list;
 623
 624 /* This symtab variable specifies the current file for printing source lines */
 625
 626 struct symtab *current_source_symtab;
 627
 628 /* This is the next line to print for listing source lines.  */
 629
 630 int current_source_line;
 631
 632 #define BLOCKVECTOR(symtab) (symtab)->blockvector
 633
 634 #define LINETABLE(symtab) (symtab)->linetable
 635 \f
 636 /* Macros normally used to access components of symbol table structures.  */
 637
 638 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
 639 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
 640
 641 #define BLOCK_START(bl) (bl)->startaddr
 642 #define BLOCK_END(bl) (bl)->endaddr
 643 #define BLOCK_NSYMS(bl) (bl)->nsyms
 644 #define BLOCK_SYM(bl, n) (bl)->sym[n]
 645 #define BLOCK_FUNCTION(bl) (bl)->function
 646 #define BLOCK_SUPERBLOCK(bl) (bl)->superblock
 647 #define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag
 648
 649 /* Nonzero if symbols of block BL should be sorted alphabetically.  */
 650 #define BLOCK_SHOULD_SORT(bl) ((bl)->nsyms >= 40)
 651
 652 #define SYMBOL_NAME(symbol) (symbol)->name
 653 #define SYMBOL_NAMESPACE(symbol) (symbol)->namespace
 654 #define SYMBOL_CLASS(symbol) (symbol)->class
 655 #define SYMBOL_VALUE(symbol) (symbol)->value.value
 656 #define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->value.address
 657 #define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
 658 #define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
 659 #define SYMBOL_VALUE_CHAIN(symbol) (symbol)->value.chain
 660 #define SYMBOL_TYPE(symbol) (symbol)->type
 661 #define SYMBOL_LINE(symbol) (symbol)->line
 662
 663 #define TYPE_NAME(thistype) (thistype)->name
 664 #define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
 665 #define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
 666 #define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
 667 #define TYPE_FUNCTION_TYPE(thistype) (thistype)->function_type
 668 #define TYPE_LENGTH(thistype) (thistype)->length
 669 #define TYPE_FLAGS(thistype) (thistype)->flags
 670 #define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
 671 #define TYPE_CODE(thistype) (thistype)->code
 672 #define TYPE_NFIELDS(thistype) (thistype)->nfields
 673 #define TYPE_FIELDS(thistype) (thistype)->fields
 674 /* C++ */
 675 #define TYPE_VPTR_BASETYPE(thistype) (thistype)->vptr_basetype
 676 #define TYPE_DOMAIN_TYPE(thistype) (thistype)->vptr_basetype
 677 #define TYPE_VPTR_FIELDNO(thistype) (thistype)->vptr_fieldno
 678 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 679 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 680 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
 681 #define TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
 682 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
 683 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
 684 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
 685 #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
 686 #define TYPE_BASECLASS_NAME(thistype,index) (thistype)->fields[index].name
 687 #define TYPE_BASECLASS_BITPOS(thistype,index) (thistype)->fields[index].bitpos
 688 #define BASETYPE_VIA_PUBLIC(thistype, index) (!TYPE_FIELD_PRIVATE(thistype, index))
 689 #define BASETYPE_VIA_VIRTUAL(thistype, index) \
 690   B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index))
 691
 692 #define TYPE_FIELD(thistype, n) (thistype)->fields[n]
 693 #define TYPE_FIELD_TYPE(thistype, n) (thistype)->fields[n].type
 694 #define TYPE_FIELD_NAME(thistype, n) (thistype)->fields[n].name
 695 #define TYPE_FIELD_VALUE(thistype, n) (* (int*) &(thistype)->fields[n].type)
 696 #define TYPE_FIELD_BITPOS(thistype, n) (thistype)->fields[n].bitpos
 697 #define TYPE_FIELD_BITSIZE(thistype, n) (thistype)->fields[n].bitsize
 698 #define TYPE_FIELD_PACKED(thistype, n) (thistype)->fields[n].bitsize
 699
 700 #define TYPE_FIELD_PRIVATE_BITS(thistype) \
 701   TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
 702 #define TYPE_FIELD_PROTECTED_BITS(thistype) \
 703   TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
 704 #define TYPE_FIELD_VIRTUAL_BITS(thistype) \
 705   TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
 706 #define SET_TYPE_FIELD_PRIVATE(thistype, n) \
 707   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 708 #define SET_TYPE_FIELD_PROTECTED(thistype, n) \
 709   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 710 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
 711   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 712 #define TYPE_FIELD_PRIVATE(thistype, n) \
 713   B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
 714 #define TYPE_FIELD_PROTECTED(thistype, n) \
 715 B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 716 #define TYPE_FIELD_VIRTUAL(thistype, n) \
 717        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 718
 719 #define TYPE_FIELD_STATIC(thistype, n) ((thistype)->fields[n].bitpos == -1)
 720 #define TYPE_FIELD_STATIC_PHYSNAME(thistype, n) ((char *)(thistype)->fields[n].bitsize)
 721
 722 #define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
 723 #define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
 724 #define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
 725 #define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
 726 #define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
 727
 728 #define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
 729 #define TYPE_FN_FIELD_NAME(thisfn, n) (thisfn)[n].name
 730 #define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
 731 #define TYPE_FN_FIELD_ARGS(thisfn, n) TYPE_ARG_TYPES ((thisfn)[n].type)
 732 #define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
 733 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 734 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 735 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 736 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
 737 #define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
 738 #define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
 739 #define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 740
 741 /* The virtual function table is now an array of structures
 742    which have the form { int16 offset, delta; void *pfn; }.
 743
 744    In normal virtual function tables, OFFSET is unused.
 745    DELTA is the amount which is added to the apparent object's base
 746    address in order to point to the actual object to which the
 747    virtual function should be applied.
 748    PFN is a pointer to the virtual function.  */
 749
 750 #define VTBL_FNADDR_OFFSET 2
 751
 752 /* Macro that yields non-zero value iff NAME is the prefix
 753    for C++ operator names.  If you leave out the parenthesis
 754    here you will lose!
 755
 756    Currently 'o' 'p' CPLUS_MARKER is used for both the symbol in the
 757    symbol-file and the names in gdb's symbol table.  */
 758 #define OPNAME_PREFIX_P(NAME) ((NAME)[0] == 'o' && (NAME)[1] == 'p' \
 759                                && (NAME)[2] == CPLUS_MARKER)
 760
 761 #define VTBL_PREFIX_P(NAME) ((NAME)[3] == CPLUS_MARKER  \
 762                              && !strncmp ((NAME), "_vt", 3))
 763 \f
 764 /* Functions that work on the objects described above */
 765
 766 extern struct symtab *lookup_symtab ();
 767 extern struct symbol *lookup_symbol ();
 768 extern struct symbol *lookup_block_symbol ();
 769 extern int lookup_misc_func ();
 770 extern void check_stub_type ();
 771 extern void check_stub_method ();
 772 extern struct type *lookup_primitive_typename ();
 773 extern struct type *lookup_typename ();
 774 extern struct type *lookup_unsigned_typename ();
 775 extern struct type *lookup_struct ();
 776 extern struct type *lookup_union ();
 777 extern struct type *lookup_enum ();
 778 extern struct type *lookup_struct_elt_type ();
 779 extern struct type *lookup_pointer_type ();
 780 extern struct type *lookup_function_type ();
 781 extern struct type *create_array_type ();
 782 extern struct symbol *block_function ();
 783 extern struct symbol *find_pc_function ();
 784 extern int find_pc_partial_function ();
 785 extern void clear_pc_function_cache ();
 786 extern struct partial_symtab *lookup_partial_symtab ();
 787 extern struct partial_symtab *find_pc_psymtab ();
 788 extern struct symtab *find_pc_symtab ();
 789 extern struct partial_symbol *find_pc_psymbol ();
 790 extern int find_pc_misc_function ();
 791 extern int find_pc_line_pc_range ();
 792 extern char *type_name_no_tag ();
 793 extern int contained_in();
 794
 795 /* C++ stuff.  */
 796 extern struct type *lookup_template_type ();
 797 extern struct type *lookup_reference_type ();
 798 extern struct type *lookup_member_type ();
 799 extern void smash_to_method_type ();
 800 void smash_to_member_type (
 801 #ifdef __STDC__
 802                            struct type *, struct type *, struct type *
 803 #endif
 804                            );
 805 extern struct type *allocate_stub_method ();
 806 /* end of C++ stuff.  */
 807
 808 extern void reread_symbols ();
 809
 810 extern struct type *builtin_type_void;
 811 extern struct type *builtin_type_char;
 812 extern struct type *builtin_type_short;
 813 extern struct type *builtin_type_int;
 814 extern struct type *builtin_type_long;
 815 extern struct type *builtin_type_unsigned_char;
 816 extern struct type *builtin_type_unsigned_short;
 817 extern struct type *builtin_type_unsigned_int;
 818 extern struct type *builtin_type_unsigned_long;
 819 extern struct type *builtin_type_float;
 820 extern struct type *builtin_type_double;
 821 extern struct type *builtin_type_long_double;
 822 extern struct type *builtin_type_complex;
 823 extern struct type *builtin_type_double_complex;
 824 /* This type represents a type that was unrecognized in symbol
 825    read-in.  */
 826 extern struct type *builtin_type_error;
 827
 828 extern struct type *builtin_type_long_long;
 829 extern struct type *builtin_type_unsigned_long_long;
 830
 831 /* Modula-2 types */
 832 extern struct type *builtin_type_m2_char;
 833 extern struct type *builtin_type_m2_int;
 834 extern struct type *builtin_type_m2_card;
 835 extern struct type *builtin_type_m2_real;
 836 extern struct type *builtin_type_m2_bool;
 837
 838 /* LONG_LONG is defined if the host has "long long".  */
 839 #ifdef LONG_LONG
 840 #define BUILTIN_TYPE_LONGEST builtin_type_long_long
 841 #define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long_long
 842 /* This should not be a typedef, because "unsigned LONGEST" needs
 843    to work.  */
 844 #define LONGEST long long
 845
 846 #else /* not LONG_LONG.  */
 847
 848 #define BUILTIN_TYPE_LONGEST builtin_type_long
 849 #define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long
 850 #define LONGEST long
 851
 852 #endif /* not LONG_LONG.  */
 853
 854 struct symtab_and_line
 855 {
 856   struct symtab *symtab;
 857   int line;
 858   CORE_ADDR pc;
 859   CORE_ADDR end;
 860 };
 861
 862 struct symtabs_and_lines
 863 {
 864   struct symtab_and_line *sals;
 865   int nelts;
 866 };
 867
 868 /* Given a pc value, return line number it is in.
 869    Second arg nonzero means if pc is on the boundary
 870    use the previous statement's line number.  */
 871
 872 struct symtab_and_line find_pc_line ();
 873
 874 /* Given a symtab and line number, return the pc there.  */
 875 extern CORE_ADDR find_line_pc ();
 876 extern int find_line_pc_range ();
 877
 878 /* Given a string, return the line specified by it.
 879    For commands like "list" and "breakpoint".  */
 880
 881 struct symtabs_and_lines decode_line_spec ();
 882 struct symtabs_and_lines decode_line_spec_1 ();
 883 struct symtabs_and_lines decode_line_1 ();
 884
 885 /* Symmisc.c */
 886 void free_symtab ();
 887
 888 /* Symbol-reading stuff in symfile.c and solib.c.  */
 889 struct symtab *psymtab_to_symtab ();
 890 void clear_solib ();
 891 void symbol_file_add ();
 892
 893 /* source.c */
 894 int identify_source_line ();
 895 void print_source_lines ();
 896 void forget_cached_source_info (
 897 #ifdef __STDC__
 898                                 void
 899 #endif
 900                                 );
 901 void select_source_symtab (
 902 #ifdef __STDC__
 903                            struct symtab *
 904 #endif
 905                            );
 906
 907 char **make_symbol_completion_list ();
 908
 909 /* Maximum and minimum values of built-in types */
 910 #define MAX_OF_TYPE(t)  \
 911    TYPE_UNSIGNED(t) ? UMAX_OF_SIZE(TYPE_LENGTH(t)) : MAX_OF_SIZE(TYPE_LENGTH(t))
 912
 913 #define MIN_OF_TYPE(t)  \
 914    TYPE_UNSIGNED(t) ? UMIN_OF_SIZE(TYPE_LENGTH(t)) : MIN_OF_SIZE(TYPE_LENGTH(t))
 915
 916 #endif /* symtab.h not already included.  */