![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tahoe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / dbx|
Return to tahoe.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / dbx |
1.1 root 1: /*
2: * Copyright (c) 1985 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)tahoe.c 5.8 (Berkeley) 6/1/90";
22: #endif /* not lint */
23:
24: /*
25: * Target machine dependent stuff.
26: */
27:
28: #include "defs.h"
29: #include "machine.h"
30: #include "process.h"
31: #include "runtime.h"
32: #include "events.h"
33: #include "main.h"
34: #include "symbols.h"
35: #include "source.h"
36: #include "mappings.h"
37: #include "object.h"
38: #include "keywords.h"
39: #include "ops.h"
40: #include "eval.h"
41: #include <signal.h>
42:
43: #ifndef public
44: typedef unsigned int Address;
45: typedef unsigned char Byte;
46: typedef unsigned int Word;
47:
48: #define NREG 16
49:
50: #define FRP 13
51: #define STKP 14
52: #define PROGCTR 15
53:
54: #define CODESTART 0
55: #define FUNCOFFSET 2
56:
57: #define BITSPERBYTE 8
58: #define BITSPERWORD (BITSPERBYTE * sizeof(Word))
59:
60: /*
61: * This magic macro enables us to look at the process' registers
62: * in its user structure.
63: */
64:
65: #define regloc(reg) (ctob(UPAGES) + (sizeof(Word) * (reg)))
66:
67: #define nargspassed(frame) (((argn(-1, frame)&0xffff)-4)/4)
68:
69: #define SYSBASE 0xc0000000 /* base of system address space */
70: #define physaddr(a) ((a) &~ 0xc0000000)
71:
72: #include "source.h"
73: #include "symbols.h"
74: #include <sys/param.h>
75: #include <machine/psl.h>
76: #include <sys/user.h>
77: #undef DELETE /* XXX */
78: #include <sys/vm.h>
79: #include <machine/reg.h>
80: #include <machine/pte.h>
81:
82: Address pc;
83: Address prtaddr;
84:
85: #endif
86:
87: /*
88: * Indices into u. for use in collecting registers values.
89: */
90: public int rloc[] =
91: { R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, FP, SP, PC };
92:
93: private Address printop();
94:
95: Optab *ioptab[256]; /* index by opcode to optab */
96: /*
97: * Initialize the opcode lookup table.
98: */
99: public optab_init()
100: {
101: register Optab *p;
102:
103: for (p = optab; p->iname; p++)
104: ioptab[p->val & 0xff] = p;
105: }
106:
107: /*
108: * Decode and print the instructions within the given address range.
109: */
110: public printinst(lowaddr, highaddr)
111: Address lowaddr, highaddr;
112: {
113: register Address addr;
114:
115: for (addr = lowaddr; addr <= highaddr; )
116: addr = printop(addr);
117: prtaddr = addr;
118: }
119:
120: /*
121: * Another approach: print n instructions starting at the given address.
122: */
123: public printninst(count, addr)
124: int count;
125: Address addr;
126: {
127: register Integer i;
128: register Address newaddr;
129:
130: if (count <= 0)
131: error("non-positive repetition count");
132: for (newaddr = addr, i = 0; i < count; i++)
133: newaddr = printop(newaddr);
134: prtaddr = newaddr;
135: }
136:
137: /*
138: * Hacked version of adb's instruction decoder.
139: */
140: private Address printop(addr)
141: Address addr;
142: {
143: register Optab *op;
144: Opcode ins;
145: unsigned char mode;
146: int argtype, amode, argno, argval, r;
147: String reg;
148: Boolean indexf;
149: short offset;
150:
151: argval = 0;
152: indexf = false;
153: printf("%08x ", addr);
154: iread(&ins, addr, sizeof(ins));
155: addr += 1;
156: op = ioptab[ins];
157: printf("%s", op->iname);
158: for (argno = 0; argno < op->numargs; argno++) {
159: if (indexf == true)
160: indexf = false;
161: else
162: printf(argno == 0 ? "\t" : ",");
163: argtype = op->argtype[argno];
164: if (is_branch_disp(argtype))
165: mode = 0xAF + (typelen(argtype) << 5);
166: else
167: iread(&mode, addr, sizeof(mode)), addr += 1;
168: reg = regname[regnm(mode)];
169: amode = addrmode(mode);
170: switch (amode) {
171:
172: case LITSHORT: case LITUPTO31:
173: case LITUPTO47: case LITUPTO63:
174: if (ins == O_KCALL && mode >= 0 && mode < SYSSIZE &&
175: systab[mode])
176: printf("$%s", systab[mode]);
177: else
178: printf("$%x", mode);
179: argval = mode;
180: break;
181:
182: case INDEX:
183: printf("[%s]", reg);
184: indexf = true;
185: argno--;
186: break;
187:
188: case REG:
189: printf("%s", reg);
190: break;
191:
192: case REGDEF:
193: printf("(%s)", reg);
194: break;
195:
196: case AUTODEC:
197: printf("-(%s)", reg);
198: break;
199:
200: case AUTOINC:
201: r = mode & 0xf;
202: if (r == 0xf || r == 8 || r == 9) {
203: int size = (mode&03) + 1;
204:
205: /* immediate mode */
206: printf("$");
207: argval = printdisp(addr, size,
208: regname[PROGCTR], amode);
209: addr += size;
210: } else
211: printf("(%s)+", reg);
212: break;
213:
214: case AUTOINCDEF:
215: if ((mode&0xf) == 0xf) {
216: printf("*$");
217: argval = printdisp(addr, 4, reg, amode);
218: addr += 4;
219: } else
220: printf("*(%s)+", reg);
221: break;
222:
223: case BYTEDISP:
224: argval = printdisp(addr, 1, reg, amode);
225: addr += 1;
226: break;
227:
228: case BYTEDISPDEF:
229: printf("*");
230: argval = printdisp(addr, 1, reg, amode);
231: addr += 1;
232: break;
233:
234: case WORDDISP:
235: argval = printdisp(addr, 2, reg, amode);
236: addr += 2;
237: break;
238:
239: case WORDDISPDEF:
240: printf("*");
241: argval = printdisp(addr, 2, reg, amode);
242: addr += 2;
243: break;
244:
245: case LONGDISP:
246: argval = printdisp(addr, 4, reg, amode);
247: addr += 4;
248: break;
249:
250: case LONGDISPDEF:
251: printf("*");
252: argval = printdisp(addr, 4, reg, amode);
253: addr += 4;
254: break;
255: }
256: }
257: if (ins == O_CASEL)
258: for (argno = 0; argno <= argval; argno++) {
259: iread(&offset, addr, sizeof(offset));
260: printf("\n\t\t%d", offset);
261: addr += 2;
262: }
263: printf("\n");
264: return (addr);
265: }
266:
267: /*
268: * Print the displacement of an instruction that uses displacement
269: * addressing.
270: */
271: private int printdisp(addr, nbytes, reg, mode)
272: Address addr;
273: int nbytes;
274: char *reg;
275: int mode;
276: {
277: char byte;
278: short hword;
279: int argval;
280: Symbol f;
281:
282: switch (nbytes) {
283:
284: case 1:
285: iread(&byte, addr, sizeof(byte));
286: argval = byte;
287: break;
288:
289: case 2:
290: iread(&hword, addr, sizeof(hword));
291: argval = hword;
292: break;
293:
294: case 4:
295: iread(&argval, addr, sizeof(argval));
296: break;
297: }
298: if (reg == regname[PROGCTR] && mode >= BYTEDISP)
299: argval += addr + nbytes;
300: if (reg == regname[PROGCTR]) {
301: f = whatblock((Address) argval + 2);
302: if (codeloc(f) == argval + 2)
303: printf("%s", symname(f));
304: else
305: printf("%x", argval);
306: } else {
307: if (varIsSet("$hexoffsets")) {
308: if (argval < 0)
309: printf("-%x(%s)", -(argval), reg);
310: else
311: printf("%x(%s)", argval, reg);
312: } else
313: printf("%d(%s)", argval, reg);
314: }
315: return (argval);
316: }
317:
318: /*
319: * Print the contents of the addresses within the given range
320: * according to the given format.
321: */
322: typedef struct {
323: String name;
324: String printfstring;
325: int length;
326: } Format;
327:
328: private Format fmt[] = {
329: { "d", " %d", sizeof(short) },
330: { "D", " %ld", sizeof(long) },
331: { "o", " %o", sizeof(short) },
332: { "O", " %lo", sizeof(long) },
333: { "x", " %04x", sizeof(short) },
334: { "X", " %08x", sizeof(long) },
335: { "b", " \\%o", sizeof(char) },
336: { "c", " '%c'", sizeof(char) },
337: { "s", "%c", sizeof(char) },
338: { "f", " %f", sizeof(float) },
339: { "g", " %g", sizeof(double) },
340: { nil, nil, 0 }
341: };
342:
343: private Format *findformat(s)
344: String s;
345: {
346: register Format *f;
347:
348: for (f = &fmt[0]; f->name != nil && !streq(f->name, s); f++)
349: ;
350: if (f->name == nil)
351: error("bad print format \"%s\"", s);
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: f = findformat(format);
368: n = 0;
369: value = 0;
370: for (addr = lowaddr; addr <= highaddr; addr += f->length) {
371: if (n == 0)
372: printf("%08x: ", addr);
373: dread(&value, addr, f->length);
374: printf(f->printfstring, value);
375: ++n;
376: if (n >= (16 div f->length)) {
377: putchar('\n');
378: n = 0;
379: }
380: }
381: if (n != 0)
382: putchar('\n');
383: prtaddr = addr;
384: return (addr);
385: }
386:
387: /*
388: * The other approach is to print n items starting with a given address.
389: */
390:
391: public printndata(count, startaddr, format)
392: int count;
393: Address startaddr;
394: String format;
395: {
396: register int i, n;
397: register Address addr;
398: register Format *f;
399: register Boolean isstring;
400: char c;
401: union {
402: char charv;
403: short shortv;
404: int intv;
405: float floatv;
406: double doublev;
407: } value;
408:
409: if (count <= 0)
410: error("non-positive repetition count");
411: f = findformat(format);
412: isstring = (Boolean) streq(f->name, "s");
413: n = 0;
414: addr = startaddr;
415: value.intv = 0;
416: for (i = 0; i < count; i++) {
417: if (n == 0)
418: printf("%08x: ", addr);
419: if (isstring) {
420: putchar('"');
421: dread(&c, addr, sizeof(char));
422: while (c != '\0') {
423: printchar(c);
424: ++addr;
425: dread(&c, addr, sizeof(char));
426: }
427: putchar('"');
428: putchar('\n');
429: n = 0;
430: addr += sizeof(String);
431: continue;
432: }
433: dread(&value, addr, f->length);
434: printf(f->printfstring, value);
435: ++n;
436: if (n >= (16 div f->length)) {
437: putchar('\n');
438: n = 0;
439: }
440: addr += f->length;
441: }
442: if (n != 0)
443: putchar('\n');
444: prtaddr = addr;
445: }
446:
447: /*
448: * Print out a value according to the given format.
449: */
450: public printvalue(v, format)
451: long v;
452: String format;
453: {
454: Format *f;
455: char *p, *q;
456:
457: f = findformat(format);
458: if (streq(f->name, "s")) {
459: putchar('"');
460: for (p = (char *) &v, q = p + sizeof(v); p < q; ++p)
461: printchar(*p);
462: putchar('"');
463: } else
464: printf(f->printfstring, v);
465: putchar('\n');
466: }
467:
468: /*
469: * Print out an execution time error.
470: * Assumes the source position of the error has been calculated.
471: *
472: * Have to check if the -r option was specified; if so then
473: * the object file information hasn't been read in yet.
474: */
475: public printerror()
476: {
477: extern Integer sys_nsig;
478: extern String sys_siglist[];
479: integer err;
480:
481: if (isfinished(process)) {
482: err = exitcode(process);
483: if (err) {
484: printf("\"%s\" terminated abnormally (exit code %d)\n",
485: objname, err);
486: erecover();
487: } else
488: printf("\"%s\" terminated normally\n", objname);
489: }
490: if (runfirst) {
491: fprintf(stderr, "Entering debugger ...\n");
492: init();
493: }
494: err = errnum(process);
495: putchar('\n');
496: printsig(err);
497: putchar(' ');
498: printloc();
499: putchar('\n');
500: if (curline > 0)
501: printlines(curline, curline);
502: else
503: printinst(pc, pc);
504: erecover();
505: }
506:
507: /*
508: * Print out a signal.
509: */
510: private String illinames[] = {
511: "reserved addressing fault",
512: "privileged instruction fault",
513: "reserved operand fault"
514: };
515: #define NILLINAMES (sizeof (illinames) / sizeof (illinames[0]))
516:
517: private String fpenames[] = {
518: nil,
519: "integer overflow trap",
520: "integer divide by zero trap",
521: "floating point divide by zero trap",
522: "floating point overflow trap",
523: "floating point underflow trap",
524: };
525: #define NFPENAMES (sizeof (fpenames) / sizeof (fpenames[0]))
526:
527: public printsig(signo)
528: integer signo;
529: {
530: integer code;
531:
532: if (signo < 0 or signo > sys_nsig)
533: printf("[signal %d]", signo);
534: else
535: printf("%s", sys_siglist[signo]);
536: code = errcode(process);
537: if (signo == SIGILL)
538: if (code >= 0 && code < NILLINAMES)
539: printf(" (%s)", illinames[code]);
540: if (signo == SIGFPE)
541: if (code > 0 and code < NFPENAMES)
542: printf(" (%s)", fpenames[code]);
543: }
544:
545: /*
546: * Note the termination of the program. We do this so as to avoid
547: * having the process exit, which would make the values of variables
548: * inaccessible. We do want to flush all output buffers here,
549: * otherwise it'll never get done.
550: */
551: public endprogram()
552: {
553: Integer exitcode;
554:
555: stepto(nextaddr(pc, true));
556: printnews();
557: exitcode = argn(1, nil);
558: if (exitcode != 0)
559: printf("\nexecution completed (exit code %d)\n", exitcode);
560: else
561: printf("\nexecution completed\n");
562: getsrcpos();
563: erecover();
564: }
565:
566: private Address getcall();
567: /*
568: * Single step the machine a source line (or instruction if "inst_tracing"
569: * is true). If "isnext" is true, skip over procedure calls.
570: */
571: public dostep(isnext)
572: Boolean isnext;
573: {
574: register Address addr;
575: register Lineno line;
576: String filename;
577: Address startaddr;
578:
579: startaddr = pc;
580: addr = nextaddr(pc, isnext);
581: if (!inst_tracing && nlhdr.nlines != 0) {
582: line = linelookup(addr);
583: for (; line == 0; line = linelookup(addr))
584: addr = nextaddr(addr, isnext);
585: curline = line;
586: } else
587: curline = 0;
588: stepto(addr);
589: filename = srcfilename(addr);
590: setsource(filename);
591: }
592:
593: private Address findnextaddr();
594: /*
595: * Compute the next address that will be executed from the given one.
596: * If "isnext" is true then consider a procedure call as straight line code.
597: *
598: * We must unfortunately do much of the same work that is necessary
599: * to print instructions. In addition we have to deal with branches.
600: * Unconditional branches we just follow, for conditional branches
601: * we continue execution to the current location and then single step
602: * the machine. We assume that the last argument in an instruction
603: * that branches is the branch address (or relative offset).
604: */
605: public Address nextaddr(startaddr, isnext)
606: Address startaddr;
607: boolean isnext;
608: {
609: Address addr;
610:
611: addr = usignal(process);
612: if (addr == 0 or addr == 1)
613: addr = findnextaddr(startaddr, isnext);
614: return (addr);
615: }
616:
617: /*
618: * Determine if it's ok to skip function f entered by instruction ins.
619: * If so, we're going to compute the return address and step to it.
620: */
621: private boolean skipfunc(ins, f)
622: Opcode ins;
623: Symbol f;
624: {
625:
626: return ((boolean) (!inst_tracing && nlhdr.nlines != 0 &&
627: nosource(curfunc) && canskip(curfunc)));
628: }
629:
630: private Address findnextaddr(startaddr, isnext)
631: Address startaddr;
632: Boolean isnext;
633: {
634: register Address addr;
635: Optab *op;
636: Opcode ins;
637: unsigned char mode;
638: int argtype, amode, argno, argval, nib;
639: String r;
640: Boolean indexf;
641: enum { KNOWN, SEQUENTIAL, BRANCH } addrstatus;
642:
643: argval = 0;
644: indexf = false;
645: addr = startaddr;
646: iread(&ins, addr, sizeof(ins));
647: switch (ins) {
648:
649: case O_CALLF:
650: case O_CALLS:
651: addrstatus = KNOWN;
652: stepto(addr);
653: pstep(process, DEFSIG);
654: addr = reg(PROGCTR);
655: pc = addr;
656: setcurfunc(whatblock(pc));
657: if (not isbperr()) {
658: printstatus();
659: /* NOTREACHED */
660: }
661: bpact();
662: if (isnext or skipfunc(ins, curfunc)) {
663: addrstatus = KNOWN;
664: addr = return_addr();
665: stepto(addr);
666: bpact();
667: } else
668: callnews(/* iscall = */ true);
669: break;
670:
671: case O_RET:
672: addrstatus = KNOWN;
673: stepto(addr);
674: callnews(/* iscall = */ false);
675: pstep(process, DEFSIG);
676: addr = reg(PROGCTR);
677: pc = addr;
678: if (not isbperr())
679: printstatus();
680: bpact();
681: break;
682:
683: case O_BRB:
684: case O_BRW:
685: case O_JMP:
686: case O_BBSSI:
687: case O_BCC:
688: case O_BCS:
689: case O_BEQL:
690: case O_BGEQ:
691: case O_BGTR:
692: case O_BGTRU:
693: case O_BLEQ:
694: case O_BLEQU:
695: case O_BLSS:
696: case O_BNEQ:
697: case O_BVC:
698: case O_BVS:
699: case O_CASEL:
700: case O_AOBLSS:
701: case O_AOBLEQ:
702: addrstatus = KNOWN;
703: stepto(addr);
704: pstep(process, DEFSIG);
705: addr = reg(PROGCTR);
706: pc = addr;
707: if (not isbperr())
708: printstatus();
709: break;
710:
711: default:
712: addrstatus = SEQUENTIAL;
713: break;
714: }
715: if (addrstatus == KNOWN)
716: return (addr);
717: addr += 1;
718: op = ioptab[ins];
719: for (argno = 0; argno < op->numargs; argno++) {
720: if (indexf == true)
721: indexf = false;
722: argtype = op->argtype[argno];
723: if (is_branch_disp(argtype))
724: mode = 0xAF + (typelen(argtype) << 5);
725: else
726: iread(&mode, addr, sizeof(mode)), addr += 1;
727: r = regname[regnm(mode)];
728: amode = addrmode(mode);
729: switch (amode) {
730:
731: case LITSHORT:
732: case LITUPTO31:
733: case LITUPTO47:
734: case LITUPTO63:
735: argval = mode;
736: break;
737:
738: case INDEX:
739: indexf = true;
740: --argno;
741: break;
742:
743: case REG:
744: case REGDEF:
745: case AUTODEC:
746: break;
747:
748: case AUTOINC:
749: nib = mode & 0xf;
750: if (nib == 0xf || nib == 8 || nib == 9) {
751: int size = (mode&03)+1;
752:
753: argval = getdisp(addr, size,
754: regname[PROGCTR], amode);
755: addr += size;
756: }
757: break;
758:
759: case AUTOINCDEF:
760: if ((mode&0xf) != 0xf)
761: break;
762: argval = getdisp(addr, 4, r, amode);
763: addr += 4;
764: break;
765:
766: case BYTEDISP:
767: case BYTEDISPDEF:
768: argval = getdisp(addr, 1, r, amode);
769: addr += 1;
770: break;
771:
772: case WORDDISP:
773: case WORDDISPDEF:
774: argval = getdisp(addr, 2, r, amode);
775: addr += 2;
776: break;
777:
778: case LONGDISP:
779: case LONGDISPDEF:
780: argval = getdisp(addr, 4, r, amode);
781: addr += 4;
782: break;
783: }
784: }
785: if (ins == O_CALLF or ins == O_CALLS)
786: argval += 2;
787: if (addrstatus == BRANCH)
788: addr = argval;
789: return (addr);
790: }
791:
792: /*
793: * Get the displacement of an instruction that uses displacement addressing.
794: */
795: private int getdisp(addr, nbytes, reg, mode)
796: Address addr;
797: int nbytes;
798: String reg;
799: int mode;
800: {
801: char byte;
802: short hword;
803: int argval;
804:
805: switch (nbytes) {
806:
807: case 1:
808: iread(&byte, addr, sizeof(byte));
809: argval = byte;
810: break;
811:
812: case 2:
813: iread(&hword, addr, sizeof(hword));
814: argval = hword;
815: break;
816:
817: case 4:
818: iread(&argval, addr, sizeof(argval));
819: break;
820: }
821: if (reg == regname[PROGCTR] && mode >= BYTEDISP)
822: argval += addr + nbytes;
823: return (argval);
824: }
825:
826: #define BP_OP O_BPT /* breakpoint trap */
827: #define BP_ERRNO SIGTRAP /* signal received at a breakpoint */
828:
829: /*
830: * Setting a breakpoint at a location consists of saving
831: * the word at the location and poking a BP_OP there.
832: *
833: * We save the locations and words on a list for use in unsetting.
834: */
835: typedef struct Savelist *Savelist;
836:
837: struct Savelist {
838: Address location;
839: Byte save;
840: Byte refcount;
841: Savelist link;
842: };
843:
844: private Savelist savelist;
845:
846: /*
847: * Set a breakpoint at the given address. Only save the word there
848: * if it's not already a breakpoint.
849: */
850: public setbp(addr)
851: Address addr;
852: {
853: Byte w, save;
854: register Savelist newsave, s;
855:
856: for (s = savelist; s != nil; s = s->link)
857: if (s->location == addr) {
858: s->refcount++;
859: return;
860: }
861: iread(&save, addr, sizeof(save));
862: newsave = new(Savelist);
863: newsave->location = addr;
864: newsave->save = save;
865: newsave->refcount = 1;
866: newsave->link = savelist;
867: savelist = newsave;
868: w = BP_OP;
869: iwrite(&w, addr, sizeof(w));
870: }
871:
872: /*
873: * Unset a breakpoint; unfortunately we have to search the SAVELIST
874: * to find the saved value. The assumption is that the SAVELIST will
875: * usually be quite small.
876: */
877: public unsetbp(addr)
878: Address addr;
879: {
880: register Savelist s, prev;
881:
882: prev = nil;
883: for (s = savelist; s != nil; s = s->link) {
884: if (s->location == addr) {
885: iwrite(&s->save, addr, sizeof(s->save));
886: s->refcount--;
887: if (s->refcount == 0) {
888: if (prev == nil)
889: savelist = s->link;
890: else
891: prev->link = s->link;
892: dispose(s);
893: }
894: return;
895: }
896: prev = s;
897: }
898: panic("unsetbp: couldn't find address %d", addr);
899: }
900:
901: /*
902: * Enter a procedure by creating and executing a call instruction.
903: */
904:
905: #define CALLSIZE 7 /* size of call instruction */
906:
907: public beginproc(p, argc)
908: Symbol p;
909: Integer argc;
910: {
911: char save[CALLSIZE];
912: struct {
913: Opcode op;
914: unsigned char numargs;
915: unsigned char mode;
916: char addr[sizeof(long)]; /* unaligned long */
917: } call;
918: long dest;
919:
920: if (4*argc+4 > 256)
921: error("too many parameters (max %d)", 256/4 - 1);
922: pc = 2;
923: iread(save, pc, sizeof(save));
924: call.op = O_CALLF;
925: call.numargs = 4*argc+4;
926: call.mode = 0xef; /* longword relative */
927: dest = codeloc(p) - 2 - (pc + CALLSIZE);
928: mov(&dest, call.addr, sizeof(call.addr));
929: iwrite(&call, pc, sizeof(call));
930: setreg(PROGCTR, pc);
931: pstep(process, DEFSIG);
932: iwrite(save, pc, sizeof(save));
933: pc = reg(PROGCTR);
934: if (not isbperr())
935: printstatus();
936: }
937:
938: /*
939: * Special variables for debugging the kernel.
940: */
941:
942: public integer masterpcbb;
943: public integer slr;
944: public struct pte *sbr;
945: private struct pcb pcb;
946:
947: public getpcb ()
948: {
949: fseek(corefile, masterpcbb & ~0xc0000000, 0);
950: get(corefile, pcb);
951: printf("p0br %lx p0lr %lx p2br %lx p2lr %lx\n",
952: pcb.pcb_p0br, pcb.pcb_p0lr, pcb.pcb_p2br, pcb.pcb_p2lr
953: );
954: setreg(0, pcb.pcb_r0);
955: setreg(1, pcb.pcb_r1);
956: setreg(2, pcb.pcb_r2);
957: setreg(3, pcb.pcb_r3);
958: setreg(4, pcb.pcb_r4);
959: setreg(5, pcb.pcb_r5);
960: setreg(6, pcb.pcb_r6);
961: setreg(7, pcb.pcb_r7);
962: setreg(8, pcb.pcb_r8);
963: setreg(9, pcb.pcb_r9);
964: setreg(10, pcb.pcb_r10);
965: setreg(11, pcb.pcb_r11);
966: setreg(12, pcb.pcb_r12);
967: setreg(FRP, pcb.pcb_fp);
968: setreg(STKP, pcb.pcb_ksp);
969: setreg(PROGCTR, pcb.pcb_pc);
970: }
971:
972: public copyregs (savreg, reg)
973: Word savreg[], reg[];
974: {
975: reg[0] = savreg[R0];
976: reg[1] = savreg[R1];
977: reg[2] = savreg[R2];
978: reg[3] = savreg[R3];
979: reg[4] = savreg[R4];
980: reg[5] = savreg[R5];
981: reg[6] = savreg[R6];
982: reg[7] = savreg[R7];
983: reg[8] = savreg[R8];
984: reg[9] = savreg[R9];
985: reg[10] = savreg[R10];
986: reg[11] = savreg[R11];
987: reg[12] = savreg[R12];
988: reg[FRP] = savreg[FP];
989: reg[STKP] = savreg[SP];
990: reg[PROGCTR] = savreg[PC];
991: }
992:
993: /*
994: * Map a virtual address to a physical address.
995: */
996:
997: public Address vmap (addr)
998: Address addr;
999: {
1000: int oldaddr = addr, v;
1001: struct pte pte;
1002:
1003: addr &= ~0xc0000000;
1004: v = btop(addr);
1005: switch (oldaddr&0xc0000000) {
1006:
1007: case 0xc0000000:
1008: /*
1009: * In system space get system pte. If
1010: * valid or reclaimable then physical address
1011: * is combination of its page number and the page
1012: * offset of the original address.
1013: */
1014: if (v >= slr)
1015: goto oor;
1016: addr = ((long)(sbr+v)) &~ 0xc0000000;
1017: goto simple;
1018:
1019: case 0x80000000:
1020: /*
1021: * In p2 spce must not be in shadow region.
1022: */
1023: if (v < pcb.pcb_p2lr)
1024: goto oor;
1025: addr = (long)(pcb.pcb_p2br+v);
1026: break;
1027:
1028: case 0x40000000:
1029: /*
1030: * In p1 space everything is verboten (for now).
1031: */
1032: goto oor;
1033:
1034: case 0x00000000:
1035: /*
1036: * In p0 space must not be off end of region.
1037: */
1038: if (v >= pcb.pcb_p0lr)
1039: goto oor;
1040: addr = (long)(pcb.pcb_p0br+v);
1041: break;
1042: oor:
1043: error("address out of segment");
1044: }
1045: /*
1046: * For p0/p1/p2 address, user-level page table should
1047: * be in kernel vm. Do second-level indirect by recursing.
1048: */
1049: if ((addr & 0xc0000000) != 0xc0000000)
1050: error("bad p0br, p1br, or p2br in pcb");
1051: addr = vmap(addr);
1052: simple:
1053: /*
1054: * Addr is now address of the pte of the page we
1055: * are interested in; get the pte and paste up the
1056: * physical address.
1057: */
1058: fseek(corefile, addr, 0);
1059: if (fread(&pte, sizeof (pte), 1, corefile) != 1)
1060: error("page table botch");
1061: /* SHOULD CHECK NOT I/O ADDRESS; NEED CPU TYPE! */
1062: if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0))
1063: error("page not valid/reclaimable");
1064: return ((long)(ptob(pte.pg_pfnum) + (oldaddr & PGOFSET)));
1065: }
1066:
1067: /*
1068: * Extract a bit field from an integer.
1069: */
1070:
1071: public integer extractField (s)
1072: Symbol s;
1073: {
1074: integer nbytes, nbits, n, r, off, len;
1075:
1076: off = s->symvalue.field.offset;
1077: len = s->symvalue.field.length;
1078: nbytes = size(s);
1079: n = 0;
1080: if (nbytes > sizeof(n)) {
1081: printf("[bad size in extractField -- word assumed]\n");
1082: nbytes = sizeof(n);
1083: }
1084: popn(nbytes, ((char *) &n) + (sizeof(Word) - nbytes));
1085: nbits = nbytes * BITSPERBYTE;
1086: r = n >> (nbits - ((off mod nbits) + len));
1087: r &= ((1 << len) - 1);
1088: return r;
1089: }
1090:
1091: /*
1092: * Change the length of a value in memory according to a given difference
1093: * in the lengths of its new and old types.
1094: */
1095:
1096: public loophole (oldlen, newlen)
1097: integer oldlen, newlen;
1098: {
1099: integer i, n;
1100: Stack *oldsp;
1101:
1102: n = newlen - oldlen;
1103: oldsp = sp - oldlen;
1104: if (n > 0) {
1105: for (i = oldlen - 1; i >= 0; i--) {
1106: oldsp[n + i] = oldsp[i];
1107: }
1108: for (i = 0; i < n; i++) {
1109: oldsp[i] = '\0';
1110: }
1111: } else {
1112: for (i = 0; i < newlen; i++) {
1113: oldsp[i] = oldsp[i - n];
1114: }
1115: }
1116: sp += n;
1117: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.