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