tstabs.c - plan9port - [fork] Plan 9 from user space
HTML git clone git://src.adamsgaard.dk/plan9port
DIR Log
DIR Files
DIR Refs
DIR README
DIR LICENSE
---
tstabs.c (15296B)
---
1 #include <u.h>
2 #include <errno.h>
3 #include <libc.h>
4 #include <bio.h>
5 #include <mach.h>
6 #include <stabs.h>
7 #include <ctype.h>
8 #include "dat.h"
9
10 static jmp_buf kaboom;
11
12 static Type *parsename(char*, char**);
13 static Type *parseinfo(char*, char**);
14 static int parsenum(char*, int*, int*, char**);
15 static int parseattr(char*, char**, char**);
16 static Type *parsedefn(char *p, Type *t, char **pp);
17 static int parsebound(char**);
18 static vlong parsebigint(char**);
19
20 typedef struct Ftypes Ftypes;
21 struct Ftypes
22 {
23 Ftypes *down;
24 Ftypes *next;
25 char *file;
26 TypeList *list;
27 };
28
29 Ftypes *fstack;
30 Ftypes *allftypes;
31
32 static char*
33 estrndup(char *s, int n)
34 {
35 char *t;
36
37 t = emalloc(n+1);
38 memmove(t, s, n);
39 return t;
40 }
41
42 static char*
43 mkpath(char *dir, char *name)
44 {
45 char *s;
46 if(name[0] == '/' || dir == nil)
47 return estrdup(name);
48 else{
49 s = emalloc(strlen(dir)+strlen(name)+1);
50 strcpy(s, dir);
51 strcat(s, name);
52 return s;
53 }
54 }
55
56 static Ftypes*
57 mkftypes(char *dir, char *name)
58 {
59 Ftypes *f;
60
61 f = emalloc(sizeof(*f));
62 f->file = mkpath(dir, name);
63 f->next = allftypes;
64 allftypes = f;
65 return f;
66 }
67
68 static Ftypes*
69 findftypes(char *dir, char *name)
70 {
71 char *s;
72 Ftypes *f, *found;
73
74 found = nil;
75 s = mkpath(dir, name);
76 for(f=allftypes; f; f=f->next)
77 if(strcmp(f->file, s) == 0)
78 found = f;
79 return found;
80 }
81
82 static void
83 oops(void)
84 {
85 longjmp(kaboom, 1);
86 }
87
88 /* find a : but skip over :: */
89 static char*
90 findcolon(char *p)
91 {
92 while((p = strchr(p, ':')) != nil && *(p+1) == ':')
93 p += 2;
94 if(p == nil)
95 oops();
96 return p;
97 }
98
99 static void
100 semi(char **p)
101 {
102 if(**p != ';')
103 oops();
104 (*p)++;
105 }
106
107 static void
108 comma(char **p)
109 {
110 if(**p != ',')
111 oops();
112 (*p)++;
113 }
114
115 static int
116 parseint(char **pp)
117 {
118 if(!isdigit((uchar)**pp))
119 oops();
120 return strtol(*pp, pp, 10);
121 }
122
123 /*
124 name ::= symbol_opt info
125 */
126 static Type*
127 parsename(char *desc, char **pp)
128 {
129 if(*desc == 'c')
130 return nil;
131
132 if(isdigit((uchar)*desc) || *desc=='-' || *desc=='(')
133 return parseinfo(desc, pp);
134 if(*desc == 0)
135 oops();
136 return parseinfo(desc+1, pp);
137 }
138
139 /*
140 info ::= num | num '=' attr* defn
141 */
142 static Type*
143 parseinfo(char *desc, char **pp)
144 {
145 int n1, n2;
146 Type *t;
147 char *attr;
148
149 n1 = n2 = 0;
150 parsenum(desc, &n1, &n2, &desc);
151 t = typebynum(n1, n2);
152 if(*desc != '='){
153 *pp = desc;
154 return t;
155 }
156 desc++;
157 if(fstack)
158 fstack->list = mktl(t, fstack->list);
159 while(parseattr(desc, &attr, &desc) >= 0){
160 if(*attr == 's')
161 t->xsizeof = atoi(attr+1)/8;
162 }
163 return parsedefn(desc, t, pp);
164 }
165
166 /*
167 num ::= integer | '(' integer ',' integer ')'
168 */
169 static int
170 parsenum(char *p, int *n1, int *n2, char **pp)
171 {
172 if(isdigit((uchar)*p)){
173 *n1 = strtol(p, &p, 10);
174 *n2 = 0;
175 *pp = p;
176 return 0;
177 }
178 if(*p == '('){
179 *n1 = strtol(p+1, &p, 10);
180 if(*p != ',')
181 oops();
182 *n2 = strtol(p+1, &p, 10);
183 if(*p != ')')
184 oops();
185 *pp = p+1;
186 return 0;
187 }
188 oops();
189 return -1;
190 }
191
192 /*
193 attr ::= '@' text ';'
194
195 text is
196 'a' integer (alignment)
197 'p' integer (pointer class)
198 'P' (packed type)
199 's' integer (size of type in bits)
200 'S' (string instead of array of chars)
201 */
202 static int
203 parseattr(char *p, char **text, char **pp)
204 {
205 if(*p != '@')
206 return -1;
207 *text = p+1;
208 if((p = strchr(p, ';')) == nil)
209 oops();
210 *pp = p+1;
211 return 0;
212 }
213
214
215 typedef struct Basic Basic;
216 struct Basic
217 {
218 int size;
219 int fmt;
220 };
221
222 static Basic baseints[] =
223 {
224 0, 0,
225 /*1*/ 4, 'd', /* int32 */
226 /*2*/ 1, 'd', /* char8 */
227 /*3*/ 2, 'd', /* int16 */
228 /*4*/ 4, 'd', /* long int32 */
229 /*5*/ 1, 'x', /* uchar8 */
230 /*6*/ 1, 'd', /* schar8 */
231 /*7*/ 2, 'x', /* uint16 */
232 /*8*/ 4, 'x', /* uint32 */
233 /*9*/ 4, 'x', /* uint32 */
234 /*10*/ 4, 'x', /* ulong32 */
235 /*11*/ 0, 0, /* void */
236 /*12*/ 4, 'f', /* float */
237 /*13*/ 8, 'f', /* double */
238 /*14*/ 10, 'f', /* long double */
239 /*15*/ 4, 'd', /* int32 */
240 /*16*/ 4, 'd', /* bool32 */
241 /*17*/ 2, 'f', /* short real */
242 /*18*/ 4, 'f', /* real */
243 /*19*/ 4, 'x', /* stringptr */
244 /*20*/ 1, 'd', /* character8 */
245 /*21*/ 1, 'x', /* logical*1 */
246 /*22*/ 2, 'x', /* logical*2 */
247 /*23*/ 4, 'X', /* logical*4 */
248 /*24*/ 4, 'X', /* logical32 */
249 /*25*/ 8, 'F', /* complex (two single) */
250 /*26*/ 16, 'F', /* complex (two double) */
251 /*27*/ 1, 'd', /* integer*1 */
252 /*28*/ 2, 'd', /* integer*2 */
253 /*29*/ 4, 'd', /* integer*4 */
254 /*30*/ 2, 'x', /* wide char */
255 /*31*/ 8, 'd', /* int64 */
256 /*32*/ 8, 'x', /* uint64 */
257 /*33*/ 8, 'x', /* logical*8 */
258 /*34*/ 8, 'd', /* integer*8 */
259 };
260
261 static Basic basefloats[] =
262 {
263 0,0,
264 /*1*/ 4, 'f', /* 32-bit */
265 /*2*/ 8, 'f', /* 64-bit */
266 /*3*/ 8, 'F', /* complex */
267 /*4*/ 4, 'F', /* complex16 */
268 /*5*/ 8, 'F', /* complex32 */
269 /*6*/ 10, 'f', /* long double */
270 };
271
272 /*
273 defn ::= info
274 | 'b' ('u' | 's') 'c'? width; offset; nbits; (builtin, signed/unsigned, char/not, width in bytes, offset & nbits of type)
275 | 'w' (aix wide char type, not used)
276 | 'R' fptype; bytes; (fptype 1=32-bit, 2=64-bit, 3=complex, 4=complex16, 5=complex32, 6=long double)
277 | 'g' typeinfo ';' nbits (aix floating, not used)
278 | 'c' typeinfo ';' nbits (aix complex, not used)
279 | 'b' typeinfo ';' bytes (ibm, no idea)
280 | 'B' typeinfo (volatile typref)
281 | 'd' typeinfo (file of typeref)
282 | 'k' typeinfo (const typeref)
283 | 'M' typeinfo ';' length (multiple instance type, fortran)
284 | 'S' typeinfo (set, typeref must have small number of values)
285 | '*' typeinfo (pointer to typeref)
286 | 'x' ('s'|'u'|'e') name ':' (struct, union, enum reference. name can have '::' in it)
287 | 'r' typeinfo ';' low ';' high ';' (subrange. typeref can be type being defined for base types!)
288 low and high are bounds
289 if bound is octal power of two, it's a big negative number
290 | ('a'|'P') indextypedef arraytypeinfo (array, index should be range type)
291 indextype is type definition not typeinfo (need not say typenum=)
292 P means packed array
293 | 'A' arraytypeinfo (open array (no index bounds))
294 | 'D' dims ';' typeinfo (dims-dimensional dynamic array)
295 | 'E' dims ';' typeinfo (subarray of N-dimensional array)
296 | 'n' typeinfo ';' bytes (max length string)
297 | 'z' typeinfo ';' bytes (no idea what difference is from 'n')
298 | 'N' (pascal stringptr)
299 | 'e' (name ':' bigint ',')* ';' (enum listing)
300 | ('s'|'u') bytes (name ':' type ',' bitoffset ',' bitsize ';')* ';' (struct/union defn)
301 tag is given as name in stabs entry, with 'T' symbol
302 | 'f' typeinfo ';' (function returning type)
303 | 'f' rettypeinfo ',' paramcount ';' (typeinfo ',' (0|1) ';')* ';'
304 | 'p' paramcount ';' (typeinfo ',' (0|1) ';')* ';'
305 | 'F' rettypeinfo ',' paramcount ';' (name ':' typeinfo ',' (0|1) ';')* ';'
306 | 'R' paramcount ';' (name ':' typeinfo ',' (0|1) ';')* ';'
307 (the 0 or 1 is pass-by-reference vs pass-by-value)
308 (the 0 or 1 is pass-by-reference vs pass-by-value)
309 */
310
311 static Type*
312 parsedefn(char *p, Type *t, char **pp)
313 {
314 char c, *name;
315 int ischar, namelen, n, wid, offset, bits, sign;
316 long val;
317 Type *tt;
318
319 if(*p == '(' || isdigit((uchar)*p)){
320 t->ty = Defer;
321 t->sub = parseinfo(p, pp);
322 return t;
323 }
324
325 switch(c = *p){
326 case '-': /* builtin */
327 n = strtol(p+1, &p, 10);
328 if(n >= nelem(baseints) || n < 0)
329 n = 0;
330 t->ty = Base;
331 t->xsizeof = baseints[n].size;
332 t->printfmt = baseints[n].fmt;
333 break;
334 case 'b': /* builtin */
335 p++;
336 if(*p != 'u' && *p != 's')
337 oops();
338 sign = (*p == 's');
339 p++;
340 ischar = 0;
341 if(*p == 'c'){
342 ischar = 1;
343 p++;
344 }
345 wid = parseint(&p);
346 semi(&p);
347 offset = parseint(&p);
348 semi(&p);
349 bits = parseint(&p);
350 semi(&p);
351 t->ty = Base;
352 t->xsizeof = wid;
353 if(sign == 1)
354 t->printfmt = 'd';
355 else
356 t->printfmt = 'x';
357 USED(bits);
358 USED(ischar);
359 break;
360 case 'R': /* fp type */
361 n = parseint(&p);
362 semi(&p);
363 wid = parseint(&p);
364 semi(&p);
365 t->ty = Base;
366 t->xsizeof = wid;
367 if(n < 0 || n >= nelem(basefloats))
368 n = 0;
369 t->xsizeof = basefloats[n].size;
370 t->printfmt = basefloats[n].fmt;
371 break;
372 case 'r': /* subrange */
373 t->ty = Range;
374 t->sub = parseinfo(p+1, &p);
375 if(*(p-1) == ';' && *p != ';')
376 p--;
377 semi(&p);
378 t->lo = parsebound(&p);
379 semi(&p);
380 t->hi = parsebound(&p);
381 semi(&p);
382 break;
383 case 'B': /* volatile */
384 case 'k': /* const */
385 t->ty = Defer;
386 t->sub = parseinfo(p+1, &p);
387 break;
388 case '*': /* pointer */
389 case 'A': /* open array */
390 case '&': /* reference */ /* guess - C++? (rob) */
391 t->ty = Pointer;
392 t->sub = parseinfo(p+1, &p);
393 break;
394 case 'a': /* array */
395 case 'P': /* packed array */
396 t->ty = Pointer;
397 tt = newtype();
398 parsedefn(p+1, tt, &p); /* index type */
399 if(*p == ';')
400 p++;
401 tt = newtype();
402 t->sub = tt;
403 parsedefn(p, tt, &p); /* element type */
404 break;
405 case 'e': /* enum listing */
406 p++;
407 t->sue = 'e';
408 t->ty = Enum;
409 while(*p != ';'){
410 name = p;
411 p = findcolon(p)+1;
412 namelen = (p-name)-1;
413 val = parsebigint(&p);
414 comma(&p);
415 if(t->n%32 == 0){
416 t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
417 t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
418 }
419 t->tname[t->n] = estrndup(name, namelen);
420 t->val[t->n] = val;
421 t->n++;
422 }
423 semi(&p);
424 break;
425
426 case 's': /* struct */
427 case 'u': /* union */
428 p++;
429 t->sue = c;
430 t->ty = Aggr;
431 n = parseint(&p);
432 while(*p != ';'){
433 name = p;
434 p = findcolon(p)+1;
435 namelen = (p-name)-1;
436 tt = parseinfo(p, &p);
437 comma(&p);
438 offset = parseint(&p);
439 comma(&p);
440 bits = parseint(&p);
441 semi(&p);
442 if(t->n%32 == 0){
443 t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
444 t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
445 t->t = erealloc(t->t, (t->n+32)*sizeof(t->t[0]));
446 }
447 t->tname[t->n] = estrndup(name, namelen);
448 t->val[t->n] = offset;
449 t->t[t->n] = tt;
450 t->n++;
451 }
452 semi(&p);
453 break;
454
455 case 'x': /* struct, union, enum reference */
456 p++;
457 t->ty = Defer;
458 if(*p != 's' && *p != 'u' && *p != 'e')
459 oops();
460 c = *p;
461 name = p+1;
462 p = findcolon(p+1);
463 name = estrndup(name, p-name);
464 t->sub = typebysue(c, name);
465 p++;
466 break;
467
468 #if 0 /* AIX */
469 case 'f': /* function */
470 case 'p': /* procedure */
471 case 'F': /* Pascal function */
472 /* case 'R': /* Pascal procedure */
473 /*
474 * Even though we don't use the info, we have
475 * to parse it in case it is embedded in other descriptions.
476 */
477 t->ty = Function;
478 p++;
479 if(c == 'f' || c == 'F'){
480 t->sub = parseinfo(p, &p);
481 if(*p != ','){
482 if(*p == ';')
483 p++;
484 break;
485 }
486 comma(&p);
487 }
488 n = parseint(&p); /* number of params */
489 semi(&p);
490 while(*p != ';'){
491 if(c == 'F' || c == 'R'){
492 name = p; /* parameter name */
493 p = findcolon(p)+1;
494 }
495 parseinfo(p, &p); /* param type */
496 comma(&p);
497 parseint(&p); /* bool: passed by value? */
498 semi(&p);
499 }
500 semi(&p);
501 break;
502 #endif
503
504 case 'f': /* static function */
505 case 'F': /* global function */
506 t->ty = Function;
507 p++;
508 t->sub = parseinfo(p, &p);
509 break;
510
511 /*
512 * We'll never see any of this stuff.
513 * When we do, we can worry about it.
514 */
515 case 'D': /* n-dimensional array */
516 case 'E': /* subarray of n-dimensional array */
517 case 'M': /* fortran multiple instance type */
518 case 'N': /* pascal string ptr */
519 case 'S': /* set */
520 case 'c': /* aix complex */
521 case 'd': /* file of */
522 case 'g': /* aix float */
523 case 'n': /* max length string */
524 case 'w': /* aix wide char */
525 case 'z': /* another max length string */
526 default:
527 fprint(2, "unsupported type char %c (%d)\n", *p, *p);
528 oops();
529 }
530 *pp = p;
531 return t;
532 }
533
534 /*
535 bound ::=
536 'A' offset (bound is on stack by ref at offset offset from arg list)
537 | 'T' offset (bound is on stack by val at offset offset from arg list)
538 | 'a' regnum (bound passed by reference in register)
539 | 't' regnum (bound passed by value in register)
540 | 'J' (no bound)
541 | bigint
542 */
543 static int
544 parsebound(char **pp)
545 {
546 char *p;
547 int n;
548
549 n = 0;
550 p = *pp;
551 switch(*p){
552 case 'A': /* bound is on stack by reference at offset n from arg list */
553 case 'T': /* bound is on stack by value at offset n from arg list */
554 case 'a': /* bound is passed by reference in register n */
555 case 't': /* bound is passed by value in register n */
556 p++;
557 parseint(&p);
558 break;
559 case 'J': /* no bound */
560 p++;
561 break;
562 default:
563 n = parsebigint(&p);
564 break;
565 }
566 *pp = p;
567 return n;
568 }
569
570 /*
571 bigint ::= '-'? decimal
572 | 0 octal
573 | -1
574 */
575 static vlong
576 parsebigint(char **pp)
577 {
578 char *p;
579 int n, neg;
580
581 p = *pp;
582 if(*p == '0'){
583 errno = 0;
584 n = strtoll(p, &p, 8);
585 if(errno)
586 n = 0;
587 goto out;
588 }
589 neg = 0;
590 if(*p == '-'){
591 neg = 1;
592 p++;
593 }
594 if(!isdigit((uchar)*p))
595 oops();
596 n = strtol(p, &p, 10);
597 if(neg)
598 n = -n;
599
600 out:
601 *pp = p;
602 return n;
603 }
604
605 int
606 stabs2acid(Stab *stabs, Biobuf *b)
607 {
608 volatile int fno, i;
609 char c, *desc, *p;
610 char *volatile dir, *volatile fn, *volatile name;
611 Ftypes *f;
612 Type *t, *tt;
613 StabSym sym;
614
615 dir = nil;
616 fno = 0;
617 fn = nil;
618 for(i=0; stabsym(stabs, i, &sym)>=0; i++){
619 if(verbose)
620 print("%d %s\n", sym.type, sym.name);
621 switch(sym.type){
622 case N_SO:
623 if(sym.name){
624 if(sym.name[0] && sym.name[strlen(sym.name)-1] == '/')
625 dir = sym.name;
626 }
627 denumber();
628 fstack = nil;
629 fno = 0;
630 break;
631 case N_BINCL:
632 fno++;
633 f = mkftypes(dir, sym.name);
634 f->down = fstack;
635 fstack = f;
636 break;
637 case N_EINCL:
638 if(fstack)
639 fstack = fstack->down;
640 break;
641 case N_EXCL:
642 fno++;
643 if((f = findftypes(dir, sym.name)) == nil){
644 static int cannotprint;
645
646 if(cannotprint++ == 0)
647 fprint(2, "cannot find remembered %s\n", sym.name);
648 continue;
649 }
650 renumber(f->list, fno);
651 break;
652 case N_GSYM:
653 case N_FUN:
654 case N_PSYM:
655 case N_LSYM:
656 case N_LCSYM:
657 case N_STSYM:
658 case N_RSYM:
659 name = sym.name;
660 if(name == nil){
661 if(sym.type==N_FUN)
662 fn = nil;
663 continue;
664 }
665 if((p = findcolon(name)) == nil)
666 continue;
667 name = estrndup(name, p-name);
668 desc = ++p;
669 c = *desc;
670 if(c == 'c'){
671 fprint(2, "skip constant %s\n", name);
672 continue;
673 }
674 if(setjmp(kaboom)){
675 static int cannotparse;
676
677 if(cannotparse++ == 0)
678 fprint(2, "cannot parse %s\n", name);
679 continue;
680 }
681 t = parsename(desc, &p);
682 if(t == nil)
683 continue;
684 if(*p != 0){
685 static int extradesc;
686
687 if(extradesc++ == 0)
688 fprint(2, "extra desc '%s' in '%s'\n", p, desc);
689 }
690 /* void is defined as itself */
691 if(t->ty==Defer && t->sub==t && strcmp(name, "void")==0){
692 t->ty = Base;
693 t->xsizeof = 0;
694 t->printfmt = '0';
695 }
696 if(*name==' ' && *(name+1) == 0)
697 *name = 0;
698 /* attach names to structs, unions, enums */
699 if(c=='T' && *name && t->sue){
700 t->suename = name;
701 if(t->name == nil)
702 t->name = name;
703 tt = typebysue(t->sue, name);
704 tt->ty = Defer;
705 tt->sub = t;
706 }
707 if(c=='t'){
708 tt = newtype();
709 tt->ty = Typedef;
710 tt->name = name;
711 tt->sub = t;
712 }
713 /* define base c types */
714 if(t->ty==None || t->ty==Range){
715 if(strcmp(name, "char") == 0){
716 t->ty = Base;
717 t->xsizeof = 1;
718 t->printfmt = 'x';
719 }
720 if(strcmp(name, "int") == 0){
721 t->ty = Base;
722 t->xsizeof = 4;
723 t->printfmt = 'd';
724 }
725 }
726 /* record declaration in list for later. */
727 if(c != 't' && c != 'T')
728 switch(sym.type){
729 case N_GSYM:
730 addsymx(nil, name, t);
731 break;
732 case N_FUN:
733 fn = name;
734 break;
735 case N_PSYM:
736 case N_LSYM:
737 case N_LCSYM:
738 case N_STSYM:
739 case N_RSYM:
740 addsymx(fn, name, t);
741 break;
742 }
743 break;
744 }
745 if(1) print("");
746 }
747
748 printtypes(b);
749 dumpsyms(b);
750 freetypes();
751
752 return 0;
753 }