![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb|
Return to print.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb |
1.1 root 1: /*
2: *
3: * UNIX debugger
4: *
5: */
6: #include "defs.h"
7:
8: MSG LONGFIL;
9: MSG NOTOPEN;
10: MSG BADMOD;
11:
12: MAP txtmap;
13: MAP datmap;
14:
15: ADDR lastframe;
16: ADDR callpc;
17:
18: INT infile;
19: INT outfile;
20: CHAR *lp;
21: L_INT maxoff;
22: L_INT maxpos;
23: INT radix;
24:
25: /* symbol management */
26: L_INT localval;
27:
28: /* breakpoints */
29: BKPTR bkpthead;
30:
31: REGLIST reglist [] = {
32: "p2lr", P2LR,
33: "p2br",P2BR,
34: "p0lr", P0LR,
35: "p0br",P0BR,
36: "ksp",KSP,
37: "hfs", HFS,
38: "psl", PSL,
39: "pc", PC,
40: "ach", ACHI,
41: "acl", ACLO,
42: "usp",USP,
43: "fp", FP,
44: "r12", R12,
45: "r11", R11,
46: "r10", R10,
47: "r9", R9,
48: "r8", R8,
49: "r7", R7,
50: "r6", R6,
51: "r5", R5,
52: "r4", R4,
53: "r3", R3,
54: "r2", R2,
55: "r1", R1,
56: "r0", R0,
57: 0
58: };
59:
60: char lastc;
61:
62: INT fcor;
63: STRING errflg;
64: INT signo;
65: INT sigcode;
66:
67:
68: L_INT dot;
69: L_INT var[];
70: STRING symfil;
71: STRING corfil;
72: L_INT pid;
73: L_INT adrval;
74: INT adrflg;
75: L_INT cntval;
76: INT cntflg;
77:
78: STRING signals[] = {
79: "",
80: "hangup",
81: "interrupt",
82: "quit",
83: "illegal instruction",
84: "trace/BPT",
85: "IOT",
86: "EMT",
87: "floating exception",
88: "killed",
89: "bus error",
90: "memory fault",
91: "bad system call",
92: "broken pipe",
93: "alarm call",
94: "terminated",
95: "signal 16",
96: "stop (signal)",
97: "stop (tty)",
98: "continue (signal)",
99: "child termination",
100: "stop (tty input)",
101: "stop (tty output)",
102: "input available (signal)",
103: "cpu timelimit",
104: "file sizelimit",
105: "signal 26",
106: "signal 27",
107: "signal 28",
108: "signal 29",
109: "signal 30",
110: "signal 31",
111: };
112:
113: /* general printing routines ($) */
114:
115: printtrace(modif)
116: {
117: REG narg, i;
118: REG BKPTR bkptr;
119: REG ADDR word;
120: REG STRING comptr;
121: REG ADDR argp, frame;
122: register struct nlist *sp;
123:
124: IF cntflg==0 THEN cntval = -1; FI
125:
126: switch (modif) {
127:
128: case '<':
129: IF cntval == 0
130: THEN WHILE readchar() != EOR
131: DO OD
132: lp--;
133: break;
134: FI
135: /* fall through */
136: case '>':
137: {CHAR file[64];
138: INT index;
139:
140: index=0;
141: IF modif=='<'
142: THEN iclose();
143: ELSE oclose();
144: FI
145: IF rdc()!=EOR
146: THEN REP file[index++]=lastc;
147: IF index>=63 THEN error(LONGFIL); FI
148: PER readchar()!=EOR DONE
149: file[index]=0;
150: IF modif=='<'
151: THEN infile=open(file,0);
152: IF infile<0
153: THEN infile=0; error(NOTOPEN);
154: ELSE IF cntflg
155: THEN var[9] = cntval;
156: ELSE var[9] = 1;
157: FI
158: FI
159: ELSE outfile=open(file,1);
160: IF outfile<0
161: THEN outfile=creat(file,0644);
162: #ifndef EDDT
163: ELSE lseek(outfile,0L,2);
164: #endif
165: FI
166: FI
167:
168: ELSE IF modif == '<'
169: THEN iclose();
170: FI
171: FI
172: lp--;
173: }
174: break;
175:
176: case 'd':
177: if (adrflg) {
178: if (!(adrval>=2 && adrval<=16 || adrval<=-2 && adrval>=-16)) {
179: printf("illegal radix %d base ten",radix);
180: break;
181: }
182: radix=adrval;
183: }
184: printf("radix=%d base ten",radix);
185: break;
186:
187: case 'q': case 'Q': case '%':
188: done();
189:
190: case 'w': case 'W':
191: maxpos=(adrflg?adrval:MAXPOS);
192: break;
193:
194: case 's': case 'S':
195: maxoff=(adrflg?adrval:MAXOFF);
196: break;
197:
198: case 'v': case 'V':
199: printf("variables\n");
200: FOR i=0;i<=35;i++
201: DO IF var[i]
202: THEN printc((i<=9 ? '0' : 'a'-10) + i);
203: printf(" = %R\n",var[i]);
204: FI
205: OD
206: break;
207:
208: case 'm': case 'M':
209: printmap("? map",&txtmap);
210: printmap("/ map",&datmap);
211: break;
212:
213: case 0: case '?':
214: IF pid
215: THEN printf("pcs id = %d\n",pid);
216: ELSE printf("no process\n");
217: FI
218: sigprint(); flushbuf();
219:
220: case 'r': case 'R':
221: printregs(modif);
222: return;
223:
224: case 'c': case 'C':
225: IF adrflg
226: THEN frame=adrval;
227: callpc=get(frame-8,DSP);
228: ELSE
229: frame= uw[FP];
230: callpc= uw[PC];
231: FI
232: lastframe=0;
233: WHILE cntval-- ANDF frame!=0 ANDF frame>lastframe ANDF (adrflg ORF INSTACK(frame))
234: DO char *name;
235: chkerr();
236: findsym(callpc,ISYM);
237: if (cursym &&
238: !strcmp(cursym->n_un.n_name, "start"))
239: break;
240: if (cursym)
241: name = cursym->n_un.n_name;
242: else
243: name = "?";
244: printf("%s(", name);
245: narg = ((get(frame-4, DSP)&0xffff)-4)/4;
246: argp = frame;
247: LOOP IF narg<=0 THEN break; FI
248: printf("%R", get(argp += 4, DSP));
249: IF --narg>0 THEN printc(','); FI
250: POOL
251: printf(") at ");
252: psymoff(callpc, ISYM, "\n");
253:
254: IF modif=='C'
255: THEN WHILE localsym(frame)
256: DO word=get(localval,DSP);
257: printf("%8t%s:%10t", cursym->n_un.n_name);
258: IF errflg THEN printf("?\n"); errflg=0; ELSE printf("%R\n",word); FI
259: OD
260: FI
261:
262: callpc=get(frame-8, DSP);
263: if (callpc > USRSTACK) {
264: printf("sigtramp()\n");
265: callpc=get(frame+44, DSP);
266: }
267: lastframe=frame;
268: frame=get(frame, DSP)&ALIGN;
269: OD
270: break;
271:
272: /*print externals*/
273: case 'e': case 'E':
274: for (sp = symtab; sp < esymtab; sp++) {
275: if (sp->n_type==(N_DATA|N_EXT) ORF sp->n_type==(N_BSS|N_EXT))
276: printf("%s:%12t%R\n", sp->n_un.n_name, get(sp->n_value,DSP));
277: }
278: break;
279:
280: /*print breakpoints*/
281: case 'b': case 'B':
282: printf("breakpoints\ncount%8tbkpt%24tcommand\n");
283: for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
284: if (bkptr->flag) {
285: printf("%-8.8d",bkptr->count);
286: psymoff(bkptr->loc,ISYM,"%24t");
287: comptr=bkptr->comm;
288: WHILE *comptr DO printc(*comptr++); OD
289: }
290: break;
291:
292: default: error(BADMOD);
293: }
294:
295: }
296:
297: printmap(s,amap)
298: STRING s; REG MAP *amap;
299: {
300: int file;
301: file=amap->ufd;
302: printf("%s%12t`%s'\n",s,(file<0 ? "-" : (file==fcor ? corfil : symfil)));
303: printf("b1 = %-16R",amap->b1);
304: printf("e1 = %-16R",amap->e1);
305: printf("f1 = %-16R",amap->f1);
306: printf("\nb2 = %-16R",amap->b2);
307: printf("e2 = %-16R",amap->e2);
308: printf("f2 = %-16R",amap->f2);
309: printc(EOR);
310: }
311:
312: printregs(c)
313: {
314: REG REGPTR p;
315: L_INT v;
316:
317: FOR p=reglist; p->rname; p++
318: DO
319: if(c!='R' && p->roffs!=PSL)
320: continue;
321: c = 'R';
322: printf("%s%6t%R %16t", p->rname, v= uw[p->roffs]);
323: valpr(v,(p->roffs==PC?ISYM:DSYM));
324: printc(EOR);
325: OD
326: printpc();
327: }
328:
329: getreg(regnam)
330: {
331: REG REGPTR p;
332: REG STRING regptr;
333: CHAR *olp;
334:
335: olp=lp;
336: FOR p=reglist; p->rname; p++
337: DO regptr=p->rname;
338: IF (regnam == *regptr++)
339: THEN
340: WHILE *regptr
341: DO IF readchar() != *regptr++
342: THEN --regptr; break;
343: FI
344: OD
345: IF *regptr
346: THEN lp=olp;
347: ELSE return(p->roffs);
348: FI
349: FI
350: OD
351: lp=olp;
1.1.1.2 ! root 352: return(-1);
1.1 root 353: }
354:
355: printpc()
356: {
357: dot= uw[PC];
358: psymoff(dot,ISYM,":%16t"); printins(ISP,chkget(dot,ISP));
359: printc(EOR);
360: }
361:
362: char *illinames[] = {
363: "reserved addressing fault",
364: "priviliged instruction fault",
365: "reserved operand fault"
366: };
367: char *fpenames[] = {
368: 0,
369: "integer overflow trap",
370: "integer divide by zero trap",
371: /* not valid
372: "floating overflow trap",
373: "floating/decimal divide by zero trap",
374: "floating underflow trap",
375: "decimal overflow trap",
376: "subscript out of range trap",
377: "floating overflow fault",
378: "floating divide by zero fault",
379: "floating undeflow fault"
380: */
381: };
382:
383: sigprint()
384: {
385: IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
386: THEN printf(signals[signo]); FI
387: switch (signo) {
388:
389: case SIGFPE:
390: IF (sigcode > 0 &&
391: sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
392: printf(" ("); printf(fpenames[sigcode]); printc(')');
393: FI
394: break;
395:
396: case SIGILL:
397: IF (sigcode >= 0 &&
398: sigcode < sizeof illinames / sizeof illinames[0]) THEN
399: printf(" ("); printf(illinames[sigcode]); printc(')');
400: FI
401: break;
402: }
403: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.