![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to debug.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 root 1: # include "mfile1.h"
2: # include "debug.h"
3:
4: /* File where debugging information is collected and printed out */
5:
6: /* This file is for pi, mostly */
7:
8: int gdebug, slineno;
9: extern int Oflag;
10:
11: #define SYMTAB struct symtab
12:
13: /* (year-80) month day(in dec), as 4 hexits */
14:
15: static vernum = 0x4501;
16:
17: static char verstr[] = "vaxpcc2";
18:
19: static char strvalfmt[] = " .stabs \"%s\",0x%x,0,%d,%d\n";
20:
21: static char strsymfmt[] = " .stabs \"%s\",0x%x,0,%d,%s\n";
22:
23: static char nulvalfmt[] = " .stabn 0x%x,0,%d,%d\n";
24:
25: static char nulsymfmt[] = " .stabn 0x%x,0,%d,%s\n";
26:
27: static char dotfmt[] = " .stabd 0x%x,0,%d\n";
28:
29: static char labstr[16];
30:
31: static char *
32: maklab(val)
33: {
34: sprintx(labstr, LABFMT, val);
35: return labstr;
36: }
37:
38: static
39: wasused( p )
40: register SYMTAB *p;
41: {
42: register i;
43:
44: switch( p->sclass ) {
45: case STNAME:
46: case UNAME:
47: case ENAME:
48: for (i = dimtab[p->sizoff+1]; i >= 0 && dimtab[i] >= 0; i++)
49: if (wasused( &stab[dimtab[i]] ))
50: return 1;
51: return 0;
52: default:
53: return p->suse < 0;
54: }
55: }
56:
57: dbnargs( n ) /* number of argument bytes in call to a function */
58: {
59: if (gdebug)
60: printx(dotfmt, N_NARGS, n/SZCHAR );
61: }
62:
63: dbfunbeg( p ) /* beginning of a function */
64: SYMTAB *p;
65: {
66: dbfile(exname(p->sname));
67: printx(strsymfmt, p->sname, N_BFUN, lineno, exname(p->sname));
68: ppstab(p);
69: }
70:
71: dbfunarg( p ) /* called for each argument of a function */
72: SYMTAB *p;
73: {
74: ppstab( p ); /* we can pick up the reg later */
75: }
76:
77: dbfunret() /* return from a function */
78: {
79: if (gdebug) {
80: dbfile(NULL);
81: printx(dotfmt, N_RFUN, slineno ? slineno : lineno );
82: slineno = 0;
83: }
84: }
85:
86: dbfunend( lab ) /* end of a function */
87: {
88: register SYMTAB *p = &stab[curftn];
89:
90: printx("%s:", maklab(lab));
91: dbfile(labstr);
92: if(gdebug)
93: printx(strsymfmt, p->sname, N_EFUN, lineno, labstr);
94: }
95:
96: dblbrac() /* block level when a { is seen */
97: {
98: if (gdebug)
99: printx(dotfmt, N_LBRAC, blevel);
100: }
101:
102: dbrbrac() /* block level when a } is seen */
103: {
104: if (gdebug)
105: printx(dotfmt, N_RBRAC, blevel);
106: }
107:
108: aobeg() /* called before printing out the autos */
109: {
110: }
111:
112: aocode(p)
113: register struct symtab *p;
114: {
115: /* called when automatic p removed from stab */
116:
117: switch( p->sclass ) {
118: case REGISTER:
119: case AUTO:
120: case STATIC:
121: case EXTDEF:
122: case STNAME:
123: case UNAME:
124: case ENAME:
125: if(!ISFTN(p->stype) && (gdebug || wasused(p)))
126: ppstab( p );
127: return;
128: case EXTERN:
129: /* for now, do not report externs */
130: return;
131: }
132: }
133:
134: aoend()
135: {
136: }
137:
138: # ifndef OUTREGNO
139: # define OUTREGNO(p) ((p)->offset)
140: # endif
141:
142: #define BYTOFF(p) (((off = (p)->offset) < 0 ? -off : off)/SZCHAR)
143:
144: ppstab( p )
145: register SYMTAB *p;
146: {
147: /* write out .stabs for the symbol p */
148: register TWORD t;
149: register off, i;
150:
151: if( p->stype == TNULL ) return;
152:
153: if(gdebug && p->sclass & FIELD) {
154: printx(strvalfmt, p->sname, N_SFLD,
155: ((p->sclass&FLDSIZ)<<BTSHIFT)|p->stype, p->offset);
156: return;
157: }
158:
159: switch( p->sclass ) {
160: case AUTO:
161: printx(strvalfmt, p->sname, N_LSYM, p->stype, BYTOFF(p));
162: break;
163: case REGISTER:
164: printx(strvalfmt, p->sname, N_RSYM, p->stype, OUTREGNO(p));
165: break;
166: case PARAM:
167: printx(strvalfmt, p->sname, N_PSYM, p->stype, BYTOFF(p));
168: break;
169: case EXTERN:
170: case EXTDEF:
171: if(gdebug)
172: printx(strvalfmt, p->sname, N_GSYM, p->stype, 0);
173: break;
174: /*
175: case EXTDEF:
176: printx(strsymfmt, p->sname, N_GSYM, p->stype,
177: exname(p->sname));
178: break;
179: */
180: case STATIC:
181: if (ISFTN(p->stype))
182: printx(strvalfmt, p->sname, N_STFUN, p->stype, 0);
183: else
184: printx(strsymfmt, p->sname,
185: (p->sflags&SBSS) ? N_LCSYM : N_STSYM, p->stype,
186: p->slevel ? maklab(p->offset) : exname(p->sname));
187: break;
188: case STNAME:
189: case UNAME:
190: case ENAME:
191: if(!gdebug)
192: break;
193: printx(strvalfmt, p->sname, N_BSTR, p->stype, 0);
194: for (i = dimtab[p->sizoff+1]; i >= 0 && dimtab[i] >= 0; i++)
195: ppstab( &stab[dimtab[i]] );
196: printx(strvalfmt, p->sname, N_ESTR, p->stype,
197: dimtab[p->sizoff]/SZCHAR);
198: return;
199: case MOS:
200: case MOU:
201: if(gdebug)
202: printx(strvalfmt, p->sname, N_SSYM, p->stype, BYTOFF(p));
203: break;
204: case MOE:
205: if(gdebug)
206: printx(strvalfmt, p->sname, N_SSYM, p->stype, p->offset);
207: return;
208: case TYPEDEF: /* !? */
209: return;
210: default:
211: fprintf(stderr,"unexpected stab class %d: %s, type = 0x%04x\n",
212: p->sclass, p->sname, p->stype);
213: fflush(stderr);
214: return;
215: }
216: /* make another entry to describe structs, unions, enums */
217: switch( BTYPE(p->stype) ) {
218: case STRTY:
219: case UNIONTY:
220: case ENUMTY:
221: if(gdebug)
222: printx(strvalfmt, stab[dimtab[p->sizoff+3]].sname,
223: N_TYID, 0, 0);
224: }
225:
226: /* make other entries with the dimensions */
227: if(!gdebug)
228: return;
229: for( t=p->stype, i=p->dimoff; t&TMASK; t = DECREF(t) )
230: {
231: if( ISARY(t) ) printx(nulvalfmt, N_DIM, 0, dimtab[i++]);
232: }
233: }
234:
235: static char orgfile[100], curfile[100], prtfile[100];
236:
237: static int srcfilop = N_SO;
238:
239: static char *
240: makstr(ip)
241: register char *ip;
242: {
243: register c; register char *jp = prtfile;
244: do {
245: if ((c = *ip++) != '"')
246: *jp++ = c;
247: } while (c);
248: return prtfile;
249: }
250:
251: dbfile(pname)
252: char *pname;
253: {
254: int seg;
255: if (strcmp(curfile, ftitle) == 0)
256: return 0;
257: strcpy(curfile, ftitle);
258: seg = locctr(PROG);
259: if(!Oflag) { /* Ln: .stabs...Ln confuses c2 */
260: if (pname == NULL)
261: printx("%s:", pname = maklab(getlab()));
262: printx(strsymfmt, makstr(curfile), srcfilop,
263: slineno ? slineno : lineno, pname);
264: }
265: slineno = 0;
266: if (srcfilop == N_SO) { /* first file */
267: printx(strvalfmt, verstr, N_VER, vernum, time(0));
268: strcpy(orgfile, ftitle);
269: srcfilop = N_SOL;
270: }
271: if (seg >= 0)
272: locctr(seg);
273: return 1;
274: }
275:
276: dbline()
277: {
278: int seg;
279: if (blevel && !dbfile(NULL) && gdebug) {
280: seg = locctr(PROG);
281: printx(dotfmt, N_SLINE, slineno ? slineno : lineno);
282: slineno = 0;
283: if (seg >= 0)
284: locctr(seg);
285: }
286: }
287:
288: ejsdb()
289: {
290: /* called at the end of the entire file */
291: register struct symtab *p;
292: extern Pflag, bbcnt;
293: int i;
294: if(Pflag) {
295: printx("\t.data\nlocprof:\t.long %d\n", bbcnt+4);
296: printx("\t.long 0\n\t.long L%db\n", bbcnt);
297: printx("\t.space %d\n", 4*bbcnt+4);
298: printx("L%db:\t.byte ", bbcnt);
299: for(i = 0; curfile[i]; i++)
300: printx("0x%x,", curfile[i]);
301: printx("0\n");
302: }
303: for( p = &stab[SYMTSZ]; --p>=stab; )
304: {
305: if( p->stype != TNULL && !ISFTN(p->stype) )
306: {
307: switch( p->sclass )
308: {
309: case EXTERN:
310: if( p->suse > 0 ) continue; /* unused */
311: case EXTDEF:
312: case STATIC:
313: case STNAME:
314: case UNAME:
315: case ENAME:
316: if (gdebug || wasused(p))
317: ppstab(p);
318: break;
319: }
320: }
321: }
322: printx(" .text\n");
323: printx("%s:", maklab(getlab()));
324: printx(strsymfmt, makstr(orgfile), N_ESO, lineno, labstr);
325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.