![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db|
Return to db3.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db |
1.1 root 1: /*
2: * db/db3.c
3: * A debugger.
4: * Command execution and display routines.
5: */
6:
7: #include "db.h"
8: #include <signal.h>
9:
10: /*
11: * Execute a command.
12: * Return 1 if more commands may be read,
13: * 0 to stop reading commands (for :e, :c, :s).
14: */
15: int
16: command(vp) register VAL *vp;
17: {
18: register int c, sig;
19:
20: switch (c = getn()) {
21:
22: /* [addr]:a Print address (default: .) */
23: case 'a':
24: if (getn() != '\n')
25: break;
26: putaddr(val_segn(vp), lvalue(vp, dot));
27: putx('\n');
28: return 1;
29:
30: /* [addr]:b[r][cmd] Set [return] breakpoint */
31: case 'b':
32: if (!IS_OBJ)
33: break;
34: if ((c = getn()) != 'r') {
35: ungetn(c);
36: c = 'b';
37: }
38: getline("i+.:a\ni+.?i\n:x");
39: /* FIX_ME :br only works at current pc, not at specified addr. */
40: if ((c == 'r' && bpt_setr(miscbuf) == 0)
41: || (c != 'r' && bpt_set(BBPT, lvalue(vp, dot), 0L, miscbuf) == 0))
42: printe("Cannot set breakpoint");
43: return 1;
44:
45: /* [addr]:c Continue */
46: case 'c':
47: if (getn() != '\n')
48: break;
49: else
50: c = '\n';
51: if (execflag == 0)
52: break;
53: if (nvalue(vp) == 0)
54: set_pc(lvalue(vp, (ADDR_T)0));
55: step_mode = SNULL;
56: return 0;
57:
58: /* [addr]:d[r][s] Delete breakpoint */
59: case 'd':
60: if (!IS_OBJ)
61: break;
62: if ((c = getn()) != 'r' && c != 's') {
63: ungetn(c);
64: c = 'b';
65: }
66: if (getn() != '\n')
67: break;
68: if (bpt_del(c, lvalue(vp, dot)) == 0)
69: printe("Cannot delete breakpoint");
70: return 1;
71:
72: /* [addr]:eargs Execute */
73: case 'e':
74: if (nvalue(vp) == 0)
75: set_pc(lvalue(vp, (ADDR_T)0));
76: getline("");
77: return runfile();
78:
79: /* :f Print fault type */
80: case 'f':
81: if (getn() != '\n')
82: break;
83: sig = get_sig();
84: printx("%s\n", (sig == 0) ? "no fault"
85: : (sig > NSIG) ? "bad signal number"
86: : signame[sig]);
87: return 1;
88:
89: /* :h[f] Print help info */
90: case 'h':
91: if ((c = getn()) != 'f')
92: ungetn(c);
93: if (getn() != '\n')
94: break;
95: helpinfo(c == 'f');
96: return 1;
97:
98: /* [n]:k ??? send a signal ??? */
99: case 'k':
100: if (execflag == 0)
101: break;
102: if (getn() != '\n')
103: break;
104: if (nvalue(vp) != 0) {
105: printe("No signal specified");
106: return 1;
107: }
108: printr("Cannot send %d", (int)rvalue(vp, 0L));
109: return 1;
110:
111: /* :m Print segmentation map */
112: case 'm':
113: if (getn() != '\n')
114: break;
115: map_print();
116: return 1;
117:
118: /* case 'n': Documented but not implemented? */
119:
120: #ifndef NOCANON
121: /* [expr]:o Change canon type, UNDOCUMENTED... */
122: case 'o':
123: if (getn() != '\n')
124: break;
125: cantype = rvalue(vp, 0L);
126: return 1;
127: #endif
128:
129: /* :p Print breakpoints */
130: case 'p':
131: if (getn() != '\n')
132: break;
133: bpt_display();
134: return 1;
135:
136: /* [expr]:q Quit */
137: case 'q':
138: if (getn() != '\n')
139: break;
140: if (rvalue(vp, 1L))
141: leave();
142: return 1;
143:
144: /* :r[N] Print registers [including NDP] */
145: case 'r':
146: if ((c = getn()) == 'N')
147: c = R_ALL;
148: else {
149: ungetn(c);
150: c = R_GEN;
151: }
152: if (getn() != '\n')
153: break;
154: if (reg_flag == R_INVALID)
155: break;
156: display_reg(c);
157: return 1;
158:
159: /* [addr][,n]:s[c] Single step [n times] [over calls] */
160: case 's':
161: if (execflag == 0)
162: break;
163: if (nvalue(vp) == 0)
164: set_pc(lvalue(vp, (ADDR_T)0));
165: step_count = rvalue(&vp[1], 1L);
166: if ((c = getn()) != 'c') {
167: step_mode = SSTEP;
168: ungetn(c);
169: } else
170: step_mode = SCONT;
171: getline("i+.?i");
172: step_cmd = save_cmd(step_cmd, miscbuf);
173: return 0;
174:
175: /* [expr]:t Call traceback [expr levels] */
176: case 't':
177: if (getn() != '\n')
178: break;
179: else
180: c = '\n';
181: if (reg_flag == R_INVALID)
182: break;
183: traceback((int)rvalue(vp, 0L));
184: return 1;
185:
186: /* [expr]:x Read and execute stdin */
187: case 'x':
188: if (getn() != '\n')
189: break;
190: if (rvalue(vp, 1L)) {
191: step_prev = step_mode;
192: step_mode = SNULL;
193: add_input(IFILE, (char *)stdin);
194: }
195: return 1;
196: }
197: printe("Illegal command");
198: while (c != '\n')
199: c = getn();
200: return 1;
201: }
202:
203: /*
204: * Print out data from segment 's' according to the given format "t1 t2".
205: */
206: char *
207: conform(sp, s, t1, t2) register char *sp; int s, t1, t2;
208: {
209: register char *lp;
210: char c;
211: unsigned char uc;
212: short sh;
213: unsigned short us;
214: int i;
215: unsigned int ui;
216: long l;
217: unsigned char v[3];
218: ADDR_T p;
219: #ifndef NOFP
220: float f;
221: double d;
222: struct _fpreg fpreg;
223: #endif
224:
225: dbprintf(("conform(... s=%d t1=%c t2=%c)\n", s, t1, t2));
226: switch (t1) {
227:
228: case 'b': /* byte */
229: if (getb(s, &uc, sizeof(uc)) == 0)
230: return NULL;
231: modsize = sizeof(uc);
232:
233: /* Sign-extend or 0-extend depending on display format. */
234: if (t2 != 'd')
235: i = ui = (unsigned int)uc;
236: else
237: i = c = uc;
238: sprintf(sp, get_format(t1, t2), i);
239: break;
240: case 'c': /* char with escapes */
241: if (getb(s, &uc, sizeof(uc)) == 0)
242: return NULL;
243: modsize = sizeof(uc);
244: return printable(sp, uc);
245: case 'C': /* char */
246: if (getb(s, &uc, sizeof(uc)) == 0)
247: return NULL;
248: modsize = sizeof(uc);
249: *sp++ = (uc >= 0x20 && uc < 0x7F) ? uc : '.';
250: return sp;
251: #ifndef NOFP
252: case 'f': /* float */
253: if (getb(s, (char *)&f, sizeof(f)) == 0)
254: return NULL;
255: modsize = sizeof(f);
256: sprintf(sp, get_format(t1, t2), f);
257: break;
258: case 'F': /* double */
259: if (getb(s, (char *)&d, sizeof(d)) == 0)
260: return NULL;
261: modsize = sizeof(d);
262: sprintf(sp, get_format(t1, t2), d);
263: break;
264: case 'N': /* NDP fp register */
265: if (getb(s, (char *)&fpreg, sizeof(fpreg)) == 0)
266: return NULL;
267: if (get_fp_reg(&fpreg, &d) == 0)
268: return NULL;
269: modsize = sizeof(fpreg);
270: sprintf(sp, get_format('F', t2), d);
271: break;
272: #endif
273: case 'h':
274: if (getb(s, (char *)&us, sizeof(us)) == 0)
275: return NULL;
276: modsize = sizeof(us);
277:
278: /* Sign-extend or 0-extend depending on display format. */
279: if (t2 != 'd')
280: i = ui = us;
281: else
282: i = sh = us;
283: sprintf(sp, get_format(t1, t2), i);
284: break;
285: case 'i': /* machine instruction */
286: modsize = INLEN;
287: return disassemble(sp, s);
288: case 'l': /* long */
289: if (getb(s, (char *)&l, sizeof(l)) == 0)
290: return NULL;
291: modsize = sizeof(l);
292: sprintf(sp, get_format(t1, t2), l);
293: break;
294: case 'p': /* pointer */
295: if (getb(s, (char *)&p, sizeof(p)) == 0)
296: return NULL;
297: modsize = sizeof(p);
298: return cvt_addr(sp, find_seg(p), p);
299: case 's': /* string with escapes */
300: case 'S': /* string */
301: lp = &sp[DISSIZE];
302: for (;;) {
303: if (getb(s, &uc, sizeof(uc)) == 0)
304: return NULL;
305: if (uc == '\0')
306: break;
307: if (t1 == 's')
308: sp = printable(sp, uc);
309: else
310: *sp++ = uc;
311: if (sp > lp)
312: return NULL;
313: }
314: modsize = sizeof(i);
315: return sp;
316: case 'v': /* l3 */
317: if (getb(s, (char *)v, sizeof(v)) == 0)
318: return NULL;
319: modsize = sizeof(v);
320: l3tol(&l, v, 1);
321: sprintf(sp, get_format(t1, t2), l);
322: break;
323: case 'w': /* word */
324: if (getb(s, (char *)&us, sizeof(us)) == 0)
325: return NULL;
326: modsize = sizeof(us);
327: sprintf(sp, get_format(t1, t2), (int)us);
328: break;
329: case 'Y': /* time */
330: modsize = sizeof(i);
331: return gettime(sp, s);
332: default:
333: return NULL;
334: }
335: return strchr(sp, '\0');
336: }
337:
338: /*
339: * Print out 'n' data items from segment 's'.
340: */
341: int
342: display(s, n) int s, n;
343: {
344: register char *sp1, *sp2, *fs;
345: register int c, r, t1, t2;
346: register char *sp3, *fp;
347: register ADDR_T nad, pad, uad;
348:
349: dbprintf(("display(%d, %d) dot=%x\n", s, n, dot));
350: r = 1;
351: t2 = '\0';
352: add = nad = pad = uad = dot;
353: sp1 = miscbuf;
354: sp3 = &sp1[DISSIZE];
355: fs = seg_format[s];
356: while (n--) {
357: fp = fs;
358: for (;;) {
359: c = *fp++;
360: if (isascii(c) && isdigit(c)) {
361: r = 0;
362: do {
363: r = r*10 + c-'0';
364: c = *fp++;
365: } while (isascii(c) && isdigit(c));
366: --fp;
367: continue;
368: }
369: switch (c) {
370: case '^':
371: add = uad;
372: continue;
373: case '+':
374: add += r;
375: r = 1;
376: continue;
377: case '-':
378: add -= r;
379: r = 1;
380: continue;
381: case 'n':
382: *sp1 = '\0';
383: flushb(nad);
384: sp1 = miscbuf;
385: nad = add;
386: continue;
387: case 'd':
388: case 'o':
389: case 'u':
390: case 'x':
391: t2 = c;
392: continue;
393: default:
394: t1 = c;
395: if (t1=='\0' && t2=='\0')
396: break;
397: if (t1 == '\0')
398: t1 = 'w';
399: if (t2 == '\0')
400: t2 = DDCHR;
401: uad = add;
402: while (r--) {
403: if (testint())
404: return 1;
405: *sp1++ = ' ';
406: pad = add;
407: sp2 = conform(sp1, s, t1, t2);
408: if (sp2 == NULL) {
409: *--sp1 = '\0';
410: if (sp1 != miscbuf)
411: flushb(nad);
412: dbprintf(("add=0x%lX cseg=%d\n", add, cseg));
413: return printe("Addressing error");
414: }
415: if (sp2 <= sp3)
416: sp1 = sp2;
417: else {
418: *--sp1 = '\0';
419: flushb(nad);
420: *sp2 = '\0';
421: *sp1 = ' ';
422: sp2 = sp1;
423: sp1 = miscbuf;
424: while (*sp2)
425: *sp1++ = *sp2++;
426: nad = pad;
427: }
428: if (c == 'i') {
429: *sp1++ = '\0';
430: flushb(nad);
431: sp1 = miscbuf;
432: nad = add;
433: }
434: }
435: r = 1;
436: t2 = '\0';
437: if (c != '\0')
438: continue;
439: }
440: break;
441: }
442: old_add = add;
443: }
444: if (sp1 != miscbuf) {
445: *sp1 = '\0';
446: flushb(nad);
447: }
448: return 1;
449: }
450:
451: /*
452: * Execute a command string.
453: */
454: void
455: execute(cmd) char *cmd;
456: {
457: register INP *ip;
458:
459: dbprintf(("execute(%s)\n", cmd));
460:
461: /* Delete input list starting at "inpp". */
462: while ((ip = inpp) != (INP *)NULL) {
463: inpp = ip->i_next;
464: nfree(ip);
465: }
466: ungotc = '\0'; /* clear ungot character */
467:
468: /* Muck with some globals. */
469: modsize = sizeof(int);
470: step_prev = SNULL;
471: dot = get_pc();
472:
473: /* Add string "cmd" to the input list and process it. */
474: if (cmd != NULL) {
475: add_input(ICORE, cmd);
476: request();
477: }
478:
479: /* Check for interrupt. */
480: testint();
481: }
482:
483: /*
484: * Flush the output buffer.
485: * Print the given address 'addr' before the contents of the buffer
486: * and set dot to it.
487: */
488: void
489: flushb(addr) ADDR_T addr;
490: {
491: dot = addr;
492: printx(addr_fmt, dot);
493: printx("\t%s\n", miscbuf);
494: }
495:
496: /*
497: * Display help info.
498: * The flag is false for :h, true for :hf.
499: */
500: void
501: helpinfo(flag) int flag;
502: {
503: printf(flag
504: ? "[addr][,n]?[ft]\tDisplay formatted information.\n"
505: "Display formats:\n"
506: "\tb\tbyte\n"
507: "\tc\tchar, control and non-chars escaped\n"
508: "\tC\tchar, control and non-chars print as '.'\n"
509: "\td\tdecimal\n"
510: "\tf\tfloat\n"
511: "\tF\tdouble\n"
512: "\ti\tdisassembled machine instruction\n"
513: "\tl\tlong\n"
514: "\tn\toutput '\\n'\n"
515: "\tN\tNDP (80387) floating point register (10 bytes)\n"
516: "\to\toctal\n"
517: "\tp\tsymbolic address\n"
518: "\ts\tstring (NUL-terminated) with escapes\n"
519: "\tS\tstring (NUL-terminated)\n"
520: "\tu\tunsigned\n"
521: "\tv\tfilesystem l3 block address (3 bytes)\n"
522: "\tw\tword\n"
523: "\tx\thexadecimal\n"
524: "\tY\ttime\n"
525: "[doux] specify numeric bases (decimal, octal, unsigned decimal, hexadecimal).\n"
526: "Each may be followed by [bwl] to indicate a datum size [byte, word, long].\n"
527: : "Requests:\n"
528: "\t[addr][,n]?[ft]\tDisplay formatted information.\n"
529: "\t\t\tFormats: bcCdfFilnNopsSuvwxY [see :hf for details]\n"
530: "\taddr?\t\tPrint address\n"
531: "\t[addr]=\t\tPrint address\n"
532: "\t[addr]=val...\tPatch address with val...\n"
533: "\t?\t\tPrint last error message\n"
534: "\t!cmd\t\tSend cmd to system\n"
535: "\t[addr]:a\tPrint address\n"
536: "\t[addr]:b[cmd]\tSet breakpoint [to execute cmd]\n"
537: "\t:br[cmd]\tSet return breakpoint [to execute cmd]\n"
538: "\t[addr]:c\tContinue [from addr]\n"
539: "\t[addr]:d[r][s]\tDelete breakpoint\n"
540: "\t[addr]:e args\tExecute\n"
541: "\t:f\t\tPrint fault type\n"
542: "\t:h[f]\t\tPrint help information [about display formats]\n"
543: /* "\t:k\t\t???\n" */
544: "\t:m\t\tPrint segmentation map\n"
545: #ifndef NOCANON
546: "\t[expr]:o\t\tSet canonization type\n"
547: #endif
548: "\t:p\t\tPrint breakpoints\n"
549: "\t[expr]:q\tQuit\n"
550: "\t:r[N]\t\tPrint registers [including NDP]\n"
551: "\t[addr][,n]:s[c]\tSingle step [over calls]\n"
552: "\t[expr]:t\tPrint traceback [to expr levels]\n"
553: "\t[expr]:x\tRead commands from stdin\n"
554: );
555: }
556:
557: /*
558: * Get a long representing the current time and convert it.
559: */
560: char *
561: gettime(sp, s) register char *sp; int s;
562: {
563: long l;
564:
565: if (getb(s, (char *)&l, sizeof(l)) == 0)
566: return NULL;
567: memcpy(sp, ctime(&l), 24);
568: return sp + 24;
569: }
570:
571: /*
572: * If the given character is unprintable,
573: * convert it into an escape sequence.
574: */
575: char *
576: printable(sp, c) register char *sp; register int c;
577: {
578: *sp++ = '\\';
579: switch (c) {
580: case '\0': *sp++ = '0'; break;
581: case '\b': *sp++ = 'b'; break;
582: case '\n': *sp++ = 'n'; break;
583: case '\f': *sp++ = 'f'; break;
584: case '\r': *sp++ = 'r'; break;
585: case '\\': *sp++ = '\\'; break;
586: default:
587: if (c<040 || c>=0177) {
588: sprintf(sp, "%03o", c);
589: while (*sp)
590: sp++;
591: break;
592: }
593: sp[-1] = c;
594: break;
595: }
596: return sp;
597: }
598:
599: /*
600: * Talk to the user and try to solve his problems.
601: */
602: void
603: process()
604: {
605: static char *xcmd = ":x\n";
606: static char *fxcmd = ":f\n:x\n";
607: register BPT *bp;
608: register ADDR_T pc, fp;
609: register int n;
610: register int bpt_next, bpt_skipped;
611: int step_flag; /* 0==not step, 1==step, 2==syscall */
612:
613: /*
614: * Reverse-engineered pseudocode, minus global variable garbage.
615: *
616: * forever:
617: * execute(":x\n") <= Preload interpreter stack.
618: * (Will come back after traced process traps, e.g. after ":e".)
619: * forever:
620: * See if at call instruction.
621: * Install breakpoints, except at current instruction.
622: * See if current instruction is a breakpoint opcode.
623: * Start up traced process, full speed or single step.
624: * Report any error from ptrace call.
625: * Wait for traced process.
626: * Fetch registers and signal received from traced process.
627: * Replace breakpoints with instructions.
628: * If signal to child was not SIGTRAP
629: * display message
630: * execute(":f\n:x\n");
631: * continue inner loop
632: * Back up instruction pointer to start of the breakpoint.
633: * If single stepping
634: * Execute single step command string (step_cmd).
635: * If last single step in count
636: * execute(":x\n")
637: * end forever
638: * end forever
639: *
640: */
641: top:
642: execute(xcmd);
643: for (;;) {
644:
645: /*
646: * If in single step mode, set up for single step.
647: * If in SCONT mode (for :sc),
648: * change to SCALL mode at call instruction.
649: */
650: if (step_mode != SNULL && step_mode != SWAIT) {
651: /* Single stepping. */
652: step_flag = 1;
653: if (step_mode == SCONT && is_call())
654: step_mode = SCALL;
655: } else
656: step_flag = 0;
657:
658: /* Place all breakpoints. */
659: if (reg_flag != R_INVALID)
660: pc = get_pc();
661: for (bpt_skipped = 0, bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
662:
663: /* Skip unused table entries. */
664: if (bp->b_flag == 0)
665: continue;
666:
667: /*
668: * If there is a breakpoint at the current PC,
669: * we do not want to install it, or we'll get nowhere.
670: * But if we are not single-stepping, we really want
671: * the breakpoint reinstalled after doing a single step.
672: * Kludge the mode to SSTEP and set 'bpt_skipped' in
673: * this case so SNULL mode gets restored after a step.
674: */
675: if (reg_flag!=R_INVALID && bp->b_badd == pc) {
676: if (step_mode == SNULL) {
677: step_mode = SSTEP;
678: bpt_skipped = step_flag = 1;
679: }
680: continue;
681: }
682:
683: /* Install a breakpoint. */
684: add = bp->b_badd;
685: dbprintf(("setting breakpoint @ %lX\n", add));
686: if (putb(ISEG, bin, sizeof(BIN)) == 0) {
687: printb(bp->b_badd);
688: goto err;
689: }
690: }
691:
692: /* Set 'bpt_next' if next instruction is a breakpoint. */
693: bpt_next = (reg_flag!=R_INVALID && bpt_test(pc));
694:
695: /* Watch out for system calls if single stepping. */
696: if (is_syscall(&step_flag) == 0)
697: goto err;
698:
699: /* Run the child. */
700: if (runc() == 0)
701: goto err;
702:
703: /* Restore if we have stepped past system call. */
704: if (step_flag == 2 && rest_syscall(&step_flag) == 0)
705: goto err;
706:
707: /* Replace breakpoints with instructions. */
708: dbprintf(("Replace breakpoints with instructions\n"));
709: for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
710: if (bp->b_flag == 0)
711: continue; /* unused */
712: dbprintf(("Restore instruction %X in bpt[%d]\n", bp->b_bins[0] & 0xFF, bp - bpt));
713: add = bp->b_badd;
714: if (putb(ISEG, bp->b_bins, sizeof(BIN)) == 0) {
715: printb(bp->b_badd);
716: goto err;
717: }
718: }
719:
720: /*
721: * If latest signal to traced process was not SIGTRAP,
722: * tell the user, then accept input.
723: */
724: if (get_sig() != SIGTRAP) {
725: if (get_sig() != SIGINT)
726: printr("Traced process did not stop at a breakpoint");
727: printf("Traced process: ");
728: execute(fxcmd);
729: continue;
730: }
731:
732: /* Resume running following skipped breakpoint. */
733: if (bpt_skipped) {
734: step_mode = SNULL;
735: continue;
736: }
737:
738: /*
739: * Find the breakpoint we are at.
740: * Back up pc to start of the breakpoint.
741: */
742: bp = (BPT *)NULL;
743: pc = get_pc() - sizeof(BIN);
744: dbprintf(("find bpt: --pc=%x step_flag=%d bpt_next=%d\n", pc, step_flag, bpt_next));
745: if (step_flag == 0 || bpt_next) {
746: for (bp = &bpt[0]; bp < &bpt[NBPT]; bp++) {
747: if (bp->b_flag == 0)
748: continue;
749: if (bp->b_badd != pc)
750: continue;
751: dbprintf(("found bpt[%d] at %x\n", bp-bpt, pc));
752: set_pc(pc);
753: break;
754: }
755: if (bp == &bpt[NBPT])
756: bp = (BPT *)NULL; /* unknown */
757: }
758:
759: /* If in single step mode, execute command. */
760: dbprintf(("step_mode=%d\n", step_mode));
761: switch (step_mode) {
762: case SSTEP:
763: case SCONT:
764: execute(step_cmd);
765: if (--step_count == 0)
766: execute(xcmd);
767: continue;
768: case SCALL:
769: /*
770: * :sc has stepped into call with step_mode SCALL.
771: * Clear other BSIN breakpoints, place a BSIN breakpoint
772: * at the return address, and set step_mode SWAIT
773: * to run until the return is executed.
774: */
775: for (n = 0; n < NBPT; n++)
776: bpt[n].b_flag &= ~BSIN;
777: step_mode = SWAIT;
778: set_ra_bpt(); /* set BSIN bpt at return address */
779: break;
780: }
781:
782: /*
783: * Handle an unexpected trace trap or unknown breakpoint.
784: * One way this can happen: if the child does not handle
785: * SIGINT, type "100:s" followed by "<Ctrl-C>" and ":c".
786: * The child is interrupted, the parent prints "Interrupted"
787: * and prompts, ":c" resumes the child with SNULL (step_flag 0),
788: * and the child then hits the actual breakpoint.
789: * t
790: */
791: if (bp == (BPT *)NULL) {
792: dbprintf(("step_mode=%d step_flag=%d bpt_next=%d\n", step_mode, step_flag, bpt_next));
793: if (step_flag == 0 || bpt_next) {
794: printf("Unexpected ");
795: execute(fxcmd);
796: }
797: continue;
798: }
799:
800: /* Single step breakpoints have highest priority. */
801: fp = get_fp();
802: if (bp->b_flag & BSIN) {
803: if (bp->b_sfpt==0 || bp->b_sfpt == fp) {
804: bp->b_flag &= ~BSIN;
805: if (step_mode == SWAIT) {
806: /*
807: * We hit the return from a called
808: * function with :sc, restore SCONT mode.
809: */
810: step_mode = SCONT;
811: execute(step_cmd);
812: if (--step_count == 0)
813: execute(xcmd);
814: continue;
815: }
816: }
817: }
818:
819: /* Return breakpoints are next. */
820: if (bp->b_flag & BRET) {
821: if (bp->b_rfpt == fp) {
822: bp->b_flag &= ~BRET;
823: execute(bp->b_rcom);
824: continue;
825: }
826: }
827:
828: /* Your conventional everyday ordinary breakpoint. */
829: if (bp->b_flag & BBPT) {
830: execute(bp->b_bcom);
831: continue;
832: }
833: }
834:
835: /*
836: * Something is terribly wrong.
837: * Kill off our child and generally reset everything to the start.
838: */
839: err:
840: killc();
841: initialize();
842: map_init();
843: if (IS_LOUT)
844: setloutseg();
845: else if (IS_COFF)
846: setcoffseg();
847: goto top;
848: }
849:
850: /*
851: * Parse requests and execute them.
852: * This is a loop which eats input and process it,
853: * using command() to execute commands.
854: * It returns when command() returns 0 or on '\n' for single step.
855: */
856: void
857: request()
858: {
859: static int ttyflag = -1;
860: register int c;
861: register char *cp;
862: register unsigned segn;
863: register ADDR_T l, d;
864: VAL val[VALSIZE];
865:
866: for(;;) {
867: /* Prompt if appropriate. */
868: if (ttyflag == -1)
869: ttyflag = isatty(fileno(stdin));
870: if (ttyflag && inpp->i_type==IFILE && inpp->i_u.i_filp==stdin) {
871: printf(prompt);
872: fflush(stdout);
873: }
874: if ((c = getn()) == EOF)
875: break;
876:
877: /* !cmd Execute cmd */
878: if (c == '!') {
879: syscall();
880: continue;
881: }
882:
883: /* ? Print fault type */
884: if (c == '?') {
885: if ((c = getn()) != '\n') {
886: printe("Syntax error");
887: goto next;
888: }
889: printr("%s", (lasterr == NULL) ? "No error" : lasterr);
890: continue;
891: }
892: ungetn(c);
893: if (expr_list(val) == 0) /* get expression list */
894: goto next;
895:
896: switch (c = getn()) {
897:
898: /* : indicates commands, handled by command(). */
899: case ':':
900: step_prev = SNULL;
901: if (command(val) == 0)
902: return;
903: continue;
904:
905: /* \n indicates more of the same, single step or display */
906: case '\n':
907: if (nvalue(&val[0]) && step_prev != SNULL) {
908: if (execflag == 0) {
909: step_prev = SNULL;
910: printe("Cannot single step");
911: continue;
912: }
913: step_mode = step_prev;
914: step_count = rvalue(&val[1], 1L);
915: return;
916: }
917: /* else fall through to print value */
918:
919: /* addr\n Print value */
920: /* [addr]=val Assign value */
921: /* [addr]? Print value */
922: case '=':
923: ungetn(c);
924: /* fall through... */
925: case '?':
926: step_prev = SNULL;
927: segn = val_segn(&val[0]);
928: if ((c = getn()) == '=') {
929: l = lvalue(&val[0], dot);
930: if ((c = getn()) == '\n') {
931: dbprintf(("print seg=%d loc=%lx fmt=%s\n", segn, l, addr_fmt));
932: printx(addr_fmt, l);
933: printx("\n");
934: continue;
935: }
936: ungetn(c);
937: dbprintf(("assign to seg=%d loc=%lx\n", segn, l));
938: if (setdata(segn, l) == 0)
939: break;
940: continue;
941: }
942: if (c != '\n') {
943: cp = &seg_format[segn][0];
944: while (c != '\n') {
945: *cp++ = c;
946: c = getn();
947: }
948: *cp++ = '\0';
949: dbprintf(("new seg_format[%d]=%s\n", segn, seg_format[segn]));
950: }
951: d = dot;
952: l = old_add;
953: dot = lvalue(&val[0], old_add);
954: display(segn, (int)rvalue(&val[1], 1L));
955: if (segn != USEG)
956: cseg = segn; /* set cseg unless USEG */
957: else {
958: dot = d; /* restore dot, old_add if USEG */
959: old_add = l;
960: }
961: continue;
962:
963: default:
964: step_prev = SNULL;
965: printe("Syntax error");
966: break;
967: }
968: next:
969: while ((c = getn()) != '\n')
970: ;
971: }
972: }
973:
974: /*
975: * Parse the command line in 'miscbuf',
976: * kill the current child and start up a new one.
977: * Return 0 on success, 1 on failure.
978: */
979: int
980: runfile()
981: {
982: register char *bp, *cp;
983: register int c;
984: char *ifn, *ofn, *argl[ARGSIZE];
985: int qflag, aflag, n;
986:
987: killc();
988: if (!IS_OBJ) {
989: printe("No executable");
990: return 1;
991: }
992: ifn = ofn = NULL;
993: aflag = qflag = n = 0;
994: for (bp = cp = miscbuf, c = *bp++; c != '\n'; ) {
995: switch (c) {
996: case '<':
997: ifn = cp;
998: c = *bp++;
999: break;
1000: case '>':
1001: ofn = cp;
1002: if ((c = *bp++) == '>') {
1003: aflag = 1;
1004: c = *bp++;
1005: }
1006: break;
1007: default:
1008: if (n >= ARGSIZE-1) {
1009: printe("Too many arguments");
1010: return 1;
1011: }
1012: argl[n++] = cp;
1013: }
1014: while (qflag || !isascii(c) || !isspace(c)) {
1015: if (c == '\n')
1016: break;
1017: if (c == '"') {
1018: qflag ^= 1;
1019: c = *bp++;
1020: continue;
1021: }
1022: if (c == '\\') {
1023: if ((c=*bp++) == '\n') {
1024: printe("Syntax error");
1025: return 1;
1026: }
1027: }
1028: *cp++ = c;
1029: c = *bp++;
1030: }
1031: if (qflag) {
1032: printe("Missing '\"'");
1033: return 1;
1034: }
1035: *cp++ = '\0';
1036: if (c == '\n')
1037: break;
1038: while (isascii(c) && isspace(c))
1039: c = *bp++;
1040: }
1041: if (n == 0)
1042: argl[n++] = lfn;
1043: argl[n] = NULL;
1044: return startc(argl, ifn, ofn, aflag) == 0;
1045: }
1046:
1047: /*
1048: * Given a pointer to an allocated buffer and a pointer to a command string,
1049: * copy the command string to the allocated buffer.
1050: * If the buffer hasn't been allocated, allocate it.
1051: */
1052: char *
1053: save_cmd(buf, s) register char *buf, *s;
1054: {
1055: if (buf == NULL)
1056: buf = nalloc(COMSIZE, "command buffer");
1057: buf[COMSIZE-1] = '\0';
1058: return strncpy(buf, s, COMSIZE-1);
1059: }
1060:
1061: /*
1062: * Change the value of a location.
1063: */
1064: int
1065: setdata(segn, a) int segn; ADDR_T a;
1066: {
1067: register char *cp;
1068: register int n;
1069: register int c;
1070: char b[1];
1071: char l3[3];
1072: int i[1];
1073: long l[1];
1074: VAL val[VALSIZE];
1075:
1076: if (expr_list(val) == 0)
1077: return 0;
1078: if ((c = getn()) != '\n')
1079: return 0;
1080: for (n = 0; n < VALSIZE; n++, a += modsize) {
1081: if (nvalue(&val[n]))
1082: continue;
1083: l[0] = rvalue(&val[n], 0L);
1084: switch (modsize) {
1085: case (sizeof(char)):
1086: b[0] = l[0];
1087: cp = b;
1088: break;
1089: case (sizeof(short)):
1090: i[0] = l[0];
1091: cp = (char *)i;
1092: break;
1093: case (sizeof(l3)):
1094: ltol3(l3, l, 1);
1095: cp = l3;
1096: break;
1097: case (sizeof(long)):
1098: cp = (char *)l;
1099: break;
1100: default:
1101: printe("Bad change type");
1102: return 1;
1103: }
1104: add = a;
1105: if (putb(segn, cp, modsize) == 0) {
1106: printe("Cannot change value");
1107: return 1;
1108: }
1109: }
1110: if (segn == USEG) {
1111: /* Reread required registers after writing register data. */
1112: reg_flag = R_INVALID;
1113: get_regs(R_SOME);
1114: }
1115: return 1;
1116: }
1117:
1118: /*
1119: * Send a command to the shell.
1120: * Return its exit status.
1121: */
1122: int
1123: syscall()
1124: {
1125: register int c, status;
1126: register char *cp;
1127:
1128: for (cp = miscbuf; (c = getn()) != '\n'; )
1129: *cp++ = c;
1130: *cp = '\0';
1131: status = system(miscbuf);
1132: testint();
1133: printf("!\n");
1134: return status;
1135: }
1136:
1137: /* end of db/db3.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.