![[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 [Research Unix] / researchv9 / cmd / sun / pcc|
Return to stab.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc |
1.1 root 1: /*
2: * Symbolic debugging info interface.
3: *
4: * Here we generate pseudo-ops that cause the assembler to put
5: * symbolic debugging information into the object file.
6: */
7:
8:
9: #ifndef lint
10: static char sccsid[] = "@(#)stab.c 1.1 86/02/03 SMI"; /* from UCB X.X XX/XX/XX */
11: #endif
12: #include "cpass1.h"
13:
14:
15: #include <sys/types.h>
16: #include <a.out.h>
17: #include "stab.h"
18:
19: #define private static
20: #define and &&
21: #define or ||
22: #define not !
23: #define div /
24: #define mod %
25: #define nil 0
26:
27: #define bytes(bits) ((bits) / SZCHAR)
28: #define bsize(p) bytes(dimtab[p->sizoff]) /* size in bytes of a symbol */
29:
30: #define NILINDEX -1
31: #define FORWARD -2
32: private int nfield;
33: #define NSTABFIELDS 7
34:
35: typedef int Boolean;
36: #define false 0
37: #define true 1
38:
39: typedef enum{ xname, lname, value } Valueform;
40:
41: extern int ddebug;
42: extern int gdebug;
43: extern int optimize;
44: extern char *malloc();
45: extern char *strcpy();
46:
47: int stabLCSYM;
48:
49: /* the values of the stab fields we are currently working on */
50: private unsigned char typeval;
51: private short descval;
52: private Valueform vform;
53: private unsigned valueval;
54:
55: /*
56: * Flag for producing either sdb or dbx symbol information.
57: */
58: int oldway = false;
59:
60:
61: /*
62: * Since type names are lost in the travels and because C has
63: * structural type equivalence we keep a table of type words that
64: * we've already seen. The first time we see a type, it is assigned
65: * (inline) a number and future references just list that number.
66: * Structures, unions, enums, and arrays must be handled carefully
67: * since not all the necessary information is in the type word.
68: */
69:
70: typedef struct Typeid *Typeid;
71:
72: struct Typeid {
73: TWORD tword;
74: int tarray;
75: int tstruct;
76: int tstrtag;
77: int f_index; /* File index */
78: int tnum; /* Type number */
79: Typeid chain;
80: };
81:
82: Typeid entertype();
83:
84: #define TABLESIZE 2003
85: #define FTBL_SIZE 11
86:
87: struct file {
88: char *ftitle; /* Copy of ftitle name */
89: int f_index; /* File name index */
90: int tnum; /* Next type num within this file */
91: };
92:
93: struct file dummy;
94: struct file *file_stack[FTBL_SIZE]; /* Hashed file table */
95: struct file **stkp = file_stack; /* Stack pointer into file_stack[] */
96: struct file *curfile = &dummy; /* Current file as we know it */
97: int f_index; /* Next file index */
98:
99: private int t_int, t_char;
100: private Typeid typetable[TABLESIZE];
101:
102: private Boolean firsttime = true;
103:
104: /*
105: * Generate debugging info for a parameter.
106: * The offset isn't known when it is first entered into the symbol table
107: * since the types are read later.
108: */
109:
110: fixarg(p)
111: struct symtab *p;
112: {
113: int offset;
114: if (oldway) {
115: old_fixarg(p);
116: } else if (gdebug) {
117: printf("\t.stabs\t\"%s:p", p->sname);
118: gentype(p);
119: offset = bytes(argoff);
120: #ifdef mc68000
121: if ( (p->stype==STRTY || p->stype==UNIONTY) && dimtab[p->sizoff]<=2*SZCHAR )
122: /* offset of itty bitty structs off by two */
123: offset += 2;
124: #endif
125: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), offset);
126: }
127: }
128:
129: /*
130: * Determine if the given symbol is a global array with dimension 0,
131: * which only makes sense if it's dimension is to be given later.
132: * We therefore currently do not generate symbol information for
133: * such entries.
134: */
135:
136: #define isglobal(class) ( \
137: class == EXTDEF or class == EXTERN or class == STATIC \
138: )
139:
140: private Boolean zero_length_array(p)
141: register struct symtab *p;
142: {
143: Boolean b;
144: int t;
145:
146: if (not isglobal(p->sclass)) {
147: b = false;
148: } else {
149: t = p->stype;
150: if (ISFTN(t)) {
151: t = DECREF(t);
152: }
153: b = (Boolean) (ISARY(t) and dimtab[p->dimoff] == 0);
154: }
155: return b;
156: }
157:
158: /*
159: * for dbx, the collating sequence of registers includes two
160: * pseudo-registers following a0-a7. These are of no interest to
161: * the rest of the compiler, so the remainder of the register
162: * sequence (i.e., fp0-fp7) must be adjusted accordingly.
163: */
164: #define stabregno(r) ((r) >= FP0 ? (r)+2 : (r))
165:
166: /*
167: * Generate debugging info for a given symbol.
168: */
169:
170: outstab(sym)
171: struct symtab *sym;
172: {
173: register struct symtab *p;
174: char *classname;
175: int offset;
176: Boolean ignore;
177:
178: if (oldway) {
179: old_outstab(sym);
180: } else if (gdebug and not zero_length_array(sym)) {
181: if (firsttime) {
182: firsttime = false;
183: inittypes();
184: }
185: ignore = false;
186: p = sym;
187: offset = bytes(p->offset);
188: switch (p->sclass) {
189: case REGISTER:
190: classname = "r";
191: offset = stabregno(p->offset);
192: break;
193:
194: /*
195: * Locals are the default class.
196: */
197: case AUTO:
198: classname = "";
199: break;
200:
201: case STATIC:
202: if (ISFTN(p->stype)) {
203: ignore = true;
204: } else if (p->slevel <= 1) {
205: classname = "S";
206: } else {
207: classname = "V";
208: }
209: break;
210:
211: case EXTDEF:
212: case EXTERN:
213: if (ISFTN(p->stype)) {
214: ignore = true;
215: } else {
216: classname = "G";
217: }
218: break;
219:
220: case TYPEDEF:
221: classname = "t";
222: break;
223:
224: case PARAM:
225: case MOS:
226: case MOU:
227: case MOE:
228: ignore = true;
229: break;
230:
231: case ENAME:
232: case UNAME:
233: case STNAME:
234: entertype(p->stype, NILINDEX, FORWARD, dimtab[p->sizoff + 3]);
235: ignore = true;
236: break;
237:
238: default:
239: if ((p->sclass&FIELD) == 0) {
240: printf("||| no info for %s (%d) \n", p->sname, p->sclass);
241: }
242: ignore = true;
243: break;
244: }
245: if ( BTYPE(p->stype) == TERROR ) {
246: /* don't try to output symbols entered in error */
247: ignore = true;
248: }
249: if (not ignore) {
250: printf("\t.stabs\t\"%s:%s", p->sname, classname);
251: setinfo(p);
252: gentype(p);
253: geninfo(p);
254: }
255: }
256: }
257: /*
258: * Look for the given type word in the type table.
259: */
260:
261: private Typeid typelookup(type, arrindex, strindex, strtag)
262: TWORD type;
263: int arrindex;
264: int strindex;
265: int strtag;
266: {
267: register TWORD tword;
268: register int i1, i2;
269: Typeid t;
270:
271: for (t = typetable[type mod TABLESIZE]; t != nil; t = t->chain) {
272: if (t->tword == type and
273: strindex == t->tstruct and strtag == t->tstrtag) {
274: if (arrindex == NILINDEX) {
275: break;
276: } else {
277: tword = type;
278: i1 = arrindex;
279: i2 = t->tarray;
280: while (ISARY(tword) and dimtab[i1] == dimtab[i2]) {
281: ++i1;
282: ++i2;
283: tword >>= TSHIFT;
284: }
285: if (!ISARY(tword)) {
286: break;
287: }
288: }
289: }
290: }
291: return t;
292: }
293:
294: /*
295: * Enter a type word and associated symtab indices into the type table.
296: */
297:
298: private Typeid entertype(type, arrindex, strindex, strtag)
299: TWORD type;
300: int arrindex;
301: int strindex;
302: int strtag;
303: {
304: register Typeid t;
305: register int i;
306:
307: t = (Typeid) malloc(sizeof(struct Typeid));
308: t->tword = type;
309: t->tarray = arrindex;
310: t->tstruct = strindex;
311: t->tstrtag = strtag;
312: t->f_index = curfile->f_index;
313: t->tnum = curfile->tnum++;
314: i = type mod TABLESIZE;
315: t->chain = typetable[i];
316: typetable[i] = t;
317: return t;
318: }
319:
320: /*
321: * Change the information associated with a type table entry.
322: * Since I'm lazy this just creates a new entry with the number
323: * as the old one.
324: */
325:
326: private reentertype(typeid, type, arrindex, strindex, strtag)
327: Typeid typeid;
328: TWORD type;
329: int arrindex;
330: int strindex;
331: int strtag;
332: {
333: register Typeid t;
334: register int i;
335:
336: t = (Typeid) malloc(sizeof(struct Typeid));
337: t->tword = type;
338: t->tarray = arrindex;
339: t->tstruct = strindex;
340: t->tstrtag = strtag;
341: t->f_index = typeid->f_index;
342: t->tnum = typeid->tnum;
343: i = type mod TABLESIZE;
344: t->chain = typetable[i];
345: typetable[i] = t;
346: }
347:
348: /*
349: * Initialize type table with predefined types.
350: */
351:
352: #define builtintype(type) entertype(type, NILINDEX, NILINDEX, NILINDEX)->tnum
353:
354: private inittypes()
355: {
356: int t;
357:
358: t_int = builtintype(INT);
359: t_char = builtintype(CHAR);
360: maketype("int", t_int, t_int, 0x80000000L, 0x7fffffffL);
361: maketype("char", t_char, t_char, 0L, 127L);
362: maketype("long", builtintype(LONG), t_int, 0x80000000L, 0x7fffffffL);
363: maketype("short", builtintype(SHORT), t_int, 0xffff8000L, 0x7fffL);
364: maketype("unsigned char", builtintype(UCHAR), t_int, 0L, 255L);
365: maketype("unsigned short", builtintype(USHORT), t_int, 0L, 0xffffL);
366: maketype("unsigned long", builtintype(ULONG), t_int, 0L, 0xffffffffL);
367: maketype("unsigned int", builtintype(UNSIGNED), t_int, 0L, 0xffffffffL);
368: maketype("float", builtintype(FLOAT), t_int, 4L, 0L);
369: maketype("double", builtintype(DOUBLE), t_int, 8L, 0L);
370: t = builtintype(UNDEF);
371: printf("\t.stabs\t\"void:t(%d,%d)=(%d,%d)", curfile->f_index, t,
372: curfile->f_index, t);
373: geninfo(nil);
374: t = builtintype(FARG);
375: printf("\t.stabs\t\"???:t(%d,%d)=(%d,%d)", curfile->f_index, t,
376: curfile->f_index, t_int);
377: geninfo(nil);
378: }
379:
380: /*
381: * Generate info for a new range type.
382: */
383:
384: private maketype(name, tnum, eqtnum, lower, upper)
385: char *name;
386: int tnum, eqtnum;
387: long lower, upper;
388: {
389: printf("\t.stabs\t\"%s:t(%d,%d)=r(%d,%d);%d;%d;",
390: name, curfile->f_index, tnum, curfile->f_index, eqtnum, lower, upper);
391: geninfo(nil);
392: }
393:
394: /*
395: * Generate debugging information for the given type of the given symbol.
396: */
397:
398: private gentype(sym)
399: struct symtab *sym;
400: {
401: register struct symtab *p;
402: register TWORD t;
403: register TWORD basictype;
404: register Typeid typeid;
405: int i, arrindex, strindex, strtag;
406: char basicchar;
407:
408: p = sym;
409: t = p->stype;
410: if (ISFTN(t)) {
411: t = DECREF(t);
412: }
413: basictype = BTYPE(t);
414: if (ISARY(t)) {
415: arrindex = p->dimoff;
416: } else {
417: arrindex = NILINDEX;
418: }
419: if (basictype == STRTY or basictype == UNIONTY or basictype == ENUMTY) {
420: strindex = dimtab[p->sizoff + 1];
421: if (strindex == -1) {
422: strindex = FORWARD;
423: strtag = dimtab[p->sizoff + 3];
424: } else {
425: strtag = NILINDEX;
426: }
427: } else {
428: strindex = NILINDEX;
429: strtag = NILINDEX;
430: }
431: i = arrindex;
432: typeid = typelookup(t, arrindex, strindex, strtag);
433: while (t != basictype and typeid == nil) {
434: typeid = entertype(t, i, strindex, strtag);
435: printf("(%d,%d)=", typeid->f_index, typeid->tnum);
436: switch (t&TMASK) {
437: case PTR:
438: printf("*");
439: break;
440:
441: case FTN:
442: printf("f");
443: break;
444:
445: case ARY:
446: printf("ar(0,%d);0;%d;", t_int, dimtab[i++] - 1);
447: break;
448: }
449: t = DECREF(t);
450: if (t == basictype) {
451: typeid = typelookup(t, NILINDEX, strindex, strtag);
452: } else {
453: typeid = typelookup(t, i, strindex, strtag);
454: }
455: }
456: if (typeid == nil) {
457: if (strindex == FORWARD) {
458: typeid = typelookup(t, NILINDEX, FORWARD, dimtab[p->sizoff + 3]);
459: if (typeid == nil) {
460: cerror("unbelievable forward reference");
461: }
462: printf("(%d,%d)", typeid->f_index, typeid->tnum);
463: } else {
464: genstruct(t, NILINDEX, NILINDEX, strindex, p->sname, bsize(p));
465: }
466: } else {
467: printf("(%d,%d)", typeid->f_index, typeid->tnum);
468: p = STP(strtag);
469: if (typeid->tstruct == FORWARD and (p->sflags & SPRFORWARD) == 0) {
470: switch (basictype) {
471: case STRTY:
472: basicchar = 's';
473: break;
474: case UNIONTY:
475: basicchar = 'u';
476: break;
477: case ENUMTY:
478: basicchar = 'e';
479: break;
480: default:
481: cerror("Bad basic type, %d, in gentype", basictype);
482: basicchar = 's';
483: }
484: printf("=x%c%s:", basicchar, STP(strtag)->sname);
485: p->sflags |= SPRFORWARD;
486: }
487: }
488: }
489:
490: /*
491: * Generate type information for structures, unions, and enumerations.
492: */
493:
494: private genstruct(t, fileid, structid, index, name, size)
495: TWORD t;
496: int fileid;
497: int structid;
498: int index;
499: char *name;
500: int size;
501: {
502: Typeid typeid;
503: register int i;
504: register struct symtab *field;
505: int id;
506: int fid;
507:
508: if (structid == NILINDEX) {
509: typeid = entertype(t, NILINDEX, index, NILINDEX);
510: id = typeid->tnum;
511: fid = typeid->f_index;
512: } else {
513: id = structid;
514: fid = fileid;
515: }
516: switch (t) {
517: case STRTY:
518: case UNIONTY:
519: printf("(%d,%d)=%c%d", fid, id, t == STRTY ? 's' : 'u', size);
520: i = index;
521: while (dimtab[i] != -1) {
522: if (nfield > NSTABFIELDS && dimtab[i+1] != -1){
523: continue_stab();
524: }
525: field = STP(dimtab[i]);
526: printf("%s:", field->sname);
527: gentype(field);
528: if (field->sclass > FIELD) {
529: printf(",%d,%d;", field->offset, field->sclass - FIELD);
530: } else {
531: printf(",%d,%d;", field->offset,
532: tsize(field->stype, field->dimoff, field->sizoff));
533: }
534: ++i;
535: ++nfield;
536: }
537: putchar(';');
538: break;
539:
540: case ENUMTY:
541: printf("(%d,%d)=e", fid, id);
542: i = index;
543: while (dimtab[i] != -1 ) {
544: if (nfield > NSTABFIELDS && dimtab[i+1] != -1){
545: continue_stab();
546: }
547: field = STP(dimtab[i]);
548: printf("%s:%d,", field->sname, field->offset);
549: ++i;
550: ++nfield;
551: }
552: putchar(';');
553: break;
554:
555: default:
556: cerror("couldn't find basic type %d for %s\n", t, name);
557: break;
558: }
559: }
560:
561: /*
562: * Generate offset and size info.
563: */
564:
565: private setinfo(p)
566: register struct symtab *p;
567: {
568: int stabtype;
569:
570: if (p == nil) {
571: typeval = N_LSYM;
572: descval = 0;
573: vform = value;
574: valueval = 0;
575: } else {
576: descval = bsize(p);
577: switch (p->sclass) {
578: case EXTERN:
579: case EXTDEF:
580: if (ISFTN(p->stype)) {
581: typeval = N_FUN;
582: vform = xname;
583: valueval = (unsigned)p->sname;
584: } else {
585: typeval = N_GSYM;
586: vform = value;
587: valueval = 0;
588: }
589: break;
590:
591: case STATIC:
592: typeval = stabLCSYM ? N_LCSYM : N_STSYM;
593: vform = xname;
594: valueval = (unsigned)p->sname;
595: if (ISFTN(p->stype)) {
596: typeval = N_FUN;
597: } else if (p->slevel > 1) {
598: vform = lname;
599: valueval = p->offset;
600: }
601: break;
602:
603: case REGISTER:
604: typeval = N_RSYM;
605: vform = value;
606: valueval = stabregno(p->offset);
607: break;
608:
609: case PARAM:
610: typeval = N_PSYM;
611: vform = value;
612: valueval = bytes(argoff);
613: break;
614:
615: default:
616: typeval = N_LSYM;
617: vform = value;
618: valueval = bytes(p->offset);
619: break;
620: }
621: }
622: }
623:
624: private geninfo(p)
625: struct symtab *p;
626: {
627: setinfo( p );
628: printf("\",0x%x,0,%d," , typeval, descval );
629: switch (vform){
630: case value: printf("%d\n", valueval); break;
631: case xname: printf("_%s\n", valueval); break;
632: case lname: printf("L%d\n", valueval); break;
633: }
634: nfield = 0;
635: }
636:
637: /* stab strings for structures can be very big. Sometimes we would
638: * like to continue them on a second line. For this case, we must
639: * write out a back-slash at the end of the quoted string, then
640: * put out the rest of the stab entry information, followed by a new
641: * .stabs line. The information we put must be setup in globals by
642: * a previous call to setinfo.
643: */
644:
645: private continue_stab()
646: {
647: printf("\\\\\",0x%x,0,%d," , typeval, descval );
648: switch (vform){
649: case value: printf("%d\n", valueval); break;
650: case xname: printf("_%s\n", valueval); break;
651: case lname: printf("L%d\n", valueval); break;
652: }
653: printf("\t.stabs\t\"");
654: nfield = 0;
655: }
656:
657: /*
658: * Generate information for a newly-defined structure.
659: */
660:
661: outstruct(szindex, paramindex)
662: int szindex, paramindex;
663: {
664: register Typeid typeid;
665: register struct symtab *p;
666: register int i, strindex;
667:
668: if (oldway) {
669: /* do nothing */;
670: } else if (gdebug) {
671: i = dimtab[szindex + 3];
672: p = STP(i);
673: if (i != -1 ) {
674: strindex = dimtab[p->sizoff + 1];
675: typeid = typelookup(p->stype, NILINDEX, FORWARD, i);
676: if (typeid != nil) {
677: if (typeid->f_index == curfile->f_index) {
678: reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX);
679: } else {
680: typeid = entertype(p->stype, NILINDEX, FORWARD, NILINDEX);
681: }
682: printf("\t.stabs\t\"%s:T", p->sname);
683: setinfo(p);
684: genstruct(p->stype, typeid->f_index, typeid->tnum, strindex,
685: p->sname, bsize(p));
686: geninfo(p);
687: } else {
688: cerror("Couldn't find struct %s", p->sname);
689: }
690: }
691: }
692: }
693:
694: pstab(name, type)
695: char *name;
696: int type;
697: {
698: register int i;
699: register char c;
700:
701: if (!gdebug) {
702: return;
703: } else if (oldway) {
704: old_pstab(name, type);
705: return;
706: }
707: /* locctr(PROG); /* .stabs must appear in .text for c2 */
708: #ifdef ASSTRINGS
709: if ( name[0] == '\0')
710: printf("\t.stabn\t");
711: else
712: #ifndef FLEXNAMES
713: printf("\t.stabs\t\"%.8s\",", name);
714: #else
715: printf("\t.stabs\t\"%s\",", name);
716: #endif
717: #else
718: printf(" .stab ");
719: for(i=0; i<8; i++)
720: if (c = name[i]) printf("'%c,", c);
721: else printf("0,");
722: #endif
723: printf("0%o,", type);
724: }
725:
726: #ifdef STABDOT
727: pstabdot(type, value)
728: int type;
729: int value;
730: {
731: if ( ! gdebug) {
732: return;
733: } else if (oldway) {
734: old_pstabdot(type, value);
735: return;
736: }
737: /* locctr(PROG); /* .stabs must appear in .text for c2 */
738: printf("\t.stabd\t");
739: printf("0%o,0,0%o\n",type, value);
740: }
741: #endif
742:
743: extern char NULLNAME[8];
744: extern int labelno;
745: extern int fdefflag;
746:
747: psline(lineno)
748: int lineno;
749: {
750: static int nrecur = 0;
751: static int lastlineno;
752: register char *cp, *cq;
753: register int i;
754: int tmp;
755:
756: if (nrecur) {
757: /*
758: * N_SLINE and N_SOL .stab lines must go into .text space.
759: * We use locctr() to get there and back, but locctr()
760: * turns around and calls US, so...
761: */
762: return;
763: }
764: if (!gdebug) {
765: return;
766: } else if (oldway) {
767: old_psline(lineno);
768: return;
769: }
770:
771: cq = ititle;
772: cp = ftitle;
773:
774: while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
775: if ( *cp == '\0' ) goto eq;
776:
777: neq: for (i=0; i<100; i++)
778: ititle[i] = '\0';
779: cp = ftitle;
780: cq = ititle;
781: while ( *cp )
782: *cq++ = *cp++;
783: *cq = '\0';
784: *--cq = '\0';
785: nrecur++; tmp = locctr(PROG);
786: #ifndef FLEXNAMES
787: for ( cp = ititle+1; *(cp-1); cp += 8 ) {
788: pstab(cp, N_SOL);
789: if (gdebug) printf("0,0,LL%d\n", labelno);
790: }
791: #else
792: pstab(ititle+1, N_SOL);
793: if (gdebug) printf("0,0,LL%d\n", labelno);
794: #endif
795: *cq = '"';
796: printf("LL%d:\n", labelno++);
797: locctr(tmp); nrecur--;
798:
799: eq: if (lineno == lastlineno) return;
800: lastlineno = lineno;
801:
802: nrecur++; tmp = locctr(PROG);
803: if ((tmp == PROG) and not optimize) {
804: #ifdef STABDOT
805: pstabdot(N_SLINE, lineno);
806: #else
807: pstab(NULLNAME, N_SLINE);
808: printf("0,%d,LL%d\n", lineno, labelno);
809: printf("LL%d:\n", labelno++);
810: #endif
811: }
812: locctr(tmp); nrecur--;
813: }
814:
815: plcstab(level)
816: int level;
817: {
818: if (!gdebug) {
819: return;
820: } else if (oldway) {
821: old_plcstab(level);
822: return;
823: }
824: #ifdef STABDOT
825: pstabdot(N_LBRAC, level);
826: #else
827: pstab(NULLNAME, N_LBRAC);
828: printf("0,%d,LL%d\n", level, labelno);
829: printf("LL%d:\n", labelno++);
830: #endif
831: }
832:
833: prcstab(level)
834: int level;
835: {
836: if (!gdebug) {
837: return;
838: } else if (oldway) {
839: old_prcstab(level);
840: return;
841: }
842: #ifdef STABDOT
843: pstabdot(N_RBRAC, level);
844: #else
845: pstab(NULLNAME, N_RBRAC);
846: printf("0,%d,LL%d\n", level, labelno);
847: printf("LL%d:\n", labelno++);
848: #endif
849: }
850:
851: pfstab(sname)
852: char *sname;
853: {
854: register struct symtab *p;
855:
856: if (gdebug) {
857: if (oldway) {
858: old_pfstab(sname);
859: } else {
860: p = STP(lookup(sname, 0));
861: printf("\t.stabs\t\"%s:", p->sname);
862: putchar((p->sclass == STATIC) ? 'f' : 'F'); setinfo(p);
863: gentype(p);
864: geninfo(p);
865: }
866: }
867: }
868:
869: /*
870: * Have the beginning of an include file.
871: * Change our notion of the current file.
872: */
873: stab_startheader()
874: {
875: char buf[256];
876:
877: if (!gdebug) {
878: return;
879: }
880: if (firsttime) {
881: firsttime = false;
882: inittypes();
883: }
884: strcpy(buf, ftitle + 1);
885: buf[strlen(buf) - 1] = '\0';
886: insert_filename(buf);
887: pstab(buf, N_BINCL);
888: printf("0,0,0\n");
889: }
890:
891: /*
892: * Have the end of an include file.
893: */
894: stab_endheader()
895: {
896: char buf[256];
897:
898: if (!gdebug) {
899: return;
900: }
901: strcpy(buf, ftitle + 1);
902: buf[strlen(buf) - 1] = '\0';
903: pstab("", N_EINCL);
904: printf("0,0,0\n");
905: curfile = *--stkp;
906: }
907:
908: /*
909: * Old way of doing things.
910: */
911:
912: private old_fixarg(p)
913: struct symtab *p; {
914: if (gdebug) {
915: old_pstab(p->sname, N_PSYM);
916: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR);
917: old_poffs(p);
918: }
919: }
920:
921: private old_outstab(p)
922: struct symtab *p; {
923: register TWORD ptype;
924: register char *pname;
925: register char pclass;
926: register int poffset;
927:
928: if (!gdebug) return;
929:
930: ptype = p->stype;
931: pname = p->sname;
932: pclass = p->sclass;
933: poffset = p->offset;
934:
935: if (ISFTN(ptype)) {
936: return;
937: }
938:
939: switch (pclass) {
940:
941: case AUTO:
942: old_pstab(pname, N_LSYM);
943: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR);
944: old_poffs(p);
945: return;
946:
947: case EXTDEF:
948: case EXTERN:
949: old_pstab(pname, N_GSYM);
950: printf("0,%d,0\n", ptype);
951: old_poffs(p);
952: return;
953:
954: case STATIC:
955: #ifdef LCOMM
956: /* stabLCSYM is 1 during nidcl so we can get stab type right */
957: old_pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM);
958: #else
959: old_pstab(pname, N_STSYM);
960: #endif
961: if (p->slevel > 1) {
962: printf("0,%d,L%d\n", ptype, poffset);
963: } else {
964: printf("0,%d,%s\n", ptype, exname(pname));
965: }
966: old_poffs(p);
967: return;
968:
969: case REGISTER:
970: old_pstab(pname, N_RSYM);
971: printf("0,%d,%d\n", ptype, poffset);
972: old_poffs(p);
973: return;
974:
975: case MOS:
976: case MOU:
977: old_pstab(pname, N_SSYM);
978: printf("0,%d,%d\n", ptype, poffset/SZCHAR);
979: old_poffs(p);
980: return;
981:
982: case PARAM:
983: /* parameter stab entries are processed in dclargs() */
984: return;
985:
986: default:
987: #ifndef FLEXNAMES
988: if (ddebug) printf(" No .stab for %.8s\n", pname);
989: #else
990: if (ddebug) printf(" No .stab for %s\n", pname);
991: #endif
992:
993: }
994: }
995:
996: private old_pstab(name, type)
997: char *name;
998: int type; {
999: register int i;
1000: register char c;
1001: if (!gdebug) return;
1002: /* locctr(PROG); /* .stabs must appear in .text for c2 */
1003: #ifdef ASSTRINGS
1004: if ( name[0] == '\0')
1005: printf("\t.stabn\t");
1006: else
1007: #ifndef FLEXNAMES
1008: printf("\t.stabs\t\"%.8s\", ", name);
1009: #else
1010: printf("\t.stabs\t\"%s\", ", name);
1011: #endif
1012: #else
1013: printf(" .stab ");
1014: for(i=0; i<8; i++)
1015: if (c = name[i]) printf("'%c,", c);
1016: else printf("0,");
1017: #endif
1018: printf("0%o,", type);
1019: }
1020:
1021: #ifdef STABDOT
1022: private old_pstabdot(type, value)
1023: int type;
1024: int value;
1025: {
1026: if ( ! gdebug) return;
1027: /* locctr(PROG); /* .stabs must appear in .text for c2 */
1028: printf("\t.stabd\t");
1029: printf("0%o,0,0%o\n",type, value);
1030: }
1031: #endif
1032:
1033: private old_poffs(p)
1034: register struct symtab *p; {
1035: int s;
1036: if (!gdebug) return;
1037: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) {
1038: old_pstab(p->sname, N_LENG);
1039: printf("1,0,%d\n", s);
1040: }
1041: }
1042:
1043: private old_psline(lineno)
1044: int lineno;
1045: {
1046: static int lastlineno;
1047: register char *cp, *cq;
1048: register int i;
1049:
1050: if (!gdebug) return;
1051:
1052: cq = ititle;
1053: cp = ftitle;
1054:
1055: while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
1056: if ( *cp == '\0' ) goto eq;
1057:
1058: neq: for (i=0; i<100; i++)
1059: ititle[i] = '\0';
1060: cp = ftitle;
1061: cq = ititle;
1062: while ( *cp )
1063: *cq++ = *cp++;
1064: *cq = '\0';
1065: *--cq = '\0';
1066: #ifndef FLEXNAMES
1067: for ( cp = ititle+1; *(cp-1); cp += 8 ) {
1068: old_pstab(cp, N_SOL);
1069: if (gdebug) printf("0,0,LL%d\n", labelno);
1070: }
1071: #else
1072: old_pstab(ititle+1, N_SOL);
1073: if (gdebug) printf("0,0,LL%d\n", labelno);
1074: #endif
1075: *cq = '"';
1076: printf("LL%d:\n", labelno++);
1077:
1078: eq: if (lineno == lastlineno) return;
1079: lastlineno = lineno;
1080:
1081: if (fdefflag) {
1082: #ifdef STABDOT
1083: old_pstabdot(N_SLINE, lineno);
1084: #else
1085: old_pstab(NULLNAME, N_SLINE);
1086: printf("0,%d,LL%d\n", lineno, labelno);
1087: printf("LL%d:\n", labelno++);
1088: #endif
1089: }
1090: }
1091:
1092: private old_plcstab(level) {
1093: if (!gdebug) return;
1094: #ifdef STABDOT
1095: old_pstabdot(N_LBRAC, level);
1096: #else
1097: old_pstab(NULLNAME, N_LBRAC);
1098: printf("0,%d,LL%d\n", level, labelno);
1099: printf("LL%d:\n", labelno++);
1100: #endif
1101: }
1102:
1103: private old_prcstab(level) {
1104: if (!gdebug) return;
1105: #ifdef STABDOT
1106: pstabdot(N_RBRAC, level);
1107: #else
1108: pstab(NULLNAME, N_RBRAC);
1109: printf("0,%d,LL%d\n", level, labelno);
1110: printf("LL%d:\n", labelno++);
1111: #endif
1112: }
1113:
1114: private old_pfstab(sname)
1115: char *sname; {
1116: if (!gdebug) return;
1117: pstab(sname, N_FUN);
1118: #ifndef FLEXNAMES
1119: printf("0,%d,_%.7s\n", lineno, sname);
1120: #else
1121: printf("0,%d,_%s\n", lineno, sname);
1122: #endif
1123: }
1124:
1125: /*
1126: * Have entered a new file.
1127: * Allocate a node for it.
1128: */
1129: insert_filename(file)
1130: char *file;
1131: {
1132: *stkp++ = curfile;
1133: curfile = (struct file *) malloc(sizeof(struct file));
1134: curfile->ftitle = strcpy(malloc(strlen(file) + 1), file);
1135: curfile->f_index = f_index++;
1136: curfile->tnum = 1;
1137: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.