STAB(5)                                                   STAB(5)

          stab - symbol table types

          #include <stab.h>

          Stab.h defines some values of the n_type field of the symbol
          table of a.out files.  These are the types for permanent
          symbols (i.e. not local labels, etc.)  used by the compiler
          cc(1), the debugger pi(1) and the Berkeley Pascal compiler
          pc(1). Symbol table entries can be produced by the .stabs
          assembler directive.  This allows one to specify a double-
          quote delimited name, a symbol type, one char and one short
          of information about the symbol, and an unsigned long (usu-
          ally an address).  To avoid having to produce an explicit
          label for the address field, the .stabd directive can be
          used to implicitly address the current location.  If no name
          is needed, symbol table entries can be generated using the
          .stabn directive.  The loader promises to preserve the order
          of symbol table entries produced by .stab directives.  As
          described in a.out(5), an element of the symbol table con-
          sists of the following structure:

           * Format of a symbol table entry.
          struct nlist {
                  union {
                           char  *n_name; /* for use when in-core */
                           long  n_strx;  /* index into file string table */
                  } n_un;
                  unsigned char  n_type;  /* type flag */
                  char           n_other; /* unused */
                  short          n_desc;  /* see struct desc, below */
                  unsigned n_value;       /* address or offset or line */

          The low bits of the n_type field are used to place a symbol
          into at most one segment, according to the following masks,
          defined in <a.out.h>.  A symbol can be in none of these seg-
          ments by having none of these segment bits set.

           * Simple values for n_type.
          #define N_UNDF  0x0   /* undefined */
          #define N_ABS   0x2   /* absolute */
          #define N_TEXT  0x4   /* text */
          #define N_DATA  0x6   /* data */

     STAB(5)                                                   STAB(5)

          #define N_BSS   0x8   /* bss */

          #define N_EXT   01    /* external bit, or'ed in */

          The n_value field of a symbol is relocated by the linker,
          ld(1) as an address within the appropriate segment.  N_value
          fields of symbols not in any segment are unchanged by the
          linker.  In addition, the linker will discard certain sym-
          bols, according to rules of its own, unless the n_type field
          has one of the following bits set:

           * Other permanent symbol table entries have some of the N_STAB bits set.
           * These are given in <stab.h>
          #define N_STAB  0xe0  /* if any of these bits set, don't discard */

          This allows up to 112 (7 * 16) symbol types, split between
          the various segments.  Some of these have already been
          claimed.  The transcendental debugger, pi(9.1), uses the
          following n_type values:

           * stabs for text symbols (must be 0x?4):
          #define N_BFUN  0x24  /* procedure: name,,0,lineno,address        */
          #define N_FUN   0x24
          #define N_NARGS 0x34  /* function call: ,,0,nbytes,address        */
          #define N_SLINE 0x44  /* src line: ,,0,lineno,address             */
          #define N_SO    0x64  /* source file: name,,0,lineno,address      */
          #define N_SOL   0x84  /* #include file: name,,0,lineno,address    */
          #define N_ESO   0x94  /* end source file: name,,0,lineno,address  */
          #define N_ENTRY 0xa4  /* alternate entry: name,,0,lineno,address  */
          #define N_RFUN  0xb4  /* return from function: ,,0,lineno,address */
          #define N_LBRAC 0xc4  /* left  bracket: ,,0,level,address         */
          #define N_RBRAC 0xd4  /* right bracket: ,,0,level,address         */
          #define N_EFUN  0xf4  /* end of function: name,,0,lineno,address  */
           * stabs for data symbols (must be 0x?6):
          #define N_STSYM 0x26  /* static symbol: name,,0,type,address      */
           * stabs for bss symbols (must be 0x?8):
          #define N_LCSYM 0x28  /* .lcomm symbol: name,,0,type,address      */
          #define N_ECOML 0xe8  /* end common (local name): ,,address       */
           * stabs for non-relocated stuff:
          #define N_GSYM  0x20  /* global symbol: name,,0,type,0            */
          #define N_FNAME 0x22  /* procedure name (f77 kludge): name,,0     */

     STAB(5)                                                   STAB(5)

          #define N_STFUN 0x32  /* static function: name,,0,type,0          */
          #define N_RSYM  0x40  /* register sym: name,,0,type,register      */
          #define N_BSTR  0x5c  /* begin structure: name,,0,type,length     */
          #define N_ESTR  0x5e  /*  end  structure: name,,0,type,length     */
          #define N_SSYM  0x60  /* structure elt: name,,0,type,offset       */
          #define N_SFLD  0x70  /* structure field: name,,0,type,offset     */
          #define N_LSYM  0x80  /* local sym: name,,0,type,offset           */
          #define N_PSYM  0xa0  /* parameter: name,,0,type,offset           */
          #define N_BCOMM 0xe2  /* begin common: name,,                     */
          #define N_ECOMM 0xe4  /* end common: name,,                       */
          #define N_VER   0xf0  /* symbol table version number              */
          #define N_TYID  0xfa  /* struct, union, or enum name              */
          #define N_DIM   0xfc  /* dimension for arrays                     */

          where the comments give the sdb conventional use for .stabs
          and the n_name, n_other, n_desc, and n_value fields of the
          given n_type. Pi uses the n_desc field to hold a type speci-
          fier in the form used by cc(1), in which a base type is
          qualified in the following structure:

          struct desc {
                  short  q6:2,

          There are four qualifications, with q1 the most significant
          and q6 the least significant:
               0    none
               1    pointer
               2    function
               3    array
          The sixteen basic types are assigned as follows:
               0    undefined
               1    function argument
               2    character
               3    short
               4    int
               5    long
               6    float
               7    double
               8    structure
               9    union
               10   enumeration
               11   member of enumeration
               12   unsigned character
               13   unsigned short
               14   unsigned int

     STAB(5)                                                   STAB(5)

               15   unsigned long
               16   void

          The Berkeley Pascal compiler, pc(1), uses the following
          n_type value:

          #define   N_PC 0x30 /* global pascal symbol: name,,0,subtype,line */

          and uses the following subtypes to do type checking across
          separately compiled files:
               1    source file name
               2    included file name
               3    global label
               4    global constant
               5    global type
               6    global variable
               7    global function
               8    global procedure
               9    external function
               10   external procedure

          as(1), ld(1), pi(1), a.out(5)

          The loader's relocation conventions limit the number of use-
          ful n_type's.

          More basic types are needed.