![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)stab.c 5.2 (Berkeley) 10/23/85";
9: #endif not lint
10:
11: /*
12: * Procedures to put out symbol table information
13: * and stabs for separate compilation type checking.
14: * These use the .stabs, .stabn, and .stabd directives.
15: */
16:
17: #include "whoami.h"
18: #ifdef PC
19: /* and the rest of the file */
20: # include "0.h"
21: # include "objfmt.h"
22: # include "yy.h"
23: # include <stab.h>
24:
25: /*
26: * additional symbol definition for <stab.h>
27: * that is used by the separate compilation facility --
28: * eventually, <stab.h> should be updated to include this
29: */
30:
31: # include "pstab.h"
32: # include "pc.h"
33:
34:
35: #define private static
36:
37: int oldway = 0;
38:
39: /*
40: * absolute value: line numbers are negative if error recovery.
41: */
42: #define ABS( x ) ( x < 0 ? -x : x )
43: long checksum();
44:
45: /*
46: * Generate information about variables.
47: */
48:
49: stabgvar (p, length, line)
50: struct nl *p;
51: int length, line;
52: {
53: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x",
54: 0, p->symbol, N_PC, N_PGVAR, ABS(line)
55: );
56: if (oldway != 0) {
57: oldstabgvar(p->symbol, p2type(p->type), 0, length, line);
58: } else if (opt('g')) {
59: putprintf("\t.stabs\t\"%s:G", 1, p->symbol);
60: gentype(p->type);
61: putprintf("\",0x%x,0,0x%x,0", 0, N_GSYM, length);
62: }
63: }
64:
65: stablvar (p, offset, length)
66: struct nl *p;
67: int offset, length;
68: {
69: int level;
70:
71: level = (p->nl_block & 037);
72: if (oldway != 0) {
73: oldstablvar(p->symbol, p2type(p->type), level, offset, length);
74: } else if (opt('g')) {
75: putprintf("\t.stabs\t\"%s:", 1, p->symbol);
76: gentype(p->type);
77: putprintf("\",0x%x,0,0x%x,0x%x", 0, N_LSYM, length, offset);
78: }
79: }
80:
81: /*
82: * global variables
83: */
84: /*ARGSUSED*/
85: oldstabgvar( name , type , offset , length , line )
86: char *name;
87: int type;
88: int offset;
89: int length;
90: int line;
91: {
92: if ( ! opt('g') ) {
93: return;
94: }
95: putprintf( " .stabs \"" , 1 );
96: putprintf( NAMEFORMAT , 1 , (int) name );
97: putprintf( "\",0x%x,0,0x%x,0" , 0 , N_GSYM , type );
98: putprintf( " .stabs \"" , 1 );
99: putprintf( NAMEFORMAT , 1 , (int) name );
100: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
101: }
102:
103: /*
104: * local variables
105: */
106: /*ARGSUSED*/
107: oldstablvar( name , type , level , offset , length )
108: char *name;
109: int type;
110: int level;
111: int offset;
112: int length;
113: {
114:
115: if ( ! opt('g') ) {
116: return;
117: }
118: putprintf( " .stabs \"" , 1 );
119: putprintf( NAMEFORMAT , 1 , (int) name );
120: putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_LSYM , type , -offset );
121: putprintf( " .stabs \"" , 1 );
122: putprintf( NAMEFORMAT , 1 , (int) name );
123: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
124: }
125:
126:
127: stabparam (p, offset, length)
128: struct nl *p;
129: int offset, length;
130: {
131: if (oldway != 0) {
132: oldstabparam(p->symbol, p2type(p->type), offset, length);
133: } else if (opt('g')) {
134: putprintf("\t.stabs\t\"%s:", 1, p->symbol);
135: if (p->class == REF) {
136: putprintf("v", 1);
137: } else {
138: putprintf("p", 1);
139: }
140: gentype((p->class == FPROC || p->class ==FFUNC) ? p : p->type);
141: putprintf("\",0x%x,0,0x%x,0x%x", 0, N_PSYM, length, offset);
142: }
143: }
144:
145: /*
146: * parameters
147: */
148: oldstabparam( name , type , offset , length )
149: char *name;
150: int type;
151: int offset;
152: int length;
153: {
154:
155: if ( ! opt('g') ) {
156: return;
157: }
158: putprintf( " .stabs \"" , 1 );
159: putprintf( NAMEFORMAT , 1 , (int) name );
160: putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_PSYM , type , offset );
161: putprintf( " .stabs \"" , 1 );
162: putprintf( NAMEFORMAT , 1 , (int) name );
163: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
164: }
165:
166: /*
167: * fields
168: */
169:
170: /*
171: * left brackets
172: * (dbx handles module-2 without these, so we won't use them either)
173: */
174: stablbrac( level )
175: int level;
176: {
177:
178: if ( ! opt('g') || oldway == 0 ) {
179: return;
180: }
181: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_LBRAC , level );
182: }
183:
184: /*
185: * right brackets
186: */
187: stabrbrac( level )
188: int level;
189: {
190:
191: if ( ! opt('g') || oldway == 0 ) {
192: return;
193: }
194: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_RBRAC , level );
195: }
196:
197: stabfunc (p, name, line, level)
198: struct nl *p;
199: char *name;
200: int line, level;
201: {
202: char extname[BUFSIZ],nestspec[BUFSIZ];
203:
204: if ( level == 1 ) {
205: if (p->class == FUNC) {
206: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x" ,
207: 0 , name , N_PC , N_PGFUNC , ABS( line )
208: );
209: } else if (p->class == PROC) {
210: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x" ,
211: 0 , name , N_PC , N_PGPROC , ABS( line )
212: );
213: }
214: }
215: if (oldway != 0) {
216: oldstabfunc(name, p->class, line, level);
217: } else if (opt('g')) {
218: putprintf("\t.stabs\t\"%s:", 1, name);
219: if (p->class == FUNC) {
220: putprintf("F", 1);
221: gentype(p->type);
222: putprintf(",", 1);
223: } else {
224: putprintf("P,", 1);
225: }
226: sextname(extname, name, level); /* set extname to entry label */
227: putprintf("%s,", 1, &(extname[1])); /* remove initial underbar */
228: snestspec(nestspec, level);
229: putprintf("%s\",0x%x,0,0,%s", 0, nestspec, N_FUN, extname);
230: }
231: }
232:
233: /*
234: * construct the colon-separated static nesting string into a
235: * caller-supplied buffer
236: */
237: private snestspec(buffer, level)
238: char buffer[];
239: int level;
240: {
241: char *starthere;
242: int i;
243:
244: if (level <= 1) {
245: buffer[0] = '\0';
246: } else {
247: starthere = &buffer[0];
248: for ( i = 1 ; i < level ; i++ ) {
249: sprintf(starthere, "%s:", enclosing[i]);
250: starthere += strlen(enclosing[i]) + 1;
251: }
252: *--starthere = '\0'; /* remove last colon */
253: if (starthere >= &buffer[BUFSIZ-1]) {
254: panic("snestspec");
255: }
256: }
257: }
258:
259: /*
260: * functions
261: */
262: oldstabfunc( name , typeclass , line , level )
263: char *name;
264: int typeclass;
265: int line;
266: long level;
267: {
268: char extname[ BUFSIZ ];
269:
270: /*
271: * for sdb
272: */
273: if ( ! opt('g') ) {
274: return;
275: }
276: putprintf( " .stabs \"" , 1 );
277: putprintf( NAMEFORMAT , 1 , (int) name );
278: sextname( extname , name , (int) level );
279: putprintf( "\",0x%x,0,0x%x,%s" , 0 , N_FUN , line , (int) extname );
280: }
281:
282: /*
283: * source line numbers
284: */
285: stabline( line )
286: int line;
287: {
288: if ( ! opt('g') ) {
289: return;
290: }
291: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_SLINE , ABS( line ) );
292: }
293:
294: /*
295: * source files get none or more of these:
296: * one as they are entered,
297: * and one every time they are returned to from nested #includes
298: */
299: stabsource(filename, firsttime)
300: char *filename;
301: bool firsttime;
302: {
303: int label;
304:
305: /*
306: * for separate compilation
307: */
308: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x", 0,
309: (int) filename, N_PC, N_PSO, N_FLAGCHECKSUM);
310: /*
311: * for debugger
312: */
313: if ( ! opt('g') ) {
314: return;
315: }
316: if (oldway != 0) {
317: label = (int) getlab();
318: putprintf( " .stabs \"" , 1 );
319: putprintf( NAMEFORMAT , 1 , filename );
320: putprintf( "\",0x%x,0,0," , 1 , N_SO );
321: putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label );
322: putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label );
323: putprintf( ":" , 0 );
324: } else {
325: if (firsttime) {
326: putprintf( " .stabs \"" , 1 );
327: putprintf( NAMEFORMAT , 1 , filename );
328: putprintf( "\",0x%x,0,0,0" , 0 , N_SO );
329: }
330: }
331: }
332:
333: /*
334: * included files get one or more of these:
335: * one as they are entered by a #include,
336: * and one every time they are returned to from nested #includes.
337: */
338: stabinclude(filename, firsttime)
339: char *filename;
340: bool firsttime;
341: {
342: int label;
343: long check;
344:
345: /*
346: * for separate compilation
347: */
348: if (firsttime) {
349: check = checksum(filename);
350: } else {
351: check = N_FLAGCHECKSUM;
352: }
353: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x", 0,
354: (int) filename, N_PC, N_PSOL, check);
355: /*
356: * for sdb
357: */
358: if ( ! opt('g') ) {
359: return;
360: }
361: if (oldway != 0) {
362: label = (int) getlab();
363: putprintf( " .stabs \"" , 1 );
364: putprintf( NAMEFORMAT , 1 , filename );
365: putprintf( "\",0x%x,0,0," , 1 , N_SOL );
366: putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label );
367: putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label );
368: putprintf( ":" , 0 );
369: }
370: }
371:
372: /*
373: * anyone know a good checksum for ascii files?
374: * this does a rotate-left and then exclusive-or's in the character.
375: * also, it avoids returning checksums of 0.
376: * The rotate is implemented by shifting and adding back the
377: * sign bit when negative.
378: */
379: long
380: checksum(filename)
381: char *filename;
382: {
383: FILE *filep;
384: register int input;
385: register long check;
386:
387: filep = fopen(filename, "r");
388: if (filep == NULL) {
389: perror(filename);
390: pexit(DIED);
391: }
392: check = 0;
393: while ((input = getc(filep)) != EOF) {
394: if (check < 0) {
395: check <<= 1;
396: check += 1;
397: } else {
398: check <<= 1;
399: }
400: check ^= input;
401: }
402: (void) fclose(filep);
403: if ((unsigned) check <= N_FLAGCHECKSUM) {
404: return N_FLAGCHECKSUM + 1;
405: } else {
406: return check;
407: }
408: }
409:
410: /*
411: * global Pascal symbols :
412: * labels, types, constants, and external procedure and function names:
413: * These are used by the separate compilation facility
414: * to be able to check for disjoint header files.
415: */
416:
417: /*
418: * global labels
419: */
420: stabglabel( label , line )
421: char *label;
422: int line;
423: {
424:
425: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
426: , (int) label , N_PC , N_PGLABEL , ABS( line ) );
427: }
428:
429: /*
430: * global constants
431: */
432: stabgconst( const , line )
433: char *const;
434: int line;
435: {
436:
437: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
438: , (int) const , N_PC , N_PGCONST , ABS( line ) );
439: }
440:
441: /*
442: * Generate symbolic information about a constant.
443: */
444:
445: stabconst (c)
446: struct nl *c;
447: {
448: if (opt('g') && oldway == 0) {
449: putprintf("\t.stabs\t\"%s:c=", 1, c->symbol);
450: if (c->type == nl + TSTR) {
451: putprintf("s'%s'", 1, c->ptr[0]);
452: } else if (c->type == nl + T1CHAR) {
453: putprintf("c%d", 1, c->range[0]);
454: } else if (isa(c->type, "i")) {
455: putprintf("i%d", 1, c->range[0]);
456: } else if (isa(c->type, "d")) {
457: putprintf("r%g", 1, c->real);
458: } else {
459: putprintf("e", 1);
460: gentype(c->type);
461: putprintf(",%d", 1, c->range[0]);
462: }
463: putprintf("\",0x%x,0,0x%x,0x%x", 0, N_LSYM, 0, 0);
464: }
465: }
466:
467: stabgtype (name, type, line)
468: char *name;
469: struct nl *type;
470: int line;
471: {
472: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x" ,
473: 0, name, N_PC , N_PGTYPE, ABS(line)
474: );
475: if (oldway == 0) {
476: stabltype(name, type);
477: }
478: }
479:
480: stabltype (name, type)
481: char *name;
482: struct nl *type;
483: {
484: if (opt('g')) {
485: putprintf("\t.stabs\t\"%s:t", 1, name);
486: gentype(type);
487: putprintf("\",0x%x,0,0,0", 0, N_LSYM);
488: }
489: }
490:
491: /*
492: * external functions and procedures
493: */
494: stabefunc( name , typeclass , line )
495: char *name;
496: int typeclass;
497: int line;
498: {
499: int type;
500:
501: if ( typeclass == FUNC ) {
502: type = N_PEFUNC;
503: } else if ( typeclass == PROC ) {
504: type = N_PEPROC;
505: } else {
506: return;
507: }
508: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
509: , (int) name , N_PC , type , ABS( line ) );
510: }
511:
512: /*
513: * Generate type information encoded as a string for dbx.
514: * The fwdptrnum field is used only when the type is a pointer
515: * to a type that isn't known when it was entered. When the
516: * type field is filled for some such tptr, fixfwdtype should
517: * be called to output an equivalencing type definition.
518: */
519:
520: typedef struct TypeDesc *TypeDesc;
521:
522: struct TypeDesc {
523: struct nl *tptr;
524: int tnum;
525: int fwdptrnum;
526: TypeDesc chain;
527: };
528:
529: #define TABLESIZE 2003
530:
531: #define typehash(t) ( ( ((int) t) >> 2 ) % TABLESIZE )
532:
533: private int tcount = 1;
534: private TypeDesc typetable[TABLESIZE];
535:
536: private TypeDesc tdlookup (t)
537: struct nl *t;
538: {
539: register TypeDesc td;
540:
541: td = typetable[typehash(t)];
542: while (td != NIL && td->tptr != t) {
543: td = td->chain;
544: }
545: return td;
546: }
547:
548: private int typelookup (t)
549: struct nl *t;
550: {
551: register TypeDesc td;
552: int r;
553:
554: td = tdlookup(t);
555: if (td == NIL) {
556: r = 0;
557: } else {
558: r = td->tnum;
559: }
560: return r;
561: }
562:
563: private int entertype (type)
564: struct nl *type;
565: {
566: register TypeDesc td;
567: register int i;
568:
569: td = (TypeDesc) malloc(sizeof(struct TypeDesc));
570: td->tptr = type;
571: td->tnum = tcount;
572: td->fwdptrnum = 0;
573: ++tcount;
574: i = typehash(type);
575: td->chain = typetable[i];
576: typetable[i] = td;
577: return td->tnum;
578: }
579:
580: /*
581: * The in_types table currently contains "boolean", "char", "integer",
582: * "real" and "_nil". (See nl.c for definition.)
583: * The lookup call below will give the TYPE class nl entry for these
584: * types. In each case except _nil, the type field of that entry is a RANGE
585: * class nl entry for the type. Sometimes other symbol table entries
586: * point to the TYPE entry (e.g., when there is a range over the base type),
587: * and other entries point to the RANGE entry (e.g., for a variable of the
588: * given type). We don't really want to distinguish between these uses
589: * in dbx, and since it appears that the RANGE entries are not reused if
590: * a range happens to coincide, we will give the two the same identifying
591: * dbx type number.
592: */
593:
594: private inittypes()
595: {
596: int i;
597: extern char *in_types[];
598: struct nl *p;
599:
600: for (i = 0; in_types[i] != NIL; i++) {
601: p = lookup(in_types[i]);
602: if (p != NIL) {
603: entertype(p);
604: if (p->type != NIL) {
605: --tcount; /* see comment above */
606: entertype(p->type);
607: }
608: }
609: }
610: }
611:
612: static genarray (t)
613: struct nl *t;
614: {
615: register struct nl *p;
616:
617: for (p = t->chain; p != NIL; p = p->chain) {
618: putprintf("a", 1);
619: gentype(p);
620: putprintf(";", 1);
621: }
622: gentype(t->type);
623: }
624:
625: /*
626: * Really we should walk through ptr[NL_FIELDLIST] for the fields,
627: * and then do the variant tag and fields separately, but dbx
628: * doesn't support this yet.
629: * So, since all the fields of all the variants are on the chain,
630: * we walk through that. Except that this gives the fields in the
631: * reverse order, so we want to print in reverse order.
632: */
633:
634: static genrecord (t)
635: struct nl *t;
636: {
637: putprintf("s%d", 1, t->value[NL_OFFS]);
638: if (t->chain != NIL) {
639: genrecfield(t->chain, 1);
640: }
641: putprintf(";", 1);
642: }
643:
644: static genrecfield (t, n)
645: struct nl *t;
646: int n;
647: {
648: if (t->chain != NULL) {
649: genrecfield(t->chain, n + 1);
650: if (n % 2 == 0) {
651: gencontinue();
652: }
653: }
654: putprintf("%s:", 1, t->symbol);
655: gentype(t->type);
656: putprintf(",%d,%d;", 1, 8*t->value[NL_OFFS], 8*lwidth(t->type));
657: }
658:
659: static genvarnt (t)
660: struct nl *t;
661: {
662: genrecord(t);
663: }
664:
665: static genptr (t)
666: struct nl *t;
667: {
668: register TypeDesc td;
669:
670: putprintf("*", 1);
671: if (t->type != NIL) {
672: gentype(t->type);
673: } else {
674: /*
675: * unresolved forward pointer: use tcount to represent what is
676: * begin pointed to, to be defined later
677: */
678: td = tdlookup(t);
679: if (td == NIL) {
680: panic("nil ptr in stab.genptr");
681: }
682: td->fwdptrnum = tcount;
683: putprintf("%d", 1, tcount);
684: ++tcount;
685: }
686: }
687:
688: /*
689: * The type t is a pointer which has just had its type field filled.
690: * We need to generate a type stab saying that the number saved
691: * in t's fwdptrnum is the same as the t->type's number
692: */
693:
694: fixfwdtype (t)
695: struct nl *t;
696: {
697: register TypeDesc td;
698:
699: if (opt('g') && oldway == 0) {
700: td = tdlookup(t);
701: if (td != NIL) {
702: putprintf("\t.stabs\t\":t%d=", 1, td->fwdptrnum);
703: gentype(t->type);
704: putprintf("\",0x%x,0,0,0", 0, N_LSYM);
705: }
706: }
707: }
708:
709: static genenum (t)
710: struct nl *t;
711: {
712: register struct nl *e;
713: register int i;
714:
715: putprintf("e", 1);
716: i = 1;
717: e = t->chain;
718: while (e != NULL) {
719: if (i > 2) {
720: gencontinue();
721: i = 0;
722: }
723: putprintf("%s:%d,", 1, e->symbol, e->range[0]);
724: e = e->chain;
725: ++i;
726: }
727: putprintf(";", 1);
728: }
729:
730: static genset (t)
731: struct nl *t;
732: {
733: putprintf("S", 1);
734: gentype(t->type);
735: }
736:
737: static genrange (t)
738: struct nl *t;
739: {
740: putprintf("r", 1);
741: gentype(t->type);
742: putprintf(";%d;%d", 1, t->range[0], t->range[1]);
743: }
744:
745: static genfparam (t)
746: struct nl *t;
747: {
748: struct nl *p;
749: int count;
750:
751: if (t->type != NULL) {
752: putprintf("f", 1);
753: gentype(t->type);
754: putprintf(",", 1);
755: } else {
756: putprintf("p", 1);
757: }
758: count = 0;
759: for (p = t->ptr[NL_FCHAIN]; p != NULL; p = p->chain) {
760: ++count;
761: }
762: putprintf("%d;", 1, count);
763: for (p = t->ptr[NL_FCHAIN]; p != NULL; p = p->chain) {
764: gentype(p->type);
765: putprintf(",%d;", 1, p->class);
766: }
767: }
768:
769: static genfile (t)
770: struct nl *t;
771: {
772: putprintf("d", 1);
773: gentype(t->type);
774: }
775:
776: static gentype (t)
777: struct nl *t;
778: {
779: int id;
780:
781: if (tcount == 1) {
782: inittypes();
783: }
784: id = typelookup(t);
785: if (id != 0) {
786: putprintf("%d", 1, id);
787: } else if (t->class == SCAL && t->chain == NULL) {
788: id = typelookup(t->type);
789: if (id != 0) {
790: putprintf("%d", 1, id);
791: } else {
792: genenum(t->type);
793: }
794: } else {
795: id = entertype(t);
796: putprintf("%d=", 1, id);
797: switch (t->class) {
798: case TYPE:
799: gentype(t->type);
800: break;
801:
802: case ARRAY:
803: genarray(t);
804: break;
805:
806: case RECORD:
807: genrecord(t);
808: break;
809:
810: case VARNT:
811: genvarnt(t);
812: break;
813:
814: case REF:
815: gentype(t->type);
816: break;
817:
818: case PTR:
819: genptr(t);
820: break;
821:
822: case SET:
823: genset(t);
824: break;
825:
826: case RANGE:
827: genrange(t);
828: break;
829:
830: case SCAL:
831: genenum(t);
832: break;
833:
834: case FPROC:
835: case FFUNC:
836: genfparam(t);
837: break;
838:
839: case FILET:
840: case PTRFILE:
841: genfile(t);
842: break;
843:
844: default:
845: /* This shouldn't happen */
846: /* Rather than bomb outright, let debugging go on */
847: warning();
848: error("Bad type class found in stab");
849: putprintf("1", 1, t->class);
850: break;
851: }
852: }
853: }
854:
855: /*
856: * Continue stab information in a namelist new entry. This is necessary
857: * to avoid overflowing putprintf's buffer.
858: */
859:
860: static gencontinue ()
861: {
862: putprintf("?\",0x%x,0,0,0", 0, N_LSYM);
863: putprintf("\t.stabs\t\"", 1);
864: }
865:
866: #endif PC
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.