![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outrel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 / i8086|
Return to outrel.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 / i8086 |
1.1 ! root 1: /* ! 2: * The routines in this file make up ! 3: * a writer for the Coherent reloc.h object ! 4: * file. During code assembly all the bits get ! 5: * written to a temporary file. At the very end the ! 6: * bits get copied back to the final object file. ! 7: * The symbol table is constructed as the code is read, ! 8: * each symbol is declared when defined. References are ! 9: * tacked onto the end of the file. ! 10: * Relocation instructions for debug and symbol table entries are ! 11: * also passed through the scratch file. ! 12: */ ! 13: #ifdef vax ! 14: #include "INC$LIB:cc2.h" ! 15: #include "INC$LIB:canon.h" ! 16: #include "INC$LIB:reloc.h" ! 17: #include "INC$LIB:debug.h" ! 18: #else ! 19: #include "cc2.h" ! 20: #include <canon.h> ! 21: #include <reloc.h> ! 22: #include <debug.h> ! 23: #endif ! 24: ! 25: #if !TINY ! 26: #define dbrpt(x,y) _dbrpt(x,y) ! 27: #else ! 28: #define dbrpt(x,y) /* dbrpt(x,y) */ ! 29: #endif ! 30: #define NTXT 512 /* Text buffer size */ ! 31: #define NREL 256 /* Relocation buffer size */ ! 32: /* ! 33: * Scratch file operators. ! 34: */ ! 35: #define TTYPE 017 /* Type mask */ ! 36: #define Tflag(x) (((x)>>4)&7) /* Get flag bits */ ! 37: #define TEND 000 /* End marker */ ! 38: #define TENTER 001 /* Enter new area */ ! 39: #define TBYTE 002 /* Byte data */ ! 40: #define TWORD 003 /* Word data */ ! 41: #if 0 ! 42: #define TTRIP 004 /* Triple byte data */ ! 43: #define TLONG 005 /* Long data */ ! 44: #endif ! 45: #define TDLAB 006 /* Debug item */ ! 46: #define TDLOC 007 /* Debug location */ ! 47: #define TCODE 010 /* Code segment base */ ! 48: #define TDATA 011 /* Data segment base */ ! 49: #define TBASE 012 /* External segment base */ ! 50: ! 51: #define TPCR 020 /* PC rel flag, ored in */ ! 52: #define TSYM 040 /* Symbol based flag, ored in */ ! 53: #define locrup(x) (((x)+01)&~01) /* memory alignment */ ! 54: objhdr_t objhdr = { /* object header */ ! 55: REL_OBJ, ! 56: "i8086", ! 57: "C", ! 58: VERSMWC ! 59: }; ! 60: ! 61: summseg_t summseg = { /* Summary segment */ ! 62: SUMMARY, ! 63: sizeof (summseg.seg_off) ! 64: }; ! 65: ! 66: extern char *calloc(); ! 67: extern char *malloc(); ! 68: extern char *strcpy(); ! 69: ! 70: ADDRESS SCODE_len; /* Length of SCODE in bytes */ ! 71: char txt[NTXT]; /* Text buffer */ ! 72: char rel[NREL]; /* Relocation buffer */ ! 73: char *txtp = txt; /* Text pointer */ ! 74: char *relp = rel; /* Relocation pointer */ ! 75: int refnum = 0; /* Symbol reference number */ ! 76: static int level = 0; /* Debug brace level */ ! 77: static int dline = 0; /* Most recent line number entry */ ! 78: ! 79: /* ! 80: * This table converts a C compiler ! 81: * segment index into a relocatable object segment type. ! 82: */ ! 83: char segindex[] = { ! 84: PURCODE, /* SCODE */ ! 85: OWNCODE, /* SLINK */ ! 86: PURDATA, /* SPURE */ ! 87: STRINGS, /* SSTRN */ ! 88: OWNDATA, /* SDATA */ ! 89: BLDATA, /* SBSS */ ! 90: -1, /* SANY */ ! 91: -1, /* SSTACK */ ! 92: -1, /* SALIEN */ ! 93: DEBUG, /* SDBG */ ! 94: SYMBOLS /* SSYM */ ! 95: }; ! 96: ! 97: /* ! 98: * Output a segment switch. ! 99: */ ! 100: outseg(s) ! 101: { ! 102: bput(TENTER); ! 103: bput(s); ! 104: } ! 105: ! 106: /* ! 107: * Output an absolute byte. ! 108: */ ! 109: outab(b) ! 110: { ! 111: bput(TBYTE); ! 112: bput(b); ! 113: dot += 1; ! 114: } ! 115: ! 116: /* ! 117: * Output an absolute word. ! 118: */ ! 119: outaw(w) ! 120: { ! 121: bput(TWORD); ! 122: iput(w); ! 123: dot += 2; ! 124: } ! 125: ! 126: ! 127: #ifdef TLONG ! 128: /* ! 129: * Output an absolute long. ! 130: */ ! 131: outal(l) ! 132: long l; ! 133: { ! 134: bput(TLONG); ! 135: lput(l); ! 136: dot += 4; ! 137: } ! 138: #endif ! 139: ! 140: /* ! 141: * Output a full byte. ! 142: */ ! 143: outxb(sp, b, pcrf) ! 144: register SYM *sp; ! 145: { ! 146: register opcode; ! 147: ! 148: opcode = TBYTE; ! 149: if (sp != NULL) ! 150: opcode |= TSYM; ! 151: if (pcrf) ! 152: opcode |= TPCR; ! 153: bput(opcode); ! 154: bput(b); ! 155: if (sp != NULL) ! 156: pput(sp); ! 157: dot += 1; ! 158: } ! 159: ! 160: /* ! 161: * Output a full word. ! 162: */ ! 163: outxw(sp, w, pcrf) ! 164: register SYM *sp; ! 165: { ! 166: register opcode; ! 167: ! 168: opcode = TWORD; ! 169: if (sp != NULL) ! 170: opcode |= TSYM; ! 171: if (pcrf) ! 172: opcode |= TPCR; ! 173: bput(opcode); ! 174: iput(w); ! 175: if (sp != NULL) ! 176: pput(sp); ! 177: dot += 2; ! 178: } ! 179: ! 180: #ifdef TLONG ! 181: /* ! 182: * Output a full long. ! 183: */ ! 184: outxl(sp, l, pcrf) ! 185: register SYM *sp; ! 186: long l; ! 187: { ! 188: register opcode; ! 189: ! 190: opcode = TLONG; ! 191: if (sp != NULL) ! 192: opcode |= TSYM; ! 193: if (pcrf) ! 194: opcode |= TPCR; ! 195: bput(opcode); ! 196: lput(lR); ! 197: if (sp != NULL) ! 198: pput(sp); ! 199: dot += 4; ! 200: } ! 201: #endif ! 202: ! 203: /* ! 204: * Copy a dlabel record from ifp to ofp. ! 205: * Flag the symbol table entry if appropriate. ! 206: */ ! 207: outdlab(l,class) ! 208: { ! 209: register int val; ! 210: register SYM *sp; ! 211: int n; ! 212: ! 213: if (l == 0) ! 214: bput(TDLAB); ! 215: bput(class); ! 216: ! 217: /* Get line number. */ ! 218: iput(iget()); ! 219: ! 220: /* Get value */ ! 221: if (class < DC_AUTO) ! 222: ; ! 223: else if (class < DC_MOS) ! 224: iput(val = iget()); ! 225: else { ! 226: bput(bget()); ! 227: bput(bget()); ! 228: iput(iget()); ! 229: } ! 230: ! 231: /* Get name */ ! 232: sget(id, NCSYMB); ! 233: ! 234: /* Check for symbol table entry */ ! 235: if (class==DC_GDEF || class==DC_SEX || class==DC_GREF) { ! 236: sp = glookup(id, 0); ! 237: sp->s_flag |= S_PUT; ! 238: } else if (class==DC_SIN) { ! 239: sp = llookup(val, 0); ! 240: sp->s_flag |= S_PUT; ! 241: } ! 242: ! 243: /* Put name */ ! 244: sput(id); ! 245: ! 246: /* Get type */ ! 247: for (;;) { ! 248: switch (bput(bget())) { ! 249: case DT_NONE: ! 250: case DT_CHAR: ! 251: case DT_UCHAR: ! 252: case DT_SHORT: ! 253: case DT_USHORT: ! 254: case DT_INT: ! 255: case DT_UINT: ! 256: case DT_LONG: ! 257: case DT_ULONG: ! 258: case DT_FLOAT: ! 259: case DT_DOUBLE: ! 260: case DT_VOID: ! 261: iput(iget()); ! 262: break; ! 263: case DT_STRUCT: ! 264: case DT_UNION: ! 265: case DT_ENUM: ! 266: case DD_PTR: ! 267: case DD_FUNC: ! 268: case DD_ARRAY: ! 269: iput(iget()); ! 270: continue; ! 271: break; ! 272: case DX_MEMBS: ! 273: bput(n = iget()); ! 274: for ( ; n > 0; n-=1) { ! 275: outdlab(1, bget()); ! 276: } ! 277: break; ! 278: case DX_NAME: ! 279: iget(); ! 280: sget(id, NCSYMB); ! 281: sput(id); ! 282: break; ! 283: default: ! 284: cbotch("outdlab: %d", n); ! 285: } ! 286: break; ! 287: } ! 288: } ! 289: ! 290: /* ! 291: * Output a debug line record. ! 292: */ ! 293: outdlin(op) ! 294: { ! 295: bput(TDLAB); ! 296: bput(DC_LINE); ! 297: iput(line); ! 298: bput(op); ! 299: bput(0); ! 300: bput(DT_NONE); ! 301: iput(0); ! 302: } ! 303: ! 304: /* ! 305: * Output a debug relocation record. ! 306: */ ! 307: outdloc(n) ! 308: { ! 309: bput(TDLOC); ! 310: iput(n); ! 311: } ! 312: ! 313: /* ! 314: * Abort illegal output. ! 315: * reloc.h doesn't handle 8087 or Large model. ! 316: */ ! 317: outbad() ! 318: { ! 319: cbotch("bad temp file object"); ! 320: } ! 321: ! 322: /* ! 323: * Output a 1 word object containing ! 324: * the base address of the current code ! 325: * segment. ! 326: */ ! 327: outcb() ! 328: { ! 329: return (outbad()); ! 330: bput(TCODE); ! 331: dot += 2; ! 332: } ! 333: ! 334: /* ! 335: * Output a 1 word object containing ! 336: * the base address of the current data ! 337: * segment. ! 338: */ ! 339: outdb() ! 340: { ! 341: return (outbad()); ! 342: bput(TDATA); ! 343: dot += 2; ! 344: } ! 345: ! 346: /* ! 347: * Output a 1 word object containing ! 348: * the base address of the external symbol ! 349: * pointed to by `sp'. ! 350: */ ! 351: outsb(sp) ! 352: SYM *sp; ! 353: { ! 354: return (outbad()); ! 355: bput(TBASE); ! 356: pput(sp); ! 357: dot += 2; ! 358: } ! 359: ! 360: /* ! 361: * Initialize the code writer. ! 362: * This routine is called before anything is written to the scratch file. ! 363: * A no op on coherent reloc.h format. ! 364: */ ! 365: outinit() ! 366: { ! 367: } ! 368: ! 369: /* ! 370: * Finish off the code writer. ! 371: * This routine is called just before the scratch file is closed. ! 372: * Write either the "end" to the output file ! 373: * if generating assembler, ! 374: * or a "TEND" code to stop the ! 375: * "copycode" routine if writing binary. ! 376: */ ! 377: outdone() ! 378: { ! 379: register SYM *sp; ! 380: register int i; ! 381: ! 382: if (isvariant(VASM)) { ! 383: return; ! 384: } ! 385: ! 386: /* ! 387: * Assign refnums to symbols. ! 388: * And make dlabel items for internally generated symbols. ! 389: */ ! 390: for (refnum = i = 0; i < NSHASH; i++) { ! 391: for (sp = hash2[i]; sp != NULL; sp = sp->s_fp) { ! 392: if ((sp->s_flag&S_GBL) != 0 ! 393: || (sp->s_flag&S_DEF) == 0) { ! 394: if ((sp->s_flag&S_LABNO) == 0) ! 395: sp->s_ref = refnum++; ! 396: if ((sp->s_flag&S_PUT) == 0) { ! 397: bput(TDLAB); ! 398: bput(DC_GREF); ! 399: iput(0); ! 400: sput(sp->s_id); ! 401: bput(DT_NONE); ! 402: iput(0); ! 403: } ! 404: } ! 405: } ! 406: } ! 407: ! 408: bput(TEND); ! 409: } ! 410: ! 411: /* ! 412: * Copy back. ! 413: * Figure out the sizes and final values ! 414: * of everything. Copy the code from the scratch ! 415: * file back to the output file. ! 416: */ ! 417: copycode() ! 418: { ! 419: int op, nd, nr; ! 420: ADDRESS data; ! 421: long addr; ! 422: fsize_t size, symsize; ! 423: unsigned char reltype, segtype; ! 424: ! 425: SCODE_len = seg[SCODE].s_dot; ! 426: ! 427: /* ! 428: * Initialize output. ! 429: */ ! 430: oheader(0); ! 431: ! 432: /* ! 433: * Copy out code. ! 434: */ ! 435: dotseg = SCODE; ! 436: dot = 0; ! 437: while ((op=bget()) != TEND) { ! 438: switch (op & TTYPE) { ! 439: ! 440: case TENTER: ! 441: oenter(bget()); ! 442: continue; ! 443: ! 444: case TBYTE: ! 445: nd = 1; ! 446: reltype = B_0; ! 447: data = bget(); ! 448: break; ! 449: ! 450: case TWORD: ! 451: nd = 2; ! 452: reltype = B_01; ! 453: data = iget(); ! 454: break; ! 455: ! 456: #ifdef TLONG ! 457: case TLONG: ! 458: nd = 4; ! 459: reltype = B_0123; ! 460: data = lget(); ! 461: break; ! 462: #endif ! 463: ! 464: case TDLAB: ! 465: getdlab(); ! 466: continue; ! 467: ! 468: case TDLOC: ! 469: getdloc(); ! 470: continue; ! 471: ! 472: default: ! 473: cbotch("copycode: op=%d", op); ! 474: ! 475: } ! 476: ! 477: switch (Tflag(op)) { ! 478: ! 479: case 0: /* Absolute */ ! 480: nr = 0; ! 481: break; ! 482: ! 483: case Tflag(TPCR|TSYM): /* Symbol based pc relative */ ! 484: data -= dot+nd; ! 485: /* Fall through */ ! 486: ! 487: case Tflag(TSYM): /* Symbol based */ ! 488: { ! 489: register SYM *sp; ! 490: ! 491: sp = pget(); ! 492: if ((sp->s_flag&S_DEF) != 0) { ! 493: nr = 6; ! 494: segtype = segindex[sp->s_seg]; ! 495: data += sp->s_value; ! 496: } else { ! 497: nr = 10; ! 498: segtype = SYMBOLS; ! 499: addr = sp->s_ref; ! 500: } ! 501: if ((op&TPCR) != 0) ! 502: segtype |= PCREL; ! 503: break; ! 504: } ! 505: ! 506: case Tflag(TPCR): /* Absolute pc relative */ ! 507: data -= dot+nd; ! 508: segtype = ABSLUTE|PCREL; ! 509: nr = 10; ! 510: addr = 0; ! 511: break; ! 512: ! 513: default: ! 514: cbotch("copycode: flags=%o", op); ! 515: } ! 516: ! 517: /* ! 518: * Write the current record. ! 519: */ ! 520: enuf(nd, nr); ! 521: if (nr != 0) { ! 522: rbbuf(reltype); ! 523: rbbuf(segtype); ! 524: rlbuf((long) dot); ! 525: if (nr == 10) ! 526: rlbuf(addr); ! 527: } ! 528: do { ! 529: bbuf((int) data); ! 530: data >>= 8; ! 531: } while (--nd > 0); ! 532: } ! 533: ! 534: if (isvariant(VLINES)) ! 535: outbrace('}'); ! 536: if (notvariant(VLIB)) ! 537: dump(); /* Dump the typedefs */ ! 538: ! 539: /* ! 540: * Flush buffers. ! 541: */ ! 542: notenuf(); ! 543: ! 544: /* ! 545: * Write symbol table. ! 546: */ ! 547: summseg.seg_off[SYMBOLS] = ftell(ofp); ! 548: segtype = SYMBOLS; ! 549: bput(segtype); ! 550: size = symsize; ! 551: cansize(size); ! 552: owrite(&size, sizeof(size)); ! 553: addr = refnum; ! 554: canuaddr(addr); ! 555: owrite(&addr, sizeof(addr)); ! 556: oglobals(); ! 557: symsize = ftell(ofp) - summseg.seg_off[SYMBOLS] - sizeof(fsize_t) - 1; ! 558: ! 559: /* ! 560: * Put end marker. ! 561: */ ! 562: segtype = LASTSEG; ! 563: bput(segtype); ! 564: ! 565: /* ! 566: * Now go back and patch the remaining holes. ! 567: */ ! 568: fseek(ofp, (fsize_t)0, 0); ! 569: oheader(1); ! 570: ! 571: /* ! 572: * Symbol segment size and count. ! 573: */ ! 574: fseek(ofp, summseg.seg_off[SYMBOLS]+1, 0); ! 575: size = symsize; ! 576: cansize(size); ! 577: owrite(&size, sizeof(size)); ! 578: addr = refnum; ! 579: canuaddr(addr); ! 580: owrite(&addr, sizeof(addr)); ! 581: } ! 582: ! 583: /* ! 584: * Switch segments. ! 585: */ ! 586: oenter(newseg) ! 587: register int newseg; ! 588: { ! 589: notenuf(); ! 590: if (dotseg != SSYM) ! 591: seg[dotseg].s_dot = dot; ! 592: dotseg = newseg; ! 593: if (dotseg != SSYM) ! 594: dot = seg[dotseg].s_dot; ! 595: else ! 596: dot = 0; ! 597: } ! 598: ! 599: /* ! 600: * This routine checks to see if ! 601: * there is enough room in the text and relocation ! 602: * buffers to hold `nt' bytes of text and `nr' bytes of ! 603: * relocation. ! 604: */ ! 605: enuf(nt, nr) ! 606: { ! 607: if (txtp+nt>&txt[NTXT] || relp+nr>&rel[NREL]) ! 608: notenuf(); ! 609: } ! 610: ! 611: /* ! 612: * Flush buffers. ! 613: */ ! 614: notenuf() ! 615: { ! 616: register n; ! 617: unsigned char segtype; ! 618: fsize_t size; ! 619: ! 620: if ((n=txtp-txt) != 0) { ! 621: if (dotseg != SSYM) { ! 622: segtype = segindex[dotseg]; ! 623: bput(segtype); ! 624: size = n; ! 625: cansize(size); ! 626: owrite(&size, sizeof(size)); ! 627: } ! 628: owrite(txt, n); ! 629: if ((n=relp-rel) != 0) { ! 630: segtype = RELOCN; ! 631: bput(segtype); ! 632: size = n; ! 633: cansize(size); ! 634: owrite(&size, sizeof(size)); ! 635: owrite(rel, n); ! 636: relp = rel; ! 637: } ! 638: } ! 639: txtp = txt; ! 640: } ! 641: ! 642: /* ! 643: * Write a byte or long to text or relocation buffers ! 644: * in canonical ordering. ! 645: */ ! 646: bbuf(b) ! 647: { ! 648: *txtp++ = b; ! 649: dot += 1; ! 650: } ! 651: ! 652: lbuf(l) ! 653: long l; ! 654: { ! 655: *txtp++ = l >> 16; ! 656: *txtp++ = l >> 24; ! 657: *txtp++ = l; ! 658: *txtp++ = l >> 8; ! 659: dot += 4; ! 660: } ! 661: ! 662: rbbuf(b) ! 663: { ! 664: *relp++ = b; ! 665: } ! 666: ! 667: rlbuf(l) ! 668: long l; ! 669: { ! 670: *relp++ = l >> 16; ! 671: *relp++ = l >> 24; ! 672: *relp++ = l; ! 673: *relp++ = l >> 8; ! 674: } ! 675: ! 676: /* ! 677: * Write a block of bytes to the output file. ! 678: */ ! 679: owrite(p, n) ! 680: register char *p; ! 681: register int n; ! 682: { ! 683: while (--n >= 0) ! 684: bput(*p++); ! 685: } ! 686: ! 687: /* ! 688: * Write the header and summary segment. ! 689: * Summary is complete on second call only. ! 690: */ ! 691: oheader(n) ! 692: { ! 693: fsize_t offs; ! 694: register int i; ! 695: register struct seg *segp; ! 696: ! 697: /* ! 698: * Write header. ! 699: */ ! 700: owrite(&objhdr, sizeof(objhdr)); ! 701: ! 702: /* ! 703: * Copy segment sizes into summary segment. ! 704: */ ! 705: for (segp = &seg[i=0]; i < NSEG; segp++, i++) { ! 706: if (segindex[i] < 0 || i == SSYM) continue; ! 707: offs = segp->s_dot; ! 708: if (i != SDBG) ! 709: offs = locrup(offs); ! 710: if (n == 0 || i >= SDBG) ! 711: summseg.seg_off[segindex[i]] += offs; ! 712: segp->s_dot = 0; ! 713: } ! 714: /* ! 715: * Write summary segment. ! 716: */ ! 717: bput(summseg.seg_type); ! 718: offs = summseg.seg_size; ! 719: cansize(offs); ! 720: owrite(&offs, sizeof(offs)); ! 721: for (i=0; i<SUMMARY; i+=1) { ! 722: offs = summseg.seg_off[i]; ! 723: cansize(offs); ! 724: owrite(&offs, sizeof(offs)); ! 725: } ! 726: } ! 727: ! 728: /* ! 729: * Structure to contain debug items on this pass. ! 730: */ ! 731: struct dbgt { ! 732: struct dbgt *d_dp; /* Link */ ! 733: int d_ref; /* Index number */ ! 734: unsigned char d_class; /* Storage class */ ! 735: unsigned char d_flag; /* Flags */ ! 736: unsigned char d_level; /* Bracket level */ ! 737: unsigned char d_seg; /* Segment */ ! 738: ADDRESS d_value; /* Offset in segment */ ! 739: int d_size; /* Size of d_data */ ! 740: char d_data[]; /* Name and type */ ! 741: }; ! 742: #define D_GBL 1 ! 743: #define D_LCL 2 ! 744: #define D_TAG 4 ! 745: #define D_NAM 8 ! 746: #define D_LAB 16 ! 747: #define D_ENU 32 ! 748: ! 749: struct dbgt *newdbgt(); ! 750: struct dbgt *getdbgt(); ! 751: struct dbgt *dbase; ! 752: struct dbgt *dnext; ! 753: char *getmembs(); ! 754: ! 755: /* ! 756: * Read debug table item(s) into memory. ! 757: */ ! 758: getdlab() ! 759: { ! 760: register struct dbgt *dp; ! 761: static int refnum = 0; ! 762: ! 763: dp = getdbgt(); ! 764: ! 765: /* This should be done in cc0 */ ! 766: ! 767: if (isvariant(VLIB)) { ! 768: switch (dp->d_class) { ! 769: case DC_TYPE: ! 770: case DC_STAG: ! 771: case DC_UTAG: ! 772: case DC_ETAG: ! 773: return; ! 774: } ! 775: } ! 776: if (dp->d_class == DC_LINE || dp->d_class == DC_LAB) ! 777: dp->d_ref = refnum; ! 778: ! 779: refnum += 1; ! 780: if (dbase == NULL) ! 781: dbase = dp; ! 782: if (dnext != NULL) ! 783: dnext->d_dp = dp; ! 784: dbrpt("enter", dp); ! 785: while (dp->d_dp != NULL) { ! 786: dp = dp->d_dp; ! 787: dbrpt("enter", dp); ! 788: } ! 789: dnext = dp; ! 790: if (dp->d_class == DC_FILE) ! 791: outbrace('{'); ! 792: } ! 793: ! 794: /* ! 795: * Read a debug relocation item and patch current `dot' ! 796: * into the appropriate debug/symbol table item. ! 797: * If the debug item is '}' and level 2, then dump the batch of locals. ! 798: * If the debug item is '}' and level 1, then dump the type definitions. ! 799: */ ! 800: getdloc() ! 801: { ! 802: register struct dbgt *dp; ! 803: register int ref; ! 804: ! 805: ref = iget(); ! 806: for (dp = dbase; ; dp = dp->d_dp) { ! 807: if (dp == NULL) ! 808: cbotch("getdloc: %d", ref); ! 809: if ((dp->d_flag&D_GBL) != 0) ! 810: continue; ! 811: if (dp->d_ref == ref) ! 812: break; ! 813: } ! 814: dp->d_seg = segindex[dotseg]; ! 815: dp->d_value = dot; ! 816: ! 817: dbrpt("reloc", dp); ! 818: if (dp->d_data[0] == '}' && dp->d_level <= 2) { ! 819: outbrace('}'); ! 820: level--; ! 821: dump(); ! 822: } ! 823: } ! 824: ! 825: /* ! 826: * Dump the locals and type definitions ! 827: */ ! 828: ! 829: dump() ! 830: { ! 831: register struct dbgt *dp, **dpp; ! 832: int saveseg; ! 833: ! 834: if ((saveseg = dotseg) != SDBG) ! 835: oenter(SDBG); ! 836: dpp = &dbase; ! 837: dnext = NULL; ! 838: while ((dp = *dpp) != NULL) { ! 839: if ((dp->d_flag&D_LCL) != 0) { ! 840: dbrpt("write", dp); ! 841: osymbol(dp, -1); ! 842: dp->d_flag &= ~D_LCL; ! 843: } ! 844: if ((dp->d_flag&D_GBL) == 0) { ! 845: dbrpt("free", dp); ! 846: *dpp = dp->d_dp; ! 847: free(dp); ! 848: } else { ! 849: dbrpt("save", dp); ! 850: dnext = dp; ! 851: dpp = &dp->d_dp; ! 852: } ! 853: } ! 854: if (saveseg != SDBG) ! 855: oenter(saveseg); ! 856: } ! 857: ! 858: /* ! 859: * Write out global symbol definitions and references. ! 860: */ ! 861: oglobals() ! 862: { ! 863: register struct dbgt *dp, *dp1; ! 864: extern int refnum; ! 865: ! 866: oenter(SSYM); ! 867: for (dp = dbase; dp != NULL; dp = dp1) { ! 868: dp1 = dp->d_dp; ! 869: dbrpt("write", dp); ! 870: if (dp->d_seg == TYPESYM || dp->d_seg == ABSLUTE) ! 871: osymbol(dp, refnum++); ! 872: else ! 873: osymbol(dp, dp->d_ref); ! 874: dbrpt("free", dp); ! 875: free(dp); ! 876: } ! 877: notenuf(); ! 878: } ! 879: ! 880: /* ! 881: * Write out a symbol to the symbol or debug table. ! 882: * Debug table symbols have negative refnums, ! 883: * and may require relocation. ! 884: */ ! 885: osymbol(dp, refnum) ! 886: register struct dbgt *dp; ! 887: { ! 888: register char *cp; ! 889: unsigned char segtype; ! 890: uaddr_t segaddr; ! 891: int nd, nr; ! 892: ! 893: /* Write scope/refnum or seg/value+relocation expression */ ! 894: nd = 5 + dp->d_size; ! 895: nr = 0; ! 896: if (refnum >= 0) { ! 897: if (dp->d_seg == ABSLUTE) { ! 898: segtype = MDSCOPE; ! 899: nd += 5; ! 900: } else if (dp->d_seg != LASTSEG) { ! 901: segtype = LDSCOPE; ! 902: nd += 5; ! 903: } else ! 904: segtype = RFSCOPE; ! 905: segaddr = refnum; ! 906: } else { ! 907: segtype = dp->d_seg; ! 908: segaddr = dp->d_value; ! 909: if (segtype < SUMMARY ! 910: && segtype != TYPESYM ! 911: && segtype != ABSLUTE) ! 912: nr = 6; ! 913: } ! 914: enuf(nd, nr); ! 915: bbuf(segtype); ! 916: if (nr != 0) { ! 917: rbbuf(B_2301); ! 918: rbbuf(dp->d_seg); ! 919: rlbuf((long) dot); ! 920: } ! 921: lbuf(segaddr); ! 922: ! 923: /* Write name */ ! 924: cp = dp->d_data; ! 925: nd = dp->d_size; ! 926: do { ! 927: bbuf(*cp); ! 928: nd -= 1; ! 929: } while (*cp++); ! 930: ! 931: /* Write seg/value expression */ ! 932: if (refnum >= 0 && (segtype == MDSCOPE || segtype == LDSCOPE)) { ! 933: bbuf(dp->d_seg); ! 934: lbuf((long) dp->d_value); ! 935: } ! 936: ! 937: /* Type */ ! 938: while (--nd >= 0) ! 939: bbuf(*cp++); ! 940: } ! 941: ! 942: /* ! 943: * Read in debug items translating into loader type syntax. ! 944: * Member definitions are fetched recursively. ! 945: * If a tag or type definition, the member definitions are appended to the ! 946: * node surrounded by "{" and "}" nodes. ! 947: * If not a tag definition, the member definitions are discarded. ! 948: * In either case, the member types are appended to the type of the ! 949: * parent node. ! 950: */ ! 951: #define DSZ 512 ! 952: struct dbgt * ! 953: getdbgt() ! 954: { ! 955: register int n; ! 956: register char *dptr; ! 957: struct dbgt d; ! 958: char data[DSZ]; ! 959: int value, width, offs; ! 960: int typet, subt, membs; ! 961: char *sdp; ! 962: ! 963: d.d_dp = NULL; ! 964: d.d_ref = -1; ! 965: d.d_flag = D_LCL; ! 966: d.d_level = level; ! 967: d.d_seg = LASTSEG; ! 968: d.d_value = 0; ! 969: d.d_size = 0; ! 970: width = membs = 0; ! 971: ! 972: /* ! 973: * Loop to read entire record: ! 974: * class, optional value, name, type. ! 975: */ ! 976: dptr = data; ! 977: for (typet = 0; ; typet += 1) { ! 978: ! 979: if (dptr >= data+DSZ) { ! 980: dbrpt("1", &d); ! 981: cbotch("getdbgt buffer"); ! 982: } ! 983: ! 984: n = bget(); ! 985: if (n < DX_MEMBS) ! 986: value = iget() * NBPBYTE; ! 987: else if (n < DC_SEX) ! 988: ; ! 989: else { ! 990: dline = iget(); ! 991: if (n < DC_AUTO) ! 992: ; ! 993: else if (n < DC_MOS) ! 994: value = iget(); ! 995: else { ! 996: width = bget(); ! 997: offs = bget(); ! 998: value = iget(); ! 999: } ! 1000: } ! 1001: subt = 0; ! 1002: ! 1003: switch (n) { ! 1004: ! 1005: /* ! 1006: * Classes: fetch values and set flags. ! 1007: */ ! 1008: case DC_SEX: ! 1009: d.d_flag |= D_NAM; ! 1010: goto setclass; ! 1011: ! 1012: case DC_GDEF: ! 1013: case DC_GREF: ! 1014: d.d_flag = D_GBL|D_NAM; ! 1015: goto setclass; ! 1016: ! 1017: case DC_ETAG: ! 1018: d.d_flag |= D_ENU; ! 1019: strcpy(dptr, "enum "); ! 1020: dptr += 5; ! 1021: goto tag; ! 1022: case DC_STAG: ! 1023: strcpy(dptr, "struct "); ! 1024: dptr += 7; ! 1025: goto tag; ! 1026: case DC_UTAG: ! 1027: strcpy(dptr, "union "); ! 1028: dptr += 6; ! 1029: case DC_TYPE: ! 1030: tag: ! 1031: d.d_flag = (level == 0) ? D_TAG|D_GBL : D_TAG|D_LCL; ! 1032: d.d_seg = TYPESYM; ! 1033: goto setclass; ! 1034: ! 1035: case DC_FILE: ! 1036: d.d_seg = PURCODE; ! 1037: goto setclass; ! 1038: ! 1039: case DC_AUTO: ! 1040: d.d_seg = L_STACK; ! 1041: d.d_value = value; ! 1042: goto setclass; ! 1043: ! 1044: case DC_SIN: ! 1045: d.d_flag |= D_LAB; ! 1046: goto setclass; ! 1047: ! 1048: case DC_REG: ! 1049: d.d_seg = L_REG; ! 1050: d.d_value = value; ! 1051: goto setclass; ! 1052: ! 1053: case DC_PREG: ! 1054: if (level == 0) { ! 1055: level++; ! 1056: outbrace('{'); ! 1057: } ! 1058: d.d_seg = L_REG; ! 1059: d.d_value = value; ! 1060: goto setclass; ! 1061: ! 1062: case DC_MOE: ! 1063: d.d_seg = ABSLUTE; ! 1064: d.d_value = value; ! 1065: goto setclass; ! 1066: ! 1067: case DC_PAUTO: ! 1068: if (level == 0) { ! 1069: level++; ! 1070: outbrace('{'); ! 1071: } ! 1072: d.d_seg = P_STACK; ! 1073: d.d_value = value; ! 1074: goto setclass; ! 1075: ! 1076: case DC_LAB: ! 1077: case DC_LINE: ! 1078: goto setclass; ! 1079: ! 1080: case DC_MOS: ! 1081: case DC_MOU: ! 1082: d.d_seg = FLD_OFF; ! 1083: d.d_value = value * NBPBYTE + offs; ! 1084: goto setclass; ! 1085: ! 1086: /* ! 1087: * Set the class field, read the name; ! 1088: * Lookup globals and statics. ! 1089: */ ! 1090: setclass: ! 1091: d.d_class = n; ! 1092: while (*dptr++ = bget()) ! 1093: ; ! 1094: if ((d.d_flag&(D_NAM|D_LAB)) != 0) { ! 1095: register SYM *sp; ! 1096: ! 1097: if ((d.d_flag&D_NAM) != 0) ! 1098: sp = glookup(data, 0); ! 1099: else ! 1100: sp = llookup(value, 0); ! 1101: if ((sp->s_flag&S_DEF) != 0) { ! 1102: d.d_seg = segindex[sp->s_seg]; ! 1103: d.d_value = sp->s_value; ! 1104: #if COMMON ! 1105: } else if (sp->s_value != 0) { ! 1106: d.d_seg = BLDATA|Cb; ! 1107: d.d_value = sp->s_value; ! 1108: #endif ! 1109: } ! 1110: if ((d.d_flag&D_GBL) != 0) ! 1111: d.d_ref = sp->s_ref; ! 1112: } ! 1113: continue; ! 1114: ! 1115: /* ! 1116: * Types: write type and prepare for trailing data. ! 1117: * For files and lines, write a phony type. ! 1118: */ ! 1119: case DT_NONE: ! 1120: if (d.d_class == DC_FILE) { ! 1121: register char *p; ! 1122: ! 1123: *dptr++ = STRINGt; ! 1124: p = "source file"; ! 1125: while (*dptr++ = *p++) ! 1126: ; ! 1127: } ! 1128: if (d.d_class == DC_LINE) { ! 1129: *dptr++ = 6; /* Line */ ! 1130: *dptr++ = dline; ! 1131: *dptr++ = dline >> 8; ! 1132: *dptr++ = 0; /* Column */ ! 1133: *dptr++ = 0; /* Flag */ ! 1134: *dptr++ = 0; /* Saved instruction */ ! 1135: *dptr++ = 0; ! 1136: } ! 1137: break; ! 1138: ! 1139: case DT_CHAR: ! 1140: case DT_SHORT: ! 1141: case DT_INT: ! 1142: case DT_LONG: ! 1143: n = Integer; ! 1144: goto getwidth; ! 1145: ! 1146: case DT_UCHAR: ! 1147: case DT_USHORT: ! 1148: case DT_UINT: ! 1149: case DT_ULONG: ! 1150: n = Natural; ! 1151: goto getwidth; ! 1152: ! 1153: case DT_FLOAT: ! 1154: case DT_DOUBLE: ! 1155: n = Rational; ! 1156: goto settype; ! 1157: ! 1158: case DT_VOID: ! 1159: n = Void; ! 1160: goto settype; ! 1161: ! 1162: case DT_STRUCT: ! 1163: membs = n; ! 1164: n = Record; ! 1165: sdp = dptr; ! 1166: goto settype; ! 1167: ! 1168: case DT_UNION: ! 1169: membs = n; ! 1170: n = Union; ! 1171: sdp = dptr; ! 1172: goto settype; ! 1173: ! 1174: case DT_ENUM: ! 1175: d.d_flag |= D_ENU; ! 1176: membs = n; ! 1177: n = Natural; ! 1178: sdp = dptr; ! 1179: goto settype; ! 1180: ! 1181: getwidth: ! 1182: if (width) ! 1183: value = width; ! 1184: ! 1185: settype: ! 1186: *dptr++ = 1; ! 1187: *dptr++ = n; ! 1188: if (n != Void) { ! 1189: if (value == 0) ! 1190: *dptr++ = ANYt; ! 1191: else if (value <= 0377) { ! 1192: *dptr++ = 1; ! 1193: *dptr++ = value; ! 1194: } else { ! 1195: *dptr++ = 2; ! 1196: *dptr++ = value; ! 1197: *dptr++ = value >> 8; ! 1198: } ! 1199: } ! 1200: if (subt) { ! 1201: *dptr++ = TYPEt; ! 1202: continue; ! 1203: } ! 1204: if (membs) { ! 1205: --typet; ! 1206: continue; ! 1207: } ! 1208: break; ! 1209: ! 1210: /* ! 1211: * Dimensions: as for types, but flag for subtypes. ! 1212: */ ! 1213: case DD_PTR: ! 1214: n = Pointer; ! 1215: ++subt; ! 1216: goto settype; ! 1217: ! 1218: case DD_FUNC: ! 1219: n = Proc; ! 1220: ++subt; ! 1221: goto settype; ! 1222: ! 1223: case DD_ARRAY: ! 1224: n = Array; ! 1225: ++subt; ! 1226: goto settype; ! 1227: ! 1228: /* ! 1229: * Trailing struct/union/enum data. ! 1230: */ ! 1231: case DX_NAME: ! 1232: dptr = sdp; ! 1233: *dptr++ = STRINGt; ! 1234: switch (membs) { ! 1235: case DT_STRUCT: ! 1236: strcpy(dptr, "struct "); ! 1237: dptr += 7; ! 1238: break; ! 1239: case DT_UNION: ! 1240: strcpy(dptr, "union "); ! 1241: dptr += 6; ! 1242: break; ! 1243: case DT_ENUM: ! 1244: strcpy(dptr, "enum "); ! 1245: dptr += 5; ! 1246: } ! 1247: while (*dptr++ = bget()) ! 1248: ; ! 1249: membs = 0; ! 1250: break; ! 1251: ! 1252: case DX_MEMBS: ! 1253: level += 1; ! 1254: dptr = getmembs(&d, data, dptr); ! 1255: level -= 1; ! 1256: membs = 0; ! 1257: break; ! 1258: ! 1259: default: ! 1260: cbotch("getdbgt: %d", n); ! 1261: } ! 1262: /* ! 1263: * Terminate types. ! 1264: */ ! 1265: if (dptr + typet >= data + DSZ) { ! 1266: dbrpt("2", &d); ! 1267: cbotch("getdbgt buffer"); ! 1268: } ! 1269: while (--typet >= 0) ! 1270: *dptr++ = 0; ! 1271: break; ! 1272: } ! 1273: ! 1274: /* ! 1275: * Check level change. ! 1276: */ ! 1277: if (data[0] == '{') { ! 1278: if (level++ == 0) { ! 1279: d.d_level = level++; ! 1280: outbrace('{'); ! 1281: } ! 1282: } ! 1283: else if (data[0] == '}') ! 1284: level -= 1; ! 1285: ! 1286: /* ! 1287: * Copy into dynamic storage. ! 1288: */ ! 1289: d.d_size = dptr - data; ! 1290: return (newdbgt(&d, data)); ! 1291: } ! 1292: ! 1293: /* ! 1294: * Read a list of members of a union/struct/enum. ! 1295: * If struct/union, append member types to caller's buffer. ! 1296: * If making a debug table: ! 1297: * If struct/union tag definition, bracket member definitions. ! 1298: * If enum tag, make member type into "enum tag". ! 1299: */ ! 1300: char * ! 1301: getmembs(dp0, bb, bp) ! 1302: struct dbgt *dp0; ! 1303: char *bb; ! 1304: register char *bp; ! 1305: { ! 1306: int nmembs, n, istag, isenu, isgbl, isdbg; ! 1307: char *sbp; ! 1308: register struct dbgt *dp; ! 1309: struct dbgt **dpp; ! 1310: register char *p; ! 1311: static struct dbgt dbrace = { ! 1312: NULL, /* d_dp */ ! 1313: -1, /* d_ref */ ! 1314: DT_NONE, /* d_class */ ! 1315: D_LCL, /* d_flag */ ! 1316: 0, /* d_level */ ! 1317: TYPESYM, /* d_seg */ ! 1318: 0, /* d_value */ ! 1319: 3 /* d_size */ ! 1320: }; ! 1321: ! 1322: dp = dp0; ! 1323: nmembs = bget(); ! 1324: istag = (dp->d_flag&D_TAG) != 0; ! 1325: isenu = (dp->d_flag&D_ENU) != 0; ! 1326: isgbl = (dp->d_flag&D_GBL) != 0; ! 1327: isdbg = (isvariant(VDSYMB) && isvariant(VTYPES)) != 0; ! 1328: if (isenu) { ! 1329: sbp = bp; ! 1330: isenu = strlen(bb) + 1 + 1; ! 1331: } ! 1332: if ( ! isenu) { ! 1333: *bp++ = 1; ! 1334: *bp++ = nmembs; ! 1335: } ! 1336: dpp = &dp->d_dp; ! 1337: if (istag && isdbg && ! isenu) { ! 1338: dp = *dpp = newdbgt(&dbrace, "{\0\0"); ! 1339: if (isgbl) ! 1340: dp->d_flag ^= D_GBL|D_LCL; ! 1341: dpp = &dp->d_dp; ! 1342: } ! 1343: while (--nmembs >= 0) { ! 1344: dp = *dpp = getdbgt(); ! 1345: if (isgbl) ! 1346: dp->d_flag ^= D_GBL|D_LCL; ! 1347: n = dp->d_size; ! 1348: p = dp->d_data; ! 1349: if (isenu && istag && isdbg) { ! 1350: dp->d_size += isenu; ! 1351: dp = newdbgt(dp, dp->d_data); ! 1352: bp = dp->d_data; ! 1353: while (*bp++) ! 1354: ; ! 1355: *bp++ = STRINGt; ! 1356: p = bb; ! 1357: while (*bp++ = *p++) ! 1358: ; ! 1359: *bp++ = 0; ! 1360: free(*dpp); ! 1361: *dpp = dp; ! 1362: bp = sbp; ! 1363: } ! 1364: if ( ! isenu) { ! 1365: do { ! 1366: --n; ! 1367: } while (*p++); ! 1368: *bp++ = TYPEt; ! 1369: if (bp + n >= bb + DSZ) { ! 1370: dbrpt("3", dp); ! 1371: cbotch("getdbgt buffer"); ! 1372: } ! 1373: do { ! 1374: *bp++ = *p++; ! 1375: } while (--n > 0); ! 1376: } ! 1377: if (istag && isdbg) ! 1378: dpp = &dp->d_dp; ! 1379: else ! 1380: free(*dpp); ! 1381: } ! 1382: if (istag && isdbg && ! isenu) { ! 1383: dp = *dpp = newdbgt(&dbrace, "}\0\0"); ! 1384: if (isgbl) ! 1385: dp->d_flag ^= D_GBL|D_LCL; ! 1386: dpp = &dp->d_dp; ! 1387: } ! 1388: *dpp = NULL; ! 1389: return (bp); ! 1390: } ! 1391: ! 1392: /* ! 1393: * Output a debug brace ! 1394: */ ! 1395: outbrace(c) ! 1396: char c; ! 1397: { ! 1398: struct dbgt *dp; ! 1399: ! 1400: if ((dp = (struct dbgt *)calloc(1, sizeof(struct dbgt) + 10)) == NULL) ! 1401: cnomem("outbrace"); ! 1402: dp->d_class = DC_LINE; ! 1403: dp->d_flag = D_LCL; ! 1404: dp->d_seg = segindex[SCODE]; ! 1405: dp->d_value = ( dotseg == SCODE ? dot : seg[SCODE].s_dot); ! 1406: dp->d_size = 10; ! 1407: dp->d_data[0] = c; ! 1408: *(dp->d_data + 2) = 6; ! 1409: *(dp->d_data + 3) = dline; ! 1410: *(dp->d_data + 4) = dline >> 8; ! 1411: if (dnext != NULL) ! 1412: dnext->d_dp = dp; ! 1413: dnext = dp; ! 1414: } ! 1415: ! 1416: struct dbgt * ! 1417: newdbgt(dp, cp) ! 1418: struct dbgt *dp; ! 1419: register char *cp; ! 1420: { ! 1421: register struct dbgt *ndp; ! 1422: register char *ncp; ! 1423: register int n; ! 1424: ! 1425: n = dp->d_size; ! 1426: if ((ndp = (struct dbgt *)malloc(sizeof(struct dbgt) + n)) == NULL) ! 1427: cnomem("newdbgt"); ! 1428: *ndp = *dp; ! 1429: for (ncp = ndp->d_data; --n >= 0; *ncp++ = *cp++) ! 1430: ; ! 1431: return (ndp); ! 1432: } ! 1433: ! 1434: #if !TINY ! 1435: _dbrpt(p, dp) ! 1436: char *p; ! 1437: register struct dbgt *dp; ! 1438: { ! 1439: if (xflag > 5) { ! 1440: printf("%5s: %-10s %2x %2d %2x %2x %2x %04x %2x\n", ! 1441: p, ! 1442: dp->d_data, ! 1443: dp->d_class, ! 1444: dp->d_ref, ! 1445: dp->d_flag, ! 1446: dp->d_level, ! 1447: dp->d_seg, ! 1448: dp->d_value, ! 1449: dp->d_size ! 1450: ); ! 1451: } ! 1452: } ! 1453: ! 1454: dbtyp(dp) ! 1455: struct dbgt *dp; ! 1456: { ! 1457: register int n; ! 1458: register char *p; ! 1459: ! 1460: if (xflag > 20) { ! 1461: n = dp->d_size; ! 1462: p = dp->d_data; ! 1463: do { ! 1464: --n; ! 1465: putchar(*p); ! 1466: } while (*p++); ! 1467: while (--n >= 0) { ! 1468: if (*p == STRINGt) { ! 1469: putchar(' '); ! 1470: putchar('"'); ! 1471: ++p; ! 1472: do { ! 1473: --n; ! 1474: } while (putchar(*p++)); ! 1475: putchar('"'); ! 1476: continue; ! 1477: } else if (*p == TYPEt) ! 1478: printf(" TYPEt"); ! 1479: else if (*p == ANYt) ! 1480: printf(" ANYt"); ! 1481: else ! 1482: printf(" %o", *p&0377); ! 1483: ++p; ! 1484: } ! 1485: putchar('\n'); ! 1486: } ! 1487: } ! 1488: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.