![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / db|
Return to trace4.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / db |
1.1 root 1: /*
2: * A debugger.
3: * Command analyser.
4: */
5: #include <stdio.h>
6: #include "trace.h"
7:
8:
9: /*
10: * Execute a command.
11: * Return true if more commands may be read.
12: */
13: command(vp)
14: register VAL *vp;
15: {
16: register int c;
17: register int n;
18:
19: switch (c=getn()) {
20: case '=':
21: if (newline() == 0)
22: break;
23: printx("%lo\n", rvalue(&vp[0], (long)dot));
24: return (1);
25: case '?':
26: if (newline() == 0)
27: break;
28: if (errrstr != NULL)
29: printx("%s\n", errrstr);
30: return (1);
31: case 'a':
32: if (newline() == 0)
33: break;
34: putaddr(vsegno(&vp[0], -1), lvalue(&vp[0], (long)dot), I);
35: putx('\n');
36: return (1);
37: case 'b':
38: if (objflag == 0)
39: break;
40: if ((c=getn()) != 'r') {
41: ungetn(c);
42: c = 'b';
43: }
44: getline("i+.:a\ni+.?i\n:x");
45: n = setubpt(c, (vaddr_t)lvalue(&vp[0], (long)dot), miscbuf);
46: if (n == 0)
47: printe("Cannot set breakpoint");
48: return (1);
49: case 'c':
50: if (newline() == 0)
51: break;
52: else
53: c = '\n';
54: if (excflag == 0)
55: break;
56: if (nvalue(&vp[0]) == 0)
57: setpc((vaddr_t)lvalue(&vp[0], (long)0));
58: sinmode = SNULL;
59: return (0);
60: case 'd':
61: if (objflag == 0)
62: break;
63: if ((c=getn())!='r' && c!='s' && c!='a') {
64: ungetn(c);
65: c = 'b';
66: }
67: if (newline() == 0)
68: break;
69: if( c == 'a') {
70: bptinit();
71: return( 1);
72: }
73: if (delubpt(c, (vaddr_t)lvalue(&vp[0], (long)dot)) == 0)
74: printe("Cannot delete breakpoint");
75: return (1);
76: case 'e':
77: if (nvalue(&vp[0]) == 0)
78: setpc((vaddr_t)lvalue(&vp[0], (long)0));
79: getline("");
80: return(runfile());
81: case 'f':
82: if (newline() == 0)
83: break;
84: printx("%s\n", trapstr!=NULL ? trapstr : "No fault");
85: return (1);
86: case 'k':
87: if (excflag == 0)
88: break;
89: if (newline() == 0)
90: break;
91: if (nvalue(&vp[0]) != 0) {
92: printe("No signal specified");
93: return (1);
94: }
95: printr("Cannot send %d", (int)rvalue(&vp[0], (long)0));
96: return (1);
97: case 'm':
98: if (newline() == 0)
99: break;
100: dispmap();
101: return (1);
102: case 'n':
103: if( ( c = getn()) == 'o')
104: dbase = 8;
105: else if( c == 'd')
106: dbase = 10;
107: else if( c == 'x')
108: dbase = 16;
109: else
110: break;
111: if( newline() == 0)
112: break;
113: return( 1);
114: case 'o':
115: if (newline() == 0)
116: break;
117: cantype = rvalue(&vp[0], (long)0);
118: return (1);
119: case 'p':
120: if (newline() == 0)
121: break;
122: dispbpt();
123: return (1);
124: case 'q':
125: if (newline() == 0)
126: break;
127: if (rvalue(&vp[0], (long)1))
128: leave();
129: return (1);
130: case 'r':
131: if (newline() == 0)
132: break;
133: else
134: c = '\n';
135: if (regflag == 0)
136: break;
137: dispreg();
138: return (1);
139: case 's':
140: if (excflag == 0)
141: break;
142: if (nvalue(&vp[0]) == 0)
143: setpc((vaddr_t)lvalue(&vp[0], (long)0));
144: sindecr = rvalue(&vp[1], (long)1);
145: sinmode = SCONT;
146: if ((c=getn()) != 'c') {
147: sinmode = SSTEP;
148: ungetn(c);
149: }
150: getline("i+.?i");
151: sinp = savecom(sinp, miscbuf);
152: return (0);
153: case 't':
154: if (newline() == 0)
155: break;
156: else
157: c = '\n';
158: if (regflag == 0)
159: break;
160: dispsbt((int)rvalue(&vp[0], (long)0));
161: return (1);
162: case 'x':
163: if (newline() == 0)
164: break;
165: if (rvalue(&vp[0], (long)1) != 0) {
166: sincmod = sinmode;
167: sinmode = SNULL;
168: addfilp(stdin);
169: }
170: return (1);
171: }
172: printe("Illegal command");
173: while (c != '\n')
174: c = getn();
175: return (1);
176: }
177:
178: /*
179: * If the next character is a newline, return 1, else 0.
180: */
181: newline()
182: {
183: return (getn()=='\n');
184: }
185:
186: /*
187: * Given a pointer to an allocated buffer and a pointer to a
188: * command string, copy the command string in the allocated
189: * buffer. If the allocated buffer hasn't been allocated,
190: * allocate it.
191: */
192: char *
193: savecom(bp, sp)
194: register char *bp;
195: register char *sp;
196: {
197: register char *cp;
198:
199: if (bp == NULL)
200: bp = nalloc(COMSIZE);
201: cp = bp;
202: while (*sp) {
203: if (cp >= &bp[COMSIZE-1])
204: break;
205: *cp++ = *sp++;
206: }
207: *cp++ = '\0';
208: return (bp);
209: }
210:
211: /*
212: * Initialise breakpoint table.
213: */
214: bptinit()
215: {
216: register BPT *bp;
217: register int n;
218:
219: for (n=NBPT, bp=&bpt[0]; --n; bp++) {
220: bp->b_flag = 0;
221: bp->b_bcom = NULL;
222: bp->b_rcom = NULL;
223: }
224: }
225:
226: /*
227: * Set a breakpoint (user callable). If the type is 'b', a regular
228: * breakpoint. If it is 'r', a return breakpoint.
229: */
230: setubpt(t, a, cp)
231: vaddr_t a;
232: char *cp;
233: {
234: register unsigned n;
235: vaddr_t pc;
236: vaddr_t fp;
237:
238: if (t == 'b')
239: n = setibpt(BBPT, a, (vaddr_t)0, cp);
240: else {
241: setretf(&pc, &fp);
242: n = setibpt(BRET, pc, fp, cp);
243: }
244: return (n);
245: }
246:
247: /*
248: * Set a breakpoint (internal routine).
249: */
250: setibpt(f, a, fp, cp)
251: register vaddr_t a;
252: vaddr_t fp;
253: char *cp;
254: {
255: register BPT *bp;
256: register int n;
257: int w;
258:
259: #if FORZ8001
260: a &= 0x7F00FFFFL;
261: #endif
262: add = (long)a;
263: if (getb(1, (char *)&w, sizeof(w)) == 0)
264: return (0);
265: for (n=NBPT, bp=&bpt[0]; --n; bp++) {
266: if (bp->b_flag!=0 && bp->b_badd==a)
267: goto out;
268: }
269: for (n=NBPT, bp=&bpt[0]; --n; bp++) {
270: if (bp->b_flag == 0)
271: goto out;
272: }
273: return (0);
274: out:
275: if (f!=BBPT && (bp->b_flag&f)!=0)
276: return (0);
277: bp->b_flag |= f;
278: bp->b_badd = a;
279: switch (f) {
280: case BBPT:
281: bp->b_bcom = savecom(bp->b_bcom, cp);
282: break;
283: case BRET:
284: bp->b_rfpt = fp;
285: bp->b_rcom = savecom(bp->b_rcom, cp);
286: break;
287: case BSIN:
288: bp->b_sfpt = fp;
289: break;
290: }
291: return (1);
292: }
293:
294: /*
295: * Delete a breakpoint. (user callable)
296: * If `r' is set, it is a return breakpoint.
297: */
298: delubpt(t, a)
299: vaddr_t a;
300: {
301: register int f;
302:
303: switch (t) {
304: case 'b':
305: f = BBPT;
306: break;
307: case 'r':
308: f = BRET;
309: break;
310: case 's':
311: f = BSIN;
312: break;
313: }
314: return (delibpt(f, a));
315: }
316:
317: /*
318: * Delete a breakpoint. (internal routine)
319: */
320: delibpt(f, a)
321: register int f;
322: vaddr_t a;
323: {
324: register BPT *bp;
325: register int n;
326:
327: for (n=NBPT, bp=&bpt[0]; --n; bp++) {
328: if ((bp->b_flag&f)==0 || bp->b_badd!=a)
329: continue;
330: bp->b_flag &= ~f;
331: return (1);
332: }
333: return (0);
334: }
335:
336: /*
337: * Display breakpoints.
338: */
339: dispbpt()
340: {
341: register BPT *bp;
342: register int n;
343:
344: for (n=NBPT, bp=&bpt[0]; --n; bp++) {
345: if (testint())
346: return;
347: if ((bp->b_flag&BBPT) != 0)
348: putlbpt(' ', bp->b_badd, bp->b_bcom);
349: if (testint())
350: return;
351: if ((bp->b_flag&BRET) != 0)
352: putlbpt('r', bp->b_badd, bp->b_rcom);
353: if (testint())
354: return;
355: if ((bp->b_flag&BSIN) != 0)
356: putlbpt('s', bp->b_badd, "");
357: }
358: }
359:
360: /*
361: * Print out a breakpoint address, type and command.
362: */
363: putlbpt(t, a, cp)
364: vaddr_t a;
365: register char *cp;
366: {
367: register int c;
368:
369: printx(DAFMT, (long)a);
370: printx("%c (", t);
371: putaddr(1, (long)a, I);
372: printx(") ");
373: while ((c=*cp++) != '\0') {
374: if (c == '\n') {
375: printx("\\n");
376: continue;
377: }
378: if (c == '\\') {
379: printx("\\\\");
380: continue;
381: }
382: putx(c);
383: }
384: putx('\n');
385: }
386:
387: /*
388: * Print out segmentation map.
389: */
390: dispmap()
391: {
392: register MAP *mp;
393: register int n;
394:
395: for (n=0; n<NSEGM; n++) {
396: if ((mp=segmapl[n]) == NULL)
397: continue;
398: printx("%s", segname[n]);
399: while (n<NSEGM-1 && segmapl[n+1]==mp)
400: printx(" == %s", segname[++n]);
401: printx("\n");
402: for (; mp!=NULL; mp=mp->m_next) {
403: printx("[");
404: putmadd(mp->m_base);
405: printx(", ");
406: putmadd(mp->m_bend);
407: printx("] => ");
408: putmadd(mp->m_offt);
409: printx(" (%d)\n", mp->m_segi);
410: if (testint())
411: return;
412: }
413: }
414: }
415:
416: /*
417: * Print out a long address for segmentation map.
418: */
419: putmadd(l)
420: fsize_t l;
421: {
422: register int c, n;
423:
424: if (l!=MLI && l!=LI) {
425: printx(VAFMT, l);
426: return;
427: }
428: c = l==MLI ? '-' : '+';
429: n = VAWID;
430: while (n--)
431: putchar(c);
432: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.