![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin / adb|
Return to print.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / adb |
1.1 root 1: static char sccsid[] = "@(#)print.c 4.11 5/2/85";
2: /*
3: *
4: * UNIX debugger
5: *
6: */
7: #include "defs.h"
8:
9: MSG LONGFIL;
10: MSG NOTOPEN;
11: MSG A68BAD;
12: MSG A68LNK;
13: MSG BADMOD;
14:
15: MAP txtmap;
16: MAP datmap;
17:
18: ADDR lastframe;
19: ADDR callpc;
20:
21: INT infile;
22: INT outfile;
23: CHAR *lp;
24: L_INT maxoff;
25: L_INT maxpos;
26: INT radix;
27:
28: /* symbol management */
29: L_INT localval;
30:
31: /* breakpoints */
32: BKPTR bkpthead;
33:
34: REGLIST reglist [] = {
35: "p1lr", P1LR, &pcb.pcb_p1lr,
36: "p1br", P1BR, &pcb.pcb_p1br,
37: "p0lr", P0LR, &pcb.pcb_p0lr,
38: "p0br", P0BR, &pcb.pcb_p0br,
39: "ksp", KSP, &pcb.pcb_ksp,
40: "esp", ESP, &pcb.pcb_esp,
41: "ssp", SSP, &pcb.pcb_ssp,
42: "psl", PSL, &pcb.pcb_psl,
43: "pc", PC, &pcb.pcb_pc,
44: "usp", USP, &pcb.pcb_usp,
45: "fp", FP, &pcb.pcb_fp,
46: "ap", AP, &pcb.pcb_ap,
47: "r11", R11, &pcb.pcb_r11,
48: "r10", R10, &pcb.pcb_r10,
49: "r9", R9, &pcb.pcb_r9,
50: "r8", R8, &pcb.pcb_r8,
51: "r7", R7, &pcb.pcb_r7,
52: "r6", R6, &pcb.pcb_r6,
53: "r5", R5, &pcb.pcb_r5,
54: "r4", R4, &pcb.pcb_r4,
55: "r3", R3, &pcb.pcb_r3,
56: "r2", R2, &pcb.pcb_r2,
57: "r1", R1, &pcb.pcb_r1,
58: "r0", R0, &pcb.pcb_r0,
59: };
60:
61: char lastc;
62:
63: INT fcor;
64: STRING errflg;
65: INT signo;
66: INT sigcode;
67:
68:
69: L_INT dot;
70: L_INT var[];
71: STRING symfil;
72: STRING corfil;
73: INT pid;
74: L_INT adrval;
75: INT adrflg;
76: L_INT cntval;
77: INT cntflg;
78:
79: STRING signals[] = {
80: "",
81: "hangup",
82: "interrupt",
83: "quit",
84: "illegal instruction",
85: "trace/BPT",
86: "IOT",
87: "EMT",
88: "floating exception",
89: "killed",
90: "bus error",
91: "memory fault",
92: "bad system call",
93: "broken pipe",
94: "alarm call",
95: "terminated",
96: "signal 16",
97: "stop (signal)",
98: "stop (tty)",
99: "continue (signal)",
100: "child termination",
101: "stop (tty input)",
102: "stop (tty output)",
103: "input available (signal)",
104: "cpu timelimit",
105: "file sizelimit",
106: "signal 26",
107: "signal 27",
108: "signal 28",
109: "signal 29",
110: "signal 30",
111: "signal 31",
112: };
113:
114: /* general printing routines ($) */
115:
116: printtrace(modif)
117: {
118: INT narg, i, stat, name, limit;
119: POS dynam;
120: REG BKPTR bkptr;
121: CHAR hi, lo;
122: ADDR word;
123: STRING comptr;
124: ADDR argp, frame, link;
125: register struct nlist *sp;
126: INT stack;
127: INT ntramp;
128:
129: IF cntflg==0 THEN cntval = -1; FI
130:
131: switch (modif) {
132:
133: case '<':
134: IF cntval == 0
135: THEN WHILE readchar() != EOR
136: DO OD
137: lp--;
138: break;
139: FI
140: IF rdc() == '<'
141: THEN stack = 1;
142: ELSE stack = 0; lp--;
143: FI
144: /* fall thru... */
145:
146: case '>':
147: {CHAR file[64];
148: CHAR Ifile[128];
149: extern CHAR *Ipath;
150: INT index;
151:
152: index=0;
153: IF rdc()!=EOR
154: THEN REP file[index++]=lastc;
155: IF index>=63 THEN error(LONGFIL); FI
156: PER readchar()!=EOR DONE
157: file[index]=0;
158: IF modif=='<'
159: THEN IF Ipath THEN
160: strcpy(Ifile, Ipath);
161: strcat(Ifile, "/");
162: strcat(Ifile, file);
163: FI
164: IF strcmp(file, "-")!=0
165: THEN iclose(stack, 0);
166: infile=open(file,0);
167: IF infile<0
168: THEN infile=open(Ifile,0);
169: FI
170: ELSE lseek(infile, 0L, 0);
171: FI
172: IF infile<0
173: THEN infile=0; error(NOTOPEN);
174: ELSE IF cntflg
175: THEN var[9] = cntval;
176: ELSE var[9] = 1;
177: FI
178: FI
179: ELSE oclose();
180: outfile=open(file,1);
181: IF outfile<0
182: THEN outfile=creat(file,0644);
183: #ifndef EDDT
184: ELSE lseek(outfile,0L,2);
185: #endif
186: FI
187: FI
188:
189: ELSE IF modif == '<'
190: THEN iclose(-1, 0);
191: ELSE oclose();
192: FI
193: FI
194: lp--;
195: }
196: break;
197:
198: case 'p':
199: IF kernel == 0
200: THEN printf("not debugging kernel\n");
201: ELSE IF adrflg
202: THEN int pte = access(RD, dot, DSP, 0);
203: masterpcbb = (pte&PG_PFNUM)*512;
204: FI
205: getpcb();
206: FI
207: break;
208:
209: case 'd':
210: IF adrflg
211: THEN IF adrval < 2 ORF adrval > 16
212: THEN printf("must have 2 <= radix <= 16");
213: break;
214: FI
215: printf("radix=%d base ten",radix=adrval);
216: FI
217: break;
218:
219: case 'q': case 'Q': case '%':
220: done();
221:
222: case 'w': case 'W':
223: maxpos=(adrflg?adrval:MAXPOS);
224: break;
225:
226: case 's': case 'S':
227: maxoff=(adrflg?adrval:MAXOFF);
228: break;
229:
230: case 'v': case 'V':
231: prints("variables\n");
232: FOR i=0;i<=35;i++
233: DO IF var[i]
234: THEN printc((i<=9 ? '0' : 'a'-10) + i);
235: printf(" = %x\n",var[i]);
236: FI
237: OD
238: break;
239:
240: case 'm': case 'M':
241: printmap("? map",&txtmap);
242: printmap("/ map",&datmap);
243: break;
244:
245: case 0: case '?':
246: IF pid
247: THEN printf("pcs id = %d\n",pid);
248: ELSE prints("no process\n");
249: FI
250: sigprint(); flushbuf();
251:
252: case 'r': case 'R':
253: printregs();
254: return;
255:
256: case 'c': case 'C':
257: IF adrflg
258: THEN frame=adrval;
259: word=get(adrval+6,DSP)&0xFFFF;
260: IF word&0x2000
261: THEN /* 'calls', can figure out argp */
262: argp=adrval+20+((word>>14)&3); word &= 0xFFF;
263: WHILE word
264: DO IF word&1
265: THEN argp+=4;
266: FI
267: word>>=1;
268: OD
269: ELSE /* 'callg', can't tell where argp is */
270: argp=frame;
271: FI
272: callpc=get(frame+16,DSP);
273: ELIF kcore
274: THEN argp = pcb.pcb_ap;
275: frame = pcb.pcb_fp;
276: callpc = pcb.pcb_pc;
277: ELSE argp= *(ADDR *)(((ADDR)&u)+AP);
278: frame= *(ADDR *)(((ADDR)&u)+FP);
279: callpc= *(ADDR *)(((ADDR)&u)+PC);
280: FI
281: lastframe=0;
282: ntramp = 0;
283: WHILE cntval--
284: DO char *name;
285: chkerr();
286: /* if in extended pcb must be signal trampoline code */
287: IF KERNOFF - ctob(UPAGES) < callpc ANDF
288: (unsigned)callpc < KERNOFF
289: THEN name = "sigtramp";
290: ntramp++;
291: ELSE ntramp = 0;
292: findsym(callpc,ISYM);
293: IF cursym ANDF
294: !strcmp(cursym->n_un.n_name, "start")
295: THEN break;
296: FI
297: IF cursym
298: THEN name = cursym->n_un.n_name;
299: ELSE name = "?";
300: FI
301: FI
302: printf("%s(", name);
303: narg = get(argp,DSP); IF narg&~0xFF THEN narg=0; FI
304: LOOP IF narg==0 THEN break; FI
305: printf("%R", get(argp += 4, DSP));
306: IF --narg!=0 THEN printc(','); FI
307: POOL
308: IF ntramp == 1
309: THEN callpc=get(frame+92, DSP);
310: ELSE callpc=get(frame+16, DSP);
311: FI
312: IF callpc != 0
313: THEN prints(") from ");
314: psymoff(callpc, ISYM, "\n");
315: ELSE prints(")\n");
316: FI
317:
318: IF modif=='C'
319: THEN WHILE localsym(frame,argp)
320: DO word=get(localval,DSP);
321: printf("%8t%s:%10t",
322: cursym->n_un.n_name);
323: IF errflg
324: THEN prints("?\n"); errflg=0;
325: ELSE printf("%R\n",word);
326: FI
327: OD
328: FI
329:
330: argp=get(frame+8, DSP);
331: lastframe=frame;
332: frame=get(frame+12, DSP)&EVEN;
333: IF frame==0 THEN break; FI
334: IF !adrflg ANDF !INSTACK(frame)
335: THEN IF !kcore ORF !kstackaddr(frame)
336: THEN break;
337: FI
338: FI
339: OD
340: break;
341:
342: /*print externals*/
343: case 'e': case 'E':
344: FOR sp = symtab; sp < esymtab; sp++
345: DO IF sp->n_type == (N_DATA|N_EXT) ORF
346: sp->n_type == (N_BSS|N_EXT)
347: THEN printf("%s:%12t%R\n", sp->n_un.n_name,
348: get(sp->n_value,DSP));
349: FI
350: OD
351: break;
352:
353: case 'a': case 'A':
354: error("No algol 68 on VAX");
355: /*NOTREACHED*/
356:
357: /*print breakpoints*/
358: case 'b': case 'B':
359: printf("breakpoints\ncount%8tbkpt%24tcommand\n");
360: FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
361: DO IF bkptr->flag
362: THEN printf("%-8.8d",bkptr->count);
363: psymoff(leng(bkptr->loc),ISYM,"%24t");
364: comptr=bkptr->comm;
365: WHILE *comptr DO printc(*comptr++); OD
366: FI
367: OD
368: break;
369:
370: default:
371: error(BADMOD);
372: }
373:
374: }
375:
376: printmap(s,amap)
377: STRING s; MAP *amap;
378: {
379: int file;
380: file=amap->ufd;
381: printf("%s%12t`%s'\n", s,
382: (file<0 ? "-" : (file==fcor ? corfil : symfil)));
383: printf("b1 = %-16R",amap->b1);
384: printf("e1 = %-16R",amap->e1);
385: printf("f1 = %-16R",amap->f1);
386: printf("\nb2 = %-16R",amap->b2);
387: printf("e2 = %-16R",amap->e2);
388: printf("f2 = %-16R",amap->f2);
389: printc(EOR);
390: }
391:
392: printregs()
393: {
394: REG REGPTR p;
395: L_INT v;
396:
397: FOR p=reglist; p < ®list[24]; p++
398: DO v = kcore ? *p->rkern : *(ADDR *)(((ADDR)&u)+p->roffs);
399: printf("%s%6t%R %16t", p->rname, v);
400: valpr(v,(p->roffs==PC?ISYM:DSYM));
401: printc(EOR);
402: OD
403: printpc();
404: }
405:
406: getreg(regnam) {
407: REG REGPTR p;
408: REG STRING regptr;
409: CHAR *olp;
410: CHAR regnxt;
411:
412: olp=lp;
413: FOR p=reglist; p < ®list[24]; p++
414: DO regptr=p->rname;
415: IF (regnam == *regptr++)
416: THEN
417: WHILE *regptr
418: DO IF (regnxt=readchar()) != *regptr++
419: THEN --regptr; break;
420: FI
421: OD
422: IF *regptr
423: THEN lp=olp;
424: ELSE
425: int i = kcore ? (int)p->rkern : p->roffs;
426: return (i);
427: FI
428: FI
429: OD
430: lp=olp;
431: return(0);
432: }
433:
434: printpc()
435: {
436: dot= *(ADDR *)(((ADDR)&u)+PC);
437: psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP));
438: printc(EOR);
439: }
440:
441: char *illinames[] = {
442: "reserved addressing fault",
443: "priviliged instruction fault",
444: "reserved operand fault"
445: };
446: char *fpenames[] = {
447: 0,
448: "integer overflow trap",
449: "integer divide by zero trap",
450: "floating overflow trap",
451: "floating/decimal divide by zero trap",
452: "floating underflow trap",
453: "decimal overflow trap",
454: "subscript out of range trap",
455: "floating overflow fault",
456: "floating divide by zero fault",
457: "floating undeflow fault"
458: };
459:
460: sigprint()
461: {
462: IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
463: THEN prints(signals[signo]); FI
464: switch (signo) {
465:
466: case SIGFPE:
467: IF (sigcode > 0 &&
468: sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
469: prints(" ("); prints(fpenames[sigcode]); prints(")");
470: FI
471: break;
472:
473: case SIGILL:
474: IF (sigcode >= 0 &&
475: sigcode < sizeof illinames / sizeof illinames[0]) THEN
476: prints(" ("); prints(illinames[sigcode]); prints(")");
477: FI
478: break;
479: }
480: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.