![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local2.vax CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc|
Return to local2.vax CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc |
1.1 ! root 1: ! 2: /* ! 3: * local2.c -- vax conditional include version ! 4: */ ! 5: static char *sccsid ="@(#)local2.vax 1.1 (Berkeley) 2/3/86"; ! 6: # ifdef FORT ! 7: int ftlab1, ftlab2; ! 8: # endif ! 9: /* a lot of the machine dependent parts of the second pass */ ! 10: extern int fltfun; ! 11: # define BITMASK(n) ((1L<<n)-1) ! 12: ! 13: where(c) ! 14: { ! 15: fprintf( stderr, "%s, line %d: ", filename, lineno ); ! 16: } ! 17: ! 18: lineid( l, fn ) char *fn; ! 19: { ! 20: /* identify line l and file fn */ ! 21: printf( "# line %d, file %s\n", l, fn ); ! 22: } ! 23: ! 24: ! 25: eobl2() ! 26: { ! 27: OFFSZ spoff; /* offset from stack pointer */ ! 28: #ifndef FORT ! 29: extern int ftlab1, ftlab2; ! 30: #endif ! 31: ! 32: spoff = maxoff; ! 33: if( spoff >= AUTOINIT ) spoff -= AUTOINIT; ! 34: spoff /= SZCHAR; ! 35: SETOFF(spoff,4); ! 36: #ifdef FORT ! 37: #ifndef FLEXNAMES ! 38: printf(" .set .F%d,%ld\n",ftnno,spoff); ! 39: #else ! 40: /* Should be L%d ... ftnno, but must change pc/f77 */ ! 41: printf(" .set LF%d,%ld\n",ftnno,spoff); ! 42: #endif ! 43: #else ! 44: printf( "L%d:\n", ftlab1); ! 45: if( spoff!=0 ) ! 46: if( spoff < 64 ) ! 47: printf( " subl2 $%ld,sp\n", spoff); ! 48: else ! 49: printf( " movab -%ld(sp),sp\n", spoff); ! 50: printf( " jbr L%d\n", ftlab2); ! 51: maxargs = -1; ! 52: #endif ! 53: } ! 54: ! 55: struct hoptab { int opmask; char * opstring; } ioptab[] = { ! 56: ! 57: ASG PLUS, "add", ! 58: ASG MINUS, "sub", ! 59: ASG MUL, "mul", ! 60: ASG DIV, "div", ! 61: ASG OR, "bis", ! 62: ASG ER, "xor", ! 63: ASG AND, "bic", ! 64: PLUS, "add", ! 65: MINUS, "sub", ! 66: MUL, "mul", ! 67: DIV, "div", ! 68: OR, "bis", ! 69: ER, "xor", ! 70: AND, "bic", ! 71: -1, "" }; ! 72: ! 73: hopcode( f, o ) ! 74: { ! 75: /* output the appropriate string from the above table */ ! 76: ! 77: register struct hoptab *q; ! 78: ! 79: for( q = ioptab; q->opmask>=0; ++q ){ ! 80: if( q->opmask == o ){ ! 81: printf( "%s", q->opstring ); ! 82: /* tbl ! 83: if( f == 'F' ) printf( "e" ); ! 84: else if( f == 'D' ) printf( "d" ); ! 85: tbl */ ! 86: /* tbl */ ! 87: switch( f ) { ! 88: case 'L': ! 89: case 'W': ! 90: case 'B': ! 91: case 'D': ! 92: case 'F': ! 93: printf("%c", tolower(f)); ! 94: break; ! 95: ! 96: } ! 97: /* tbl */ ! 98: return; ! 99: } ! 100: } ! 101: cerror( "no hoptab for %s", opst[o] ); ! 102: } ! 103: ! 104: char * ! 105: rnames[] = { /* keyed to register number tokens */ ! 106: "r0", "r1", ! 107: "r2", "r3", "r4", "r5", ! 108: "r6", "r7", "r8", "r9", "r10", "r11", ! 109: "ap", "fp", "sp", "pc", ! 110: }; ! 111: ! 112: int rstatus[] = { ! 113: SAREG|STAREG, SAREG|STAREG, ! 114: SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, ! 115: SAREG, SAREG, SAREG, SAREG, SAREG, SAREG, ! 116: SAREG, SAREG, SAREG, SAREG, ! 117: }; ! 118: ! 119: tlen(p) NODE *p; ! 120: { ! 121: switch(p->in.type) { ! 122: case CHAR: ! 123: case UCHAR: ! 124: return(1); ! 125: ! 126: case SHORT: ! 127: case USHORT: ! 128: return(2); ! 129: ! 130: case DOUBLE: ! 131: return(8); ! 132: ! 133: default: ! 134: return(4); ! 135: } ! 136: } ! 137: ! 138: ! 139: mixtypes(p, q) NODE *p, *q; ! 140: { ! 141: register tp, tq; ! 142: ! 143: tp = p->in.type; ! 144: tq = q->in.type; ! 145: ! 146: return( (tp==FLOAT || tp==DOUBLE) != ! 147: (tq==FLOAT || tq==DOUBLE) ); ! 148: } ! 149: ! 150: prtype(n) NODE *n; ! 151: { ! 152: switch (n->in.type) ! 153: { ! 154: case DOUBLE: ! 155: printf("d"); ! 156: return; ! 157: ! 158: case FLOAT: ! 159: printf("f"); ! 160: return; ! 161: ! 162: case LONG: ! 163: case ULONG: ! 164: case INT: ! 165: case UNSIGNED: ! 166: printf("l"); ! 167: return; ! 168: ! 169: case SHORT: ! 170: case USHORT: ! 171: printf("w"); ! 172: return; ! 173: ! 174: case CHAR: ! 175: case UCHAR: ! 176: printf("b"); ! 177: return; ! 178: ! 179: default: ! 180: if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type"); ! 181: else { ! 182: printf("l"); ! 183: return; ! 184: } ! 185: } ! 186: } ! 187: ! 188: zzzcode( p, c ) register NODE *p; ! 189: { ! 190: register m; ! 191: CONSZ val; ! 192: switch( c ){ ! 193: ! 194: case 'N': /* logical ops, turned into 0-1 */ ! 195: /* use register given by register 1 */ ! 196: cbgen( 0, m=getlab(), 'I' ); ! 197: deflab( p->bn.label ); ! 198: printf( " clrl %s\n", temp = rnames[getlr( p, '1' )->tn.rval] ); ! 199: usedregs |= 1<<temp; ! 200: deflab( m ); ! 201: return; ! 202: ! 203: case 'I': ! 204: cbgen( p->in.op, p->bn.label, c ); ! 205: return; ! 206: ! 207: /* stack management macros */ ! 208: case '-': ! 209: printf( "sp@-"); ! 210: case 'P': ! 211: toff += 4; ! 212: if (toff > maxtoff) maxtoff = toff; ! 213: return; ! 214: ! 215: case '0': ! 216: toff = 0; return; ! 217: #endif ! 218: ! 219: case 'A': ! 220: { ! 221: register NODE *l, *r; ! 222: ! 223: if (xdebug) eprint(p, 0, &val, &val); ! 224: r = getlr(p, 'R'); ! 225: if (optype(p->in.op) == LTYPE || p->in.op == UNARY MUL) ! 226: { ! 227: l = resc; ! 228: l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? DOUBLE : INT); ! 229: } ! 230: else ! 231: l = getlr(p, 'L'); ! 232: if (r->in.op == ICON) ! 233: if(r->in.name[0] == '\0') ! 234: { ! 235: if (r->tn.lval == 0) ! 236: { ! 237: printf("clr"); ! 238: prtype(l); ! 239: printf(" "); ! 240: adrput(l); ! 241: return; ! 242: } ! 243: if (r->tn.lval < 0 && r->tn.lval >= -63) ! 244: { ! 245: printf("mneg"); ! 246: prtype(l); ! 247: r->tn.lval = -r->tn.lval; ! 248: goto ops; ! 249: } ! 250: r->in.type = (r->tn.lval < 0 ? ! 251: (r->tn.lval >= -128 ? CHAR ! 252: : (r->tn.lval >= -32768 ? SHORT ! 253: : INT )) : r->in.type); ! 254: r->in.type = (r->tn.lval >= 0 ? ! 255: (r->tn.lval <= 63 ? INT ! 256: : ( r->tn.lval <= 127 ? CHAR ! 257: : (r->tn.lval <= 255 ? UCHAR ! 258: : (r->tn.lval <= 32767 ? SHORT ! 259: : (r->tn.lval <= 65535 ? USHORT ! 260: : INT ))))) : r->in.type ); ! 261: } ! 262: else ! 263: { ! 264: printf("moval"); ! 265: printf(" "); ! 266: acon(r); ! 267: printf(","); ! 268: adrput(l); ! 269: return; ! 270: } ! 271: ! 272: if (l->in.op == REG && l->in.type != FLOAT && l->in.type != DOUBLE) ! 273: { ! 274: if( tlen(l) < tlen(r) ) ! 275: { ! 276: if (!mixtypes(l,r)) ! 277: { ! 278: !ISUNSIGNED(l->in.type)? ! 279: printf("cvt"): ! 280: printf("movz"); ! 281: prtype(l); ! 282: printf("l"); ! 283: goto ops; ! 284: } ! 285: else ! 286: { ! 287: printf("cvt"); ! 288: prtype(r); ! 289: prtype(l); ! 290: printf(" "); ! 291: adrput(r); ! 292: printf(","); ! 293: adrput(l); ! 294: printf("cvt"); ! 295: prtype(l); ! 296: printf("l"); ! 297: printf(" "); ! 298: adrput(l); ! 299: printf(","); ! 300: adrput(l); ! 301: return; ! 302: } ! 303: } ! 304: else ! 305: { ! 306: l->in.type = INT; ! 307: } ! 308: } ! 309: if (!mixtypes(l,r)) ! 310: { ! 311: if (tlen(l) == tlen(r)) ! 312: { ! 313: printf("mov"); ! 314: prtype(l); ! 315: goto ops; ! 316: } ! 317: else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type)) ! 318: { ! 319: printf("movz"); ! 320: } ! 321: else ! 322: { ! 323: printf("cvt"); ! 324: } ! 325: } ! 326: else ! 327: { ! 328: printf("cvt"); ! 329: } ! 330: prtype(r); ! 331: prtype(l); ! 332: ops: ! 333: printf(" "); ! 334: adrput(r); ! 335: printf(","); ! 336: adrput(l); ! 337: return; ! 338: } ! 339: ! 340: case 'B': /* get oreg value in temp register for left shift */ ! 341: { ! 342: register NODE *r; ! 343: if (xdebug) eprint(p, 0, &val, &val); ! 344: r = p->in.right; ! 345: if( tlen(r) == sizeof(int) && r->in.type != FLOAT ) ! 346: printf("movl"); ! 347: else { ! 348: printf("cvt"); ! 349: prtype(r); ! 350: printf("l"); ! 351: } ! 352: return; ! 353: } ! 354: ! 355: case 'C': /* num words pushed on arg stack */ ! 356: { ! 357: extern int gc_numbytes; ! 358: extern int xdebug; ! 359: ! 360: if (xdebug) printf("->%d<-",gc_numbytes); ! 361: ! 362: printf("$%d", gc_numbytes/(SZLONG/SZCHAR) ); ! 363: return; ! 364: } ! 365: ! 366: case 'D': /* INCR and DECR */ ! 367: zzzcode(p->in.left, 'A'); ! 368: printf("\n "); ! 369: ! 370: case 'E': /* INCR and DECR, FOREFF */ ! 371: if (p->in.right->tn.lval == 1) ! 372: { ! 373: printf("%s", (p->in.op == INCR ? "inc" : "dec") ); ! 374: prtype(p->in.left); ! 375: printf(" "); ! 376: adrput(p->in.left); ! 377: return; ! 378: } ! 379: printf("%s", (p->in.op == INCR ? "add" : "sub") ); ! 380: prtype(p->in.left); ! 381: printf("2 "); ! 382: adrput(p->in.right); ! 383: printf(","); ! 384: adrput(p->in.left); ! 385: return; ! 386: ! 387: case 'F': /* register type of right operand */ ! 388: { ! 389: register NODE *n; ! 390: extern int xdebug; ! 391: register int ty; ! 392: ! 393: n = getlr( p, 'R' ); ! 394: ty = n->in.type; ! 395: ! 396: if (xdebug) printf("->%d<-", ty); ! 397: ! 398: if ( ty==DOUBLE) printf("d"); ! 399: else if ( ty==FLOAT ) printf("f"); ! 400: else printf("l"); ! 401: return; ! 402: } ! 403: ! 404: case 'L': /* type of left operand */ ! 405: case 'R': /* type of right operand */ ! 406: { ! 407: register NODE *n; ! 408: extern int xdebug; ! 409: ! 410: n = getlr ( p, c); ! 411: if (xdebug) printf("->%d<-", n->in.type); ! 412: ! 413: prtype(n); ! 414: return; ! 415: } ! 416: ! 417: case 'Z': /* complement mask for bit instr */ ! 418: printf("$%ld", ~p->in.right->tn.lval); ! 419: return; ! 420: ! 421: case 'U': /* 32 - n, for unsigned right shifts */ ! 422: printf("$%d", 32 - p->in.right->tn.lval ); ! 423: return; ! 424: ! 425: case 'T': /* rounded structure length for arguments */ ! 426: { ! 427: int size; ! 428: ! 429: size = p->stn.stsize; ! 430: SETOFF( size, 4); ! 431: printf("$%d", size); ! 432: return; ! 433: } ! 434: ! 435: case 'S': /* structure assignment */ ! 436: { ! 437: register NODE *l, *r; ! 438: register size; ! 439: ! 440: if( p->in.op == STASG ){ ! 441: l = p->in.left; ! 442: r = p->in.right; ! 443: ! 444: } ! 445: else if( p->in.op == STARG ){ /* store an arg into a temporary */ ! 446: l = getlr( p, '3' ); ! 447: r = p->in.left; ! 448: } ! 449: else cerror( "STASG bad" ); ! 450: ! 451: if( r->in.op == ICON ) r->in.op = NAME; ! 452: else if( r->in.op == REG ) r->in.op = OREG; ! 453: else if( r->in.op != OREG ) cerror( "STASG-r" ); ! 454: ! 455: size = p->stn.stsize; ! 456: ! 457: if( size <= 0 || size > 65535 ) ! 458: cerror("structure size <0=0 or >65535"); ! 459: ! 460: switch(size) { ! 461: case 1: ! 462: printf(" movb "); ! 463: break; ! 464: case 2: ! 465: printf(" movw "); ! 466: break; ! 467: case 4: ! 468: printf(" movl "); ! 469: break; ! 470: case 8: ! 471: printf(" movq "); ! 472: break; ! 473: default: ! 474: printf(" movc3 $%d,", size); ! 475: break; ! 476: } ! 477: adrput(r); ! 478: printf(","); ! 479: adrput(l); ! 480: printf("\n"); ! 481: ! 482: if( r->in.op == NAME ) r->in.op = ICON; ! 483: else if( r->in.op == OREG ) r->in.op = REG; ! 484: ! 485: } ! 486: break; ! 487: ! 488: default: ! 489: cerror( "illegal zzzcode" ); ! 490: } ! 491: } ! 492: ! 493: ! 494: rmove( rt, rs, t ) ! 495: { ! 496: printf( " %s %s,%s\n", ! 497: (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), ! 498: rnames[rs], rnames[rt] ); ! 499: } ! 500: ! 501: struct respref ! 502: respref[] = { ! 503: INTAREG|INTBREG, INTAREG|INTBREG, ! 504: INAREG|INBREG, INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON, ! 505: INTEMP, INTEMP, ! 506: FORARG, FORARG, ! 507: INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM, ! 508: 0, 0 }; ! 509: ! 510: setregs() ! 511: { /* set up temporary registers */ ! 512: fregs = 6; /* tbl- 6 free regs on VAX (0-5) */ ! 513: ; ! 514: } ! 515: ! 516: szty(t) ! 517: { /* size, in registers, needed to hold thing of type t */ ! 518: return( (t==DOUBLE||t==FLOAT) ? 2 : 1 ); ! 519: } ! 520: ! 521: rewfld( p ) NODE *p; ! 522: { ! 523: return(1); ! 524: } ! 525: ! 526: callreg(p) NODE *p; ! 527: { ! 528: return( R0 ); ! 529: } ! 530: /* BEGIN haven't touched yet */ ! 531: ! 532: base( p ) register NODE *p; ! 533: { ! 534: register int o = p->in.op; ! 535: ! 536: if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */ ! 537: if( o==REG ) return( p->tn.rval ); ! 538: if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON) ! 539: return( p->in.left->tn.rval ); ! 540: if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) ! 541: return( p->tn.rval + 0200*1 ); ! 542: if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 ); ! 543: if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 ); ! 544: if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG ! 545: && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) ! 546: return( p->in.left->in.left->tn.rval + 0200*(1+2) ); ! 547: return( -1 ); ! 548: } ! 549: ! 550: offset( p, tyl ) register NODE *p; int tyl; ! 551: { ! 552: ! 553: if( tyl==1 && p->in.op==REG && (p->in.type==INT || p->in.type==UNSIGNED) ) return( p->tn.rval ); ! 554: if( (p->in.op==LS && p->in.left->in.op==REG && (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) && ! 555: (p->in.right->in.op==ICON && p->in.right->in.name[0]=='\0') ! 556: && (1<<p->in.right->tn.lval)==tyl)) ! 557: return( p->in.left->tn.rval ); ! 558: return( -1 ); ! 559: } ! 560: ! 561: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; ! 562: { ! 563: register NODE *t; ! 564: register int i; ! 565: NODE *f; ! 566: ! 567: p->in.op = OREG; ! 568: f = p->in.left; /* have to free this subtree later */ ! 569: ! 570: /* init base */ ! 571: switch (q->in.op) { ! 572: case ICON: ! 573: case REG: ! 574: case OREG: ! 575: t = q; ! 576: break; ! 577: ! 578: case MINUS: ! 579: q->in.right->tn.lval = -q->in.right->tn.lval; ! 580: case PLUS: ! 581: t = q->in.right; ! 582: break; ! 583: ! 584: case INCR: ! 585: case ASG MINUS: ! 586: t = q->in.left; ! 587: break; ! 588: ! 589: case UNARY MUL: ! 590: t = q->in.left->in.left; ! 591: break; ! 592: ! 593: default: ! 594: cerror("illegal makeor2"); ! 595: } ! 596: ! 597: p->tn.lval = t->tn.lval; ! 598: #ifndef FLEXNAMES ! 599: for(i=0; i<NCHNAM; ++i) ! 600: p->in.name[i] = t->in.name[i]; ! 601: #else ! 602: p->in.name = t->in.name; ! 603: #endif ! 604: ! 605: /* init offset */ ! 606: p->tn.rval = R2PACK( (b & 0177), o, (b>>7) ); ! 607: ! 608: tfree(f); ! 609: return; ! 610: } ! 611: ! 612: canaddr( p ) NODE *p; ! 613: { ! 614: register int o = p->in.op; ! 615: ! 616: if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1); ! 617: return(0); ! 618: } ! 619: ! 620: /* END haven't touched yet */ ! 621: ! 622: shltype( o, p ) register NODE *p; ! 623: { ! 624: return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->in.left)) ); ! 625: } ! 626: ! 627: flshape( p ) register NODE *p; ! 628: { ! 629: return( p->in.op == REG || p->in.op == NAME || p->in.op == ICON || ! 630: (p->in.op == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) ); ! 631: } ! 632: ! 633: shtemp( p ) register NODE *p; ! 634: { ! 635: if( p->in.op == STARG ) p = p->in.left; ! 636: return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) ); ! 637: } ! 638: ! 639: ! 640: shumul( p ) register NODE *p; ! 641: { ! 642: register o; ! 643: extern int xdebug; ! 644: ! 645: if (xdebug) { ! 646: printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op); ! 647: printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval); ! 648: } ! 649: ! 650: ! 651: o = p->in.op; ! 652: if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM ); ! 653: ! 654: if( ( o == INCR || o == ASG MINUS ) && ! 655: ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) && ! 656: p->in.right->in.name[0] == '\0' ) ! 657: { ! 658: switch (p->in.left->in.type) ! 659: { ! 660: case CHAR|PTR: ! 661: case UCHAR|PTR: ! 662: o = 1; ! 663: break; ! 664: ! 665: case SHORT|PTR: ! 666: case USHORT|PTR: ! 667: o = 2; ! 668: break; ! 669: ! 670: case INT|PTR: ! 671: case UNSIGNED|PTR: ! 672: case LONG|PTR: ! 673: case ULONG|PTR: ! 674: case FLOAT|PTR: ! 675: o = 4; ! 676: break; ! 677: ! 678: case DOUBLE|PTR: ! 679: o = 8; ! 680: break; ! 681: ! 682: default: ! 683: if ( ISPTR(p->in.left->in.type) ) { ! 684: o = 4; ! 685: break; ! 686: } ! 687: else return(0); ! 688: } ! 689: return( p->in.right->tn.lval == o ? STARREG : 0); ! 690: } ! 691: ! 692: return( 0 ); ! 693: } ! 694: ! 695: adrcon( val ) CONSZ val; ! 696: { ! 697: printf( "$" ); ! 698: printf( CONFMT, val ); ! 699: } ! 700: ! 701: conput( p ) register NODE *p; ! 702: { ! 703: switch( p->in.op ){ ! 704: ! 705: case ICON: ! 706: acon( p ); ! 707: return; ! 708: ! 709: case REG: ! 710: printf( "%s", rnames[p->tn.rval] ); ! 711: return; ! 712: ! 713: default: ! 714: cerror( "illegal conput" ); ! 715: } ! 716: } ! 717: ! 718: insput( p ) register NODE *p; ! 719: { ! 720: cerror( "insput" ); ! 721: } ! 722: ! 723: upput( p ) register NODE *p; ! 724: { ! 725: cerror( "upput" ); ! 726: } ! 727: ! 728: adrput( p ) register NODE *p; ! 729: { ! 730: /* the 68k code saves lval and restores after the switch */ ! 731: register int r; ! 732: /* output an address, with offsets, from p */ ! 733: ! 734: if( p->in.op == FLD ){ ! 735: p = p->in.left; ! 736: } ! 737: switch( p->in.op ){ ! 738: ! 739: case NAME: ! 740: acon( p ); ! 741: return; ! 742: ! 743: case ICON: ! 744: /* addressable value of the constant */ ! 745: printf( "$" ); ! 746: acon( p ); ! 747: return; ! 748: ! 749: case REG: ! 750: printf( "%s", rnames[p->tn.rval] ); ! 751: return; ! 752: ! 753: case OREG: ! 754: r = p->tn.rval; ! 755: if( R2TEST(r) ){ /* double indexing */ ! 756: register int flags; ! 757: ! 758: flags = R2UPK3(r); ! 759: if( flags & 1 ) printf("*"); ! 760: if( flags & 4 ) printf("-"); ! 761: if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p); ! 762: if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] ); ! 763: if( flags & 2 ) printf("+"); ! 764: printf( "[%s]", rnames[R2UPK2(r)] ); ! 765: return; ! 766: } ! 767: if( r == AP ){ /* in the argument region */ ! 768: if( p->tn.lval <= 0 || p->in.name[0] != '\0' ) werror( "bad arg temp" ); ! 769: printf( CONFMT, p->tn.lval ); ! 770: printf( "(ap)" ); ! 771: return; ! 772: } ! 773: if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p ); ! 774: printf( "(%s)", rnames[p->tn.rval] ); ! 775: return; ! 776: ! 777: case UNARY MUL: ! 778: /* STARNM or STARREG found */ ! 779: if( tshape(p, STARNM) ) { ! 780: printf( "*" ); ! 781: adrput( p->in.left); ! 782: } ! 783: else { /* STARREG - really auto inc or dec */ ! 784: register NODE *q; ! 785: ! 786: /* tbl ! 787: p = p->in.left; ! 788: p->in.left->in.op = OREG; ! 789: if( p->in.op == INCR ) { ! 790: adrput( p->in.left ); ! 791: printf( "+" ); ! 792: } ! 793: else { ! 794: printf( "-" ); ! 795: adrput( p->in.left ); ! 796: } ! 797: tbl */ ! 798: printf("%s(%s)%s", (p->in.left->in.op==INCR ? "" : "-"), ! 799: rnames[p->in.left->in.left->tn.rval], ! 800: (p->in.left->in.op==INCR ? "+" : "") ); ! 801: p->in.op = OREG; ! 802: p->tn.rval = p->in.left->in.left->tn.rval; ! 803: q = p->in.left; ! 804: p->tn.lval = (p->in.left->in.op == INCR ? -p->in.left->in.right->tn.lval : 0); ! 805: #ifndef FLEXNAMES ! 806: p->in.name[0] = '\0'; ! 807: #else ! 808: p->in.name = ""; ! 809: #endif ! 810: tfree(q); ! 811: } ! 812: return; ! 813: ! 814: ! 815: default: ! 816: cerror( "illegal address" ); ! 817: return; ! 818: ! 819: } ! 820: ! 821: } ! 822: ! 823: acon( p ) register NODE *p; ! 824: { /* print out a constant */ ! 825: ! 826: if( p->in.name[0] == '\0' ){ ! 827: printf( CONFMT, p->tn.lval); ! 828: } ! 829: else if( p->tn.lval == 0 ) { ! 830: #ifndef FLEXNAMES ! 831: printf( "%.8s", p->in.name ); ! 832: #else ! 833: printf( "%s", p->in.name ); ! 834: #endif ! 835: } ! 836: else { ! 837: #ifndef FLEXNAMES ! 838: printf( "%.8s+", p->in.name ); ! 839: #else ! 840: printf( "%s+", p->in.name ); ! 841: #endif ! 842: printf( CONFMT, p->tn.lval ); ! 843: } ! 844: } ! 845: ! 846: /* ! 847: aacon( p ) register NODE *p; ! 848: { /* print out a constant */ ! 849: /* ! 850: ! 851: if( p->in.name[0] == '\0' ){ ! 852: printf( CONFMT, p->tn.lval); ! 853: return( 0 ); ! 854: } ! 855: else if( p->tn.lval == 0 ) { ! 856: #ifndef FLEXNAMES ! 857: printf( "$%.8s", p->in.name ); ! 858: #else ! 859: printf( "$%s", p->in.name ); ! 860: #endif ! 861: return( 1 ); ! 862: } ! 863: else { ! 864: printf( "$(" ); ! 865: printf( CONFMT, p->tn.lval ); ! 866: printf( "+" ); ! 867: #ifndef FLEXNAMES ! 868: printf( "%.8s)", p->in.name ); ! 869: #else ! 870: printf( "%s)", p->in.name ); ! 871: #endif ! 872: return(1); ! 873: } ! 874: } ! 875: */ ! 876: ! 877: genscall( p, cookie ) register NODE *p; ! 878: { ! 879: /* structure valued call */ ! 880: return( gencall( p, cookie ) ); ! 881: } ! 882: ! 883: /* tbl */ ! 884: int gc_numbytes; ! 885: /* tbl */ ! 886: ! 887: gencall( p, cookie ) register NODE *p; ! 888: { ! 889: /* generate the call given by p */ ! 890: register NODE *p1, *ptemp; ! 891: register temp, temp1; ! 892: register m; ! 893: ! 894: if( p->in.right ) temp = argsize( p->in.right ); ! 895: else temp = 0; ! 896: ! 897: if( p->in.op == STCALL || p->in.op == UNARY STCALL ){ ! 898: /* set aside room for structure return */ ! 899: ! 900: if( p->stn.stsize > temp ) temp1 = p->stn.stsize; ! 901: else temp1 = temp; ! 902: } ! 903: ! 904: if( temp > maxargs ) maxargs = temp; ! 905: SETOFF(temp1,4); ! 906: ! 907: if( p->in.right ){ /* make temp node, put offset in, and generate args */ ! 908: ptemp = talloc(); ! 909: ptemp->in.op = OREG; ! 910: ptemp->tn.lval = -1; ! 911: ptemp->tn.rval = SP; ! 912: #ifndef FLEXNAMES ! 913: ptemp->in.name[0] = '\0'; ! 914: #else ! 915: ptemp->in.name = ""; ! 916: #endif ! 917: ptemp->in.rall = NOPREF; ! 918: ptemp->in.su = 0; ! 919: genargs( p->in.right, ptemp ); ! 920: ptemp->in.op = FREE; ! 921: } ! 922: ! 923: p1 = p->in.left; ! 924: if( p1->in.op != ICON ){ ! 925: if( p1->in.op != REG ){ ! 926: if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){ ! 927: if( p1->in.op != NAME ){ ! 928: order( p1, INAREG ); ! 929: } ! 930: } ! 931: } ! 932: } ! 933: ! 934: /* ! 935: if( p1->in.op == REG && p->tn.rval == R5 ){ ! 936: cerror( "call register overwrite" ); ! 937: } ! 938: */ ! 939: /* tbl ! 940: setup gc_numbytes so reference to ZC works */ ! 941: ! 942: gc_numbytes = temp&(0x3ff); ! 943: /* tbl */ ! 944: ! 945: p->in.op = UNARY CALL; ! 946: m = match( p, INTAREG|INTBREG ); ! 947: ! 948: /* compensate for deficiency in 'ret' instruction ... wah,kre */ ! 949: /* (plus in assignment to gc_numbytes above, for neatness only) */ ! 950: if (temp >= 1024) ! 951: printf(" addl2 $%d,sp\n", (temp&(~0x3ff))); ! 952: ! 953: /* tbl ! 954: switch( temp ) { ! 955: case 0: ! 956: break; ! 957: case 2: ! 958: printf( " tst (sp)+\n" ); ! 959: break; ! 960: case 4: ! 961: printf( " cmp (sp)+,(sp)+\n" ); ! 962: break; ! 963: default: ! 964: printf( " add $%d,sp\n", temp); ! 965: } ! 966: tbl */ ! 967: return(m != MDONE); ! 968: } ! 969: ! 970: ! 971: /* tbl */ ! 972: char * ! 973: ccbranches[] = { ! 974: " jeql L%d\n", ! 975: " jneq L%d\n", ! 976: " jleq L%d\n", ! 977: " jlss L%d\n", ! 978: " jgeq L%d\n", ! 979: " jgtr L%d\n", ! 980: " jlequ L%d\n", ! 981: " jlssu L%d\n", ! 982: " jgequ L%d\n", ! 983: " jgtru L%d\n", ! 984: }; ! 985: ! 986: /* tbl */ ! 987: ! 988: cbgen( o, lab, mode ) ! 989: { /* printf conditional and unconditional branches */ ! 990: ! 991: /* tbl */ ! 992: if( o == 0 ) printf( " jbr L%d\n", lab ); ! 993: /* tbl */ ! 994: else { ! 995: if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] ); ! 996: printf( ccbranches[o-EQ], lab ); ! 997: } ! 998: } ! 999: ! 1000: nextcook( p, cookie ) NODE *p; ! 1001: { ! 1002: /* we have failed to match p with cookie; try another */ ! 1003: if( cookie == FORREW ) return( 0 ); /* hopeless! */ ! 1004: if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG ); ! 1005: if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG ); ! 1006: return( FORREW ); ! 1007: } ! 1008: ! 1009: lastchance( p, cook ) NODE *p; ! 1010: { ! 1011: /* forget it! */ ! 1012: return(0); ! 1013: } ! 1014: ! 1015: optim2( p ) register NODE *p; ! 1016: { ! 1017: /* do local tree transformations and optimizations */ ! 1018: ! 1019: register NODE *r; ! 1020: ! 1021: switch( p->in.op ) { ! 1022: ! 1023: case AND: ! 1024: /* commute L and R to eliminate compliments and constants */ ! 1025: if( (p->in.left->in.op==ICON&&p->in.left->in.name[0]==0) || p->in.left->in.op==COMPL ) { ! 1026: r = p->in.left; ! 1027: p->in.left = p->in.right; ! 1028: p->in.right = r; ! 1029: } ! 1030: case ASG AND: ! 1031: /* change meaning of AND to ~R&L - bic on pdp11 */ ! 1032: r = p->in.right; ! 1033: if( r->in.op==ICON && r->in.name[0]==0 ) { /* compliment constant */ ! 1034: r->tn.lval = ~r->tn.lval; ! 1035: } ! 1036: else if( r->in.op==COMPL ) { /* ~~A => A */ ! 1037: r->in.op = FREE; ! 1038: p->in.right = r->in.left; ! 1039: } ! 1040: else { /* insert complement node */ ! 1041: p->in.right = talloc(); ! 1042: p->in.right->in.op = COMPL; ! 1043: p->in.right->in.rall = NOPREF; ! 1044: p->in.right->in.type = r->in.type; ! 1045: p->in.right->in.left = r; ! 1046: p->in.right->in.right = NULL; ! 1047: } ! 1048: break; ! 1049: ! 1050: } ! 1051: } ! 1052: ! 1053: NODE * addroreg(l) ! 1054: /* OREG was built in clocal() ! 1055: * for an auto or formal parameter ! 1056: * now its address is being taken ! 1057: * local code must unwind it ! 1058: * back to PLUS/MINUS REG ICON ! 1059: * according to local conventions ! 1060: */ ! 1061: { ! 1062: cerror("address of OREG taken"); ! 1063: } ! 1064: ! 1065: ! 1066: ! 1067: # ifndef ONEPASS ! 1068: main( argc, argv ) char *argv[]; ! 1069: { ! 1070: return( mainp2( argc, argv ) ); ! 1071: } ! 1072: # endif ! 1073: ! 1074: ! 1075: /* added by jwf */ ! 1076: struct functbl { ! 1077: int fop; ! 1078: TWORD ftype; ! 1079: char *func; ! 1080: } opfunc[] = { ! 1081: DIV, TANY, "udiv", ! 1082: MOD, TANY, "urem", ! 1083: ASG DIV, TANY, "udiv", ! 1084: ASG MOD, TANY, "urem", ! 1085: 0, 0, 0 }; ! 1086: ! 1087: hardops(p) register NODE *p; ! 1088: { ! 1089: /* change hard to do operators into function calls. */ ! 1090: register NODE *q; ! 1091: register struct functbl *f; ! 1092: register o; ! 1093: register TWORD t; ! 1094: ! 1095: o = p->in.op; ! 1096: t = p->in.type; ! 1097: if( t!=UNSIGNED && t!=ULONG ) return; ! 1098: ! 1099: for( f=opfunc; f->fop; f++ ) { ! 1100: if( o==f->fop ) goto convert; ! 1101: } ! 1102: return; ! 1103: ! 1104: /* need to rewrite tree for ASG OP */ ! 1105: /* must change ASG OP to a simple OP */ ! 1106: convert: ! 1107: if( asgop( o ) ) { ! 1108: q = talloc(); ! 1109: switch( p->in.op ) { ! 1110: case ASG DIV: ! 1111: q->in.op = DIV; ! 1112: break; ! 1113: case ASG MOD: ! 1114: q->in.op = MOD; ! 1115: break; ! 1116: } ! 1117: q->in.rall = NOPREF; ! 1118: q->in.type = p->in.type; ! 1119: q->in.left = tcopy(p->in.left); ! 1120: q->in.right = p->in.right; ! 1121: p->in.op = ASSIGN; ! 1122: p->in.right = q; ! 1123: zappost(q->in.left); /* remove post-INCR(DECR) from new node */ ! 1124: fixpre(q->in.left); /* change pre-INCR(DECR) to +/- */ ! 1125: p = q; ! 1126: ! 1127: } ! 1128: ! 1129: /* build comma op for args to function */ ! 1130: q = talloc(); ! 1131: q->in.op = CM; ! 1132: q->in.rall = NOPREF; ! 1133: q->in.type = INT; ! 1134: q->in.left = p->in.left; ! 1135: q->in.right = p->in.right; ! 1136: p->in.op = CALL; ! 1137: p->in.right = q; ! 1138: ! 1139: /* put function name in left node of call */ ! 1140: p->in.left = q = talloc(); ! 1141: q->in.op = ICON; ! 1142: q->in.rall = NOPREF; ! 1143: q->in.type = INCREF( FTN + p->in.type ); ! 1144: #ifndef FLEXNAMES ! 1145: strcpy( q->in.name, f->func ); ! 1146: #else ! 1147: q->in.name = f->func; ! 1148: #endif ! 1149: q->tn.lval = 0; ! 1150: q->tn.rval = 0; ! 1151: ! 1152: return; ! 1153: ! 1154: } ! 1155: ! 1156: zappost(p) NODE *p; ! 1157: { ! 1158: /* look for ++ and -- operators and remove them */ ! 1159: ! 1160: register o, ty; ! 1161: register NODE *q; ! 1162: o = p->in.op; ! 1163: ty = optype( o ); ! 1164: ! 1165: switch( o ){ ! 1166: ! 1167: case INCR: ! 1168: case DECR: ! 1169: q = p->in.left; ! 1170: p->in.right->in.op = FREE; /* zap constant */ ! 1171: ncopy( p, q ); ! 1172: q->in.op = FREE; ! 1173: return; ! 1174: ! 1175: } ! 1176: ! 1177: if( ty == BITYPE ) zappost( p->in.right ); ! 1178: if( ty != LTYPE ) zappost( p->in.left ); ! 1179: } ! 1180: ! 1181: fixpre(p) NODE *p; ! 1182: { ! 1183: ! 1184: register o, ty; ! 1185: o = p->in.op; ! 1186: ty = optype( o ); ! 1187: ! 1188: switch( o ){ ! 1189: ! 1190: case ASG PLUS: ! 1191: p->in.op = PLUS; ! 1192: break; ! 1193: case ASG MINUS: ! 1194: p->in.op = MINUS; ! 1195: break; ! 1196: } ! 1197: ! 1198: if( ty == BITYPE ) fixpre( p->in.right ); ! 1199: if( ty != LTYPE ) fixpre( p->in.left ); ! 1200: } ! 1201: ! 1202: myreader(p) register NODE *p; ! 1203: { ! 1204: walkf( p, hardops ); /* convert ops to function calls */ ! 1205: canon( p ); /* expands r-vals for fileds */ ! 1206: walkf( p, optim2 ); ! 1207: /* jwf toff = 0; /* stack offset swindle */ ! 1208: } ! 1209:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.