![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / sdb|
Return to display.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / sdb |
1.1 root 1: static char sccsid[] = "@(#)display.c 4.1 10/9/80";
2: #include "head.h"
3: #include <a.out.h>
4: #include <stab.h>
5: #include "cdefs.h"
6: struct user u;
7: BKPTR bkpthead;
8:
9: #ifdef FLEXNAMES
10: #define bread(a,b,c) stread(b,c)
11: #define blseek(a,b,c) stseek(b,c)
12: #endif
13:
14: /* initialize frame pointers to top of call stack */
15: /* MACHINE DEPENDENT */
16: struct proct *
17: initframe() {
18: argp = *(ADDR *) (((ADDR) &u) + AP);
19: frame = *(ADDR *) (((ADDR) &u) + FP);
20: callpc = *(ADDR *) (((ADDR) &u) + PC);
21: if ((frame == 0) || (frame & 0xf0000000 != 0x70000000))
22: return(badproc);
23: return(adrtoprocp(callpc++)); /* ++ because UNIX backs up instrs */
24: }
25:
26:
27: struct proct *
28: nextframe() {
29: callpc = get(frame+16, DSP);
30: argp = get(frame+8, DSP);
31: frame = get(frame+12, DSP) & EVEN;
32: if (callpc > 0x70000000) { /* error handler kludge */
33: callpc = get(argp+12, DSP);
34: argp = get(frame+8, DSP);
35: frame = get(frame+12, DSP) & EVEN;
36: }
37: if ((frame == 0) || (frame & 0xf0000000 != 0x70000000))
38: return(badproc);
39: return(adrtoprocp(callpc-1));
40: }
41:
42: /* returns core image address for variable */
43: /* MACHINE DEPENDENT */
44: ADDR
45: formaddr(class, addr)
46: register char class;
47: ADDR addr; {
48: if (debug) printf("formaddr(%o, %d)\n", class & 0377, addr);
49: switch(class & STABMASK) {
50: case N_RSYM:
51: return(stackreg(addr));
52: case N_GSYM:
53: case N_SSYM:
54: case N_STSYM:
55: case N_LCSYM:
56: return(addr);
57:
58: case N_PSYM:
59: return(argp+addr);
60:
61: case N_LSYM:
62: return(frame+addr);
63:
64: default:
65: printf("Bad class in formaddr: 0%o",
66: class & 0377);
67: return(0);
68: }
69: }
70:
71: char class;
72:
73: /*
74: * stackreg(reg):
75: * If the register for the current frame is somewhere on the stack
76: * then return the address of where it is, otherwise its still in
77: * the register so return the register number.
78: * We distinguish the two by noting that register numbers are less
79: * than 16 and that stack addresses are greater.
80: *
81: * MACHINE DEPENDENT
82: */
83: ADDR
84: stackreg(reg) {
85: register int curframe, regfl, mask, i;
86: struct proct *procp;
87: ADDR regaddr;
88:
89: curframe = frame;
90: regaddr = reg;
91: regfl = 0x10000 << reg;
92: for (procp=initframe(); frame!=curframe; procp=nextframe()) {
93: if (procp == badproc) {
94: error("Stackreg error: frame");
95: return(-1);
96: }
97: mask = get(frame+4, DSP);
98: if (mask & regfl) {
99: regaddr = frame + 20;
100: for (i=0; i<reg; i++) {
101: if (mask & 0x10000)
102: regaddr += WORDSIZE;
103: mask = mask >> 1;
104: }
105: if (!(mask & 0x10000)) {
106: error("Stackreg error: contents");
107: return(-1);
108: }
109: }
110: }
111: return(regaddr);
112: }
113:
114: /* returns address of proc:var. Sets externals class and subflag */
115: ADDR
116: varaddr(proc, var)
117: char *proc, *var; {
118: return(findvar(proc, var, "", 0));
119: }
120:
121: /*
122: * displays values of variables matching proc:var,
123: * returns its address
124: */
125: ADDR
126: dispvar(proc, var, fmt)
127: char *proc, *var, *fmt; {
128: return(findvar(proc, var, fmt, 1));
129: }
130:
131: /*
132: * Find and print values of all variables matching proc:var
133: * using specified format.
134: * Returns address of last matching variable.
135: *
136: * prvar==0 => no output,
137: * prvar==1 => output value,
138: * prvar==2 => output addr
139: */
140: ADDR
141: findvar(proc, var, fmt, prvar)
142: char *proc, *var, *fmt; {
143: ADDR addr = -1, a = -1;
144: int metaflag = 0, match=0, nullflag=0, depthcnt = -1;
145: char *comblk;
146: register struct proct *procp;
147:
148: if (percentflag) { /* kludge for register names */
149: return(regout(var, prvar, fmt));
150: }
151:
152: if (var[0] == '\0') {
153: error("Unexpected null variable name");
154: return(-1);
155: }
156:
157: metaflag = eqany('*', proc) || eqany('?', proc) ||
158: eqany('*', var) || eqany('?', var);
159:
160: if (proc[0] == '\0') {
161: nullflag++;
162: proc = curproc()->pname;
163: }
164:
165: comblk = colonflag ? "" : "*";
166:
167: if (integ && !eqany(var[0], "->.[")) {
168: depthcnt = integ;
169: }
170: if (integ) {
171: if (eqany(var[0], "->.["))
172: match++;
173: else
174: depthcnt = integ;
175: }
176:
177: procp = initframe();
178: if (!eqany(var[0], "->.[") && !(nullflag && colonflag)) {
179: do {
180: if (eqpat(proc, procp->pname)) {
181: match++;
182: if (--depthcnt==0 || integ==0) {
183: a = outvar(procp->pname, var, fmt,
184: metaflag, integ, N_GSYM,
185: 0, prname, comblk, prvar);
186: if (a != -1)
187: addr = a;
188: if (depthcnt == 0)
189: break;
190: }
191: }
192: } while ((procp=nextframe()) != badproc);
193: }
194:
195: if ((colonflag || metaflag || a == -1) &&
196: (nullflag || eqpat(proc, ""))) {
197: a = outvar("", var, fmt, metaflag, integ,
198: N_GSYM, 0, prname, comblk, prvar);
199: if (a != -1) {
200: addr = a;
201: match++;
202: }
203: }
204:
205: if (match==0 && colonflag) {
206: procp = initframe();
207: do {
208: if (eqstr(curproc()->pname, procp->pname))
209: break;
210: } while ((procp=nextframe()) != badproc);
211: a = outvar(curproc()->pname, var, fmt, metaflag,
212: integ, N_GSYM, 0, prname,
213: nullflag ? "_BLNK_" : proc, prvar);
214: if (a != -1) {
215: addr = a;
216: match++;
217: }
218: }
219:
220: if (addr == -1 && match == 0) {
221: addr = extoutvar(var, fmt, metaflag, prvar);
222: if (addr != -1)
223: return(addr);
224: }
225: if (match == 0) {
226: printf("%s not an active procedure\n", proc);
227: return(-1);
228: }
229: if (addr == -1) {
230: if (var[0] == '.')
231: var++;
232: if (proc[0])
233: #ifndef FLEXNAMES
234: printf("%.16s:%s not found\n", proc, var);
235: #else
236: printf("%s:%s not found\n", proc, var);
237: #endif
238: else
239: printf("%s not found\n", var);
240: return(-1);
241: }
242: return(addr);
243: }
244:
245: char *
246: typetodesc(type, subflag)
247: short type; {
248: register int ptr, ftn, ary;
249: register char *desc;
250:
251: static char *typedesc[] = {
252: "d", /* undef */
253: "d", /* farg */
254: "c", /* char */
255: "hd", /* short */
256: "d", /* int */
257: "ld", /* long */
258: "f", /* float */
259: "g", /* double */
260: "d", /* strty */
261: "d", /* unionty */
262: "d", /* enumty */
263: "d", /* moety */
264: "bu", /* uchar */
265: "hu", /* ushort */
266: "u", /* unsigned */
267: "lu", /* ulong */
268: "d" /* ? */
269: };
270:
271: ptr = ftn = ary = 0;
272:
273: desc = typedesc[type&BTMASK];
274: for (; type & TMASK; type = DECREF(type)) {
275: if (ISPTR(type)) ptr++;
276: else if (ISFTN(type)) ftn++;
277: else if (ISARY(type)) ary++;
278: }
279:
280: if ((ptr-subflag == 1 || ary-subflag == 1) && desc[0] == 'c')
281: return("s");
282: if (debug)
283: printf ("PTR %d; FTN %d; ARY %d; DESC %s\n",ptr,ftn,ary,desc);
284: if (ptr + ary == subflag)
285: return(desc);
286: if (ptr) return("x");
287: if (ptr==1 && ftn==1) return("p");
288: return(desc);
289: }
290:
291: typetosize(type, stsize)
292: short type; {
293: register int ptr, ftn, ary;
294: register int size;
295:
296: static char typesize[] = {
297: 4, /* undef */
298: 4, /* farg */
299: 1, /* char */
300: 2, /* short */
301: WORDSIZE, /* int */
302: 4, /* long */
303: 4, /* float */
304: 8, /* double */
305: 0, /* strty */
306: 0, /* unionty */
307: 4, /* enumty */
308: 4, /* moety */
309: 1, /* uchar */
310: 2, /* ushort */
311: 4, /* unsigned */
312: 4, /* ulong */
313: 4 /* ? */
314: };
315:
316: ptr = ftn = ary = 0;
317:
318: size = typesize[type&BTMASK];
319: for (; type & TMASK; type = DECREF(type)) {
320: if (ISPTR(type)) ptr++;
321: else if (ISFTN(type)) ftn++;
322: else if (ISARY(type)) ary++;
323: }
324:
325: if (debug)
326: printf ("PTR %d; FTN %d; ARY %d; SIZE %d; STSIZE %d\n",
327: ptr,ftn,ary,size,stsize);
328: if (ptr>1) return(4);
329: if (size == 0) return(stsize);
330: else return(size);
331: }
332:
333:
334: /* print breakpoints */
335: prbkpt() {
336: register BKPTR bkptr;
337: register int cnt;
338: char *cmdp;
339:
340: cnt = 0;
341:
342: for (bkptr = bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
343: if (bkptr->flag) {
344: cnt++;
345: printbkpt("", adrtoprocp(bkptr->loc), bkptr->loc);
346: cmdp = bkptr->comm;
347: if (*cmdp != '\n') {
348: printf(" <");
349: while (*cmdp != '\n')
350: printf("%c", *cmdp++);
351: printf(">\n");
352: }
353: else
354: printf("\n");
355: }
356: if (cnt == 0)
357: printf("No breakpoints set\n");
358: }
359:
360: /* interactively delete breakpoints */
361:
362: idbkpt() {
363: register BKPTR bkptr;
364: register int yesflg, cnt;
365: register char c;
366:
367: cnt = 0;
368:
369: for (bkptr = bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
370: if (bkptr->flag) {
371: printbkpt(" ? ", adrtoprocp(bkptr->loc), bkptr->loc);
372: yesflg = 0;
373: cnt++;
374: do {
375: c = getchar();
376: if (c == 'y' || c == 'd') yesflg++;
377: } while (c != '\n');
378: if (yesflg)
379: bkptr->flag = 0;
380: }
381: if (cnt == 0)
382: printf("No breakpoints set\n");
383: }
384:
385: /* delete all breakpoints */
386:
387: dabkpt() {
388: register BKPTR bkptr;
389:
390: for (bkptr = bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
391: bkptr->flag = 0;
392: }
393:
394: /*
395: * Print name of breakpoint for a, b, d commands:
396: */
397: printbkpt(s, procp, dot)
398: char *s; struct proct *procp; ADDR dot; {
399: adrtolineno(dot);
400: if (dot != lnfaddr)
401: printf("0x%x (", dot);
402: prlnoff(procp, dot);
403: if (dot != lnfaddr)
404: printf(")");
405: printf("%s", s);
406: }
407:
408: /* print call frame */
409: prframe() {
410: prfrx(0);
411: }
412:
413: /* set top to print just the top procedure */
414: prfrx(top) {
415: int narg;
416: long offset;
417: register char class;
418: register int endflg;
419: char *p;
420: struct proct *procp;
421: struct nlist stentry;
422:
423: if ((procp = initframe()) == badproc) return;
424: do {
425: if (get(frame+12, DSP) == 0) return;
426: p = procp->pname;
427: if (eqstr("__dbsubc", p)) return;
428: if (p[0] == '_') {
429: endflg = 1;
430: #ifndef FLEXNAMES
431: printf("%.15s(", p+1);
432: #else
433: printf("%s(", p+1);
434: #endif
435: }
436: else {
437: #ifndef FLEXNAMES
438: printf("%.16s(", p);
439: #else
440: printf("%s(", p);
441: #endif
442: endflg = 0;
443: }
444: if (endflg == 0) {
445: offset = procp->st_offset;
446: blseek(&sbuf, offset, 0);
447: do {
448: if (bread(&sbuf, &stentry, sizeof stentry) <
449: sizeof stentry) {
450: endflg++;
451: break;
452: }
453: class = stentry.n_type & STABMASK;
454: } while (class == N_FUN);
455: while (class != N_PSYM) {
456: if (bread(&sbuf, &stentry, sizeof stentry) <
457: sizeof stentry) {
458: endflg++;
459: break;
460: }
461: class = stentry.n_type & STABMASK;
462: if (class == N_FUN) {
463: endflg++;
464: break;
465: }
466: }
467: }
468:
469: narg = get(argp, DSP);
470: if (narg & ~0xff) narg = 0;
471: argp += WORDSIZE;
472: while (narg) {
473: if (endflg) {
474: printf("%d", get(argp, DSP));
475: argp += 4;
476: } else {
477: int length;
478: #ifndef FLEXNAMES
479: printf("%.16s=", stentry.n_name);
480: #else
481: printf("%s=", stentry.n_un.n_name);
482: #endif
483: dispx(argp, "", N_GSYM, stentry.n_desc,
484: 0, 0, DSP);
485: length = typetosize(stentry.n_desc, 0);
486: if (length > WORDSIZE)
487: argp += length;
488: else
489: argp += WORDSIZE;
490: }
491: do {
492: if (endflg) break;
493: if (bread(&sbuf, &stentry, sizeof stentry) <
494: sizeof stentry) {
495: endflg++;
496: break;
497: }
498: class = stentry.n_type & STABMASK;
499: if (class == N_FUN) {
500: endflg++;
501: break;
502: }
503: } while (class != N_PSYM);
504: l1: if (--narg != 0) printf(",");
505: }
506: printf(")");
507: if (debug) printf(" @ 0x%x ", callpc);
508: if (procp->sfptr != badfile)
509: printf(" [%s:%d]", adrtofilep(callpc-1)->sfilename,
510: adrtolineno(callpc-1));
511: printf("\n");
512: } while (((procp = nextframe()) != badproc) && !top);
513: }
514:
515: INT signo;
516: STRING signals[];
517: extern nsig;
518: sigprint()
519: {
520:
521: if (signo < nsig)
522: printf("%s", signals[signo]);
523: else
524: printf("signal %d???", signals[signo]);
525: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.