UNIX 6th Ed. - /usr/source/s1/cdb1.c

   1: #
   2: /*
   3: 
   4: 	C debugger
   5: 
   6: */
   7: 
   8: #include "/usr/sys/param.h"
   9: #include "/usr/sys/user.h"
  10: 
  11: #define DSP 0
  12: #define ISP 1
  13: #define NBKP    10
  14: #define SYMSIZ  12*400
  15: #define BADJST  01
  16: 
  17: int fcore;
  18: int errno;
  19: int fsym;
  20: int symoff;
  21: char    *lp;
  22: int errflg;
  23: int symlen;
  24: int symct;
  25: int symcor;
  26: int symbuf[SYMSIZ];
  27: int *symptr;
  28: struct {
  29:     int loc;
  30:     int ins;
  31:     int count;
  32:     int flag;
  33: } bkptl[NBKP];
  34: int lastbp;
  35: char    symbol[8];
  36: int symflg;
  37: int symval;
  38: char    tsym[8];
  39: char    fsymbol[10];
  40: char    ssymbol[8];
  41: int ssymflg;
  42: int ssymval;
  43: int signo;
  44: char    line[128];
  45: int regbuf[512];
  46: char    **uregs &regbuf[512];
  47: char    *rtsize;
  48: int loccsv;
  49: int locsr5;
  50: #define RUSER   1
  51: #define RIUSER  2
  52: #define WUSER   4
  53: #define RUREGS  3
  54: #define WUREGS  6
  55: #define SETTRC  0
  56: #define CONTIN  7
  57: #define EXIT    8
  58: 
  59: #define ps  -1
  60: #define pc  -2
  61: #define sp  -6
  62: #define r5  -9
  63: #define r4  -10
  64: #define r3  -11
  65: #define r2  -12
  66: #define r1  -5
  67: #define r0  -3
  68: struct reglist {
  69:     char    *rname;
  70:     int roffs;
  71: } reglist[] {
  72:     "ps", ps,
  73:     "pc", pc,
  74:     "sp", sp,
  75:     "r5", r5,
  76:     "r4", r4,
  77:     "r3", r3,
  78:     "r2", r2,
  79:     "r1", r1,
  80:     "r0", r0,
  81: };
  82: 
  83: struct sfregs {
  84:     int junk[2];
  85:     int fpsr;
  86:     float   sfr[6];
  87: };
  88: 
  89: struct lfregs {
  90:     int junk[2];
  91:     int fpsr;
  92:     double  lfr[6];
  93: };
  94: 
  95: int frnames[] { 0, 3, 4, 5, 1, 2 };
  96: int dot;
  97: int tdot;
  98: int dotinc 2;
  99: int lastcom '/';
 100: int lastype 'o';
 101: int modifier;
 102: char    *symfil "a.out";
 103: char    *corfil "core";
 104: int callist[50];
 105: int entpt[50];
 106: int callev;
 107: int pid;
 108: int adrflg;
 109: int idsep;
 110: char    *signals[] {
 111:     "",
 112:     "Hangup",
 113:     "Interrupt",
 114:     "Quit",
 115:     "Illegal instruction",
 116:     "Trace/BTP",
 117:     "IOT",
 118:     "EMT",
 119:     "Floating exception",
 120:     "Killed",
 121:     "Bus error",
 122:     "Memory fault",
 123:     "Bad system call",
 124:     "",
 125:     "",
 126:     "",
 127: };
 128: 
 129: main(argc, argv)
 130: char **argv;
 131: {
 132:     int onintr();
 133: 
 134:     if (argc>1)
 135:         symfil = argv[1];
 136:     if (argc>2)
 137:         corfil = argv[2];
 138:     fcore = open(corfil, 0);
 139:     if ((fsym = open(symfil, 0)) < 0) {
 140:         printf("%s not found\n", symfil);
 141:         return;
 142:     }
 143:     read(fsym, regbuf, 020);
 144:     if (regbuf[0]==0411)            /* I/D separated */
 145:         idsep++;
 146:     else if (regbuf[0]!=0410 && regbuf[0]!=0407) {  /* magic */
 147:         printf("Bad format: %s\n", symfil);
 148:         return;
 149:     }
 150:     symoff = regbuf[1] + regbuf[2];
 151:     symlen = regbuf[4];
 152:     if (regbuf[7] != 1)
 153:         symoff =<< 1;
 154:     symoff =+ 020;
 155:     seek(fsym, symoff, 0);
 156:     symcor = read(fsym, symbuf, sizeof symbuf);
 157:     if (symcor>0)
 158:         symoff =+ symcor;
 159:     symcor =>> 1;
 160:     read(fcore, regbuf, 1024);
 161:     signo = regbuf[0].u_arg[0]&017;
 162:     regbuf->u_tsize =<< 6;
 163:     regbuf->u_dsize =<< 6;
 164:     regbuf->u_ssize =<< 6;
 165:     rtsize = (regbuf->u_tsize+017777) & ~017777;
 166:     if (symlook("csv\0\0\0\0"))
 167:         loccsv = ssymval;
 168:     if (symlook("savr5\0\0\0"))
 169:         locsr5 = ssymval;
 170:     setstack();
 171:     signal(SIGINS, onintr);
 172:     setexit();
 173:     signal(SIGINT, onintr);
 174: loop:
 175:     if (errflg) {
 176:         printf("?\n");
 177:         errflg = 0;
 178:     }
 179:     lp = line;
 180:     while ((*lp = getchar()) != '\n')
 181:         if (*lp++ == '\0') {
 182:             if (pid)
 183:                 ptrace(EXIT, pid, 0, 0);
 184:             return;
 185:         }
 186:     lp = line;
 187:     command();
 188:     goto loop;
 189: }
 190: 
 191: command()
 192: {
 193:     register n;
 194: 
 195:     adrflg = expr();
 196:     if (errflg)
 197:         return;
 198:     n = getcnt();
 199:     if (lastcom=='$')
 200:         lastcom = '/';
 201:     if (*lp == '\n') {
 202:         if (!adrflg)
 203:             dot =+ dotinc;
 204:     } else
 205:         lastcom = *lp++;
 206:     modifier = 0;
 207:     if (*lp != '\n')
 208:         modifier = *lp++;
 209:     if (lastcom=='%' && modifier=='r') {
 210:         runcom();
 211:         return;
 212:     }
 213:     if (*lp != '\n') {
 214:         errflg++;
 215:         return;
 216:     }
 217:     if (adrflg)
 218:         dot = tdot;
 219:     while(n) {
 220:         scommand(n);
 221:         if (errflg)
 222:             return;
 223:         if (--n)
 224:             dot =+ dotinc;
 225:     }
 226: }
 227: 
 228: scommand(n)
 229: {
 230:     register w, c;
 231:     double fw;
 232:     struct { int i[4]; };
 233:     int onintr();
 234: 
 235:     switch(lastcom) {
 236: 
 237:     case '/':
 238:         w = cget(dot, DSP);
 239:         if (modifier)
 240:             lastype = modifier;
 241:         switch(lastype) {
 242: 
 243:         case 'o':
 244:             printf("%.1o\n", w);
 245:             dotinc = 2;
 246:             return;
 247: 
 248:         case 'i':
 249:             printf("%d\n", w);
 250:             dotinc = 2;
 251:             return;
 252: 
 253:         case 'f':
 254:             fw = 0;
 255:             fw.i[0] = w;
 256:             fw.i[1] = cget(dot+2, DSP);
 257:             printf("%e\n", fw);
 258:             dotinc = 4;
 259:             return;
 260: 
 261:         case 'd':
 262:             fw.i[0] = w;
 263:             fw.i[1] = cget(dot+2, DSP);
 264:             fw.i[2] = cget(dot+4, DSP);
 265:             fw.i[3] = cget(dot+6, DSP);
 266:             printf("%e\n", fw);
 267:             dotinc = 8;
 268:             return;
 269:         }
 270:         errflg++;
 271:         return;
 272: 
 273:     case '\\':
 274:         printf("%.1o\n", cget(dot, DSP)&0377);
 275:         dotinc = 1;
 276:         return;
 277: 
 278:     case '=':
 279:         printf("%.1o\n", dot);
 280:         return;
 281: 
 282:     case '\'':
 283:         printc(cget(dot, DSP) & 0377);
 284:         if (n<=1)
 285:             putchar('\n');
 286:         dotinc = 1;
 287:         return;
 288: 
 289:     case '"':
 290:         w = cget(dot, DSP);
 291:         while(c = cget(w++, DSP)&0377)
 292:             printc(c);
 293:         putchar('\n');
 294:         return;
 295: 
 296:     case '&':
 297:         psymoff(cget(dot, DSP), 0100000);
 298:         printf("\n");
 299:         return;
 300: 
 301:     case '$':
 302:         printf("%s\n", signals[signo]);
 303:         printtrace();
 304:         return;
 305: 
 306:     case '?':
 307:         printins(0);
 308:         printf("\n");
 309:         return;
 310: 
 311:     case '%':
 312:         runcom();
 313:         signal(SIGINT, onintr);
 314:         return;
 315: 
 316:     }
 317:     errflg++;
 318: }
 319: 
 320: getcnt()
 321: {
 322:     register t1, t2;
 323: 
 324:     if (*lp != ',')
 325:         return(1);
 326:     lp++;
 327:     t1 = tdot;
 328:     if (expr() == 0) {
 329:         tdot = t1;
 330:         return(1);
 331:     }
 332:     t2 = tdot;
 333:     tdot = t1;
 334:     return(t2);
 335: }
 336: 
 337: cget(n, space)
 338: {
 339:     register w;
 340: 
 341:     w = get(n, space);
 342:     if (errflg)
 343:         reset();
 344:     return(w);
 345: }
 346: 
 347: printc(c)
 348: {
 349:     if (c<' ' || c>'~')
 350:         printf("\\%o", c);
 351:     else
 352:         printf("%c", c);
 353: }
 354: 
 355: expr()
 356: {
 357:     int i, t1, t2, donef, lastop, b;
 358: 
 359:     tdot = 0;
 360:     adrflg = 0;
 361:     lastop = '+';
 362:     ssymval = 0;
 363:     donef = 0;
 364: loop:
 365:     fsymbol[0] = 0;
 366:     if (symchar(0)) {
 367:         adrflg++;
 368:         symcollect('_');
 369:         if (*lp++==':' && symchar(0)) {
 370:             for (i=0; i<8; i++)
 371:                 fsymbol[i] = tsym[i];
 372:             fsymbol[0] = '~';
 373:             symcollect(0);
 374:         } else
 375:             lp--;
 376:         if (symlook(tsym) == 0) {
 377:             errflg++;
 378:             reset();
 379:         }
 380:         goto loop;
 381:     }
 382:     if (*lp>='0' && *lp<='9') {
 383:         adrflg++;
 384:         ssymval = 0;
 385:         if (*lp == '0')
 386:             b = 8;
 387:         else
 388:             b = 10;
 389:         while (*lp>='0' && *lp<='9') {
 390:             ssymval =* b;
 391:             ssymval =+ *lp++ -'0';
 392:         }
 393:         goto loop;
 394:     }
 395:     switch (*lp) {
 396: 
 397:     default:
 398:         donef++;
 399: 
 400:     case '+':
 401:     case '-':
 402:         switch(lastop) {
 403: 
 404:         case '+':
 405:             tdot =+ ssymval;
 406:             goto op;
 407: 
 408:         case '-':
 409:             tdot =- ssymval;
 410: 
 411:         op:
 412:             if (donef)
 413:                 return(adrflg);
 414:             else
 415:                 lastop = *lp++;
 416:         }
 417:         goto loop;
 418: 
 419:     case ' ':
 420:     case '\t':
 421:         lp++;
 422:         goto loop;
 423: 
 424:     case '[':
 425:         lp++;
 426:         t1 = ssymval;
 427:         t2 = tdot;
 428:         if (expr() == 0)
 429:             tdot = 0;
 430:         ssymval = cget(t1 + (tdot<<1), DSP);
 431:         tdot = t2;
 432:         if (*lp == ']')
 433:             lp++;
 434:         goto loop;
 435:     }
 436: }
 437: 
 438: symcollect(c)
 439: {
 440:     register char *p;
 441: 
 442:     p = tsym;
 443:     if (c)
 444:         *p++ = c;
 445:     while (symchar(1)) {
 446:         if (p < &tsym[8])
 447:             *p++ = *lp;
 448:         lp++;
 449:     }
 450:     while (p < &tsym[8])
 451:         *p++ = 0;
 452: }
 453: 
 454: symchar(dig)
 455: {
 456:     if (*lp>='a'&&*lp<='z' || *lp=='_')
 457:         return(1);
 458:     if (dig && *lp>='0' && *lp<='9')
 459:         return(1);
 460:     return(0);
 461: }
 462: 
 463: error()
 464: {
 465:     errflg++;
 466:     reset();
 467: }
 468: 
 469: printtrace()
 470: {
 471:     int tpc, tr5, narg, argp, i;
 472: 
 473:     if (modifier=='r') {
 474:         printregs();
 475:         return;
 476:     }
 477:     if (modifier=='f' || modifier=='d') {
 478:         printfregs();
 479:         return;
 480:     }
 481:     tpc = uregs[pc];
 482:     tr5 = uregs[r5];
 483:     if (locsr5)
 484:         if (narg = get(locsr5, DSP)) {
 485:             tr5 = narg;
 486:         }
 487:     callev = 0;
 488:     while (errflg == 0) {
 489:         narg = findroutine(tpc, tr5);
 490:         printf("%2d: %.8s(", callev, ssymbol);
 491:         if (--narg >= 0)
 492:             printf("%.1o", get(tr5+4, DSP));
 493:         argp = tr5+4;
 494:         while(--narg >= 0)
 495:             printf(",%.1o", get(argp =+ 2, DSP));
 496:         printf(")\n");
 497:         tpc = get(tr5+2, DSP);
 498:         if (callev < 50) {
 499:             entpt[callev] = ssymval;
 500:             callist[callev++] = tr5;
 501:         }
 502:         if ((tr5 = get(tr5, DSP)) == 0)
 503:             break;
 504:     }
 505: }
 506: 
 507: setstack()
 508: {
 509:     register int tpc, tr5, i;
 510: 
 511:     tpc = uregs[pc];
 512:     tr5 = uregs[r5];
 513:     if (locsr5)
 514:         if (i = get(locsr5, DSP)) {
 515:             tr5 = i;
 516:         }
 517:     callev = 0;
 518:     while (errflg == 0) {
 519:         findroutine(tpc, tr5);
 520:         tpc = get(tr5+2, DSP);
 521:         if (callev >= 50)
 522:             break;
 523:         entpt[callev] = ssymval;
 524:         callist[callev++] = tr5;
 525:         if ((tr5 = get(tr5, DSP)) == 0)
 526:             break;
 527:     }
 528:     errflg = 0;
 529: }
 530: 
 531: printfregs()
 532: {
 533:     register i;
 534:     double f;
 535: 
 536:     printf("fpsr	%.1o\n", regbuf[0].fpsr);
 537:     for (i=0; i<6; i++) {
 538:         if (regbuf[0].fpsr&0200)    /* long mode */
 539:             f = regbuf[0].lfr[frnames[i]];
 540:         else
 541:             f = regbuf[0].sfr[frnames[i]];
 542:         printf("fr%d	%e\n", i, f);
 543:     }
 544: }
 545: 
 546: printregs()
 547: {
 548:     register struct reglist *p;
 549:     register char *v, *d;
 550: 
 551:     for (p=reglist; p < &reglist[9]; p++) {
 552:         printf("%s	%.1o", p->rname, v=uregs[p->roffs]);
 553:         d = vallook(v);
 554:         if (d < 010000) {
 555:             printf("	%.8s", ssymbol);
 556:             if (d)
 557:                 printf("+%.1o", d);
 558:         }
 559:         printf("\n");
 560:     }
 561: }
 562: 
 563: findroutine(rpc, rr5)
 564: {
 565:     register callpt, inst, narg;
 566: 
 567:     callpt = get(rr5+2, DSP);
 568:     if ((inst=get(callpt-4, ISP)) == 04737) /* jsr pc,*$... */
 569:         narg = 1;
 570:     else if ((inst&~077)==04700)        /* jsr pc,... */
 571:         narg = 0;
 572:     else {
 573:         errflg++;
 574:         return(0);
 575:     }
 576:     inst = vallook((inst==04767?callpt:0) + get(callpt-2, ISP));
 577:     if (inst) {
 578:         ssymbol[0] = '?';
 579:         ssymbol[1] = 0;
 580:         ssymval = 0;
 581:     }
 582:     inst = get(callpt, ISP);
 583:     if (inst == 05726)      /* tst (sp)+ */
 584:         return(narg+1);
 585:     if (inst == 022626)     /* cmp (sp)+,(sp)+ */
 586:         return(narg+2);
 587:     if (inst == 062706)     /* add $n,sp */
 588:         return(narg+get(callpt+2, ISP)/2);
 589:     return(narg);
 590: }
 591: 
 592: runcom()
 593: {
 594:     int stat;
 595:     register w, i;
 596: 
 597:     switch(modifier) {
 598: 
 599: 
 600:     /* delete breakpoint */
 601:     case 'd':
 602:         if (adrflg==0)
 603:             error();
 604:         for (w=0; w<NBKP; w++) {
 605:             i = bkptl[w].loc;
 606:             if (bkptl[w].flag & BADJST)
 607:                 i =- 4;
 608:             if (dot==i) {
 609:                 if (lastbp==bkptl[w].loc) {
 610:                     ptrace(WUREGS,pid,2*(512+ps),uregs[ps]&~020);
 611:                     lastbp = 0;
 612:                 } else {
 613:                     ptrace(WUSER,pid,bkptl[w].loc,bkptl[w].ins);
 614:                 }
 615:                 bkptl[w].loc = 0;
 616:                 bkptl[w].flag = 0;
 617:                 return;
 618:             }
 619:         }
 620:         error();
 621: 
 622:     /* set breakpoint */
 623:     case 'b':
 624:         if (adrflg==0)
 625:             error();
 626:         for (w=0; w<NBKP; w++) {
 627:             i = bkptl[w].loc;
 628:             if (bkptl[w].flag&BADJST)
 629:                 i =- 4;
 630:             if (i==dot)
 631:                 return;
 632:         }
 633:         for (w=0; w<NBKP; w++)
 634:             if (bkptl[w].loc==0) {
 635:                 bkptl[w].loc = dot;
 636:                 return;
 637:             }
 638:         error();
 639: 
 640:     /* run program */
 641:     case 'r':
 642:         lastbp = 0;
 643:         if (pid) {
 644:             ptrace(EXIT, pid, 0, 0);
 645:             pid = 0;
 646:         }
 647:         if ((pid = fork())==0) {
 648:             ptrace(SETTRC, 0, 0, 0);
 649:             signal(SIGINT, 0);
 650:             signal(SIGINS, 0);
 651:             doexec();
 652:             printf("Can't execute %s\n", symfil);
 653:             exit(0);
 654:         }
 655:         bpwait(0);
 656:         setbp(1);
 657:         ptrace(WUREGS, pid, 2*(512+ps), 0170000);
 658: 
 659:     case 'c':
 660:         if (pid==0)
 661:             error();
 662:         setbp(0);
 663:         if (lastbp) {
 664:             w = lastbp;
 665:             ptrace(CONTIN, pid, 0, 0);
 666:             bpwait(1);
 667:             ptrace(WUSER, pid, w, 03);
 668:             ptrace(WUREGS, pid, 2*(512+ps), uregs[ps]&~020);
 669:             lastbp = 0;
 670:         }
 671:         ptrace(CONTIN, pid, 0, 0);
 672:         bpwait(1);
 673:         w = uregs[pc]-2;
 674:         for (i=0; i<NBKP; i++)
 675:             if (bkptl[i].loc == w)
 676:                 break;
 677:         if (i >= NBKP) {
 678:             printf("%s\n", signals[signo]);
 679:             return;
 680:         }
 681:         lastbp = w;
 682:         ptrace(WUSER, pid, w, bkptl[i].ins);
 683:         ptrace(WUREGS, pid, 2*(512+pc), w);
 684:         ptrace(WUREGS, pid, 2*(512+ps), uregs[ps]|020);
 685:         printf("Breakpoint: ");
 686:         psymoff(w, 0777);
 687:         printf("\n");
 688:         return;
 689:     }
 690:     error();
 691: }
 692: 
 693: doexec()
 694: {
 695:     extern _exectrap;
 696:     char *argl[32];
 697:     register char *p, **ap;
 698:     register c;
 699: 
 700:     _exectrap++;
 701:     ap = argl;
 702:     *ap++ = symfil;
 703:     p = lp;
 704:     do {
 705:         while (*p==' ')
 706:             p++;
 707:         if (*p=='\n' || *p=='\0')
 708:             break;
 709:         *ap++ = p;
 710:         while (*p!=' ' && *p!='\n')
 711:             p++;
 712:         c = *p;
 713:         *p++ = '\0';
 714:     } while (c != '\n');
 715:     *ap++ = 0;
 716:     execv(symfil, argl);
 717: }
 718: 
 719: setbp(runflag)
 720: {
 721:     register w, i1, l;
 722:     int i2;
 723: 
 724:     for (w=0; w<NBKP; w++) {
 725:         l = bkptl[w].loc;
 726:         if (l && (runflag||bkptl[w].ins==0)) {
 727:             i1 = ptrace(RUSER, pid, l, 0);
 728:             if (i1==04567) {    /* jsr r5,... */
 729:                 i2 = ptrace(RUSER, pid, l+2, 0);
 730:                 if (loccsv == i2+l+4) { /* jsr r5,csv */
 731:                     l =+ 4;
 732:                     bkptl[w].loc = l;
 733:                     bkptl[w].flag =| BADJST;
 734:                     i1 = ptrace(RUSER, pid, l, 0);
 735:                 }
 736:             }
 737:             bkptl[w].ins = i1;
 738:             ptrace(WUSER, pid, l, 03);
 739:             if (errno) {
 740:                 printf("Can't set breakpoint ");
 741:                 psymoff(bkptl[w].loc);
 742:                 printf("\n");
 743:             }
 744:         }
 745:     }
 746: }
 747: 
 748: bpwait(f)
 749: {
 750:     extern int onintr();
 751:     register w;
 752:     int stat;
 753: 
 754:     loop:
 755:     signal(SIGINT, 1);
 756:     while ((w = wait(&stat))!=pid && w != -1);
 757:     signal(SIGINT, onintr);
 758:     if (w == -1) {
 759:         ptrace(EXIT, pid, 0, 0);
 760:         pid = 0;
 761:         printf("Wait error\n");
 762:         reset();
 763:     }
 764:     if ((stat & 0377) != 0177) {
 765:         if (signo = stat&0177)
 766:             printf("%s\n", signals[signo]);
 767:         printf("Process terminated.\n");
 768:         if (pid == w) {
 769:             pid = 0;
 770:             reset();
 771:         }
 772:         goto loop;
 773:     }
 774:     signo = stat>>8;
 775:     collinfo();
 776:     if (signo!=SIGTRC) {
 777:         printf("%s\n", signals[signo]);
 778:         reset();
 779:     }
 780: }
 781: 
 782: collinfo()
 783: {
 784:     register i;
 785: 
 786:     for (i=0; i<9; i++)
 787:         uregs[reglist[i].roffs] =
 788:             ptrace(RUREGS, pid, 2*(512+reglist[i].roffs), 0);
 789:     setstack();
 790: }
 791: 
 792: symlook(symstr)
 793: char *symstr;
 794: {
 795:     register i;
 796:     register symv;
 797: 
 798:     symset();
 799:     if (fsymbol[0]==0) {
 800:         while(symget()) {
 801:             if (eqstr(symbol, symstr)) {
 802:                 savsym();
 803:                 return(1);
 804:             }
 805:         }
 806:         return(0);
 807:     }
 808:     while (symget()) {
 809:         /* wait for function symbol */
 810:         if (symbol[0]!='~' || !eqstr(symbol, fsymbol))
 811:             continue;
 812:         symv = symval;
 813:         while (symget()&& symbol[0]!='~' &&symflg!=037)
 814:             if (eqstr(symbol, symstr))
 815:                 return(localsym(symv));
 816:         return(0);
 817:     }
 818: }
 819: 
 820: localsym(s)
 821: {
 822:     register i, xr5;
 823: 
 824:     /* label, static */
 825:     if (symflg>=2 && symflg<=4) {
 826:         ssymval = symval;
 827:         return(1);
 828:     }
 829:     /* auto, arg */
 830:     if (symflg==1) {
 831:         for (i=0; i<callev; i++)
 832:             if (entpt[i]==s) {
 833:                 ssymval = symval+callist[i];
 834:                 return(1);
 835:             }
 836:         return(0);
 837:     }
 838:     /* register */
 839:     if (symflg==20) {
 840:         for (i=0; i<callev; i++)
 841:             if (entpt[i]==s) {
 842:                 if (i==0) {
 843:                     return(0); /* temp, no reg lvalue */
 844:                 }
 845:                 ssymval = callist[i-1] - 10 + 2*symval;
 846:                 return(1);
 847:             }
 848:         return(0);
 849:     }
 850:     return(0);
 851: }
 852: 
 853: eqstr(as1, as2)
 854: int *as1, *as2;
 855: {
 856:     register char *s1, *s2, *es1;
 857: 
 858:     s1 = as1;
 859:     s2 = as2;
 860:     for (es1 = s1+8; s1 < es1; )
 861:         if (*s1++ != *s2++)
 862:             return(0);
 863:     return(1);
 864: }
 865: 
 866: vallook(value)
 867: char *value;
 868: {
 869:     register char *diff;
 870: 
 871:     diff = 0177777;
 872:     symset();
 873:     while (symget())
 874:         if (symflg&040 && value-symval<=diff) {
 875:             if (symflg==1 && value!=symval)
 876:                 continue;
 877:             savsym('_');
 878:             diff = value-symval;
 879:         }
 880:     return(diff);
 881: }
 882: 
 883: get(aaddr, space)
 884: char *aaddr;
 885: {
 886:     int w;
 887:     register int w1;
 888:     register char *addr;
 889: 
 890:     addr = aaddr;
 891:     if (pid) {      /* tracing on? */
 892:         w = ptrace(space==DSP?RUSER:RIUSER, pid, addr, 0);
 893:         if (addr&01) {
 894:             w1 = ptrace(space==DSP?RUSER:RIUSER, pid, addr+1, 0);
 895:             w = (w>>8)&0377 | (w1<<8);
 896:         }
 897:         errflg = errno;
 898:         return(w);
 899:     }
 900:     w = 0;
 901:     if (idsep==0&&addr<regbuf->u_tsize || idsep&&space==ISP) {
 902:         seek(fsym, addr+020, 0);
 903:         if (read(fsym, &w, 2) != 2)
 904:             errflg++;
 905:         return(w);
 906:     }
 907:     if (addr < rtsize+regbuf->u_dsize) {
 908:         if (idsep==0)
 909:             addr =- rtsize;
 910:     } else if (-addr < regbuf->u_ssize)
 911:         addr =+ regbuf->u_dsize + regbuf->u_ssize;
 912:     else
 913:         errflg++;
 914:     seek(fcore, addr+1024, 0);
 915:     if (read(fcore, &w, 2) < 2)
 916:         errflg++;
 917:     return(w);
 918: }
 919: 
 920: symset()
 921: {
 922:     symct = symlen;
 923:     symptr = symbuf;
 924:     seek(fsym, symoff, 0);
 925: }
 926: 
 927: symget()
 928: {
 929:     register int *p, *q;
 930:     if ((symct =- 12) < 0)
 931:         return(0);
 932:     if (symptr < &symbuf[symcor]) {
 933:         p = symptr;
 934:         for (q=symbol; q <= &symval;)
 935:             *q++ = *p++;
 936:         symptr = p;
 937:         return(1);
 938:     }
 939:     return(read(fsym, symbol, 12) == 12);
 940: }
 941: 
 942: savsym(skip)
 943: {
 944:     register int ch;
 945:     register char *p, *q;
 946: 
 947:     p = symbol;
 948:     q = ssymbol;
 949:     while (p<symbol+8 && (ch = *p++)) {
 950:         if (ch == skip)
 951:             continue;
 952:         *q++ = ch;
 953:     }
 954:     while (q < ssymbol+8)
 955:         *q++ = '\0';
 956:     ssymflg = symflg;
 957:     ssymval = symval;
 958: }
 959: 
 960: onintr()
 961: {
 962:     putchar('\n');
 963:     errflg++;
 964:     reset();
 965: }

Defined functions

Defined variables

Defined struct's

Defined macros