![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdb_print.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / kdb|
Return to kdb_print.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / kdb |
1.1 root 1: /*
2: * Copyright (c) 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)kdb_print.c 7.5 (Berkeley) 12/15/86
7: */
8:
9: #include "../kdb/defs.h"
10:
11: char *BADRAD;
12:
13: ADDR lastframe;
14: ADDR callpc;
15:
16: char *BADMOD;
17: char *lp;
18: long maxpos;
19: int radix;
20: char lastc;
21:
22: /* breakpoints */
23: BKPTR bkpthead;
24:
25: extern REGLIST reglist[];
26:
27: /* general printing routines ($) */
28:
29: printtrace(modif)
30: {
31: register narg, i;
32: register BKPTR bkptr;
33: register ADDR word;
34: register char *comptr;
35: register ADDR argp, frame;
36: register struct nlist *sp;
37: int ntramp;
38: register struct proc *p;
39: extern struct proc *allproc;
40:
41: if (cntflg==0)
42: cntval = -1;
43: switch (modif) {
44:
45: case 'd':
46: if (adrflg) {
47: if (adrval < 2 || adrval > 16)
48: error(BADRAD);
49: radix = adrval;
50: }
51: printf("radix=%d base ten", radix);
52: break;
53:
54: case 'w': case 'W':
55: printf("maxpos=%d", maxpos=(adrflg?adrval:MAXPOS));
56: break;
57:
58: case 's': case 'S':
59: printf("maxoff=%d", maxoff=(adrflg?adrval:MAXOFF));
60: break;
61:
62: case 'v': case 'V':
63: printf("variables\n");
64: for (i=0;i<=35;i++)
65: if (var[i]) {
66: printc((i<=9 ? '0' : 'a'-10) + i);
67: printf(" = %R\n",var[i]);
68: }
69: break;
70:
71: case 0: case '?':
72: if (p = (struct proc *)var[varchk('p')])
73: printf("pid = %d\n", p->p_pid);
74: else
75: printf("in idle loop\n");
76: printtrap(var[varchk('t')], var[varchk('c')]);
77: /* fall thru... */
78: case 'r': case 'R':
79: printregs(modif);
80: return;
81:
82: case 'c': case 'C':
83: if (adrflg) {
84: frame = adrval;
85: callpc = getprevpc(frame);
86: } else {
87: frame = pcb.pcb_fp;
88: callpc = pcb.pcb_pc;
89: }
90: lastframe = NOFRAME;
91: ntramp = 0;
92: while (cntval-- && frame != NOFRAME) {
93: char *name;
94:
95: chkerr();
96: /* check for pc in pcb (signal trampoline code) */
97: if (issignalpc(callpc)) {
98: name = "sigtramp";
99: ntramp++;
100: } else {
101: ntramp = 0;
102: (void) findsym((long)callpc, ISYM);
103: if (cursym)
104: name = cursym->n_un.n_name;
105: else
106: name = "?";
107: }
108: printf("%s(", name);
109: narg = getnargs(frame);
110: argp = frame;
111: if (ntramp != 1)
112: while (narg) {
113: printf("%R",
114: get((off_t)(argp = nextarg(argp)),
115: DSP));
116: if (--narg != 0)
117: printc(',');
118: }
119: printf(") at ");
120: psymoff((long)callpc, ISYM, "\n");
121:
122: if (modif=='C') {
123: while (localsym((long)frame)) {
124: word = get((off_t)localval, DSP);
125: printf("%8t%s:%10t",
126: cursym->n_un.n_name);
127: if (errflg) {
128: printf("?\n");
129: errflg = 0;
130: } else
131: printf("%R\n", word);
132: }
133: }
134: if (ntramp != 1) {
135: callpc = getprevpc(frame);
136: lastframe = frame;
137: frame = getprevframe(frame);
138: } else
139: callpc = getsignalpc(lastframe);
140: if (!adrflg && !INSTACK(frame))
141: break;
142: }
143: break;
144:
145: /*print externals*/
146: case 'e': case 'E':
147: for (sp = symtab; sp < esymtab; sp++)
148: if (sp->n_type==(N_DATA|N_EXT) ||
149: sp->n_type==(N_BSS|N_EXT))
150: printf("%s:%12t%R\n", sp->n_un.n_name,
151: get((off_t)sp->n_value, DSP));
152: break;
153:
154: /*print breakpoints*/
155: case 'b': case 'B':
156: printf("breakpoints\ncount%8tbkpt%24tcommand\n");
157: for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
158: if (bkptr->flag) {
159: printf("%-8.8d",bkptr->count);
160: psymoff((long)bkptr->loc,ISYM,"%24t");
161: comptr=bkptr->comm;
162: while (*comptr)
163: printc(*comptr++);
164: }
165: break;
166:
167: case 'l':
168: for (p = allproc; p; p = p->p_nxt) {
169: printf("%X pid %5d %c", p, p->p_pid,
170: p->p_stat == SSLEEP ? 'S' :
171: p->p_stat == SRUN ? 'R':
172: p->p_stat == SIDL ? 'I':
173: p->p_stat == SSTOP ? 'T' : '?');
174: if (p->p_wchan) {
175: printf(" wait ");
176: psymoff((long)p->p_wchan, ISYM, "");
177: }
178: printc(EOR);
179: }
180: break;
181:
182: default:
183: error(BADMOD);
184: }
185: }
186:
187: static
188: printregs(c)
189: {
190: register REGPTR p;
191: ADDR v;
192:
193: for (p = reglist; p->rname; p++) {
194: if (c != 'R' && ishiddenreg(p))
195: continue;
196: v = *p->rkern;
197: printf("%s%6t%R %16t", p->rname, v);
198: valpr((long)v, p->rkern == &pcb.pcb_pc ? ISYM : DSYM);
199: printc(EOR);
200: }
201: printpc();
202: }
203:
204: getreg(regnam)
205: {
206: register REGPTR p;
207: register char *regptr;
208: char *olp;
209:
210: olp = lp;
211: for (p = reglist; p->rname; p++) {
212: regptr = p->rname;
213: if (regnam == *regptr++) {
214: while (*regptr)
215: if (readchar() != *regptr++) {
216: --regptr;
217: break;
218: }
219: if (*regptr)
220: lp = olp;
221: else
222: return ((int)p->rkern);
223: }
224: }
225: lp = olp;
226: return (-1);
227: }
228:
229: printpc()
230: {
231:
232: psymoff((long)pcb.pcb_pc, ISYM, ":%16t");
233: printins(ISP, (long)chkget((off_t)pcb.pcb_pc, ISP));
234: printc(EOR);
235: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.