home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Atari / Gnu / gdb36p4s.zoo / symseg.h < prev    next >
C/C++ Source or Header  |  1990-06-29  |  19KB  |  518 lines
  1. /* GDB symbol table format definitions.
  2.    Copyright (C) 1986, 1989 Free Software Foundation, Inc.
  3.    Hacked by Michael Tiemann (tiemann@mcc.com)
  4.  
  5. This file is part of GDB.
  6.  
  7. GDB is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GDB is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GDB; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* Format of GDB symbol table data.
  22.    There is one symbol segment for each source file or
  23.    independant compilation.  These segments are simply concatenated
  24.    to form the GDB symbol table.  A zero word where the beginning
  25.    of a segment is expected indicates there are no more segments.
  26.  
  27. Format of a symbol segment:
  28.  
  29.    The symbol segment begins with a word containing 1
  30.    if it is in the format described here.  Other formats may
  31.    be designed, with other code numbers.
  32.  
  33.    The segment contains many objects which point at each other.
  34.    The pointers are offsets in bytes from the beginning of the segment.
  35.    Thus, each segment can be loaded into core and its pointers relocated
  36.    to make valid in-core pointers.
  37.  
  38.    All the data objects in the segment can be found indirectly from
  39.    one of them, the root object, of type `struct symbol_root'.
  40.    It appears at the beginning of the segment.
  41.  
  42.    The total size of the segment, in bytes, appears as the `length'
  43.    field of this object.  This size includes the size of the
  44.    root object.
  45.  
  46.    All the object data types are defined here to contain pointer types
  47.    appropriate for in-core use on a relocated symbol segment.
  48.    Casts to and from type int are required for working with
  49.    unrelocated symbol segments such as are found in the file.
  50.  
  51.    The ldsymaddr word is filled in by the loader to contain
  52.    the offset (in bytes) within the ld symbol table
  53.    of the first nonglobal symbol from this compilation.
  54.    This makes it possible to match those symbols
  55.    (which contain line number information) reliably with
  56.    the segment they go with.
  57.  
  58.    Core addresses within the program that appear in the symbol segment
  59.    are not relocated by the loader.  They are inserted by the assembler
  60.    and apply to addresses as output by the assembler, so GDB must
  61.    relocate them when it loads the symbol segment.  It gets the information
  62.    on how to relocate from the textrel, datarel, bssrel, databeg and bssbeg
  63.    words of the root object.
  64.  
  65.    The words textrel, datarel and bssrel
  66.    are filled in by ld with the amounts to relocate within-the-file
  67.    text, data and bss addresses by; databeg and bssbeg can be
  68.    used to tell which kind of relocation an address needs.  */
  69.  
  70. enum language {language_c};
  71.  
  72. struct symbol_root
  73. {
  74.   int format;            /* Data format version */
  75.   int length;            /* # bytes in this symbol segment */
  76.   int ldsymoff;            /* Offset in ld symtab of this file's syms */
  77.   int textrel;            /* Relocation for text addresses */
  78.   int datarel;            /* Relocation for data addresses */
  79.   int bssrel;            /* Relocation for bss addresses */
  80.   char *filename;        /* Name of main source file compiled */
  81.   char *filedir;        /* Name of directory it was reached from */
  82.   struct blockvector *blockvector; /* Vector of all symbol-naming blocks */
  83.   struct typevector *typevector; /* Vector of all data types */
  84.   enum language language;    /* Code identifying the language used */
  85.   char *version;        /* Version info.  Not fully specified */
  86.   char *compilation;        /* Compilation info.  Not fully specified */
  87.   int databeg;            /* Address within the file of data start */
  88.   int bssbeg;            /* Address within the file of bss start */
  89.   struct sourcevector *sourcevector; /* Vector of line-number info */
  90. };
  91.  
  92. /* All data types of symbols in the compiled program
  93.    are represented by `struct type' objects.
  94.    All of these objects are pointed to by the typevector.
  95.    The type vector may have empty slots that contain zero.  */
  96.  
  97. struct typevector
  98. {
  99.   int length;            /* Number of types described */
  100.   struct type *type[1];
  101. };
  102.  
  103. /* Different kinds of data types are distinguished by the `code' field.  */
  104.  
  105. enum type_code
  106. {
  107.   TYPE_CODE_UNDEF,        /* Not used; catches errors */
  108.   TYPE_CODE_PTR,        /* Pointer type */
  109.   TYPE_CODE_ARRAY,        /* Array type, lower bound zero */
  110.   TYPE_CODE_STRUCT,        /* C struct or Pascal record */
  111.   TYPE_CODE_UNION,        /* C union or Pascal variant part */
  112.   TYPE_CODE_ENUM,        /* Enumeration type */
  113.   TYPE_CODE_FUNC,        /* Function type */
  114.   TYPE_CODE_INT,        /* Integer type */
  115.   TYPE_CODE_FLT,        /* Floating type */
  116.   TYPE_CODE_VOID,        /* Void type (values zero length) */
  117.   TYPE_CODE_SET,        /* Pascal sets */
  118.   TYPE_CODE_RANGE,        /* Range (integers within spec'd bounds) */
  119.   TYPE_CODE_PASCAL_ARRAY,    /* Array with explicit type of index */
  120.  
  121.   /* C++ */
  122.   TYPE_CODE_MEMBER,        /* Member type */
  123.   TYPE_CODE_METHOD,        /* Method type */
  124.   TYPE_CODE_REF,        /* C++ Reference types */
  125. };
  126.  
  127. /* This appears in a type's flags word for an unsigned integer type.  */
  128. #define TYPE_FLAG_UNSIGNED 1
  129. /* This appears in a type's flags word
  130.    if it is a (pointer to a|function returning a)* built in scalar type.
  131.    These types are never freed.  */
  132. #define TYPE_FLAG_PERM 4
  133. /* This appears in a type's flags word if it is a stub type (eg. if
  134.    someone referenced a type that wasn't definined in a source file
  135.    via (struct sir_not_appearing_in_this_film *)).  */
  136. #define TYPE_FLAG_STUB 8
  137.  
  138. /* Change by Bryan Boreham, Kewill, Sun Sep 17 18:04:48 1989.
  139.    This appears in a type's flags word if it is an undefined type and
  140.    we have already checked to see if it can be resolved in some other 
  141.    file. It breaks some uses of add-file command, and should be
  142.    removed. */
  143. #define TYPE_FLAG_STUB_CHECKED                16
  144.  
  145. /* Set when a class has a constructor defined */
  146. #define    TYPE_FLAG_HAS_CONSTRUCTOR    256
  147. /* Set when a class has a destructor defined */
  148. #define    TYPE_FLAG_HAS_DESTRUCTOR    512
  149. /* Indicates that this type is a public baseclass of another class,
  150.    i.e. that all its public methods are available in the derived
  151.    class. */
  152. #define    TYPE_FLAG_VIA_PUBLIC        1024
  153. /* Indicates that this type is a virtual baseclass of another class,
  154.    i.e. that if this class is inherited more than once by another
  155.    class, only one set of member variables will be included. */ 
  156. #define    TYPE_FLAG_VIA_VIRTUAL        2048
  157.  
  158. struct type
  159. {
  160.   /* Code for kind of type */
  161.   enum type_code code;
  162.   /* Name of this type, or zero if none.
  163.      This is used for printing only.
  164.      Type names specified as input are defined by symbols.  */
  165.   char *name;
  166.   /* Length in bytes of storage for a value of this type */
  167.   int length;
  168.   /* For a pointer type, describes the type of object pointed to.
  169.      For an array type, describes the type of the elements.
  170.      For a function or method type, describes the type of the value.
  171.      For a range type, describes the type of the full range.
  172.      Unused otherwise.  */
  173.   struct type *target_type;
  174.   /* Type that is a pointer to this type.
  175.      Zero if no such pointer-to type is known yet.
  176.      The debugger may add the address of such a type
  177.      if it has to construct one later.  */ 
  178.   struct type *pointer_type;
  179.   /* C++: also need a reference type.  */
  180.   struct type *reference_type;
  181.   struct type **arg_types;
  182.   
  183.   /* Type that is a function returning this type.
  184.      Zero if no such function type is known here.
  185.      The debugger may add the address of such a type
  186.      if it has to construct one later.  */
  187.   struct type *function_type;
  188.  
  189. /* Handling of pointers to members:
  190.    TYPE_MAIN_VARIANT is used for pointer and pointer
  191.    to member types.  Normally it the value of the address of its
  192.    containing type.  However, for pointers to members, we must be
  193.    able to allocate pointer to member types and look them up
  194.    from some place of reference.
  195.    NEXT_VARIANT is the next element in the chain. */
  196.   struct type *main_variant, *next_variant;
  197.  
  198.   /* Flags about this type.  */
  199.   short flags;
  200.   /* Number of fields described for this type */
  201.   short nfields;
  202.   /* For structure and union types, a description of each field.
  203.      For set and pascal array types, there is one "field",
  204.      whose type is the domain type of the set or array.
  205.      For range types, there are two "fields",
  206.      the minimum and maximum values (both inclusive).
  207.      For enum types, each possible value is described by one "field".
  208.  
  209.      Using a pointer to a separate array of fields
  210.      allows all types to have the same size, which is useful
  211.      because we can allocate the space for a type before
  212.      we know what to put in it.  */
  213.   struct field
  214.     {
  215.       /* Position of this field, counting in bits from start of
  216.      containing structure.  For a function type, this is the
  217.      position in the argument list of this argument.
  218.      For a range bound or enum value, this is the value itself.  */
  219.       int bitpos;
  220.       /* Size of this field, in bits, or zero if not packed.
  221.      For an unpacked field, the field's type's length
  222.      says how many bytes the field occupies.  */
  223.       int bitsize;
  224.       /* In a struct or enum type, type of this field.
  225.      In a function type, type of this argument.
  226.      In an array type, the domain-type of the array.  */
  227.       struct type *type;
  228.       /* Name of field, value or argument.
  229.      Zero for range bounds and array domains.  */
  230.       char *name;
  231.     } *fields;
  232.  
  233.   /* C++ */
  234.   int *private_field_bits;
  235.   int *protected_field_bits;
  236.  
  237.   /* Number of methods described for this type */
  238.   short nfn_fields;
  239.   /* Number of base classes this type derives from. */
  240.   short n_baseclasses;
  241.  
  242.   /* Number of methods described for this type plus all the
  243.      methods that it derives from.  */
  244.   int nfn_fields_total;
  245.  
  246.   /* For classes, structures, and unions, a description of each field,
  247.      which consists of an overloaded name, followed by the types of
  248.      arguments that the method expects, and then the name after it
  249.      has been renamed to make it distinct.  */
  250.   struct fn_fieldlist
  251.     {
  252.       /* The overloaded name.  */
  253.       char *name;
  254.       /* The number of methods with this name.  */
  255.       int length;
  256.       /* The list of methods.  */
  257.       struct fn_field
  258.     {
  259. #if 0
  260.       /* The overloaded name */
  261.       char *name;
  262. #endif
  263.       /* The return value of the method */
  264.       struct type *type;
  265.       /* The name after it has been processed */
  266.       char *physname;
  267.       /* If this is a virtual function, the offset into the vtbl-1,
  268.          else 0.  */
  269.       int voffset;
  270.     } *fn_fields;
  271.  
  272.       int *private_fn_field_bits;
  273.       int *protected_fn_field_bits;
  274.  
  275.     } *fn_fieldlists;
  276.  
  277.   unsigned char via_protected;
  278.   unsigned char via_public;
  279.  
  280.   /* For types with virtual functions, VPTR_BASETYPE is the base class which
  281.      defined the virtual function table pointer.  VPTR_FIELDNO is
  282.      the field number of that pointer in the structure.
  283.  
  284.      For types that are pointer to member types, VPTR_BASETYPE
  285.      ifs the type that this pointer is a member of.
  286.  
  287.      Unused otherwise.  */
  288.   struct type *vptr_basetype;
  289.  
  290.   int vptr_fieldno;
  291.  
  292.   /* If this type has a base class, put it here.
  293.      If this type is a pointer type, the chain of member pointer
  294.      types goes here.
  295.      Unused otherwise.
  296.      
  297.      Contrary to all maxims of C style and common sense, the baseclasses
  298.      are indexed from 1 to N_BASECLASSES rather than 0 to N_BASECLASSES-1
  299.      (i.e. BASECLASSES points to one *before* the first element of
  300.      the array).  */
  301.   struct type **baseclasses;
  302. };
  303.  
  304. /* All of the name-scope contours of the program
  305.    are represented by `struct block' objects.
  306.    All of these objects are pointed to by the blockvector.
  307.  
  308.    Each block represents one name scope.
  309.    Each lexical context has its own block.
  310.  
  311.    The first two blocks in the blockvector are special.
  312.    The first one contains all the symbols defined in this compilation
  313.    whose scope is the entire program linked together.
  314.    The second one contains all the symbols whose scope is the
  315.    entire compilation excluding other separate compilations.
  316.    In C, these correspond to global symbols and static symbols.
  317.  
  318.    Each block records a range of core addresses for the code that
  319.    is in the scope of the block.  The first two special blocks
  320.    give, for the range of code, the entire range of code produced
  321.    by the compilation that the symbol segment belongs to.
  322.  
  323.    The blocks appear in the blockvector
  324.    in order of increasing starting-address,
  325.    and, within that, in order of decreasing ending-address.
  326.  
  327.    This implies that within the body of one function
  328.    the blocks appear in the order of a depth-first tree walk.  */
  329.  
  330. struct blockvector
  331. {
  332.   /* Number of blocks in the list.  */
  333.   int nblocks;
  334.   /* The blocks themselves.  */
  335.   struct block *block[1];
  336. };
  337.  
  338. struct block
  339. {
  340.   /* Addresses in the executable code that are in this block.
  341.      Note: in an unrelocated symbol segment in a file,
  342.      these are always zero.  They can be filled in from the
  343.      N_LBRAC and N_RBRAC symbols in the loader symbol table.  */
  344.   int startaddr, endaddr;
  345.   /* The symbol that names this block,
  346.      if the block is the body of a function;
  347.      otherwise, zero.
  348.      Note: In an unrelocated symbol segment in an object file,
  349.      this field may be zero even when the block has a name.
  350.      That is because the block is output before the name
  351.      (since the name resides in a higher block).
  352.      Since the symbol does point to the block (as its value),
  353.      it is possible to find the block and set its name properly.  */
  354.   struct symbol *function;
  355.   /* The `struct block' for the containing block, or 0 if none.  */
  356.   /* Note that in an unrelocated symbol segment in an object file
  357.      this pointer may be zero when the correct value should be
  358.      the second special block (for symbols whose scope is one compilation).
  359.      This is because the compiler ouptuts the special blocks at the
  360.      very end, after the other blocks.   */
  361.   struct block *superblock;
  362.   /* A flag indicating whether or not the fucntion corresponding
  363.      to this block was compiled with gcc or not.  If there is no
  364.      function corresponding to this block, this meaning of this flag
  365.      is undefined.  (In practice it will be 1 if the block was created
  366.      while processing a file compiled with gcc and 0 when not). */
  367.   unsigned char gcc_compile_flag;
  368.   /* Number of local symbols.  */
  369.   int nsyms;
  370.   /* The symbols.  */
  371.   struct symbol *sym[1];
  372. };
  373.  
  374. /* Represent one symbol name; a variable, constant, function or typedef.  */
  375.  
  376. /* Different name spaces for symbols.  Looking up a symbol specifies
  377.    a namespace and ignores symbol definitions in other name spaces.
  378.  
  379.    VAR_NAMESPACE is the usual namespace.
  380.    In C, this contains variables, function names, typedef names
  381.    and enum type values.
  382.  
  383.    STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
  384.    Thus, if `struct foo' is used in a C program,
  385.    it produces a symbol named `foo' in the STRUCT_NAMESPACE.
  386.  
  387.    LABEL_NAMESPACE may be used for names of labels (for gotos);
  388.    currently it is not used and labels are not recorded at all.  */
  389.  
  390. /* For a non-global symbol allocated statically,
  391.    the correct core address cannot be determined by the compiler.
  392.    The compiler puts an index number into the symbol's value field.
  393.    This index number can be matched with the "desc" field of
  394.    an entry in the loader symbol table.  */
  395.  
  396. enum namespace
  397. {
  398.   UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE,
  399. };
  400.  
  401. /* An address-class says where to find the value of the symbol in core.  */
  402.  
  403. enum address_class
  404. {
  405.   LOC_UNDEF,        /* Not used; catches errors */
  406.   LOC_CONST,        /* Value is constant int */
  407.   LOC_STATIC,        /* Value is at fixed address */
  408.   LOC_REGISTER,        /* Value is in register */
  409.   LOC_ARG,        /* Value is at spec'd position in arglist */
  410.   LOC_REF_ARG,        /* Value address is at spec'd position in */
  411.             /* arglist.  */
  412.   LOC_REGPARM,        /* Value is at spec'd position in  register window */
  413.   LOC_LOCAL,        /* Value is at spec'd pos in stack frame */
  414.   LOC_TYPEDEF,        /* Value not used; definition in SYMBOL_TYPE
  415.                Symbols in the namespace STRUCT_NAMESPACE
  416.                all have this class.  */
  417.   LOC_LABEL,        /* Value is address in the code */
  418.   LOC_BLOCK,        /* Value is address of a `struct block'.
  419.                Function names have this class.  */
  420.   LOC_EXTERNAL,        /* Value is at address not in this compilation.
  421.                This is used for .comm symbols
  422.                and for extern symbols within functions.
  423.                Inside GDB, this is changed to LOC_STATIC once the
  424.                real address is obtained from a loader symbol.  */
  425.   LOC_CONST_BYTES    /* Value is a constant byte-sequence.   */
  426. };
  427.  
  428. struct symbol
  429. {
  430.   /* Symbol name */
  431.   char *name;
  432.   /* Name space code.  */
  433.   enum namespace namespace;
  434.   /* Address class */
  435.   enum address_class class;
  436.   /* Data type of value */
  437.   struct type *type;
  438.   /* constant value, or address if static, or register number,
  439.      or offset in arguments, or offset in stack frame.  */
  440.   union
  441.     {
  442.       long value;
  443.       struct block *block;      /* for LOC_BLOCK */
  444.       char *bytes;        /* for LOC_CONST_BYTES */
  445.     }
  446.   value;
  447. };
  448.  
  449. struct partial_symbol
  450. {
  451.   /* Symbol name */
  452.   char *name;
  453.   /* Name space code.  */
  454.   enum namespace namespace;
  455.   /* Address class (for info_symbols) */
  456.   enum address_class class;
  457.   /* Value (only used for static functions currently).  Done this
  458.      way so that we can use the struct symbol macros.
  459.      Note that the address of a function is SYMBOL_VALUE (pst)
  460.      in a partial symbol table, but BLOCK_START (SYMBOL_BLOCK_VALUE (st))
  461.      in a symbol table.  */
  462.   union
  463.     {
  464.       long value;
  465.     }
  466.   value;
  467. };
  468.  
  469. /* 
  470.  * Vectors of all partial symbols read in from file; actually declared
  471.  * and used in dbxread.c.
  472.  */
  473. extern struct psymbol_allocation_list {
  474.   struct partial_symbol *list, *next;
  475.   int size;
  476. } global_psymbols, static_psymbols;
  477.  
  478.  
  479. /* Source-file information.
  480.    This describes the relation between source files and line numbers
  481.    and addresses in the program text.  */
  482.  
  483. struct sourcevector
  484. {
  485.   int length;            /* Number of source files described */
  486.   struct source *source[1];    /* Descriptions of the files */
  487. };
  488.  
  489. /* Each item represents a line-->pc (or the reverse) mapping.  This is
  490.    somewhat more wasteful of space than one might wish, but since only
  491.    the files which are actually debugged are read in to core, we don't
  492.    waste much space.
  493.  
  494.    Each item used to be an int; either minus a line number, or a
  495.    program counter.  If it represents a line number, that is the line
  496.    described by the next program counter value.  If it is positive, it
  497.    is the program counter at which the code for the next line starts.  */
  498.  
  499. struct linetable_entry
  500. {
  501.   int line;
  502.   CORE_ADDR pc;
  503. };
  504.  
  505. struct linetable
  506. {
  507.   int nitems;
  508.   struct linetable_entry item[1];
  509. };
  510.  
  511. /* All the information on one source file.  */
  512.  
  513. struct source
  514. {
  515.   char *name;            /* Name of file */
  516.   struct linetable contents;
  517. };
  518.