blob: 30a05fc700226560db530c7bd336d54ee8442054 [file] [log] [blame]
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Parse stabs debug info.
#include "a.h"
int stabsdebug = 1;
// Hash table for type lookup by number.
Type *hash[1024];
// Look up type by number pair.
// TODO(rsc): Iant points out that n1 and n2 are always small and dense,
// so an array of arrays would be a better representation.
Type*
typebynum(uint n1, uint n2)
{
uint h;
Type *t;
h = (n1*53+n2) % nelem(hash);
for(t=hash[h]; t; t=t->next)
if(t->n1 == n1 && t->n2 == n2)
return t;
t = emalloc(sizeof *t);
t->next = hash[h];
hash[h] = t;
t->n1 = n1;
t->n2 = n2;
return t;
}
// Parse name and colon from *pp, leaving copy in *sp.
static int
parsename(char **pp, char **sp)
{
char *p;
char *s;
p = *pp;
while(*p != '\0' && *p != ':')
p++;
if(*p == '\0') {
fprint(2, "parsename expected colon\n");
return -1;
}
s = emalloc(p - *pp + 1);
memmove(s, *pp, p - *pp);
*sp = s;
*pp = p+1;
return 0;
}
// Parse single number from *pp.
static int
parsenum1(char **pp, vlong *np)
{
char *p;
p = *pp;
if(*p != '-' && (*p < '0' || *p > '9')) {
fprint(2, "parsenum expected minus or digit\n");
return -1;
}
*np = strtoll(p, pp, 10);
return 0;
}
// Parse type number - either single number or (n1, n2).
static int
parsetypenum(char **pp, vlong *n1p, vlong *n2p)
{
char *p;
p = *pp;
if(*p == '(') {
p++;
if(parsenum1(&p, n1p) < 0)
return -1;
if(*p++ != ',') {
if(stabsdebug)
fprint(2, "parsetypenum expected comma\n");
return -1;
}
if(parsenum1(&p, n2p) < 0)
return -1;
if(*p++ != ')') {
if(stabsdebug)
fprint(2, "parsetypenum expected right paren\n");
return -1;
}
*pp = p;
return 0;
}
if(parsenum1(&p, n1p) < 0)
return -1;
*n2p = 0;
*pp = p;
return 0;
}
// Written to parse max/min of vlong correctly.
static vlong
parseoctal(char **pp)
{
char *p;
vlong n;
p = *pp;
if(*p++ != '0')
return 0;
n = 0;
while(*p >= '0' && *p <= '9')
n = n << 3 | *p++ - '0';
*pp = p;
return n;
}
// Integer types are represented in stabs as a "range"
// type with a lo and a hi value. The lo and hi used to
// be lo and hi for the type, but there are now odd
// extensions for floating point and 64-bit numbers.
//
// Have to keep signs separate from values because
// Int64's lo is -0.
typedef struct Intrange Intrange;
struct Intrange
{
vlong lo;
vlong hi;
int kind;
};
Intrange intranges[] = {
0, 127, Int8, // char
-128, 127, Int8, // signed char
0, 255, Uint8,
-32768, 32767, Int16,
0, 65535, Uint16,
-2147483648LL, 2147483647LL, Int32,
0, 4294967295LL, Uint32,
1LL << 63, ~(1LL << 63), Int64,
0, -1, Uint64,
4, 0, Float32,
8, 0, Float64,
16, 0, Void,
};
static int kindsize[] = {
0,
0,
8,
8,
16,
16,
32,
32,
64,
64,
};
// Parse a single type definition from *pp.
static Type*
parsedef(char **pp, char *name)
{
char *p;
Type *t, *tt;
int i;
vlong n1, n2, lo, hi;
Field *f;
Intrange *r;
p = *pp;
// reference to another type?
if(isdigit(*p) || *p == '(') {
if(parsetypenum(&p, &n1, &n2) < 0)
return nil;
t = typebynum(n1, n2);
if(name && t->name == nil) {
t->name = name;
// save definitions of names beginning with $
if(name[0] == '$' && !t->saved) {
typ = erealloc(typ, (ntyp+1)*sizeof typ[0]);
typ[ntyp] = t;
ntyp++;
}
}
// is there an =def suffix?
if(*p == '=') {
p++;
tt = parsedef(&p, name);
if(tt == nil)
return nil;
if(tt == t) {
tt->kind = Void;
} else {
t->type = tt;
t->kind = Typedef;
}
// assign given name, but do not record in typ.
// assume the name came from a typedef
// which will be recorded.
if(name)
tt->name = name;
}
*pp = p;
return t;
}
// otherwise a type literal. first letter identifies kind
t = emalloc(sizeof *t);
switch(*p) {
default:
fprint(2, "unknown type char %c in %s\n", *p, p);
*pp = "";
return t;
case '@': // type attribute
while (*++p != ';');
*pp = ++p;
return parsedef(pp, nil);
case '*': // pointer
p++;
t->kind = Ptr;
tt = parsedef(&p, nil);
if(tt == nil)
return nil;
t->type = tt;
break;
case 'a': // array
p++;
t->kind = Array;
// index type
tt = parsedef(&p, nil);
if(tt == nil)
return nil;
t->size = tt->size;
// element type
tt = parsedef(&p, nil);
if(tt == nil)
return nil;
t->type = tt;
break;
case 'e': // enum type - record $names in con array.
p++;
for(;;) {
if(*p == '\0')
return nil;
if(*p == ';') {
p++;
break;
}
if(parsename(&p, &name) < 0)
return nil;
if(parsenum1(&p, &n1) < 0)
return nil;
if(name[0] == '$') {
con = erealloc(con, (ncon+1)*sizeof con[0]);
name++;
con[ncon].name = name;
con[ncon].value = n1;
ncon++;
}
if(*p != ',')
return nil;
p++;
}
break;
case 'f': // function
p++;
if(parsedef(&p, nil) == nil)
return nil;
break;
case 'B': // volatile
case 'k': // const
++*pp;
return parsedef(pp, nil);
case 'r': // sub-range (used for integers)
p++;
if(parsedef(&p, nil) == nil)
return nil;
// usually, the return from parsedef == t, but not always.
if(*p != ';' || *++p == ';') {
if(stabsdebug)
fprint(2, "range expected number: %s\n", p);
return nil;
}
if(*p == '0')
lo = parseoctal(&p);
else
lo = strtoll(p, &p, 10);
if(*p != ';' || *++p == ';') {
if(stabsdebug)
fprint(2, "range expected number: %s\n", p);
return nil;
}
if(*p == '0')
hi = parseoctal(&p);
else
hi = strtoll(p, &p, 10);
if(*p != ';') {
if(stabsdebug)
fprint(2, "range expected trailing semi: %s\n", p);
return nil;
}
p++;
t->size = hi+1; // might be array size
for(i=0; i<nelem(intranges); i++) {
r = &intranges[i];
if(r->lo == lo && r->hi == hi) {
t->kind = r->kind;
break;
}
}
break;
case 's': // struct
case 'u': // union
t->kind = Struct;
if(*p == 'u')
t->kind = Union;
// assign given name, but do not record in typ.
// assume the name came from a typedef
// which will be recorded.
if(name)
t->name = name;
p++;
if(parsenum1(&p, &n1) < 0)
return nil;
t->size = n1;
for(;;) {
if(*p == '\0')
return nil;
if(*p == ';') {
p++;
break;
}
t->f = erealloc(t->f, (t->nf+1)*sizeof t->f[0]);
f = &t->f[t->nf];
if(parsename(&p, &f->name) < 0)
return nil;
f->type = parsedef(&p, nil);
if(f->type == nil)
return nil;
if(*p != ',') {
fprint(2, "expected comma after def of %s:\n%s\n", f->name, p);
return nil;
}
p++;
if(parsenum1(&p, &n1) < 0)
return nil;
f->offset = n1;
if(*p != ',') {
fprint(2, "expected comma after offset of %s:\n%s\n", f->name, p);
return nil;
}
p++;
if(parsenum1(&p, &n1) < 0)
return nil;
f->size = n1;
if(*p != ';') {
fprint(2, "expected semi after size of %s:\n%s\n", f->name, p);
return nil;
}
while(f->type->kind == Typedef)
f->type = f->type->type;
if(f->type->kind == 0 && f->size <= 64 && (f->size&(f->size-1)) == 0) {
// unknown type but <= 64 bits and bit size is a power of two.
// could be enum - make Uint64 and then let it reduce
tt = emalloc(sizeof *tt);
*tt = *f->type;
f->type = tt;
tt->kind = Uint64;
}
// rewrite
// uint32 x : 8;
// into
// uint8 x;
// hooray for bitfields.
while(Int16 <= f->type->kind && f->type->kind <= Uint64 && kindsize[f->type->kind] > f->size) {
tt = emalloc(sizeof *tt);
*tt = *f->type;
f->type = tt;
f->type->kind -= 2;
}
p++;
t->nf++;
}
break;
case 'x':
// reference to struct, union not yet defined.
p++;
switch(*p) {
case 's':
t->kind = Struct;
break;
case 'u':
t->kind = Union;
break;
default:
fprint(2, "unknown x type char x%c", *p);
*pp = "";
return t;
}
if(parsename(&p, &t->name) < 0)
return nil;
break;
}
*pp = p;
return t;
}
// Parse a stab type in p, saving info in the type hash table
// and also in the list of recorded types if appropriate.
void
parsestabtype(char *p)
{
char *p0, *name;
p0 = p;
// p is the quoted string output from gcc -gstabs on a .stabs line.
// name:t(1,2)
// name:t(1,2)=def
if(parsename(&p, &name) < 0) {
Bad:
// Use fprint instead of sysfatal to avoid
// sysfatal's internal buffer size limit.
fprint(2, "cannot parse stabs type:\n%s\n(at %s)\n", p0, p);
sysfatal("stabs parse");
}
if(*p != 't' && *p != 'T')
goto Bad;
p++;
// parse the definition.
if(name[0] == '\0')
name = nil;
if(parsedef(&p, name) == nil)
goto Bad;
if(*p != '\0')
goto Bad;
}