mirror of
https://github.com/9fans/plan9port.git
synced 2025-01-24 11:41:58 +00:00
add acidtypes
This commit is contained in:
rsc
parent
70e24710a8
commit
98cd2746cf
7 changed files with 1763 additions and 0 deletions
72
src/cmd/acidtypes/dat.h
Normal file
72
src/cmd/acidtypes/dat.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
typedef struct Type Type;
|
||||
typedef struct Typeref Typeref;
|
||||
typedef struct TypeList TypeList;
|
||||
|
||||
enum
|
||||
{
|
||||
None,
|
||||
Base,
|
||||
Enum,
|
||||
Aggr,
|
||||
Function,
|
||||
Pointer,
|
||||
Array,
|
||||
Range,
|
||||
Defer,
|
||||
Typedef,
|
||||
};
|
||||
|
||||
struct Type
|
||||
{ /* Font Tab 4 */
|
||||
uint ty; /* None, Struct, ... */
|
||||
vlong lo; /* for range */
|
||||
char sue;
|
||||
vlong hi;
|
||||
uint gen;
|
||||
uint n1; /* type number (impl dependent) */
|
||||
uint n2; /* another type number */
|
||||
char *name; /* name of type */
|
||||
char *suename; /* name of struct, union, enumeration */
|
||||
uint isunion; /* is this Struct a union? */
|
||||
uint printfmt; /* describes base type */
|
||||
uint xsizeof; /* size of type */
|
||||
Type *sub; /* subtype */
|
||||
uint n; /* count for t, tname, val */
|
||||
Type **t; /* members of sue, params of function */
|
||||
char **tname; /* associated names */
|
||||
long *val; /* associated offsets or values */
|
||||
uint didtypedef; /* internal flag */
|
||||
uint didrange; /* internal flag */
|
||||
uint printed; /* internal flag */
|
||||
Type *equiv; /* internal */
|
||||
};
|
||||
|
||||
struct TypeList
|
||||
{
|
||||
Type *hd;
|
||||
TypeList *tl;
|
||||
};
|
||||
|
||||
void *erealloc(void*, uint);
|
||||
void *emalloc(uint);
|
||||
char *estrdup(char*);
|
||||
void warn(char*, ...);
|
||||
|
||||
Type *typebynum(uint n1, uint n2);
|
||||
Type *typebysue(char, char*);
|
||||
void printtypes(Biobuf*);
|
||||
void renumber(TypeList*, uint);
|
||||
void denumber(void);
|
||||
TypeList *mktl(Type*, TypeList*);
|
||||
|
||||
struct Dwarf;
|
||||
struct Stab;
|
||||
int dwarf2acid(struct Dwarf*, Biobuf*);
|
||||
int stabs2acid(struct Stab*, Biobuf*);
|
||||
|
||||
Type *newtype(void);
|
||||
char *nameof(Type*, int);
|
||||
void freetypes(void);
|
||||
|
||||
extern char *prefix;
|
||||
char *fixname(char*);
|
||||
193
src/cmd/acidtypes/dwarf.c
Normal file
193
src/cmd/acidtypes/dwarf.c
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <mach.h>
|
||||
#include <elf.h>
|
||||
#include <dwarf.h>
|
||||
#include "dat.h"
|
||||
|
||||
static ulong
|
||||
valof(uint ty, DwarfVal *v)
|
||||
{
|
||||
switch(ty){
|
||||
default:
|
||||
fmtinstall('H', encodefmt);
|
||||
fprint(2, "valof %d %.*H\n", ty, v->b.len, v->b.data);
|
||||
return 0;
|
||||
case TConstant:
|
||||
return v->c;
|
||||
}
|
||||
}
|
||||
|
||||
static Type*
|
||||
xnewtype(uint ty, DwarfSym *s)
|
||||
{
|
||||
Type *t;
|
||||
|
||||
t = typebynum(s->unit+s->uoff, 0);
|
||||
t->ty = ty;
|
||||
return t;
|
||||
}
|
||||
|
||||
int
|
||||
dwarf2acid(Dwarf *d, Biobuf *b)
|
||||
{
|
||||
char *fn;
|
||||
DwarfSym s;
|
||||
Type *t;
|
||||
|
||||
/* pass over dwarf section pulling out type info */
|
||||
|
||||
if(dwarfenum(d, &s) < 0)
|
||||
return -1;
|
||||
|
||||
while(dwarfnextsym(d, &s, s.depth!=1) == 1){
|
||||
top:
|
||||
switch(s.attrs.tag){
|
||||
case TagSubprogram:
|
||||
case TagLexDwarfBlock:
|
||||
dwarfnextsym(d, &s, 1);
|
||||
goto top;
|
||||
|
||||
case TagTypedef:
|
||||
t = xnewtype(Typedef, &s);
|
||||
t->name = s.attrs.name;
|
||||
t->sub = typebynum(s.attrs.type, 0);
|
||||
break;
|
||||
case TagBaseType:
|
||||
t = xnewtype(Base, &s);
|
||||
t->xsizeof = s.attrs.bytesize;
|
||||
switch(s.attrs.encoding){
|
||||
default:
|
||||
case TypeAddress:
|
||||
t->printfmt = 'x';
|
||||
break;
|
||||
case TypeBoolean:
|
||||
case TypeUnsigned:
|
||||
case TypeSigned:
|
||||
case TypeSignedChar:
|
||||
case TypeUnsignedChar:
|
||||
t->printfmt = 'd';
|
||||
break;
|
||||
case TypeFloat:
|
||||
t->printfmt = 'f';
|
||||
break;
|
||||
case TypeComplexFloat:
|
||||
t->printfmt = 'F';
|
||||
break;
|
||||
case TypeImaginaryFloat:
|
||||
t->printfmt = 'i';
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case TagPointerType:
|
||||
t = xnewtype(Pointer, &s);
|
||||
t->sub = typebynum(s.attrs.type, 0);
|
||||
break;
|
||||
case TagStructType:
|
||||
case TagUnionType:
|
||||
t = xnewtype(Aggr, &s);
|
||||
t->sue = s.attrs.tag==TagStructType ? 's' : 'u';
|
||||
t->xsizeof = s.attrs.bytesize;
|
||||
t->suename = s.attrs.name;
|
||||
t->isunion = s.attrs.tag==TagUnionType;
|
||||
dwarfnextsym(d, &s, 1);
|
||||
if(s.depth != 2)
|
||||
goto top;
|
||||
do{
|
||||
if(!s.attrs.have.name || !s.attrs.have.type || s.attrs.tag != TagMember)
|
||||
continue;
|
||||
if(t->n%32 == 0){
|
||||
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
|
||||
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
|
||||
t->t = erealloc(t->t, (t->n+32)*sizeof(t->t[0]));
|
||||
}
|
||||
t->tname[t->n] = s.attrs.name;
|
||||
if(t->isunion)
|
||||
t->val[t->n] = 0;
|
||||
else
|
||||
t->val[t->n] = valof(s.attrs.have.datamemberloc, &s.attrs.datamemberloc);
|
||||
t->t[t->n] = typebynum(s.attrs.type, 0);
|
||||
t->n++;
|
||||
}while(dwarfnextsym(d, &s, 1) == 1 && s.depth==2);
|
||||
goto top;
|
||||
break;
|
||||
case TagSubroutineType:
|
||||
t = xnewtype(Function, &s);
|
||||
break;
|
||||
case TagConstType:
|
||||
case TagVolatileType:
|
||||
t = xnewtype(Defer, &s);
|
||||
t->sub = typebynum(s.attrs.type, 0);
|
||||
break;
|
||||
case TagArrayType:
|
||||
t = xnewtype(Array, &s);
|
||||
t->sub = typebynum(s.attrs.type, 0);
|
||||
break;
|
||||
case TagEnumerationType:
|
||||
t = xnewtype(Enum, &s);
|
||||
t->sue = 'e';
|
||||
t->suename = s.attrs.name;
|
||||
t->xsizeof = s.attrs.bytesize;
|
||||
dwarfnextsym(d, &s, 1);
|
||||
if(s.depth != 2)
|
||||
goto top;
|
||||
do{
|
||||
if(!s.attrs.have.name || !s.attrs.have.constvalue || s.attrs.tag != TagEnumerator)
|
||||
continue;
|
||||
if(t->n%32 == 0){
|
||||
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
|
||||
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
|
||||
}
|
||||
t->tname[t->n] = s.attrs.name;
|
||||
t->val[t->n] = valof(s.attrs.have.constvalue, &s.attrs.constvalue);
|
||||
t->n++;
|
||||
}while(dwarfnextsym(d, &s, 1) == 1 && s.depth==2);
|
||||
goto top;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printtypes(b);
|
||||
|
||||
/* pass over dwarf section pulling out type definitions */
|
||||
|
||||
if(dwarfenum(d, &s) < 0)
|
||||
goto out;
|
||||
|
||||
fn = nil;
|
||||
while(dwarfnextsym(d, &s, 1) == 1){
|
||||
if(s.depth == 1)
|
||||
fn = nil;
|
||||
switch(s.attrs.tag){
|
||||
case TagSubprogram:
|
||||
fn = s.attrs.name;
|
||||
break;
|
||||
case TagFormalParameter:
|
||||
if(s.depth != 2)
|
||||
break;
|
||||
/* fall through */
|
||||
case TagVariable:
|
||||
if(s.attrs.name == nil || s.attrs.type == 0)
|
||||
continue;
|
||||
t = typebynum(s.attrs.type, 0);
|
||||
if(t->ty == Pointer){
|
||||
t = t->sub;
|
||||
if(t && t->equiv)
|
||||
t = t->equiv;
|
||||
}
|
||||
if(t == nil)
|
||||
break;
|
||||
if(t->ty != Aggr)
|
||||
break;
|
||||
Bprint(b, "complex %s %s%s%s;\n", nameof(t, 1),
|
||||
fn ? fixname(fn) : "", fn ? ":" : "", fixname(s.attrs.name));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
freetypes();
|
||||
return 0;
|
||||
}
|
||||
|
||||
66
src/cmd/acidtypes/main.c
Normal file
66
src/cmd/acidtypes/main.c
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <mach.h>
|
||||
#include "dat.h"
|
||||
|
||||
void
|
||||
usage(void)
|
||||
{
|
||||
fprint(2, "usage: acidtypes [-p prefix] executable...\n");
|
||||
exits("usage");
|
||||
}
|
||||
|
||||
void
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
Fhdr *fp;
|
||||
Biobuf b;
|
||||
char err[ERRMAX];
|
||||
|
||||
quotefmtinstall();
|
||||
|
||||
ARGBEGIN{
|
||||
case 'p':
|
||||
prefix = EARGF(usage());
|
||||
break;
|
||||
default:
|
||||
usage();
|
||||
}ARGEND
|
||||
|
||||
if(argc < 1)
|
||||
usage();
|
||||
|
||||
Binit(&b, 1, OWRITE);
|
||||
for(i=0; i<argc; i++){
|
||||
Bprint(&b, "\n//\n// symbols for %s\n//\n\n", argv[i]);
|
||||
if((fp = crackhdr(argv[i], OREAD)) == nil){
|
||||
rerrstr(err, sizeof err);
|
||||
Bprint(&b, "// open %s: %s\n\n", argv[i], err);
|
||||
fprint(2, "open %s: %s\n", argv[i], err);
|
||||
continue;
|
||||
}
|
||||
if(fp->dwarf){
|
||||
if(dwarf2acid(fp->dwarf, &b) < 0){
|
||||
rerrstr(err, sizeof err);
|
||||
Bprint(&b, "// dwarf2acid %s: %s\n\n", argv[i], err);
|
||||
fprint(2, "dwarf2acid %s: %s\n", argv[i], err);
|
||||
}
|
||||
}else if(fp->stabs.stabbase){
|
||||
if(stabs2acid(&fp->stabs, &b) < 0){
|
||||
rerrstr(err, sizeof err);
|
||||
Bprint(&b, "// dwarf2acid %s: %s\n\n", argv[i], err);
|
||||
fprint(2, "dwarf2acid %s: %s\n", argv[i], err);
|
||||
}
|
||||
}else{
|
||||
Bprint(&b, "// no debugging symbols in %s\n\n", argv[i]);
|
||||
// fprint(2, "no debugging symbols in %s\n", argv[i]);
|
||||
}
|
||||
uncrackhdr(fp);
|
||||
}
|
||||
Bflush(&b);
|
||||
Bterm(&b);
|
||||
exits(0);
|
||||
}
|
||||
|
||||
23
src/cmd/acidtypes/mkfile
Normal file
23
src/cmd/acidtypes/mkfile
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
<$PLAN9/src/mkhdr
|
||||
|
||||
TARG=acidtypes
|
||||
|
||||
OFILES=\
|
||||
dwarf.$O\
|
||||
main.$O\
|
||||
stabs.$O\
|
||||
type.$O\
|
||||
util.$O\
|
||||
|
||||
HFILES=\
|
||||
dat.h\
|
||||
../../libmach/mach.h\
|
||||
../../libmach/elf.h\
|
||||
../../libmach/dwarf.h\
|
||||
../../libmach/stabs.h\
|
||||
|
||||
CFLAGS=-I../../libmach $CFLAGS
|
||||
SHORTLIB=mach bio 9
|
||||
|
||||
<$PLAN9/src/mkone
|
||||
|
||||
775
src/cmd/acidtypes/stabs.c
Normal file
775
src/cmd/acidtypes/stabs.c
Normal file
|
|
@ -0,0 +1,775 @@
|
|||
#include <u.h>
|
||||
#include <errno.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <mach.h>
|
||||
#include <stabs.h>
|
||||
#include <ctype.h>
|
||||
#include "dat.h"
|
||||
|
||||
static jmp_buf kaboom;
|
||||
|
||||
static Type *parsename(char*, char**);
|
||||
static Type *parseinfo(char*, char**);
|
||||
static int parsenum(char*, int*, int*, char**);
|
||||
static int parseattr(char*, char**, char**);
|
||||
static Type *parsedefn(char *p, Type *t, char **pp);
|
||||
static int parsebound(char**);
|
||||
static vlong parsebigint(char**);
|
||||
|
||||
typedef struct Sym Sym;
|
||||
struct Sym
|
||||
{
|
||||
char *fn;
|
||||
char *name;
|
||||
Type *type;
|
||||
Sym *next;
|
||||
};
|
||||
|
||||
typedef struct Ftypes Ftypes;
|
||||
struct Ftypes
|
||||
{
|
||||
Ftypes *down;
|
||||
Ftypes *next;
|
||||
char *file;
|
||||
TypeList *list;
|
||||
};
|
||||
|
||||
Ftypes *fstack;
|
||||
Ftypes *allftypes;
|
||||
|
||||
static Sym*
|
||||
mksym(char *fn, char *name, Type *type)
|
||||
{
|
||||
Sym *s;
|
||||
|
||||
s = emalloc(sizeof *s);
|
||||
s->fn = fn;
|
||||
s->name = name;
|
||||
s->type = type;
|
||||
return s;
|
||||
}
|
||||
|
||||
static char*
|
||||
estrndup(char *s, int n)
|
||||
{
|
||||
char *t;
|
||||
|
||||
t = emalloc(n+1);
|
||||
memmove(t, s, n);
|
||||
return t;
|
||||
}
|
||||
|
||||
static char*
|
||||
mkpath(char *dir, char *name)
|
||||
{
|
||||
char *s;
|
||||
if(name[0] == '/')
|
||||
return estrdup(name);
|
||||
else{
|
||||
s = emalloc(strlen(dir)+strlen(name)+1);
|
||||
strcpy(s, dir);
|
||||
strcat(s, name);
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
static Ftypes*
|
||||
mkftypes(char *dir, char *name)
|
||||
{
|
||||
Ftypes *f;
|
||||
|
||||
f = emalloc(sizeof(*f));
|
||||
f->file = mkpath(dir, name);
|
||||
f->next = allftypes;
|
||||
allftypes = f;
|
||||
return f;
|
||||
}
|
||||
|
||||
static Ftypes*
|
||||
findftypes(char *dir, char *name)
|
||||
{
|
||||
char *s;
|
||||
Ftypes *f, *found;
|
||||
|
||||
found = nil;
|
||||
s = mkpath(dir, name);
|
||||
for(f=allftypes; f; f=f->next)
|
||||
if(strcmp(f->file, s) == 0)
|
||||
found = f;
|
||||
return found;
|
||||
}
|
||||
|
||||
static void
|
||||
oops(void)
|
||||
{
|
||||
longjmp(kaboom, 1);
|
||||
}
|
||||
|
||||
/* find a : but skip over :: */
|
||||
static char*
|
||||
findcolon(char *p)
|
||||
{
|
||||
while((p = strchr(p, ':')) != nil && *(p+1) == ':')
|
||||
p += 2;
|
||||
if(p == nil)
|
||||
oops();
|
||||
return p;
|
||||
}
|
||||
|
||||
static void
|
||||
semi(char **p)
|
||||
{
|
||||
if(**p != ';')
|
||||
oops();
|
||||
(*p)++;
|
||||
}
|
||||
|
||||
static void
|
||||
comma(char **p)
|
||||
{
|
||||
if(**p != ',')
|
||||
oops();
|
||||
(*p)++;
|
||||
}
|
||||
|
||||
static int
|
||||
parseint(char **pp)
|
||||
{
|
||||
if(!isdigit(**pp))
|
||||
oops();
|
||||
return strtol(*pp, pp, 10);
|
||||
}
|
||||
|
||||
/*
|
||||
name ::= symbol_opt info
|
||||
*/
|
||||
static Type*
|
||||
parsename(char *desc, char **pp)
|
||||
{
|
||||
if(*desc == 'c')
|
||||
return nil;
|
||||
|
||||
if(isdigit(*desc) || *desc=='-' || *desc=='(')
|
||||
return parseinfo(desc, pp);
|
||||
if(*desc == 0)
|
||||
oops();
|
||||
return parseinfo(desc+1, pp);
|
||||
}
|
||||
|
||||
/*
|
||||
info ::= num | num '=' attr* defn
|
||||
*/
|
||||
static Type*
|
||||
parseinfo(char *desc, char **pp)
|
||||
{
|
||||
int n1, n2;
|
||||
Type *t;
|
||||
char *attr;
|
||||
|
||||
parsenum(desc, &n1, &n2, &desc);
|
||||
t = typebynum(n1, n2);
|
||||
if(*desc != '='){
|
||||
*pp = desc;
|
||||
return t;
|
||||
}
|
||||
desc++;
|
||||
if(fstack)
|
||||
fstack->list = mktl(t, fstack->list);
|
||||
while(parseattr(desc, &attr, &desc) >= 0){
|
||||
if(*attr == 's')
|
||||
t->xsizeof = atoi(attr+1)/8;
|
||||
}
|
||||
return parsedefn(desc, t, pp);
|
||||
}
|
||||
|
||||
/*
|
||||
num ::= integer | '(' integer ',' integer ')'
|
||||
*/
|
||||
static int
|
||||
parsenum(char *p, int *n1, int *n2, char **pp)
|
||||
{
|
||||
if(isdigit(*p)){
|
||||
*n1 = strtol(p, &p, 10);
|
||||
*n2 = 0;
|
||||
*pp = p;
|
||||
return 0;
|
||||
}
|
||||
if(*p == '('){
|
||||
*n1 = strtol(p+1, &p, 10);
|
||||
if(*p != ',')
|
||||
oops();
|
||||
*n2 = strtol(p+1, &p, 10);
|
||||
if(*p != ')')
|
||||
oops();
|
||||
*pp = p+1;
|
||||
return 0;
|
||||
}
|
||||
oops();
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
attr ::= '@' text ';'
|
||||
|
||||
text is
|
||||
'a' integer (alignment)
|
||||
'p' integer (pointer class)
|
||||
'P' (packed type)
|
||||
's' integer (size of type in bits)
|
||||
'S' (string instead of array of chars)
|
||||
*/
|
||||
static int
|
||||
parseattr(char *p, char **text, char **pp)
|
||||
{
|
||||
if(*p != '@')
|
||||
return -1;
|
||||
*text = p+1;
|
||||
if((p = strchr(p, ';')) == nil)
|
||||
oops();
|
||||
*pp = p+1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
typedef struct Basic Basic;
|
||||
struct Basic
|
||||
{
|
||||
int size;
|
||||
int fmt;
|
||||
};
|
||||
|
||||
static Basic baseints[] =
|
||||
{
|
||||
0, 0,
|
||||
/*1*/ 4, 'd', /* int32 */
|
||||
/*2*/ 1, 'd', /* char8 */
|
||||
/*3*/ 2, 'd', /* int16 */
|
||||
/*4*/ 4, 'd', /* long int32 */
|
||||
/*5*/ 1, 'x', /* uchar8 */
|
||||
/*6*/ 1, 'd', /* schar8 */
|
||||
/*7*/ 2, 'x', /* uint16 */
|
||||
/*8*/ 4, 'x', /* uint32 */
|
||||
/*9*/ 4, 'x', /* uint32 */
|
||||
/*10*/ 4, 'x', /* ulong32 */
|
||||
/*11*/ 0, 0, /* void */
|
||||
/*12*/ 4, 'f', /* float */
|
||||
/*13*/ 8, 'f', /* double */
|
||||
/*14*/ 10, 'f', /* long double */
|
||||
/*15*/ 4, 'd', /* int32 */
|
||||
/*16*/ 4, 'd', /* bool32 */
|
||||
/*17*/ 2, 'f', /* short real */
|
||||
/*18*/ 4, 'f', /* real */
|
||||
/*19*/ 4, 'x', /* stringptr */
|
||||
/*20*/ 1, 'd', /* character8 */
|
||||
/*21*/ 1, 'x', /* logical*1 */
|
||||
/*22*/ 2, 'x', /* logical*2 */
|
||||
/*23*/ 4, 'X', /* logical*4 */
|
||||
/*24*/ 4, 'X', /* logical32 */
|
||||
/*25*/ 8, 'F', /* complex (two single) */
|
||||
/*26*/ 16, 'F', /* complex (two double) */
|
||||
/*27*/ 1, 'd', /* integer*1 */
|
||||
/*28*/ 2, 'd', /* integer*2 */
|
||||
/*29*/ 4, 'd', /* integer*4 */
|
||||
/*30*/ 2, 'x', /* wide char */
|
||||
/*31*/ 8, 'd', /* int64 */
|
||||
/*32*/ 8, 'x', /* uint64 */
|
||||
/*33*/ 8, 'x', /* logical*8 */
|
||||
/*34*/ 8, 'd', /* integer*8 */
|
||||
};
|
||||
|
||||
static Basic basefloats[] =
|
||||
{
|
||||
0,0,
|
||||
/*1*/ 4, 'f', /* 32-bit */
|
||||
/*2*/ 8, 'f', /* 64-bit */
|
||||
/*3*/ 8, 'F', /* complex */
|
||||
/*4*/ 4, 'F', /* complex16 */
|
||||
/*5*/ 8, 'F', /* complex32 */
|
||||
/*6*/ 10, 'f', /* long double */
|
||||
};
|
||||
|
||||
/*
|
||||
defn ::= info
|
||||
| '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)
|
||||
| '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)
|
||||
*/
|
||||
|
||||
static Type*
|
||||
parsedefn(char *p, Type *t, char **pp)
|
||||
{
|
||||
char c, *name;
|
||||
int ischar, namelen, n, wid, offset, bits, sign;
|
||||
long val;
|
||||
Type *tt;
|
||||
|
||||
if(*p == '(' || isdigit(*p)){
|
||||
t->ty = Defer;
|
||||
t->sub = parseinfo(p, pp);
|
||||
return t;
|
||||
}
|
||||
|
||||
switch(c = *p){
|
||||
case '-': /* builtin */
|
||||
n = strtol(p+1, &p, 10);
|
||||
if(n >= nelem(baseints) || n < 0)
|
||||
n = 0;
|
||||
t->ty = Base;
|
||||
t->xsizeof = baseints[n].size;
|
||||
t->printfmt = baseints[n].fmt;
|
||||
break;
|
||||
case 'b': /* builtin */
|
||||
p++;
|
||||
if(*p != 'u' && *p != 's')
|
||||
oops();
|
||||
sign = (*p == 's');
|
||||
p++;
|
||||
if(*p == 'c'){
|
||||
ischar = 1;
|
||||
p++;
|
||||
}
|
||||
wid = parseint(&p);
|
||||
semi(&p);
|
||||
offset = parseint(&p);
|
||||
semi(&p);
|
||||
bits = parseint(&p);
|
||||
semi(&p);
|
||||
t->ty = Base;
|
||||
t->xsizeof = wid;
|
||||
if(sign == 1)
|
||||
t->printfmt = 'd';
|
||||
else
|
||||
t->printfmt = 'x';
|
||||
break;
|
||||
case 'R': /* fp type */
|
||||
n = parseint(&p);
|
||||
semi(&p);
|
||||
wid = parseint(&p);
|
||||
semi(&p);
|
||||
t->ty = Base;
|
||||
t->xsizeof = wid;
|
||||
if(n < 0 || n >= nelem(basefloats))
|
||||
n = 0;
|
||||
t->xsizeof = basefloats[n].size;
|
||||
t->printfmt = basefloats[n].fmt;
|
||||
break;
|
||||
case 'r': /* subrange */
|
||||
t->ty = Range;
|
||||
t->sub = parseinfo(p+1, &p);
|
||||
if(*(p-1) == ';' && *p != ';')
|
||||
p--;
|
||||
semi(&p);
|
||||
t->lo = parsebound(&p);
|
||||
semi(&p);
|
||||
t->hi = parsebound(&p);
|
||||
semi(&p);
|
||||
break;
|
||||
case 'B': /* volatile */
|
||||
case 'k': /* const */
|
||||
t->ty = Defer;
|
||||
t->sub = parseinfo(p+1, &p);
|
||||
break;
|
||||
case '*': /* pointer */
|
||||
case 'A': /* open array */
|
||||
t->ty = Pointer;
|
||||
t->sub = parseinfo(p+1, &p);
|
||||
break;
|
||||
case 'a': /* array */
|
||||
case 'P': /* packed array */
|
||||
t->ty = Pointer;
|
||||
tt = newtype();
|
||||
parsedefn(p+1, tt, &p); /* index type */
|
||||
if(*p == ';')
|
||||
p++;
|
||||
tt = newtype();
|
||||
t->sub = tt;
|
||||
parsedefn(p, tt, &p); /* element type */
|
||||
break;
|
||||
case 'e': /* enum listing */
|
||||
p++;
|
||||
t->sue = 'e';
|
||||
t->ty = Enum;
|
||||
while(*p != ';'){
|
||||
name = p;
|
||||
p = findcolon(p)+1;
|
||||
namelen = (p-name)-1;
|
||||
val = parsebigint(&p);
|
||||
comma(&p);
|
||||
if(t->n%32 == 0){
|
||||
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
|
||||
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
|
||||
}
|
||||
t->tname[t->n] = estrndup(name, namelen);
|
||||
t->val[t->n] = val;
|
||||
t->n++;
|
||||
}
|
||||
semi(&p);
|
||||
break;
|
||||
|
||||
case 's': /* struct */
|
||||
case 'u': /* union */
|
||||
p++;
|
||||
t->sue = c;
|
||||
t->ty = Aggr;
|
||||
n = parseint(&p);
|
||||
while(*p != ';'){
|
||||
name = p;
|
||||
p = findcolon(p)+1;
|
||||
namelen = (p-name)-1;
|
||||
tt = parseinfo(p, &p);
|
||||
comma(&p);
|
||||
offset = parseint(&p);
|
||||
comma(&p);
|
||||
bits = parseint(&p);
|
||||
semi(&p);
|
||||
if(t->n%32 == 0){
|
||||
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
|
||||
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
|
||||
t->t = erealloc(t->t, (t->n+32)*sizeof(t->t[0]));
|
||||
}
|
||||
t->tname[t->n] = estrndup(name, namelen);
|
||||
t->val[t->n] = offset;
|
||||
t->t[t->n] = tt;
|
||||
t->n++;
|
||||
}
|
||||
semi(&p);
|
||||
break;
|
||||
|
||||
case 'x': /* struct, union, enum reference */
|
||||
p++;
|
||||
t->ty = Defer;
|
||||
if(*p != 's' && *p != 'u' && *p != 'e')
|
||||
oops();
|
||||
c = *p;
|
||||
name = p+1;
|
||||
p = findcolon(p+1);
|
||||
name = estrndup(name, p-name);
|
||||
t->sub = typebysue(c, name);
|
||||
p++;
|
||||
break;
|
||||
|
||||
#if 0 /* AIX */
|
||||
case 'f': /* function */
|
||||
case 'p': /* procedure */
|
||||
case 'F': /* Pascal function */
|
||||
/* case 'R': /* Pascal procedure */
|
||||
/*
|
||||
* Even though we don't use the info, we have
|
||||
* to parse it in case it is embedded in other descriptions.
|
||||
*/
|
||||
t->ty = Function;
|
||||
p++;
|
||||
if(c == 'f' || c == 'F'){
|
||||
t->sub = parseinfo(p, &p);
|
||||
if(*p != ','){
|
||||
if(*p == ';')
|
||||
p++;
|
||||
break;
|
||||
}
|
||||
comma(&p);
|
||||
}
|
||||
n = parseint(&p); /* number of params */
|
||||
semi(&p);
|
||||
while(*p != ';'){
|
||||
if(c == 'F' || c == 'R'){
|
||||
name = p; /* parameter name */
|
||||
p = findcolon(p)+1;
|
||||
}
|
||||
parseinfo(p, &p); /* param type */
|
||||
comma(&p);
|
||||
parseint(&p); /* bool: passed by value? */
|
||||
semi(&p);
|
||||
}
|
||||
semi(&p);
|
||||
break;
|
||||
#endif
|
||||
|
||||
case 'f': /* static function */
|
||||
case 'F': /* global function */
|
||||
t->ty = Function;
|
||||
p++;
|
||||
t->sub = parseinfo(p, &p);
|
||||
break;
|
||||
|
||||
/*
|
||||
* We'll never see any of this stuff.
|
||||
* When we do, we can worry about it.
|
||||
*/
|
||||
case 'D': /* n-dimensional array */
|
||||
case 'E': /* subarray of n-dimensional array */
|
||||
case 'M': /* fortran multiple instance type */
|
||||
case 'N': /* pascal string ptr */
|
||||
case 'S': /* set */
|
||||
case 'c': /* aix complex */
|
||||
case 'd': /* file of */
|
||||
case 'g': /* aix float */
|
||||
case 'n': /* max length string */
|
||||
case 'w': /* aix wide char */
|
||||
case 'z': /* another max length string */
|
||||
default:
|
||||
fprint(2, "unsupported type char %c (%d)\n", *p, *p);
|
||||
oops();
|
||||
}
|
||||
*pp = p;
|
||||
return t;
|
||||
}
|
||||
|
||||
/*
|
||||
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
|
||||
*/
|
||||
static int
|
||||
parsebound(char **pp)
|
||||
{
|
||||
char *p;
|
||||
int n;
|
||||
|
||||
n = 0;
|
||||
p = *pp;
|
||||
switch(*p){
|
||||
case 'A': /* bound is on stack by reference at offset n from arg list */
|
||||
case 'T': /* bound is on stack by value at offset n from arg list */
|
||||
case 'a': /* bound is passed by reference in register n */
|
||||
case 't': /* bound is passed by value in register n */
|
||||
p++;
|
||||
parseint(&p);
|
||||
break;
|
||||
case 'J': /* no bound */
|
||||
p++;
|
||||
break;
|
||||
default:
|
||||
n = parsebigint(&p);
|
||||
break;
|
||||
}
|
||||
*pp = p;
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
bigint ::= '-'? decimal
|
||||
| 0 octal
|
||||
| -1
|
||||
*/
|
||||
static vlong
|
||||
parsebigint(char **pp)
|
||||
{
|
||||
char *p;
|
||||
int n, neg;
|
||||
|
||||
p = *pp;
|
||||
if(*p == '0'){
|
||||
errno = 0;
|
||||
n = strtoll(p, &p, 8);
|
||||
if(errno)
|
||||
n = 0;
|
||||
goto out;
|
||||
}
|
||||
neg = 0;
|
||||
if(*p == '-'){
|
||||
neg = 1;
|
||||
p++;
|
||||
}
|
||||
if(!isdigit(*p))
|
||||
oops();
|
||||
n = strtol(p, &p, 10);
|
||||
if(neg)
|
||||
n = -n;
|
||||
|
||||
out:
|
||||
*pp = p;
|
||||
return n;
|
||||
}
|
||||
|
||||
int
|
||||
stabs2acid(Stab *stabs, Biobuf *b)
|
||||
{
|
||||
int fno, i;
|
||||
char c, *dir, *fn, *file, *name, *desc, *p;
|
||||
Ftypes *f;
|
||||
Type *t, *tt;
|
||||
StabSym sym;
|
||||
Sym *symbols, *s;
|
||||
Sym **lsym;
|
||||
|
||||
dir = nil;
|
||||
file = nil;
|
||||
fno = 0;
|
||||
fn = nil;
|
||||
symbols = nil;
|
||||
lsym = &symbols;
|
||||
for(i=0; stabsym(stabs, i, &sym)>=0; i++){
|
||||
switch(sym.type){
|
||||
case N_SO:
|
||||
if(sym.name){
|
||||
if(sym.name[0] && sym.name[strlen(sym.name)-1] == '/')
|
||||
dir = sym.name;
|
||||
else
|
||||
file = sym.name;
|
||||
}
|
||||
denumber();
|
||||
fstack = nil;
|
||||
fno = 0;
|
||||
break;
|
||||
case N_BINCL:
|
||||
fno++;
|
||||
f = mkftypes(dir, sym.name);
|
||||
f->down = fstack;
|
||||
fstack = f;
|
||||
break;
|
||||
case N_EINCL:
|
||||
if(fstack)
|
||||
fstack = fstack->down;
|
||||
break;
|
||||
case N_EXCL:
|
||||
fno++;
|
||||
if((f = findftypes(dir, sym.name)) == nil){
|
||||
fprint(2, "cannot find remembered %s\n", sym.name);
|
||||
continue;
|
||||
}
|
||||
renumber(f->list, fno);
|
||||
break;
|
||||
case N_GSYM:
|
||||
case N_FUN:
|
||||
case N_PSYM:
|
||||
case N_LSYM:
|
||||
case N_LCSYM:
|
||||
case N_STSYM:
|
||||
case N_RSYM:
|
||||
name = sym.name;
|
||||
if(name == nil){
|
||||
if(sym.type==N_FUN)
|
||||
fn = nil;
|
||||
continue;
|
||||
}
|
||||
if((p = strchr(name, ':')) == nil)
|
||||
continue;
|
||||
name = estrndup(name, p-name);
|
||||
desc = ++p;
|
||||
c = *desc;
|
||||
if(c == 'c'){
|
||||
fprint(2, "skip constant %s\n", name);
|
||||
continue;
|
||||
}
|
||||
if(setjmp(kaboom)){
|
||||
fprint(2, "cannot parse %s\n", name);
|
||||
continue;
|
||||
}
|
||||
t = parsename(desc, &p);
|
||||
if(t == nil)
|
||||
continue;
|
||||
if(*p != 0)
|
||||
fprint(2, "extra desc '%s' in '%s'\n", p, desc);
|
||||
/* void is defined as itself */
|
||||
if(t->ty==Defer && t->sub==t && strcmp(name, "void")==0){
|
||||
t->ty = Base;
|
||||
t->xsizeof = 0;
|
||||
t->printfmt = '0';
|
||||
}
|
||||
if(*name==' ' && *(name+1) == 0)
|
||||
*name = 0;
|
||||
/* attach names to structs, unions, enums */
|
||||
if(c=='T' && *name && t->sue){
|
||||
t->suename = name;
|
||||
if(t->name == nil)
|
||||
t->name = name;
|
||||
tt = typebysue(t->sue, name);
|
||||
tt->ty = Defer;
|
||||
tt->sub = t;
|
||||
}
|
||||
if(c=='t'){
|
||||
tt = newtype();
|
||||
tt->ty = Typedef;
|
||||
tt->name = name;
|
||||
tt->sub = t;
|
||||
}
|
||||
/* define base c types */
|
||||
if(t->ty==None || t->ty==Range){
|
||||
if(strcmp(name, "char") == 0){
|
||||
t->ty = Base;
|
||||
t->xsizeof = 1;
|
||||
t->printfmt = 'x';
|
||||
}
|
||||
if(strcmp(name, "int") == 0){
|
||||
t->ty = Base;
|
||||
t->xsizeof = 4;
|
||||
t->printfmt = 'd';
|
||||
}
|
||||
}
|
||||
/* record declaration in list for later. */
|
||||
if(c != 't' && c != 'T')
|
||||
switch(sym.type){
|
||||
case N_GSYM:
|
||||
*lsym = mksym(nil, name, t);
|
||||
lsym = &(*lsym)->next;
|
||||
break;
|
||||
case N_FUN:
|
||||
fn = name;
|
||||
break;
|
||||
case N_PSYM:
|
||||
case N_LSYM:
|
||||
case N_LCSYM:
|
||||
case N_STSYM:
|
||||
case N_RSYM:
|
||||
*lsym = mksym(fn, name, t);
|
||||
lsym = &(*lsym)->next;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
printtypes(b);
|
||||
|
||||
for(s=symbols; s; s=s->next){
|
||||
t = s->type;
|
||||
if(t->ty == Pointer){
|
||||
t = t->sub;
|
||||
if(t && t->equiv)
|
||||
t = t->equiv;
|
||||
}
|
||||
if(t == nil || t->ty != Aggr)
|
||||
continue;
|
||||
Bprint(b, "complex %s %s%s%s;\n", nameof(t, 1),
|
||||
s->fn ? fixname(s->fn) : "", s->fn ? ":" : "", fixname(s->name));
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
571
src/cmd/acidtypes/type.c
Normal file
571
src/cmd/acidtypes/type.c
Normal file
|
|
@ -0,0 +1,571 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <mach.h>
|
||||
#include <ctype.h>
|
||||
#include "dat.h"
|
||||
|
||||
char *prefix = "";
|
||||
|
||||
static TypeList *thash[1021];
|
||||
static TypeList *namehash[1021];
|
||||
static TypeList *alltypes;
|
||||
|
||||
static uint
|
||||
hash(uint num, uint num1)
|
||||
{
|
||||
return (num*1009 + num1*1013) % nelem(thash);
|
||||
}
|
||||
|
||||
static uint
|
||||
shash(char *s)
|
||||
{
|
||||
uint h;
|
||||
|
||||
h = 0;
|
||||
for(; *s; s++)
|
||||
h = 37*h + *s;
|
||||
return h%nelem(namehash);
|
||||
}
|
||||
|
||||
void
|
||||
addnamehash(Type *t)
|
||||
{
|
||||
uint h;
|
||||
|
||||
if(t->name){
|
||||
h = shash(t->name);
|
||||
namehash[h] = mktl(t, namehash[h]);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
addhash(Type *t)
|
||||
{
|
||||
uint h;
|
||||
|
||||
if(t->n1 || t->n2){
|
||||
h = hash(t->n1, t->n2);
|
||||
thash[h] = mktl(t, thash[h]);
|
||||
}
|
||||
if(t->name)
|
||||
addnamehash(t);
|
||||
}
|
||||
|
||||
Type*
|
||||
typebysue(char sue, char *name)
|
||||
{
|
||||
Type *t;
|
||||
TypeList *tl;
|
||||
|
||||
for(tl=namehash[shash(name)]; tl; tl=tl->tl){
|
||||
t = tl->hd;
|
||||
if(t->sue==sue && t->suename && strcmp(name, t->suename)==0)
|
||||
return t;
|
||||
}
|
||||
t = newtype();
|
||||
if(sue=='e')
|
||||
t->ty = Enum;
|
||||
else
|
||||
t->ty = Aggr;
|
||||
if(sue=='u')
|
||||
t->isunion = 1;
|
||||
t->sue = sue;
|
||||
t->suename = name;
|
||||
addnamehash(t);
|
||||
return t;
|
||||
}
|
||||
|
||||
Type*
|
||||
typebynum(uint n1, uint n2)
|
||||
{
|
||||
Type *t;
|
||||
TypeList *tl;
|
||||
|
||||
if(n1 || n2){
|
||||
for(tl=thash[hash(n1, n2)]; tl; tl=tl->tl){
|
||||
t = tl->hd;
|
||||
if(t->n1==n1 && t->n2==n2)
|
||||
return t;
|
||||
}
|
||||
}
|
||||
|
||||
t = newtype();
|
||||
t->n1 = n1;
|
||||
t->n2 = n2;
|
||||
addhash(t);
|
||||
return t;
|
||||
}
|
||||
|
||||
Type*
|
||||
newtype(void)
|
||||
{
|
||||
Type *t;
|
||||
static int gen;
|
||||
|
||||
t = emalloc(sizeof *t);
|
||||
t->gen = ++gen;
|
||||
alltypes = mktl(t, alltypes);
|
||||
return t;
|
||||
}
|
||||
|
||||
struct {
|
||||
char *old;
|
||||
char *new;
|
||||
} fixes[] = { /* Font Tab 4 */
|
||||
"append", "$append",
|
||||
"builtin", "$builtin",
|
||||
"complex", "$complex",
|
||||
"delete", "$delete",
|
||||
"do", "$do",
|
||||
"else", "$else",
|
||||
"eval", "$eval",
|
||||
"fmt", "$fmt",
|
||||
"fn", "$fn",
|
||||
"head", "$head",
|
||||
"if", "$if",
|
||||
"local", "$local",
|
||||
"loop", "$loop",
|
||||
"ret", "$ret",
|
||||
"tail", "$tail",
|
||||
"then", "$then",
|
||||
"whatis", "$whatis",
|
||||
"while", "$while",
|
||||
};
|
||||
|
||||
char*
|
||||
fixname(char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(name == nil)
|
||||
return nil;
|
||||
for(i=0; i<nelem(fixes); i++)
|
||||
if(name[0]==fixes[i].old[0] && strcmp(name, fixes[i].old)==0)
|
||||
return fixes[i].new;
|
||||
return name;
|
||||
}
|
||||
|
||||
void
|
||||
denumber(void)
|
||||
{
|
||||
memset(thash, 0, sizeof thash);
|
||||
memset(namehash, 0, sizeof namehash);
|
||||
}
|
||||
|
||||
void
|
||||
renumber(TypeList *tl, uint n1)
|
||||
{
|
||||
Type *t;
|
||||
|
||||
for(; tl; tl=tl->tl){
|
||||
t = tl->hd;
|
||||
t->n1 = n1;
|
||||
addhash(t);
|
||||
}
|
||||
}
|
||||
|
||||
static Type*
|
||||
defer(Type *t)
|
||||
{
|
||||
Type *u, *oldt;
|
||||
int n;
|
||||
|
||||
u = t;
|
||||
n = 0;
|
||||
oldt = t;
|
||||
while(t && (t->ty == Defer || t->ty == Typedef)){
|
||||
if(n++%2)
|
||||
u = u->sub;
|
||||
t = t->sub;
|
||||
if(t == u) /* cycle */
|
||||
goto cycle;
|
||||
}
|
||||
return t;
|
||||
|
||||
cycle:
|
||||
fprint(2, "cycle\n");
|
||||
t = oldt;
|
||||
n = 0;
|
||||
while(t && (t->ty==Defer || t->ty==Typedef)){
|
||||
fprint(2, "t %p/%d %s\n", t, t->ty, t->name);
|
||||
if(t == u && n++ == 2)
|
||||
break;
|
||||
t = t->sub;
|
||||
}
|
||||
return u;
|
||||
}
|
||||
|
||||
static void
|
||||
dotypedef(Type *t)
|
||||
{
|
||||
if(t->ty != Typedef && t->ty != Defer)
|
||||
return;
|
||||
|
||||
if(t->didtypedef)
|
||||
return;
|
||||
|
||||
t->didtypedef = 1;
|
||||
if(t->sub == nil)
|
||||
return;
|
||||
|
||||
/* push names downward to remove anonymity */
|
||||
if(t->name && t->sub->name == nil)
|
||||
t->sub->name = t->name;
|
||||
|
||||
dotypedef(t->sub);
|
||||
}
|
||||
|
||||
static int
|
||||
countbytes(uvlong x)
|
||||
{
|
||||
int n;
|
||||
|
||||
for(n=0; x; n++)
|
||||
x>>=8;
|
||||
return n;
|
||||
}
|
||||
|
||||
static void
|
||||
dorange(Type *t)
|
||||
{
|
||||
Type *tt;
|
||||
|
||||
if(t->ty != Range)
|
||||
return;
|
||||
if(t->didrange)
|
||||
return;
|
||||
t->didrange = 1;
|
||||
tt = defer(t->sub);
|
||||
if(tt == nil)
|
||||
return;
|
||||
dorange(tt);
|
||||
if(t != tt && tt->ty != Base)
|
||||
return;
|
||||
t->ty = Base;
|
||||
t->xsizeof = tt->xsizeof;
|
||||
if(t->lo == 0)
|
||||
t->printfmt = 'x';
|
||||
else
|
||||
t->printfmt = 'd';
|
||||
if(t->xsizeof == 0)
|
||||
t->xsizeof = countbytes(t->hi);
|
||||
}
|
||||
|
||||
|
||||
char*
|
||||
nameof(Type *t, int doanon)
|
||||
{
|
||||
static char buf[1024];
|
||||
char *p;
|
||||
|
||||
if(t->name)
|
||||
strcpy(buf, fixname(t->name));
|
||||
else if(t->suename)
|
||||
snprint(buf, sizeof buf, "%s_%s", t->isunion ? "union" : "struct", t->suename);
|
||||
else if(doanon)
|
||||
snprint(buf, sizeof buf, "%s_%lud_", prefix, t->gen);
|
||||
else
|
||||
return "";
|
||||
for(p=buf; *p; p++)
|
||||
if(isspace(*p))
|
||||
*p = '_';
|
||||
return buf;
|
||||
}
|
||||
|
||||
static char
|
||||
basecharof(Type *t) //XXX
|
||||
{
|
||||
switch(t->xsizeof){
|
||||
default:
|
||||
return 'X';
|
||||
case 1:
|
||||
return 'b';
|
||||
case 2:
|
||||
if(t->printfmt=='d')
|
||||
return 'd';
|
||||
else
|
||||
return 'x';
|
||||
case 4:
|
||||
if(t->printfmt=='d')
|
||||
return 'D';
|
||||
else if(t->printfmt=='f')
|
||||
return 'f';
|
||||
else
|
||||
return 'X';
|
||||
case 8:
|
||||
if(t->printfmt=='d')
|
||||
return 'V';
|
||||
else if(t->printfmt=='f')
|
||||
return 'F';
|
||||
else
|
||||
return 'Y';
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
nilstrcmp(char *a, char *b)
|
||||
{
|
||||
if(a == b)
|
||||
return 0;
|
||||
if(a == nil)
|
||||
return -1;
|
||||
if(b == nil)
|
||||
return 1;
|
||||
return strcmp(a, b);
|
||||
}
|
||||
|
||||
static int
|
||||
typecmp(Type *t, Type *u)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(t == u)
|
||||
return 0;
|
||||
if(t == nil)
|
||||
return -1;
|
||||
if(u == nil)
|
||||
return 1;
|
||||
|
||||
if(t->ty < u->ty)
|
||||
return -1;
|
||||
if(t->ty > u->ty)
|
||||
return 1;
|
||||
|
||||
if(t->isunion != u->isunion)
|
||||
return t->isunion - u->isunion;
|
||||
|
||||
i = nilstrcmp(t->name, u->name);
|
||||
if(i)
|
||||
return i;
|
||||
|
||||
i = nilstrcmp(t->suename, u->suename);
|
||||
if(i)
|
||||
return i;
|
||||
|
||||
if(t->name || t->suename)
|
||||
return 0;
|
||||
|
||||
if(t->ty==Enum){
|
||||
if(t->n < u->n)
|
||||
return -1;
|
||||
if(t->n > u->n)
|
||||
return 1;
|
||||
if(t->n == 0)
|
||||
return 0;
|
||||
i = strcmp(t->tname[0], u->tname[0]);
|
||||
return i;
|
||||
}
|
||||
if(t < u)
|
||||
return -1;
|
||||
if(t > u)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
qtypecmp(const void *va, const void *vb)
|
||||
{
|
||||
Type *t, *u;
|
||||
|
||||
t = *(Type**)va;
|
||||
u = *(Type**)vb;
|
||||
return typecmp(t, u);
|
||||
}
|
||||
|
||||
void
|
||||
printtype(Biobuf *b, Type *t)
|
||||
{
|
||||
char *name;
|
||||
int j, nprint;
|
||||
Type *tt, *ttt;
|
||||
|
||||
if(t->printed)
|
||||
return;
|
||||
t->printed = 1;
|
||||
switch(t->ty){
|
||||
case Aggr:
|
||||
name = nameof(t, 1);
|
||||
Bprint(b, "sizeof%s = %lud;\n", name, t->xsizeof);
|
||||
Bprint(b, "aggr %s {\n", name);
|
||||
nprint = 0;
|
||||
for(j=0; j<t->n; j++){
|
||||
tt = defer(t->t[j]);
|
||||
if(tt && tt->equiv)
|
||||
tt = tt->equiv;
|
||||
if(tt == nil){
|
||||
Bprint(b, "// oops: nil type\n");
|
||||
continue;
|
||||
}
|
||||
switch(tt->ty){
|
||||
default:
|
||||
Bprint(b, "// oops: unknown type %d for %p/%s (%d,%d; %c,%s; %p)\n",
|
||||
tt->ty, tt, fixname(t->tname[j]),
|
||||
tt->n1, tt->n2, tt->sue ? tt->sue : '.', tt->suename, tt->sub);
|
||||
Bprint(b, "// t->t[j] = %p\n", ttt=t->t[j]);
|
||||
while(ttt){
|
||||
Bprint(b, "// %s %d (%d,%d) sub %p\n", ttt->name, ttt->ty, ttt->n1, ttt->n2, ttt->sub);
|
||||
ttt=ttt->sub;
|
||||
}
|
||||
case Base:
|
||||
case Pointer:
|
||||
case Enum:
|
||||
case Array:
|
||||
case Function:
|
||||
nprint++;
|
||||
Bprint(b, "\t'%c' %lud %s;\n", basecharof(tt), t->val[j], fixname(t->tname[j]));
|
||||
break;
|
||||
case Aggr:
|
||||
nprint++;
|
||||
Bprint(b, "\t%s %lud %s;\n", nameof(tt, 1), t->val[j], fixname(t->tname[j]));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(nprint == 0)
|
||||
Bprint(b, "\t'X' 0 __dummy;\n");
|
||||
Bprint(b, "};\n\n");
|
||||
|
||||
name = nameof(t, 1); /* might have smashed it */
|
||||
Bprint(b, "defn %s(addr) { indent_%s(addr, \"\"); }\n", name, name);
|
||||
Bprint(b, "defn\nindent_%s(addr, indent) {\n", name);
|
||||
Bprint(b, "\tcomplex %s addr;\n", name);
|
||||
for(j=0; j<t->n; j++){
|
||||
name = fixname(t->tname[j]);
|
||||
tt = defer(t->t[j]);
|
||||
if(tt == nil){
|
||||
Bprint(b, "// oops nil %s\n", name);
|
||||
continue;
|
||||
}
|
||||
switch(tt->ty){
|
||||
case Base:
|
||||
base:
|
||||
Bprint(b, "\tprint(indent, \"%s\t\", addr.%s, \"\\n\");\n",
|
||||
name, name);
|
||||
break;
|
||||
case Pointer:
|
||||
ttt = defer(tt->sub);
|
||||
if(ttt && ttt->ty == Aggr)
|
||||
Bprint(b, "\tprint(indent, \"%s\t%s(\", addr.%s, \")\\n\");\n",
|
||||
name, nameof(ttt, 1), name);
|
||||
else
|
||||
goto base;
|
||||
break;
|
||||
case Array:
|
||||
Bprint(b, "\tprint(indent, \"%s\t\", addr.%s\\X, \"\\n\");\n",
|
||||
name, name);
|
||||
break;
|
||||
case Enum:
|
||||
Bprint(b, "\tprint(indent, \"%s\t\", addr.%s, \" \", %s(addr.%s), \"\\n\");\n",
|
||||
name, name, nameof(tt, 1), name);
|
||||
break;
|
||||
case Aggr:
|
||||
Bprint(b, "\tprint(indent, \"%s\t%s{\\n\");\n",
|
||||
name, nameof(tt, 0));
|
||||
Bprint(b, "\tindent_%s(addr+%lud, indent+\" \");\n",
|
||||
nameof(tt, 1), t->val[j]);
|
||||
Bprint(b, "\tprint(indent, \"\t}\\n\");\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
Bprint(b, "};\n\n");
|
||||
break;
|
||||
|
||||
case Enum:
|
||||
name = nameof(t, 1);
|
||||
Bprint(b, "// enum %s\n", name);
|
||||
for(j=0; j<t->n; j++)
|
||||
Bprint(b, "%s = %ld;\n", fixname(t->tname[j]), t->val[j]);
|
||||
|
||||
Bprint(b, "vals_%s = {\n", name);
|
||||
for(j=0; j<t->n; j++)
|
||||
Bprint(b, "\t%lud,\n", t->val[j]);
|
||||
Bprint(b, "};\n");
|
||||
Bprint(b, "names_%s = {\n", name);
|
||||
for(j=0; j<t->n; j++)
|
||||
Bprint(b, "\t\"%s\",\n", fixname(t->tname[j]));
|
||||
Bprint(b, "};\n");
|
||||
Bprint(b, "defn\n%s(val) {\n", name);
|
||||
Bprint(b, "\tlocal i;\n");
|
||||
Bprint(b, "\ti = match(val, vals_%s);\n", name);
|
||||
Bprint(b, "\tif i >= 0 then return names_%s[i];\n", name);
|
||||
Bprint(b, "\treturn \"???\";\n");
|
||||
Bprint(b, "};\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
printtypes(Biobuf *b)
|
||||
{
|
||||
int i, n, nn;
|
||||
Type *t, *tt, **all;
|
||||
TypeList *tl;
|
||||
|
||||
/* check that pointer resolved */
|
||||
for(tl=alltypes; tl; tl=tl->tl){
|
||||
t = tl->hd;
|
||||
if(t->ty==None){
|
||||
if(t->n1 || t->n2)
|
||||
warn("type %d,%d referenced but not defined", t->n1, t->n2);
|
||||
else if(t->sue && t->suename)
|
||||
warn("%s %s referenced but not defined",
|
||||
t->sue=='s' ? "struct" :
|
||||
t->sue=='u' ? "union" :
|
||||
t->sue=='e' ? "enum" : "???", t->suename);
|
||||
}
|
||||
}
|
||||
|
||||
/* push typedefs down, base types up */
|
||||
n = 0;
|
||||
for(tl=alltypes; tl; tl=tl->tl){
|
||||
n++;
|
||||
t = tl->hd;
|
||||
if(t->ty == Typedef || t->ty == Defer)
|
||||
dotypedef(t);
|
||||
}
|
||||
|
||||
/* push ranges around */
|
||||
for(tl=alltypes; tl; tl=tl->tl)
|
||||
dorange(tl->hd);
|
||||
|
||||
/*
|
||||
* only take one type of a given name; acid is going to do this anyway,
|
||||
* and this will reduce the amount of code we output considerably.
|
||||
* we could run a DFA equivalence relaxation sort of algorithm
|
||||
* to find the actual equivalence classes, and then rename types
|
||||
* appropriately, but this will do for now.
|
||||
*/
|
||||
all = emalloc(n*sizeof(all[0]));
|
||||
n = 0;
|
||||
for(tl=alltypes; tl; tl=tl->tl)
|
||||
all[n++] = tl->hd;
|
||||
|
||||
qsort(all, n, sizeof(all[0]), qtypecmp);
|
||||
|
||||
nn = 0;
|
||||
for(i=0; i<n; i++){
|
||||
if(i==0 || typecmp(all[i-1], all[i]) != 0)
|
||||
all[nn++] = all[i];
|
||||
else
|
||||
all[i]->equiv = all[nn-1];
|
||||
}
|
||||
|
||||
for(tl=alltypes; tl; tl=tl->tl){
|
||||
t = tl->hd;
|
||||
tt = defer(t);
|
||||
if(tt && tt->equiv)
|
||||
t->equiv = tt->equiv;
|
||||
}
|
||||
|
||||
for(i=0; i<nn; i++)
|
||||
printtype(b, all[i]);
|
||||
|
||||
free(all);
|
||||
}
|
||||
|
||||
void
|
||||
freetypes(void)
|
||||
{
|
||||
memset(thash, 0, sizeof(thash));
|
||||
memset(namehash, 0, sizeof namehash);
|
||||
}
|
||||
63
src/cmd/acidtypes/util.c
Normal file
63
src/cmd/acidtypes/util.c
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <mach.h>
|
||||
#include "dat.h"
|
||||
|
||||
static int nwarn;
|
||||
|
||||
void
|
||||
warn(char *fmt, ...)
|
||||
{
|
||||
va_list arg;
|
||||
|
||||
if(++nwarn < 5){
|
||||
va_start(arg, fmt);
|
||||
fprint(2, "warning: ");
|
||||
vfprint(2, fmt, arg);
|
||||
fprint(2, "\n");
|
||||
va_end(arg);
|
||||
}else if(nwarn == 5)
|
||||
fprint(2, "[additional warnings elided...]\n");
|
||||
}
|
||||
|
||||
void*
|
||||
erealloc(void *v, uint n)
|
||||
{
|
||||
v = realloc(v, n);
|
||||
if(v == nil)
|
||||
sysfatal("realloc: %r");
|
||||
return v;
|
||||
}
|
||||
|
||||
void*
|
||||
emalloc(uint n)
|
||||
{
|
||||
void *v;
|
||||
|
||||
v = mallocz(n, 1);
|
||||
if(v == nil)
|
||||
sysfatal("malloc: %r");
|
||||
return v;
|
||||
}
|
||||
|
||||
char*
|
||||
estrdup(char *s)
|
||||
{
|
||||
s = strdup(s);
|
||||
if(s == nil)
|
||||
sysfatal("strdup: %r");
|
||||
return s;
|
||||
}
|
||||
|
||||
TypeList*
|
||||
mktl(Type *hd, TypeList *tail)
|
||||
{
|
||||
TypeList *tl;
|
||||
|
||||
tl = emalloc(sizeof(*tl));
|
||||
tl->hd = hd;
|
||||
tl->tl = tail;
|
||||
return tl;
|
||||
}
|
||||
|
||||
Loading…
Reference in a new issue