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