166 lines
4.6 KiB
Text
166 lines
4.6 KiB
Text
stabs
|
|
|
|
N_MAIN with name "main" to identify entry function
|
|
N_SO source file. might be preceded by dir ending in /
|
|
value is code ptr
|
|
empty string means source done
|
|
N_SOL source include file, value = text addr of where this starts
|
|
N_SLINE start of source line
|
|
no name
|
|
desc = line number
|
|
value = code addr for that line
|
|
|
|
N_FUN (36) function def
|
|
'F' global 'f' local
|
|
value = addr
|
|
desc = line number of def
|
|
return type is number after :
|
|
|
|
nil name marks end of function
|
|
|
|
constants
|
|
|
|
c= XXX p. 15
|
|
|
|
N_LSYM (128) local variable
|
|
:type-number
|
|
value = offset from fp
|
|
:ptype means parameter passed in reg but stored as variable
|
|
|
|
N_GSYM (32) global variable
|
|
addr not given (use external symbol)
|
|
:type
|
|
|
|
N_RSYM register value
|
|
|
|
N_STSYM(38)/N_FUN/N_LCSYM(40) data/text/bss
|
|
static varibale 'S' file static 'V' procedure static
|
|
:Stype :Vtype
|
|
|
|
N_PSYM (160) parameter
|
|
:ptype
|
|
value=offset from fp
|
|
desc = line number of decl
|
|
|
|
register params followed by an N_RSYM with same name and :rtype.
|
|
|
|
skip types
|
|
|
|
type (a,b) means a=file number b=type number
|
|
|
|
N_BINCL/N_EINCL begin/end include
|
|
N_EXCL - same effect as earlier guy
|
|
|
|
|
|
|
|
=============
|
|
|
|
type crap
|
|
|
|
|
|
|
|
name:symbol_opt typeinfo
|
|
|
|
typeinfo ::= typenum | typenum = attr* typedef
|
|
|
|
typenum ::= integer | '(' integer ',' integer ')'
|
|
|
|
attr ::= @ attrtext ;
|
|
|
|
attrtext ::= 'a' integer (alignment)
|
|
| 'p' integer (pointer class)
|
|
| 'P' (packed type)
|
|
| 's' integer (size of type in bits)
|
|
| 'S' (string instead of array of chars)
|
|
|
|
typedef ::= typeinfo
|
|
| 'b' ('u' | 's') 'c'? width; offset; nbits; (builtin, signed/unsigned, char/not, width in bytes, offset & nbits of type)
|
|
| 'w' (aix wide char type, not used)
|
|
| 'R' fptype; bytes; (fptype 1=32-bit, 2=64-bit, 3=complex, 4=complex16, 5=complex32, 6=long double)
|
|
| 'g' typeinfo ';' nbits (aix floating, not used)
|
|
| 'c' typeinfo ';' nbits (aix complex, not used)
|
|
| -1 int32
|
|
| -2 char8
|
|
| -3 int16
|
|
| -4 int32 (long)
|
|
| -5 uchar8
|
|
| -6 schar8
|
|
| -7 uint16
|
|
| -8 uint32
|
|
| -9 uint32
|
|
| -10 ulong32
|
|
| -11 void
|
|
| -12 float
|
|
| -13 double
|
|
| -14 long double
|
|
| -15 int32
|
|
| -16 bool32
|
|
| -17 short real
|
|
| -18 real
|
|
| -19 stringptr
|
|
| -20 character8
|
|
| -21 logical*1 8
|
|
| -22 logical*2 16
|
|
| -23 logical*4 32
|
|
| -24 logical 32
|
|
| -25 complex (two single)
|
|
| -26 complex (two double)
|
|
| -27 integer*1 8 signed
|
|
| -28 integer*2 16 signed
|
|
| -29 integer*4 32 signed
|
|
| -30 wchar 16 wide char
|
|
| -31 int64
|
|
| -32 uint64
|
|
| -33 logical*8 64
|
|
| -34 integer*8 64 signed
|
|
| 'b' typeinfo ';' bytes (ibm, no idea)
|
|
| 'B' typeinfo (volatile typref)
|
|
| 'd' typeinfo (file of typeref)
|
|
| 'k' typeinfo (const typeref)
|
|
| 'M' typeinfo ';' length (multiple instance type, fortran)
|
|
| 'S' typeinfo (set, typeref must have small number of values)
|
|
| '*' typeinfo (pointer to typeref)
|
|
| 'x' ('s'|'u'|'e') name ':' (struct, union, enum reference. name can have '::' in it)
|
|
| 'r' typeinfo ';' low ';' high ';' (subrange. typeref can be type being defined for base types!)
|
|
low and high are bounds
|
|
if bound is octal power of two, it's a big negative number
|
|
| ('a'|'P') indextypedef arraytypeinfo (array, index should be range type)
|
|
indextype is type definition not typeinfo (need not say typenum=)
|
|
P means packed array
|
|
| 'A' arraytypeinfo (open array (no index bounds))
|
|
| 'D' dims ';' typeinfo (dims-dimensional dynamic array)
|
|
| 'E' dims ';' typeinfo (subarray of N-dimensional array)
|
|
| 'n' typeinfo ';' bytes (max length string)
|
|
| 'z' typeinfo ';' bytes (no idea what difference is from 'n')
|
|
| 'N' (pascal stringptr)
|
|
| 'e' (name ':' bigint ',')* ';' (enum listing)
|
|
| ('s'|'u') bytes (name ':' type ',' bitoffset ',' bitsize ';')* ';' (struct/union defn)
|
|
tag is given as name in stabs entry, with 'T' symbol
|
|
| 'f' typeinfo ';' (function returning type)
|
|
| 'f' rettypeinfo ',' paramcount ';' (typeinfo ',' (0|1) ';')* ';'
|
|
| 'p' paramcount ';' (typeinfo ',' (0|1) ';')* ';'
|
|
| 'F' rettypeinfo ',' paramcount ';' (name ':' typeinfo ',' (0|1) ';')* ';'
|
|
| 'R' paramcount ';' (name ':' typeinfo ',' (0|1) ';')* ';'
|
|
(the 0 or 1 is pass-by-reference vs pass-by-value)
|
|
(the 0 or 1 is pass-by-reference vs pass-by-value)
|
|
|
|
bound ::=
|
|
'A' offset (bound is on stack by ref at offset offset from arg list)
|
|
| 'T' offset (bound is on stack by val at offset offset from arg list)
|
|
| 'a' regnum (bound passed by reference in register)
|
|
| 't' regnum (bound passed by value in register)
|
|
| 'J' (no bound)
|
|
| bigint
|
|
|
|
bigint ::= '-'? decimal
|
|
| 0 octal
|
|
| -1
|
|
|
|
C++
|
|
|
|
symbol 'Tt' means typename + tag in one stab
|
|
|
|
names can have ::, as in foo::bar::baz::t1
|
|
|
|
t16 unknown type just like void
|
|
t17 vtable record type
|