![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machine.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / dbx|
Return to machine.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / dbx |
1.1 root 1: /* Copyright (c) 1982 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)machine.c 1.9 8/5/83";
4:
5: /*
6: * Target machine dependent stuff.
7: */
8:
9: #include "defs.h"
10: #include "machine.h"
11: #include "process.h"
12: #include "events.h"
13: #include "main.h"
14: #include "symbols.h"
15: #include "source.h"
16: #include "mappings.h"
17: #include "object.h"
18: #include "ops.h"
19: #include <signal.h>
20:
21: #ifndef public
22: typedef unsigned int Address;
23: typedef unsigned char Byte;
24: typedef unsigned int Word;
25:
26: #define NREG 16
27:
28: #define ARGP 12
29: #define FRP 13
30: #define STKP 14
31: #define PROGCTR 15
32:
33: #define BITSPERBYTE 8
34: #define BITSPERWORD (BITSPERBYTE * sizeof(Word))
35:
36: #define nargspassed(frame) argn(0, frame)
37:
38: #include "source.h"
39: #include "symbols.h"
40:
41: Address pc;
42: Address prtaddr;
43:
44: #endif
45:
46: private Address printop();
47:
48: /*
49: * Decode and print the instructions within the given address range.
50: */
51:
52: public printinst(lowaddr, highaddr)
53: Address lowaddr;
54: Address highaddr;
55: {
56: register Address addr;
57:
58: for (addr = lowaddr; addr <= highaddr; ) {
59: addr = printop(addr);
60: }
61: prtaddr = addr;
62: }
63:
64: /*
65: * Another approach: print n instructions starting at the given address.
66: */
67:
68: public printninst(count, addr)
69: int count;
70: Address addr;
71: {
72: register Integer i;
73: register Address newaddr;
74:
75: if (count <= 0) {
76: error("non-positive repetition count");
77: } else {
78: newaddr = addr;
79: for (i = 0; i < count; i++) {
80: newaddr = printop(newaddr);
81: }
82: prtaddr = newaddr;
83: }
84: }
85:
86: /*
87: * Hacked version of adb's VAX instruction decoder.
88: */
89:
90: private Address printop(addr)
91: Address addr;
92: {
93: Optab op;
94: VaxOpcode ins;
95: unsigned char mode;
96: int argtype, amode, argno, argval;
97: String reg;
98: Boolean indexf;
99: short offset;
100:
101: argval = 0;
102: indexf = false;
103: printf("%08x ", addr);
104: iread(&ins, addr, sizeof(ins));
105: addr += 1;
106: op = optab[ins];
107: printf("%s", op.iname);
108: for (argno = 0; argno < op.numargs; argno++) {
109: if (indexf == true) {
110: indexf = false;
111: } else if (argno == 0) {
112: printf("\t");
113: } else {
114: printf(",");
115: }
116: argtype = op.argtype[argno];
117: if (is_branch_disp(argtype)) {
118: mode = 0xAF + (typelen(argtype) << 5);
119: } else {
120: iread(&mode, addr, sizeof(mode));
121: addr += 1;
122: }
123: reg = regname[regnm(mode)];
124: amode = addrmode(mode);
125: switch (amode) {
126: case LITSHORT:
127: case LITUPTO31:
128: case LITUPTO47:
129: case LITUPTO63:
130: if (typelen(argtype) == TYPF || typelen(argtype) ==TYPD)
131: printf("$%s", fltimm[mode]);
132: else
133: printf("$%x", mode);
134: argval = mode;
135: break;
136:
137: case INDEX:
138: printf("[%s]", reg);
139: indexf = true;
140: argno--;
141: break;
142:
143: case REG:
144: printf("%s", reg);
145: break;
146:
147: case REGDEF:
148: printf("(%s)", reg);
149: break;
150:
151: case AUTODEC:
152: printf("-(%s)", reg);
153: break;
154:
155: case AUTOINC:
156: if (reg != regname[PROGCTR]) {
157: printf("(%s)+", reg);
158: } else {
159: printf("$");
160: switch (typelen(argtype)) {
161: case TYPB:
162: argval = printdisp(addr, 1, reg, amode);
163: addr += 1;
164: break;
165:
166: case TYPW:
167: argval = printdisp(addr, 2, reg, amode);
168: addr += 2;
169: break;
170:
171: case TYPL:
172: argval = printdisp(addr, 4, reg, amode);
173: addr += 4;
174: break;
175:
176: case TYPF:
177: iread(&argval, addr, sizeof(argval));
178: printf("%06x", argval);
179: addr += 4;
180: break;
181:
182: case TYPQ:
183: case TYPD:
184: iread(&argval, addr, sizeof(argval));
185: printf("%06x", argval);
186: iread(&argval, addr+4, sizeof(argval));
187: printf("%06x", argval);
188: addr += 8;
189: break;
190: }
191: }
192: break;
193:
194: case AUTOINCDEF:
195: if (reg == regname[PROGCTR]) {
196: printf("*$");
197: argval = printdisp(addr, 4, reg, amode);
198: addr += 4;
199: } else {
200: printf("*(%s)+", reg);
201: }
202: break;
203:
204: case BYTEDISP:
205: argval = printdisp(addr, 1, reg, amode);
206: addr += 1;
207: break;
208:
209: case BYTEDISPDEF:
210: printf("*");
211: argval = printdisp(addr, 1, reg, amode);
212: addr += 1;
213: break;
214:
215: case WORDDISP:
216: argval = printdisp(addr, 2, reg, amode);
217: addr += 2;
218: break;
219:
220: case WORDDISPDEF:
221: printf("*");
222: argval = printdisp(addr, 2, reg, amode);
223: addr += 2;
224: break;
225:
226: case LONGDISP:
227: argval = printdisp(addr, 4, reg, amode);
228: addr += 4;
229: break;
230:
231: case LONGDISPDEF:
232: printf("*");
233: argval = printdisp(addr, 4, reg, amode);
234: addr += 4;
235: break;
236: }
237: }
238: if (ins == O_CASEB || ins == O_CASEW || ins == O_CASEL) {
239: for (argno = 0; argno <= argval; argno++) {
240: iread(&offset, addr, sizeof(offset));
241: printf("\n\t\t%d", offset);
242: addr += 2;
243: }
244: }
245: printf("\n");
246: return addr;
247: }
248:
249: /*
250: * Print the displacement of an instruction that uses displacement
251: * addressing.
252: */
253:
254: private int printdisp(addr, nbytes, reg, mode)
255: Address addr;
256: int nbytes;
257: char *reg;
258: int mode;
259: {
260: char byte;
261: short hword;
262: int argval;
263: Symbol f;
264:
265: switch (nbytes) {
266: case 1:
267: iread(&byte, addr, sizeof(byte));
268: argval = byte;
269: break;
270:
271: case 2:
272: iread(&hword, addr, sizeof(hword));
273: argval = hword;
274: break;
275:
276: case 4:
277: iread(&argval, addr, sizeof(argval));
278: break;
279: }
280: if (reg == regname[PROGCTR] && mode >= BYTEDISP) {
281: argval += addr + nbytes;
282: }
283: if (reg == regname[PROGCTR]) {
284: f = whatblock((Address) argval + 2);
285: if (codeloc(f) == argval + 2) {
286: printf("%s", symname(f));
287: } else {
288: printf("%x", argval);
289: }
290: } else {
291: printf("%d(%s)", argval, reg);
292: }
293: return argval;
294: }
295:
296: /*
297: * Print the contents of the addresses within the given range
298: * according to the given format.
299: */
300:
301: typedef struct {
302: String name;
303: String printfstring;
304: int length;
305: } Format;
306:
307: private Format fmt[] = {
308: { "d", " %d", sizeof(short) },
309: { "D", " %ld", sizeof(long) },
310: { "o", " %o", sizeof(short) },
311: { "O", " %lo", sizeof(long) },
312: { "x", " %04x", sizeof(short) },
313: { "X", " %08x", sizeof(long) },
314: { "b", " \\%o", sizeof(char) },
315: { "c", " '%c'", sizeof(char) },
316: { "s", "%c", sizeof(char) },
317: { "f", " %f", sizeof(float) },
318: { "g", " %g", sizeof(double) },
319: { nil, nil, 0 }
320: };
321:
322: private Format *findformat(s)
323: String s;
324: {
325: register Format *f;
326:
327: f = &fmt[0];
328: while (f->name != nil and not streq(f->name, s)) {
329: ++f;
330: }
331: if (f->name == nil) {
332: error("bad print format \"%s\"", s);
333: }
334: return f;
335: }
336:
337: public Address printdata(lowaddr, highaddr, format)
338: Address lowaddr;
339: Address highaddr;
340: String format;
341: {
342: register int n;
343: register Address addr;
344: register Format *f;
345: int value;
346:
347: if (lowaddr > highaddr) {
348: error("first address larger than second");
349: }
350: f = findformat(format);
351: n = 0;
352: value = 0;
353: for (addr = lowaddr; addr <= highaddr; addr += f->length) {
354: if (n == 0) {
355: printf("%08x: ", addr);
356: }
357: dread(&value, addr, f->length);
358: printf(f->printfstring, value);
359: ++n;
360: if (n >= (16 div f->length)) {
361: putchar('\n');
362: n = 0;
363: }
364: }
365: if (n != 0) {
366: putchar('\n');
367: }
368: prtaddr = addr;
369: return addr;
370: }
371:
372: /*
373: * The other approach is to print n items starting with a given address.
374: */
375:
376: public printndata(count, startaddr, format)
377: int count;
378: Address startaddr;
379: String format;
380: {
381: register int i, n;
382: register Address addr;
383: register Format *f;
384: register Boolean isstring;
385: char c;
386: union {
387: char charv;
388: short shortv;
389: int intv;
390: float floatv;
391: double doublev;
392: } value;
393:
394: if (count <= 0) {
395: error("non-positive repetition count");
396: }
397: f = findformat(format);
398: isstring = (Boolean) streq(f->name, "s");
399: n = 0;
400: addr = startaddr;
401: value.intv = 0;
402: for (i = 0; i < count; i++) {
403: if (n == 0) {
404: printf("%08x: ", addr);
405: }
406: if (isstring) {
407: putchar('"');
408: dread(&c, addr, sizeof(char));
409: while (c != '\0') {
410: printchar(c);
411: ++addr;
412: dread(&c, addr, sizeof(char));
413: }
414: putchar('"');
415: putchar('\n');
416: n = 0;
417: addr += sizeof(String);
418: } else {
419: dread(&value, addr, f->length);
420: printf(f->printfstring, value);
421: ++n;
422: if (n >= (16 div f->length)) {
423: putchar('\n');
424: n = 0;
425: }
426: addr += f->length;
427: }
428: }
429: if (n != 0) {
430: putchar('\n');
431: }
432: prtaddr = addr;
433: }
434:
435: /*
436: * Print out a value according to the given format.
437: */
438:
439: public printvalue(v, format)
440: long v;
441: String format;
442: {
443: Format *f;
444: char *p, *q;
445:
446: f = findformat(format);
447: if (streq(f->name, "s")) {
448: putchar('"');
449: p = (char *) &v;
450: q = p + sizeof(v);
451: while (p < q) {
452: printchar(*p);
453: ++p;
454: }
455: putchar('"');
456: } else {
457: printf(f->printfstring, v);
458: }
459: putchar('\n');
460: }
461:
462: /*
463: * Print out an execution time error.
464: * Assumes the source position of the error has been calculated.
465: *
466: * Have to check if the -r option was specified; if so then
467: * the object file information hasn't been read in yet.
468: */
469:
470: public printerror()
471: {
472: extern Integer sys_nsig;
473: extern String sys_siglist[];
474: Integer err;
475:
476: if (isfinished(process)) {
477: printf("\"%s\" exits with code %d\n", objname, exitcode(process));
478: erecover();
479: }
480: if (runfirst) {
481: fprintf(stderr, "Entering debugger ...");
482: init();
483: fprintf(stderr, " type 'help' for help\n");
484: }
485: err = errnum(process);
486: if (err == SIGINT) {
487: printf("\n\ninterrupt ");
488: printloc();
489: } else if (err == SIGTRAP) {
490: printf("\nerror ");
491: printloc();
492: } else {
493: if (err < 0 or err > sys_nsig) {
494: printf("\nsignal %d ", err);
495: } else {
496: printf("\n%s ", sys_siglist[err]);
497: }
498: printloc();
499: }
500: putchar('\n');
501: if (curline > 0) {
502: printlines(curline, curline);
503: } else {
504: printinst(pc, pc);
505: }
506: erecover();
507: }
508:
509: /*
510: * Note the termination of the program. We do this so as to avoid
511: * having the process exit, which would make the values of variables
512: * inaccessible. We do want to flush all output buffers here,
513: * otherwise it'll never get done.
514: */
515:
516: public endprogram()
517: {
518: Integer exitcode;
519:
520: stepto(nextaddr(pc, true));
521: printnews();
522: exitcode = argn(1, nil);
523: printf("\nexecution completed, exit code is %d\n", exitcode);
524: getsrcpos();
525: erecover();
526: }
527:
528: /*
529: * Single step the machine a source line (or instruction if "inst_tracing"
530: * is true). If "isnext" is true, skip over procedure calls.
531: */
532:
533: private Address getcall();
534:
535: public dostep(isnext)
536: Boolean isnext;
537: {
538: register Address addr;
539: register Lineno line;
540: String filename;
541:
542: addr = nextaddr(pc, isnext);
543: if (not inst_tracing and nlhdr.nlines != 0) {
544: line = linelookup(addr);
545: while (line == 0) {
546: addr = nextaddr(addr, isnext);
547: line = linelookup(addr);
548: }
549: curline = line;
550: } else {
551: curline = 0;
552: }
553: stepto(addr);
554: filename = srcfilename(addr);
555: setsource(filename);
556: }
557:
558: /*
559: * Compute the next address that will be executed from the given one.
560: * If "isnext" is true then consider a procedure call as straight line code.
561: *
562: * We must unfortunately do much of the same work that is necessary
563: * to print instructions. In addition we have to deal with branches.
564: * Unconditional branches we just follow, for conditional branches
565: * we continue execution to the current location and then single step
566: * the machine. We assume that the last argument in an instruction
567: * that branches is the branch address (or relative offset).
568: */
569:
570: public Address nextaddr(startaddr, isnext)
571: Address startaddr;
572: Boolean isnext;
573: {
574: register Address addr;
575: Optab op;
576: VaxOpcode ins;
577: unsigned char mode;
578: int argtype, amode, argno, argval;
579: String r;
580: Boolean indexf;
581: enum { KNOWN, SEQUENTIAL, BRANCH } addrstatus;
582:
583: argval = 0;
584: indexf = false;
585: addr = startaddr;
586: iread(&ins, addr, sizeof(ins));
587: switch (ins) {
588: case O_BRB:
589: case O_BRW:
590: case O_JMP:
591: addrstatus = BRANCH;
592: break;
593:
594: case O_BSBB:
595: case O_BSBW:
596: case O_JSB:
597: case O_CALLG:
598: case O_CALLS:
599: if (isnext) {
600: addrstatus = SEQUENTIAL;
601: } else {
602: addrstatus = KNOWN;
603: stepto(addr);
604: pstep(process);
605: addr = reg(PROGCTR);
606: pc = addr;
607: curfunc = whatblock(pc);
608: if (not isbperr()) {
609: printstatus();
610: /* NOTREACHED */
611: }
612: bpact();
613: if (nosource(curfunc) and canskip(curfunc) and
614: nlhdr.nlines != 0) {
615: addrstatus = KNOWN;
616: addr = return_addr();
617: stepto(addr);
618: bpact();
619: } else {
620: callnews(/* iscall = */ true);
621: }
622: }
623: break;
624:
625: case O_RSB:
626: case O_RET:
627: addrstatus = KNOWN;
628: callnews(/* iscall = */ false);
629: addr = return_addr();
630: stepto(addr);
631: bpact();
632: break;
633:
634: case O_BNEQ: case O_BEQL: case O_BGTR:
635: case O_BLEQ: case O_BGEQ: case O_BLSS:
636: case O_BGTRU: case O_BLEQU: case O_BVC:
637: case O_BVS: case O_BCC: case O_BCS:
638: case O_CASEB: case O_CASEW: case O_CASEL:
639: case O_BBS: case O_BBC: case O_BBSS: case O_BBCS:
640: case O_BBSC: case O_BBCC: case O_BBSSI:
641: case O_BBCCI: case O_BLBS: case O_BLBC:
642: case O_ACBL: case O_AOBLSS: case O_AOBLEQ:
643: case O_SOBGEQ: case O_SOBGTR:
644: addrstatus = KNOWN;
645: stepto(addr);
646: pstep(process);
647: addr = reg(PROGCTR);
648: pc = addr;
649: if (not isbperr()) {
650: printstatus();
651: }
652: break;
653:
654: default:
655: addrstatus = SEQUENTIAL;
656: break;
657: }
658: if (addrstatus != KNOWN) {
659: addr += 1;
660: op = optab[ins];
661: for (argno = 0; argno < op.numargs; argno++) {
662: if (indexf == true) {
663: indexf = false;
664: }
665: argtype = op.argtype[argno];
666: if (is_branch_disp(argtype)) {
667: mode = 0xAF + (typelen(argtype) << 5);
668: } else {
669: iread(&mode, addr, sizeof(mode));
670: addr += 1;
671: }
672: r = regname[regnm(mode)];
673: amode = addrmode(mode);
674: switch (amode) {
675: case LITSHORT:
676: case LITUPTO31:
677: case LITUPTO47:
678: case LITUPTO63:
679: argval = mode;
680: break;
681:
682: case INDEX:
683: indexf = true;
684: --argno;
685: break;
686:
687: case REG:
688: case REGDEF:
689: case AUTODEC:
690: break;
691:
692: case AUTOINC:
693: if (r == regname[PROGCTR]) {
694: switch (typelen(argtype)) {
695: case TYPB:
696: argval = getdisp(addr, 1, r, amode);
697: addr += 1;
698: break;
699:
700: case TYPW:
701: argval = getdisp(addr, 2, r, amode);
702: addr += 2;
703: break;
704:
705: case TYPL:
706: argval = getdisp(addr, 4, r, amode);
707: addr += 4;
708: break;
709:
710: case TYPF:
711: iread(&argval, addr, sizeof(argval));
712: addr += 4;
713: break;
714:
715: case TYPQ:
716: case TYPD:
717: iread(&argval, addr+4, sizeof(argval));
718: addr += 8;
719: break;
720: }
721: }
722: break;
723:
724: case AUTOINCDEF:
725: if (r == regname[PROGCTR]) {
726: argval = getdisp(addr, 4, r, amode);
727: addr += 4;
728: }
729: break;
730:
731: case BYTEDISP:
732: case BYTEDISPDEF:
733: argval = getdisp(addr, 1, r, amode);
734: addr += 1;
735: break;
736:
737: case WORDDISP:
738: case WORDDISPDEF:
739: argval = getdisp(addr, 2, r, amode);
740: addr += 2;
741: break;
742:
743: case LONGDISP:
744: case LONGDISPDEF:
745: argval = getdisp(addr, 4, r, amode);
746: addr += 4;
747: break;
748: }
749: }
750: if (ins == O_CALLS or ins == O_CALLG) {
751: argval += 2;
752: }
753: if (addrstatus == BRANCH) {
754: addr = argval;
755: }
756: }
757: return addr;
758: }
759:
760: /*
761: * Get the displacement of an instruction that uses displacement addressing.
762: */
763:
764: private int getdisp(addr, nbytes, reg, mode)
765: Address addr;
766: int nbytes;
767: String reg;
768: int mode;
769: {
770: char byte;
771: short hword;
772: int argval;
773:
774: switch (nbytes) {
775: case 1:
776: iread(&byte, addr, sizeof(byte));
777: argval = byte;
778: break;
779:
780: case 2:
781: iread(&hword, addr, sizeof(hword));
782: argval = hword;
783: break;
784:
785: case 4:
786: iread(&argval, addr, sizeof(argval));
787: break;
788: }
789: if (reg == regname[PROGCTR] && mode >= BYTEDISP) {
790: argval += addr + nbytes;
791: }
792: return argval;
793: }
794:
795: #define BP_OP O_BPT /* breakpoint trap */
796: #define BP_ERRNO SIGTRAP /* signal received at a breakpoint */
797:
798: /*
799: * Setting a breakpoint at a location consists of saving
800: * the word at the location and poking a BP_OP there.
801: *
802: * We save the locations and words on a list for use in unsetting.
803: */
804:
805: typedef struct Savelist *Savelist;
806:
807: struct Savelist {
808: Address location;
809: Byte save;
810: Byte refcount;
811: Savelist link;
812: };
813:
814: private Savelist savelist;
815:
816: /*
817: * Set a breakpoint at the given address. Only save the word there
818: * if it's not already a breakpoint.
819: */
820:
821: public setbp(addr)
822: Address addr;
823: {
824: Byte w;
825: Byte save;
826: register Savelist newsave, s;
827:
828: for (s = savelist; s != nil; s = s->link) {
829: if (s->location == addr) {
830: s->refcount++;
831: return;
832: }
833: }
834: iread(&save, addr, sizeof(save));
835: newsave = new(Savelist);
836: newsave->location = addr;
837: newsave->save = save;
838: newsave->refcount = 1;
839: newsave->link = savelist;
840: savelist = newsave;
841: w = BP_OP;
842: iwrite(&w, addr, sizeof(w));
843: }
844:
845: /*
846: * Unset a breakpoint; unfortunately we have to search the SAVELIST
847: * to find the saved value. The assumption is that the SAVELIST will
848: * usually be quite small.
849: */
850:
851: public unsetbp(addr)
852: Address addr;
853: {
854: register Savelist s, prev;
855:
856: prev = nil;
857: for (s = savelist; s != nil; s = s->link) {
858: if (s->location == addr) {
859: iwrite(&s->save, addr, sizeof(s->save));
860: s->refcount--;
861: if (s->refcount == 0) {
862: if (prev == nil) {
863: savelist = s->link;
864: } else {
865: prev->link = s->link;
866: }
867: dispose(s);
868: }
869: return;
870: }
871: prev = s;
872: }
873: panic("unsetbp: couldn't find address %d", addr);
874: }
875:
876: /*
877: * Predicate to test if the reason the process stopped was because
878: * of a breakpoint.
879: */
880:
881: public Boolean isbperr()
882: {
883: return (Boolean) (not isfinished(process) and errnum(process) == SIGTRAP);
884: }
885:
886: /*
887: * Enter a procedure by creating and executing a call instruction.
888: */
889:
890: #define CALLSIZE 7 /* size of call instruction */
891:
892: public beginproc(p, argc)
893: Symbol p;
894: Integer argc;
895: {
896: char save[CALLSIZE];
897: struct {
898: VaxOpcode op;
899: unsigned char numargs;
900: unsigned char mode;
901: char addr[sizeof(long)]; /* unaligned long */
902: } call;
903: long dest;
904:
905: pc = 2;
906: iread(save, pc, sizeof(save));
907: call.op = O_CALLS;
908: call.numargs = argc;
909: call.mode = 0xef;
910: dest = codeloc(p) - 2 - (pc + 7);
911: mov(&dest, call.addr, sizeof(call.addr));
912: iwrite(&call, pc, sizeof(call));
913: setreg(PROGCTR, pc);
914: pstep(process);
915: iwrite(save, pc, sizeof(save));
916: pc = reg(PROGCTR);
917: if (not isbperr()) {
918: printstatus();
919: }
920: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.