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