![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db_400|
Return to trace6.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db_400 |
1.1 ! root 1: /* ! 2: * trace6.c ! 3: * ! 4: * The information contained herein is a trade secret of Mark Williams ! 5: * Company, and is confidential information. It is provided under a ! 6: * license agreement, and may be copied or disclosed only under the ! 7: * terms of that agreement. Any reproduction or disclosure of this ! 8: * material without the express written authorization of Mark Williams ! 9: * Company or persuant to the license agreement is unlawful. ! 10: * ! 11: * COHERENT Version 2.3.35 ! 12: * Copyright (c) 1982, 1983, 1984. ! 13: * An unpublished work by Mark Williams Company, Chicago. ! 14: * All rights reserved. ! 15: * ! 16: * Miscellaneous routines. ! 17: */ ! 18: #include <stdio.h> ! 19: #include <ctype.h> ! 20: #include <canon.h> ! 21: #include <l.out.h> ! 22: #include "trace.h" ! 23: ! 24: #define MYPRINTF(x) printf(x) ! 25: #define DEBUG 0 ! 26: ! 27: unsigned short getMagic(); ! 28: caddr_t initn(); ! 29: off_t initb(); ! 30: off_t incb(); ! 31: off_t incb(); ! 32: off_t getseekoff(); ! 33: ! 34: /* ! 35: * Save the rest of the input line in `miscbuf'. If line is ! 36: * not given, save the default, `cp'. ! 37: */ ! 38: getline(cp) ! 39: register char *cp; ! 40: { ! 41: register int c; ! 42: register char *bp; ! 43: ! 44: bp = miscbuf; ! 45: if ((c=getn()) != '\n') { ! 46: while (c != '\n') { ! 47: if (c == '\\') ! 48: if ((c=getn())!='\n' && c!='\\') ! 49: *bp++ = '\\'; ! 50: *bp++ = c; ! 51: c = getn(); ! 52: } ! 53: } else { ! 54: while (*cp != '\0') ! 55: *bp++ = *cp++; ! 56: } ! 57: *bp++ = '\n'; ! 58: *bp = '\0'; ! 59: } ! 60: ! 61: /* ! 62: * Add a string onto the input stream. ! 63: * Make a node for string "cp" and insert it at the front of "inpp". ! 64: */ ! 65: addstrp(cp) ! 66: char *cp; ! 67: { ! 68: register INP *ip; ! 69: ! 70: ip = nalloc(sizeof (INP)); ! 71: ip->i_st2.i_next = inpp; ! 72: ip->i_st2.i_type = ICORE; ! 73: ip->i_st2.i_strp = cp; ! 74: inpp = ip; ! 75: } ! 76: ! 77: /* ! 78: * Add a file pointer onto the input stack. ! 79: */ ! 80: addfilp(fp) ! 81: FILE *fp; ! 82: { ! 83: register INP *ip; ! 84: ! 85: ip = nalloc(sizeof (INP)); ! 86: ip->i_st1.i_next = inpp; ! 87: ip->i_st1.i_type = IFILE; ! 88: ip->i_st1.i_filp = fp; ! 89: inpp = ip; ! 90: } ! 91: ! 92: /* ! 93: * Get the next character from the input stream. ! 94: */ ! 95: getn() ! 96: { ! 97: register INP *ip; ! 98: register int c; ! 99: ! 100: if (lastc != '\0') { ! 101: c = lastc; ! 102: lastc = '\0'; ! 103: return (c); ! 104: } ! 105: while ((ip=inpp) != NULL) { ! 106: switch (ip->i_st1.i_type) { ! 107: case ICORE: ! 108: if ((c=*ip->i_st2.i_strp++) != '\0') ! 109: return (c); ! 110: break; ! 111: case IFILE: ! 112: if ((c=getc(ip->i_st1.i_filp)) != EOF) ! 113: return (c); ! 114: if (ip->i_st1.i_filp == stdin) { ! 115: if (testint()) ! 116: continue; ! 117: leave(); ! 118: } ! 119: fclose(ip->i_st1.i_filp); ! 120: break; ! 121: } ! 122: inpp = inpp->i_st1.i_next; ! 123: nfree(ip); ! 124: } ! 125: return (EOF); ! 126: } ! 127: ! 128: /* ! 129: * Put back a character onto the current input stream. ! 130: */ ! 131: ungetn(c) ! 132: { ! 133: lastc = c; ! 134: } ! 135: ! 136: /* ! 137: * Put out an address. `t' is the tolerance allowed. ! 138: */ ! 139: putaddr(s, l, t) ! 140: long l; ! 141: { ! 142: register char *sp; ! 143: ! 144: sp = conaddr(miscbuf, s, l, t); ! 145: *sp = '\0'; ! 146: printx("%s", miscbuf); ! 147: } ! 148: ! 149: /* ! 150: * Read `n' bytes from the current position in segment `seg' ! 151: * and store it in the buffer `bp'. ! 152: */ ! 153: getb(segn, bp, n) ! 154: char *bp; ! 155: unsigned n; ! 156: { ! 157: if (getputb(segn, bp, n, 0) == 0) ! 158: return (0); ! 159: canon(bp, n); ! 160: ! 161: #if DEBUG ! 162: { ! 163: int i; ! 164: for (i=0; i<n; i++) printf("bp = %x\n", (unsigned char)bp[i]); ! 165: } ! 166: #endif ! 167: return (1); ! 168: } ! 169: ! 170: /* ! 171: * Put `n' bytes from the buffer `bp' into segment `seg'. ! 172: */ ! 173: putb(segn, bp, n) ! 174: char *bp; ! 175: unsigned n; ! 176: { ! 177: canon(bp, n); ! 178: return (getputb(segn, bp, n, 1)); ! 179: } ! 180: ! 181: /* ! 182: * Canonize the buffer `bp' of length `n' according to `cantype'. ! 183: */ ! 184: canon(bp, n) ! 185: register char *bp; ! 186: unsigned n; ! 187: { ! 188: register int i; ! 189: register int t; ! 190: ! 191: if (cantype == 1) { ! 192: if ((n&1) != 0) ! 193: return; ! 194: for (i=0; i<n; i+=2) { ! 195: t = bp[i]; ! 196: bp[i] = bp[i+1]; ! 197: bp[i+1] = t; ! 198: } ! 199: } ! 200: } ! 201: ! 202: /* ! 203: * Move `n' bytes between the buffer `bp' and the segment `segn'. ! 204: * The flag `d' controls the direction. ! 205: */ ! 206: getputb(segn, bp, n, d) ! 207: char *bp; ! 208: unsigned n; ! 209: { ! 210: register MAP *mp; ! 211: register unsigned l; ! 212: register unsigned s; ! 213: register int (*f)(); ! 214: off_t a; ! 215: ! 216: s = n; ! 217: a = add; ! 218: while (s) { ! 219: if ((mp=mapaddr(segn, a)) == NULL) { ! 220: return 0; ! 221: } ! 222: l = s; ! 223: if (a+l > mp->m_bend) ! 224: l = mp->m_bend-a+1; ! 225: f = d ? mp->m_putf : mp->m_getf; ! 226: if ((*f)(mp->m_segi, mp->m_offt+(a-mp->m_base), bp, l) == 0) { ! 227: return 0; ! 228: } ! 229: bp += l; ! 230: a += l; ! 231: s -= l; ! 232: } ! 233: add += n; ! 234: return (1); ! 235: } ! 236: ! 237: /* ! 238: * Given a segment number and an address, return the segment map ! 239: * in which the address falls. ! 240: */ ! 241: MAP * ! 242: mapaddr(n, a) ! 243: off_t a; ! 244: { ! 245: register MAP *mp; ! 246: ! 247: for (mp=segmapl[n]; mp; mp=mp->m_next) { ! 248: if (mp->m_base<=a && a<mp->m_bend) ! 249: break; ! 250: } ! 251: return (mp); ! 252: } ! 253: ! 254: /* ! 255: * Read a symbol and return its value in the given `VAL' structure. ! 256: */ ! 257: getsval(vp) ! 258: VAL *vp; ! 259: { ! 260: register int n; ! 261: register int c; ! 262: struct LDSYM lds; ! 263: ! 264: n = 0; ! 265: c = getn(); ! 266: while (isascii(c) && (isalnum(c)||c=='_')) { ! 267: if (n < NCPLN) ! 268: lds.ls_id[n++] = c; ! 269: c = getn(); ! 270: } ! 271: ungetn(c); ! 272: while (n < NCPLN) ! 273: lds.ls_id[n++] = '\0'; ! 274: if (specsym(&lds)==0 && regaddr(&lds)==0 && nameval(&lds)==0) { ! 275: printe("Symbol not found"); ! 276: return (0); ! 277: } ! 278: switch (lds.ls_type&LR_SEG) { ! 279: case L_SHRI: ! 280: case L_PRVI: ! 281: case L_BSSI: ! 282: vp->v_segn = 1; ! 283: vp->v_flag = VLVAL; ! 284: break; ! 285: case L_SHRD: ! 286: case L_PRVD: ! 287: case L_BSSD: ! 288: case L_ABS: ! 289: vp->v_segn = 0; ! 290: vp->v_flag = VLVAL; ! 291: break; ! 292: ! 293: case L_REF: ! 294: printe("Symbol not defined"); ! 295: return (0); ! 296: case L_REG: ! 297: vp->v_segn = 2; ! 298: vp->v_flag = VLVAL; ! 299: break; ! 300: } ! 301: vp->v_nval = lds.ls_addr; ! 302: return (1); ! 303: } ! 304: ! 305: /* ! 306: * See if the given symbol is a special symbol. ! 307: */ ! 308: specsym(ldp) ! 309: register struct LDSYM *ldp; ! 310: { ! 311: if (ldp->ls_id[1] != '\0') ! 312: return (0); ! 313: switch (ldp->ls_id[0]) { ! 314: case 'd': ! 315: ldp->ls_type = L_SHRD; ! 316: break; ! 317: case 'i': ! 318: ldp->ls_type = L_SHRI; ! 319: break; ! 320: case 'u': ! 321: ldp->ls_type = L_REG; ! 322: break; ! 323: default: ! 324: return (0); ! 325: } ! 326: ldp->ls_addr = 0; ! 327: return (1); ! 328: } ! 329: ! 330: /* ! 331: * Convert a value to an address. `t' is the tolerance ! 332: * allowed. ! 333: */ ! 334: char * ! 335: conaddr(sp, s, l, t) ! 336: register char *sp; ! 337: unsigned long l; ! 338: { ! 339: /* Bug in PDP11 compiler ! 340: register unsigned d; ! 341: */ ! 342: unsigned d; ! 343: struct LDSYM ldsym; ! 344: ! 345: ! 346: /* Bug in 8086 compiler ! 347: if (t<0 || valname(s, l, &ldsym)==0 || (d=l-ldsym.ls_addr)>t) ! 348: */ ! 349: if (t<0 || valname(s, l, &ldsym)==0 || ! 350: (d=(unsigned)l-ldsym.ls_addr)>t) ! 351: concons(sp, l); ! 352: else { ! 353: sprintf(sp, "%.*s", NCPLN, ldsym.ls_id); ! 354: while (*sp) ! 355: sp++; ! 356: if (d != 0) { ! 357: *sp++ = '+'; ! 358: sprintf(sp, "%u", d); ! 359: } ! 360: } ! 361: while (*sp) ! 362: sp++; ! 363: return (sp); ! 364: } ! 365: ! 366: /* ! 367: * Find the value of a symbol. ! 368: */ ! 369: nameval(ldp) ! 370: struct LDSYM *ldp; ! 371: { ! 372: register int u; ! 373: register caddr_t n; ! 374: register SYM *sp; ! 375: register int r; ! 376: register int h; ! 377: register off_t b; ! 378: struct LDSYM lds; ! 379: struct LDSYM ldu; ! 380: ! 381: u = 0; ! 382: h = hash(ldp); ! 383: evalhdrinfo(lfp); ! 384: for (n=initn(), sp=ssymp, b=initb(); n-- ! 385: ; sp++, b=incb(b, ((caddr_t)sngblsym-n))) { ! 386: if (ssymp!=NULL && sp->s_hash!=h) { ! 387: continue; ! 388: } ! 389: ! 390: if (hdrinfo.magic == L_MAGIC) { ! 391: if (!rdldSym(sfp, (long)b, &lds)) ! 392: return(0); ! 393: } ! 394: else ! 395: if (!rdcoff_to_loutSym(sfp, (long)b, &lds)) ! 396: return(0); ! 397: ! 398: if ((r=namecmp(ldp, &lds)) > 0) { ! 399: *ldp = lds; ! 400: return (1); ! 401: } ! 402: if (r < 0) { ! 403: ldu = lds; ! 404: u = 1; ! 405: } ! 406: } ! 407: if (u) { ! 408: *ldp = ldu; ! 409: return (1); ! 410: } ! 411: return (0); ! 412: } ! 413: ! 414: /* ! 415: * Compare the names of two symbol table entries. If the compare ! 416: * fails and the name of the first entry doesn't already end with ! 417: * an '_', the compare is effectively tried again after appending ! 418: * an '_', to the end of the first symbol name. ! 419: */ ! 420: namecmp(ldp1, ldp2) ! 421: struct LDSYM *ldp1; ! 422: struct LDSYM *ldp2; ! 423: { ! 424: register char *cp1; ! 425: register char *cp2; ! 426: register int n; ! 427: ! 428: n = CCSSIZE; ! 429: cp1 = ldp1->ls_id; ! 430: cp2 = ldp2->ls_id; ! 431: do { ! 432: if (*cp1 != *cp2++) { ! 433: if (*cp2!='\0' || *--cp2!='_') ! 434: return (0); ! 435: if (*cp1!='\0' || *--cp1=='_') ! 436: return (0); ! 437: return (-1); ! 438: } ! 439: if (*cp1++ == '\0') ! 440: return (1); ! 441: } while (--n); ! 442: return (1); ! 443: } ! 444: ! 445: #define NEW 1 ! 446: ! 447: /* ! 448: * Given a value, find the closest symbol below. ! 449: */ ! 450: valname(s, m, ldp) ! 451: off_t m; ! 452: struct LDSYM *ldp; ! 453: { ! 454: register int n; ! 455: register off_t a; ! 456: register SYM *sp; ! 457: register int t; ! 458: register int n1; ! 459: register off_t a1; ! 460: struct LDSYM lds; ! 461: off_t b, seekoff; ! 462: ! 463: strncpy(ldp->ls_id, "", NCPLN); ! 464: if (sfp == NULL) ! 465: return (0); ! 466: a1 = 0; ! 467: n1 = -1; ! 468: if (ssymp == NULL) ! 469: fseek(sfp, (long)sbase, 0); ! 470: hdrinfo.magic = getMagic(lfp); ! 471: for (n=0, sp=ssymp, b=initb(); n<initn() ! 472: ; n++, sp++, b=incb(b, ((caddr_t)n))) { ! 473: if (ssymp != NULL) { ! 474: a = sp->s_sval; ! 475: t = sp->s_type; ! 476: } ! 477: else { ! 478: if (hdrinfo.magic == L_MAGIC) { ! 479: if (!rdldSym(sfp, (long)b, &lds)) ! 480: return(0); ! 481: } ! 482: else { ! 483: if (!rdcoff_to_loutSym(sfp, (long)b, &lds)) ! 484: return(0); ! 485: } ! 486: a = (off_t)lds.ls_addr; ! 487: t = lds.ls_type; ! 488: } ! 489: if (hdrinfo.magic == L_MAGIC) { ! 490: switch (t&LR_SEG) { ! 491: case L_SHRI: ! 492: case L_PRVI: ! 493: case L_BSSI: ! 494: if (s == 0) ! 495: continue; ! 496: break; ! 497: case L_SHRD: ! 498: case L_PRVD: ! 499: case L_BSSD: ! 500: if (s == 1) ! 501: continue; ! 502: break; ! 503: default: ! 504: continue; ! 505: } ! 506: } ! 507: if ( ((unsigned long)a <= (unsigned long)m) ) { ! 508: if (a1==0 || (unsigned long)a > (unsigned long)a1) { ! 509: a1 = a; ! 510: n1 = n; ! 511: } ! 512: } ! 513: } ! 514: ! 515: if (n1 >= 0) { ! 516: seekoff = sbase + getseekoff(n1); ! 517: if (hdrinfo.magic == L_MAGIC) { ! 518: if (!rdldSym(sfp, seekoff, ldp)) ! 519: return(0); ! 520: } ! 521: else { ! 522: if (!rdcoff_to_loutSym(sfp, seekoff, ldp)) ! 523: return(0); ! 524: } ! 525: return (1); ! 526: } ! 527: return (0); ! 528: } ! 529: ! 530: rdldSym(fp, seekoff, LDSP) ! 531: FILE *fp; ! 532: long seekoff; ! 533: struct LDSYM *LDSP; ! 534: { ! 535: register int i; ! 536: struct ldsym lds; ! 537: ! 538: fseek(fp, seekoff, 0); ! 539: if (fread(&lds, sizeof(struct ldsym), 1, fp) != 1) ! 540: return (0); ! 541: canint(lds.ls_type); ! 542: canvaddr(lds.ls_addr); ! 543: for (i=0; i<NCPLN; i++) ! 544: LDSP->ls_id[i] = lds.ls_id[i]; ! 545: LDSP->ls_type = lds.ls_type; ! 546: LDSP->ls_addr = (long)lds.ls_addr; ! 547: return(1); ! 548: } ! 549: ! 550: /* ! 551: * Read `n' bytes from the file specified by `f' starting at ! 552: * address `seek'. ! 553: */ ! 554: getf(f, seek, bp, n) ! 555: long seek; ! 556: char *bp; ! 557: { ! 558: register FILE *fp; ! 559: ! 560: fp = f ? cfp : lfp; ! 561: fseek(fp, (long)seek, 0); ! 562: return (fread(bp, n, 1, fp)); ! 563: } ! 564: ! 565: /* ! 566: * Write `n' bytes into the files specified by `f' starting at ! 567: * address `seek'. ! 568: */ ! 569: putf(f, seek, bp, n) ! 570: long seek; ! 571: char *bp; ! 572: { ! 573: register FILE *fp; ! 574: int ret = 1; ! 575: ! 576: fp = f ? cfp : lfp; ! 577: fseek(fp, (long)seek, 0); ! 578: if (fwrite(bp, n, 1, fp) != 1) { ! 579: ret = 0; ! 580: } ! 581: if (ret) { ! 582: if (fflush(fp)!=EOF) { ! 583: ret = 0; ! 584: } ! 585: } ! 586: return ret; ! 587: } ! 588: ! 589: /* ! 590: * Allocate `n' bytes. ! 591: */ ! 592: char * ! 593: nalloc(n) ! 594: { ! 595: register char *cp; ! 596: ! 597: if ((cp=malloc(n)) == NULL) ! 598: panic("No memory"); ! 599: return (cp); ! 600: } ! 601: ! 602: /* ! 603: * Free up storage. ! 604: */ ! 605: nfree(cp) ! 606: char *cp; ! 607: { ! 608: free(cp); ! 609: } ! 610: ! 611: /* ! 612: * Print out an error message and exit. ! 613: */ ! 614: panic(a1) ! 615: char *a1; ! 616: { ! 617: fprintf(stderr, "%r", &a1); ! 618: putc('\n', stderr); ! 619: exit(1); ! 620: } ! 621: ! 622: /* ! 623: * Print out a breakpoint error message. ! 624: */ ! 625: printb(a) ! 626: caddr_t a; ! 627: { ! 628: fprintf(stderr, "Breakpoint error at "); ! 629: fprintf(stderr, DAFMT, (long)a); ! 630: putc('\n', stderr); ! 631: } ! 632: ! 633: /* ! 634: * Print out a fatal error message. ! 635: */ ! 636: printr(a1) ! 637: char *a1; ! 638: { ! 639: fprintf(stderr, "%r", &a1); ! 640: putc('\n', stderr); ! 641: } ! 642: ! 643: /* ! 644: * Print out an error message. ! 645: */ ! 646: printe(sp) ! 647: char *sp; ! 648: { ! 649: errrstr = sp; ! 650: fprintf(stderr, "%s?\n", errrstr); ! 651: } ! 652: ! 653: /* ! 654: * Print formatted. ! 655: */ ! 656: printx(a1) ! 657: char *a1; ! 658: { ! 659: printf("%r", &a1); ! 660: } ! 661: ! 662: /* ! 663: * Put out a character. ! 664: */ ! 665: putx(c) ! 666: { ! 667: putchar(c); ! 668: } ! 669: ! 670: ! 671: /****************************************************************************** ! 672: * ! 673: * Note some #defines in these include files interferes with ! 674: * items in preceeding include files. Hence the strange ! 675: * program order. ! 676: * ! 677: ******************************************************************************/ ! 678: ! 679: #include <coff.h> ! 680: ! 681: static FILEHDR coffh; ! 682: ! 683: evalhdrinfo(fp) ! 684: FILE *fp; ! 685: { ! 686: hdrinfo.magic = getMagic(fp); ! 687: if (hdrinfo.magic == C_386_MAGIC) ! 688: hdrinfo.defsegatt = DSA32; ! 689: else ! 690: hdrinfo.defsegatt = DSA16; ! 691: } ! 692: ! 693: unsigned short ! 694: getMagic(fp) ! 695: FILE *fp; ! 696: { ! 697: fseek(fp,0L,0); ! 698: if ( fread(&coffh, sizeof(FILEHDR), 1, fp) != 1 ) ! 699: panic("Cannot read object file"); ! 700: if (coffh.f_magic == C_386_MAGIC) ! 701: return(C_386_MAGIC); ! 702: else { ! 703: canint(coffh.f_magic); ! 704: if ( coffh.f_magic == L_MAGIC ) ! 705: return(L_MAGIC); ! 706: else ! 707: panic("Bad object file"); ! 708: } ! 709: return(0); ! 710: } ! 711: ! 712: rdcoff_to_loutSym(fp, seekoff, ldsp) ! 713: FILE *fp; ! 714: long seekoff; ! 715: struct LDSYM *ldsp; ! 716: { ! 717: SYMENT coffsym; ! 718: char *str_tabp; ! 719: SCNHDR *scnhp; ! 720: ! 721: str_tabp = (char *)read_str_tab(fp, snsym, sbase); ! 722: ! 723: fseek(fp, seekoff, 0); ! 724: if (fread(&coffsym, sizeof(SYMENT), 1, fp) != 1) { ! 725: printf("Unable to read coff symbols\n"); ! 726: return(0); ! 727: } ! 728: ! 729: scnhp = (SCNHDR *)read_scns(fp, coffh.f_nscns ! 730: , sizeof(FILEHDR)+coffh.f_opthdr); ! 731: if (scnhp == NULL) { ! 732: printf("Unable to read section headers\n"); ! 733: return(0); ! 734: } ! 735: ! 736: coff_to_lout(&coffsym, ldsp, str_tabp, scnhp); ! 737: ! 738: nfree(str_tabp); ! 739: nfree(scnhp); ! 740: return(1); ! 741: } ! 742: ! 743: ! 744: caddr_t ! 745: initn() ! 746: { ! 747: ! 748: return(hdrinfo.magic == C_386_MAGIC ? (caddr_t)sngblsym : (caddr_t)snsym); ! 749: } ! 750: ! 751: off_t ! 752: initb() ! 753: { ! 754: off_t b; ! 755: ! 756: b = (hdrinfo.magic == C_386_MAGIC ! 757: ? ( sbase+(gblsymMap[0]*(off_t)sizeof(SYMENT)) ) ! 758: : sbase); ! 759: return(b); ! 760: } ! 761: ! 762: off_t ! 763: incb(b, i) ! 764: off_t b; ! 765: int i; ! 766: { ! 767: b += ( hdrinfo.magic == C_386_MAGIC ! 768: ? ( (gblsymMap[i] - gblsymMap[i-1L]) * sizeof(SYMENT) ) ! 769: : sizeof(struct ldsym) ); ! 770: return(b); ! 771: } ! 772: ! 773: off_t ! 774: getseekoff(n1) ! 775: { ! 776: off_t b; ! 777: ! 778: b = ( hdrinfo.magic == C_386_MAGIC ! 779: ? ( (gblsymMap[n1]) * sizeof(SYMENT) ) ! 780: : (n1 * sizeof(struct ldsym)) ); ! 781: return(b); ! 782: } ! 783: ! 784: /* end of trace6.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.