![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cgen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / ccom / common|
Return to cgen.c CVS log | Up to [Research Unix] / researchv8dc / cmd / ccom / common |
1.1 ! root 1: /* @(#) cgen.c: 1.2 1/12/84 */ ! 2: ! 3: # include "mfile2.h" ! 4: # define istnode(p) (p->in.op==REG && istreg(p->tn.rval)) ! 5: ! 6: /* ! 7: ** For God's workes are, like him, all infinite ! 8: ** And curious search but craftie sin's delight. ! 9: */ ! 10: ! 11: rewcom( p, goal ) ! 12: NODE *p; ! 13: ! 14: { ! 15: /* find all , ops, move as high as is legal */ ! 16: /* rewrite p in place; this takes some doing! */ ! 17: /* while we are at it, take care of setting the goal field */ ! 18: int o, ty, g1, g2; ! 19: NODE *l, *r, *ql, *qr; ! 20: ! 21: o = p->tn.op; ! 22: g1 = g2 = NRGS; ! 23: p->tn.goal = goal; ! 24: ! 25: /* special cases for subtrees: ! 26: ** GENBR has left as Condition codes ! 27: ** COMOP has left as Effects ! 28: ** COLON, GENUBR, CM, GENLAB have descendents = node ! 29: ** CALL, STCALL, FORTCALL has right as Effects ! 30: ** All others use registers ! 31: */ ! 32: ! 33: switch( o ) ! 34: { ! 35: ! 36: case FREE: ! 37: cerror( "rewcom(%d) is FREE", p-node ); ! 38: ! 39: case GENBR: ! 40: g1 = CCC; ! 41: break; ! 42: ! 43: case COMOP: ! 44: g1 = CEFF; ! 45: g2 = goal; ! 46: break; ! 47: ! 48: case COLON: ! 49: case GENUBR: ! 50: case CM: ! 51: case GENLAB: ! 52: g1 = g2 = goal; ! 53: break; ! 54: ! 55: case CALL: ! 56: case STCALL: ! 57: case FORTCALL: ! 58: g2 = CEFF; ! 59: break; ! 60: } ! 61: ! 62: ! 63: switch( ty = optype(o) ) ! 64: { ! 65: ! 66: case BITYPE: ! 67: rewcom( r = p->in.right, g2 ); ! 68: case UTYPE: ! 69: rewcom( l = p->in.left, g1 ); ! 70: break; ! 71: case LTYPE: ! 72: return; ! 73: } ! 74: ! 75: if( o==COMOP || o==COLON || o==GENLAB ) return; ! 76: ! 77: /* look for (A,B) op C and A op (B,C), and rewrite */ ! 78: /* A,B if A headed by GENBR can't be rewritten */ ! 79: /* the assumption is that B is executed immediately after A, */ ! 80: /* and this won't necessarily be true if op is commutative */ ! 81: ! 82: if( l->tn.op == COMOP && l->in.left->tn.op != GENBR ) ! 83: { ! 84: /* rewrite it... */ ! 85: /* (A,B) op C => A,(B op C) */ ! 86: /* also, for unary ops, op (A,B) => A , (op B) */ ! 87: ql = l->in.left; ! 88: qr = l->in.right; ! 89: *l = *p; /* copies op, and other stuff if op is unary */ ! 90: l->in.left = qr; ! 91: p->in.right = l; ! 92: p->in.left = ql; ! 93: p->tn.op = COMOP; ! 94: rewcom( p, p->tn.goal ); ! 95: } ! 96: if( ty == UTYPE ) return; ! 97: if( r->tn.op == COMOP && r->in.right->tn.op != GENBR ) ! 98: { ! 99: /* rewrite, again */ ! 100: /* A op (B,C) => B,(A op C) */ ! 101: /* op is not unary now */ ! 102: ql = r->in.left; ! 103: qr = r->in.right; ! 104: *r = *p; ! 105: p->tn.op = COMOP; ! 106: p->in.left = ql; ! 107: r->in.right = qr; ! 108: rewcom( p, p->tn.goal ); ! 109: } ! 110: } ! 111: ! 112: rewlhs(p) ! 113: NODE *p; ! 114: ! 115: { ! 116: /* rewrite x op= y as (x op= y),x */ ! 117: /* it would be really nice to optimize after doing this . . . */ ! 118: NODE *q, *t; ! 119: q = talloc(); ! 120: *q = *p; ! 121: t = tcopy( p->in.left, 0 ); ! 122: p->in.left = q; ! 123: p->in.right = t; ! 124: p->tn.op = COMOP; ! 125: return; ! 126: } ! 127: ! 128: rewsto(p) ! 129: NODE *p; ! 130: { ! 131: /* a temp, t, is generated, and p is rewritten as ((t=p),t) */ ! 132: /* if p has the form x op= A, and x is of the right form, rewrite ! 133: /* as ((x op= A), x) */ ! 134: ! 135: int o, ao; ! 136: NODE *t, *q; ! 137: /* probably not perfect for structs: CHECK UP.. */ ! 138: ! 139: while( (o=p->tn.op) == COMOP ) p = p->in.right; ! 140: if( o == TEMP ) return(0); /* nothing to do */ ! 141: if( o == STARG ) ! 142: { ! 143: /* store a structure argument */ /* like storing a usual argument, but we have addresses */ ! 144: ! 145: t = talloc(); ! 146: *t = *p->in.left; /* copy contents, mainly for type, etc. */ ! 147: q = talloc(); ! 148: *q = *t; ! 149: t->tn.op = TEMP; ! 150: t->tn.lval = freetemp(argsize(p)/SZINT ); ! 151: t->tn.lval = BITOOR(t->tn.lval); ! 152: t->tn.name = (char *) 0; ! 153: t->tn.type = TSTRUCT; ! 154: q->tn.op = UNARY AND; ! 155: q->in.left = t; ! 156: /* now, q has & TEMP */ ! 157: t = talloc(); ! 158: *t = *p; ! 159: t->in.left = q; ! 160: t->in.right = p->in.left; ! 161: t->tn.op = STASG; ! 162: /* now, t has (&TEMP) = struct */ ! 163: p->in.left = talloc(); ! 164: p->in.left->tn.op = COMOP; ! 165: p->in.left->in.left = t; ! 166: p->in.left->in.right = t = talloc(); /* copy q here */ ! 167: *t = *q; ! 168: t->in.left = talloc(); ! 169: *t->in.left = *q->in.left; ! 170: /* finally, have (&TEMP = struct),(&TEMP) */ ! 171: /* this should do it: whew! */ ! 172: #ifndef NODBG ! 173: if( odebug>1 ) e2print( p ); ! 174: #endif ! 175: return( 1 ); ! 176: } ! 177: ! 178: #ifndef NODBG ! 179: if( odebug>1 ) ! 180: { ! 181: e2print( p ); ! 182: printf( "\nrewritten by rewsto as:\n" ); ! 183: } ! 184: #endif ! 185: if( asgop(o) && o!=INCR && o!=DECR && lhsok( p->in.left ) ) { ! 186: /* x op= y turns into (x op= y), x */ ! 187: rewlhs( p ); ! 188: return( 1 ); ! 189: } ! 190: ao = ASG o; ! 191: if( asgbinop(ao) ) ! 192: { ! 193: if( p->in.left->tn.op == TEMP ) ! 194: { ! 195: p->tn.op = ao; ! 196: rewlhs( p ); ! 197: #ifndef NODBG ! 198: if( odebug>1 ) e2print( p ); ! 199: #endif ! 200: return( 1 ); ! 201: } ! 202: } ! 203: ! 204: /* to rewrite in place, p becomes a COMOP; rhs is the temp, lsh ! 205: ** /* is t = p, where p has been converted to the intermediate type ! 206: */ ! 207: /* after some debate, the type of the temp will be the type of p */ ! 208: ! 209: t = talloc(); ! 210: *t = *p; /* copy contents, mainly for type, etc. */ ! 211: q = talloc(); ! 212: *q = *p; ! 213: t->tn.op = TEMP; ! 214: t->tn.lval = freetemp(argsize(p)/SZINT ); ! 215: t->tn.lval = BITOOR(t->tn.lval); ! 216: t->tn.name = (char *) 0; ! 217: q->tn.op = ASSIGN; ! 218: q->in.left = t; ! 219: q->in.right = talloc(); ! 220: *(q->in.right) = *p; ! 221: /* now, q has (t=p) */ ! 222: p->in.right = talloc(); ! 223: *(p->in.right) = *t; ! 224: p->tn.op = COMOP; ! 225: p->in.left = q; ! 226: /* this should do it: whew! */ ! 227: #ifndef NODBG ! 228: if( odebug>1 ) e2print( p ); ! 229: #endif ! 230: return( 1 ); ! 231: } ! 232: ! 233: iseff( p ) ! 234: NODE *p; ! 235: ! 236: { ! 237: /* return 1 if p has some side effects, 0 otherwise */ ! 238: int o; ! 239: o = p->tn.op; ! 240: if( callop(o) || asgop(o) ) return( 1 ); ! 241: switch( optype( o ) ) ! 242: { ! 243: case BITYPE: ! 244: if( iseff( p->in.right ) ) return( 1 ); ! 245: case UTYPE: ! 246: return( iseff( p->in.left ) ); ! 247: } ! 248: return( 0 ); ! 249: } ! 250: ! 251: NODE * ! 252: lhsto( p ) ! 253: NODE *p; ! 254: ! 255: { ! 256: /* find a piece of the LHS to be stored */ ! 257: /* if found, rewrite tree */ ! 258: NODE *q; ! 259: int o; ! 260: ! 261: for( q = p->in.left; (o=q->tn.op)!=STAR; q=q->in.left ) ! 262: { ! 263: if( optype(o) == LTYPE ) return( (NODE *)0); ! 264: } ! 265: /* q is now the * node, if there one */ ! 266: q = q->in.left; ! 267: o = q->tn.op; ! 268: if( optype(o) == LTYPE ) return( (NODE *)0 ); ! 269: else return( q ); ! 270: } ! 271: ! 272: static int ! 273: c2bigger( p ) NODE *p; { ! 274: /* p is a conversion op; does it make things bigger */ ! 275: register TWORD t, tl; ! 276: ! 277: t = p->tn.type; ! 278: tl = p->in.left->tn.type; ! 279: ! 280: if( (t|tl)&TPOINT ) return( 0 ); /* pointers are funny */ ! 281: if( t&TDOUBLE ) return( 1 ); ! 282: if( tl&TDOUBLE ) return( 0 ); ! 283: if( t&TFLOAT ) return( 1 ); ! 284: if( tl&TFLOAT ) return( 0 ); ! 285: if( t&(TLONG|TULONG) ) return( 1 ); ! 286: if( tl&(TLONG|TULONG) ) return( 0 ); ! 287: if( t&(TINT|TUNSIGNED) ) return( 1 ); ! 288: if( tl&(TINT|TUNSIGNED) ) return( 0 ); ! 289: if( t &(TSHORT|TUSHORT) ) return( 1 ); ! 290: return( 0 ); ! 291: } ! 292: ! 293: NODE * ! 294: ind2type( p ) ! 295: register NODE *p; ! 296: ! 297: { ! 298: /* make the type of p be the appropriate type for an argument */ ! 299: register TWORD t; ! 300: NODE *q; ! 301: ! 302: t = p->tn.type; ! 303: if( t == TCHAR || t == TSHORT ) t = TINT; ! 304: else if( t == TUCHAR || t == TUSHORT ) t = TUNSIGNED; ! 305: else if( t == TFLOAT ) t = TDOUBLE; ! 306: else return( p ); ! 307: ! 308: if( p->tn.op == CONV && c2bigger(p) ) ! 309: { ! 310: p->tn.type = t; ! 311: return( p ); ! 312: } ! 313: q = talloc(); ! 314: q->tn.op = CONV; ! 315: q->in.left = p; ! 316: q->in.right = 0; ! 317: q->tn.name = (char *) 0; ! 318: q->tn.type = t; ! 319: q->tn.goal = NRGS; ! 320: return( q ); ! 321: } ! 322: ! 323: NODE * ! 324: reweop( p ) ! 325: register NODE *p; ! 326: ! 327: { ! 328: /* rewrite A op= B as A = A op B */ ! 329: /* also, rewrite (CONV A) op= B as A = (CONV ( (CONV A) op B ) ) */ ! 330: /* rewritten in place */ ! 331: /* on input, the type of the op= equals the type of A */ ! 332: /* the type of the op node on output is the type of B */ ! 333: /* the type of the = node on output is the type of A */ ! 334: ! 335: register NODE *q, *t; ! 336: register TWORD ty; ! 337: ! 338: #ifndef NODBG ! 339: if( odebug>1 ) ! 340: { ! 341: e2print( p ); ! 342: printf( "\nrewritten by reweop as:\n" ); ! 343: } ! 344: #endif ! 345: q = tcopy( p, 0 ); ! 346: if( p->in.left->tn.op == CONV ) ! 347: { ! 348: /* ( CONV (A) ) op= B becomes A = CONV ( CONV(A) op B ) */ ! 349: /* the op is done to the type of B */ ! 350: /* the assignment is done to the type of A */ ! 351: t = p->in.left; ! 352: ty = t->in.left->tn.type; ! 353: p->in.left = t->in.left; ! 354: tfree( p->in.right ); ! 355: p->in.right = t; ! 356: t->in.left = q; ! 357: /* now, have the tree built; fix the types */ ! 358: t->tn.type = ty; ! 359: } ! 360: else ! 361: { ! 362: tfree( p->in.right ); ! 363: p->in.right = q; ! 364: } ! 365: /* NOTE: no =ops for structures... */ ! 366: p->tn.op = ASSIGN; ! 367: q->tn.op = NOASG q->tn.op; ! 368: p->tn.type = p->in.left->tn.type; ! 369: q->tn.type = q->in.right->tn.type; ! 370: #ifndef NODBG ! 371: if( odebug>1 ) e2print( p ); ! 372: #endif ! 373: } ! 374: ! 375: rewass( p ) ! 376: NODE *p; ! 377: ! 378: { ! 379: NODE *q; ! 380: int o; ! 381: /* look for =ops to be rewritten */ ! 382: ! 383: #ifndef NODBG ! 384: if( odebug ) ! 385: { ! 386: printf( "rewass called with:\n" ); ! 387: e2print( p ); ! 388: } ! 389: #endif ! 390: o = p->tn.op; ! 391: if( o == UNARY AND ) ! 392: { ! 393: if( p->in.left->tn.op == RNODE ) ! 394: { ! 395: /* this should happen only with structure returns */ ! 396: q = p->in.left; ! 397: q->tn.op = ICON; ! 398: *p = *q; ! 399: q->tn.op = FREE; ! 400: return(0); /* keep going in costs */ ! 401: } ! 402: /* this case should happen only with short structures */ ! 403: rewsto( p->in.left ); ! 404: /* & f() has turned into & ( t=f(),t) */ ! 405: #ifndef NODBG ! 406: if( odebug ) ! 407: { ! 408: printf( "\nrewritten by rewass as:\n" ); ! 409: e2print( p ); ! 410: } ! 411: #endif ! 412: return(1); ! 413: } ! 414: if( !asgop(o) || o==ASSIGN ) ! 415: { ! 416: if( o==ASSIGN ) ! 417: { ! 418: /* look for funny nodes on lhs */ ! 419: o = p->in.left->tn.op; ! 420: if( o==RNODE || o==QNODE || o==SNODE ) ! 421: { ! 422: /* force into r0 */ ! 423: p->in.left->tn.op = REG; ! 424: p->in.left->tn.rval = callreg( p->in.right ); ! 425: #ifndef NODBG ! 426: if( odebug ) ! 427: { ! 428: printf( "funny node redone\n" ); ! 429: e2print(p); ! 430: } ! 431: #endif ! 432: return(0); ! 433: } ! 434: } ! 435: else ! 436: { ! 437: TWORD t = p->in.left->tn.type; ! 438: /* this case is, for example, ! 439: unsigned char a, b; ! 440: ... a*b ! 441: /* we convert both to a reasonable type */ ! 442: /* the result is assumed to be automatically ! 443: /* converted downwards if it should be... */ ! 444: ! 445: p->in.left = ind2type( p->in.left ); ! 446: p->in.right = ind2type( p->in.right ); ! 447: #ifndef NODBG ! 448: if( odebug ) { ! 449: printf( "conversions inserted" ); ! 450: e2print(p); ! 451: } ! 452: #endif ! 453: /* if this didn't work, we are in trouble */ ! 454: if( t != p->in.left->tn.type ) { ! 455: /* we have changed something */ ! 456: return( 0 ); ! 457: } ! 458: } ! 459: e2print(p); ! 460: cerror( "can't deal with op %s", opst[o] ); ! 461: } ! 462: if( o == INCR || o == DECR ) ! 463: { ! 464: /* very crude: a++ becomes (a+=1)-1 */ ! 465: #ifndef NODBG ! 466: if( odebug>1 ) ! 467: { ! 468: e2print( p ); ! 469: printf( "\nrewritten by rewass as:\n" ); ! 470: } ! 471: #endif ! 472: if( p->in.goal == CEFF ) ! 473: { ! 474: p->in.op = ((o==INCR)?ASG PLUS:ASG MINUS); ! 475: } ! 476: else ! 477: { ! 478: q = tcopy(p, 0); ! 479: regrcl( p->in.left ); ! 480: tfree( p->in.left ); ! 481: p->in.left = q; ! 482: q->tn.op = ((o==INCR)?ASG PLUS:ASG MINUS); ! 483: p->tn.op = ((o==INCR)?MINUS:PLUS); ! 484: } ! 485: #ifndef NODBG ! 486: if( odebug ) ! 487: { ! 488: printf( "\nrewritten by rewass as:\n" ); ! 489: e2print( p ); ! 490: } ! 491: #endif ! 492: return(1); ! 493: } ! 494: /* find out if some subtree has to be stored into a temp... */ ! 495: if( q = lhsto(p) ) ! 496: { ! 497: if( !rewsto( q ) ) cerror( "rewass0" ); /* q => t=q,t */ ! 498: rewcom( p, p->tn.goal ); /* move COMOP to the top */ ! 499: if( p->tn.op != COMOP ) cerror( "rewass1" ); ! 500: if( !asgop( p->in.right->tn.op ) ) cerror( "rewass2" ); ! 501: reweop( p->in.right ); ! 502: } ! 503: else reweop( p ); /* rewrite p as an =OP */ ! 504: return(1); ! 505: } ! 506: ! 507: # ifdef NONEST ! 508: subcall( p ) ! 509: register NODE *p; ! 510: ! 511: { ! 512: /* return 1 if p contains a callop */ ! 513: register o, t; ! 514: ! 515: o = p->tn.op; ! 516: if( callop(o) ! 517: # ifndef UCALLBAD ! 518: && o!=UNARY CALL ! 519: # endif ! 520: # ifndef STCALLBAD ! 521: && o!=UNARY STCALL ! 522: # endif ! 523: # ifndef UFCALLBAD ! 524: && o!=UNARY FORTCALL ! 525: # endif ! 526: ) return( 1 ); ! 527: t = optype( o ); ! 528: if( t==BITYPE && subcall(p->in.right) ) return( 1 ); ! 529: if( t!=LTYPE ) return( subcall( p->in.left ) ); ! 530: return( 0 ); ! 531: } ! 532: ! 533: nonest( p ) ! 534: register NODE *p; ! 535: ! 536: { ! 537: register o, t; ! 538: /* right now, this is very crude */ ! 539: /* find arguments below a call; store them */ ! 540: /* nonest is called up to a call; stocm is called within args */ ! 541: ! 542: o = p->tn.op; ! 543: t = optype( o ); ! 544: if( o==CALL || o==STCALL || o==FORTCALL) ! 545: { ! 546: stocm( p->in.right ); ! 547: nonest( p->in.left ); ! 548: return; ! 549: } ! 550: if( t == BITYPE ) nonest( p->in.right ); ! 551: if( t != LTYPE ) nonest( p->in.left ); ! 552: } ! 553: ! 554: stocm( p ) ! 555: register NODE *p; ! 556: ! 557: { ! 558: /* all call arguments below p must be stored */ ! 559: register NODE *q; ! 560: register o; ! 561: ! 562: while( (o=p->tn.op) == CM ) ! 563: { ! 564: stocm( p->in.right ); ! 565: p = p->in.left; ! 566: } ! 567: if( o != STARG && o != FUNARG ) cerror( "stocm" ); ! 568: ! 569: q = p->in.left; ! 570: if( subcall( q ) ) ! 571: { ! 572: if( o == FUNARG ) rewsto( q ); ! 573: else ! 574: { ! 575: /* structure argument with call beneath */ ! 576: rewsto( p ); ! 577: } ! 578: /* now q will be done outside of a call, so use nonest */ ! 579: nonest( q ); ! 580: } ! 581: } ! 582: # endif ! 583: ! 584: outshp( pp ) ! 585: SHAPE **pp; ! 586: ! 587: { ! 588: SHAPE *p; ! 589: ! 590: if (pp == 0) ! 591: return; ! 592: ! 593: for( ; p = *pp; ++pp ) ! 594: { ! 595: printf("\t\t"); ! 596: shpr(p); ! 597: printf( " (%d)\n", p->sc ); ! 598: } ! 599: } ! 600: ! 601: tabpr() ! 602: { ! 603: register OPTAB *p; ! 604: for (p =table; ;p++) ! 605: { ! 606: printf("Dump of table[%d] (stinline %d)\n", p-table, p->stinline ); ! 607: printf("\top = %s\n", opst[p->op]); ! 608: printf("\tnextop = %d\n", p->nextop?p->nextop-table:-1 ); ! 609: printf("\tlshape = %d\n", p->lshape-pshape); ! 610: printf("\tltype = 0%o\n", p->ltype); ! 611: printf("\trshape = %d\n", p->rshape-pshape); ! 612: printf("\trtype = 0%o\n", p->rtype); ! 613: printf("\tneeds = %d\n", p->needs); ! 614: printf("\trewrite = %d\n", p->rewrite); ! 615: printf("\tcstring = %s", p->cstring); ! 616: printf("\tcost = %d\n", p->cost); ! 617: printf("\tLeft:\n"); ! 618: outshp(p->lshape); ! 619: printf("\tRight:\n"); ! 620: outshp(p->rshape); ! 621: printf("\n"); ! 622: } ! 623: } ! 624: ! 625: codgen( p ) ! 626: NODE *p; ! 627: ! 628: { ! 629: ! 630: /* generate the code for p; */ ! 631: int i, flag; ! 632: ! 633: #ifndef NODBG ! 634: if (odebug > 5) ! 635: { ! 636: tabpr(); ! 637: /* NOTREACHED */ ! 638: } ! 639: #endif ! 640: ! 641: # ifdef NONEST ! 642: nonest(p); ! 643: # endif ! 644: ! 645: /* if we make drastic changes to the tree (e.g., introduce temps) ! 646: ** /* we will go back and do the whole thing again ! 647: */ ! 648: /* statistics indicate that this happens about 10% of the time */ ! 649: /* if the percentage rises, there are many things that can be done to ! 650: ** /* improve matters ! 651: */ ! 652: /* for example, RNODE, etc., could be removed by reader, and some of ! 653: ** /* the op rewriting could be discovered by reader as well ! 654: */ ! 655: ! 656: again: ! 657: ! 658: /* move the comma ops as high as practical */ ! 659: ! 660: rewcom( p, CEFF ); ! 661: ! 662: #ifndef NODBG ! 663: if( odebug ) ! 664: { ! 665: printf( "After goals are computed:" ); ! 666: e2print( p ); ! 667: } ! 668: #endif ! 669: ! 670: /* compute the costs */ ! 671: ! 672: if( costs( p ) ) goto again; /* if rewritten, do again */ ! 673: ! 674: #ifndef NODBG ! 675: if( odebug ) ! 676: { ! 677: printf( "After costs are computed:" ); ! 678: e2print( p ); ! 679: } ! 680: #endif ! 681: ! 682: /* do a trial code generation */ ! 683: nins = 0; ! 684: insout( p, CEFF ); ! 685: ! 686: /* rewrite stored subtrees as assignments to temps, with COMOP's */ ! 687: flag = 0; ! 688: for( i=0; i<nins; ++i ) ! 689: { ! 690: if( inst[i].goal == CTEMP ) ! 691: { ! 692: #ifndef NODBG ! 693: if( odebug ) ! 694: { ! 695: printf( "subtree is stored in temp:\n" ); ! 696: e2print( inst[i].p ); ! 697: } ! 698: #endif ! 699: if( rewsto( inst[i].p ) ) { ! 700: if( !fast ) goto again; ! 701: /* otherwise, rewrite all temps now */ ! 702: flag = 1; ! 703: } ! 704: } ! 705: } ! 706: if( flag ) goto again; ! 707: ! 708: #ifndef NODBG ! 709: if( odebug ) e2print(p); ! 710: #endif ! 711: /* output the actual instructions */ ! 712: insprt(); ! 713: } ! 714: ! 715: INST inst[NINS]; ! 716: int nins; ! 717: ! 718: insprt() ! 719: { ! 720: int i; ! 721: register INST *pi; ! 722: register NODE *p; ! 723: register OPTAB *q; ! 724: register c, goal; ! 725: ! 726: for( pi=inst,i=0; i<nins; ++i,++pi ) ! 727: { ! 728: p = pi->p; ! 729: q = pi->q; ! 730: c = pi->goal; ! 731: if( c == CCC && (q->rewrite&RESCC) ) goal = FORCC; ! 732: else if( c == CEFF ) goal = FOREFF; ! 733: else goal = INREG; ! 734: #ifndef NODEBUG ! 735: if(odebug > 4) ! 736: { ! 737: printf("INSOUT: %d c=",i); ! 738: preff(c); ! 739: printf(" goal="); ! 740: prgoal(goal); ! 741: printf("\n"); ! 742: e2print(p); ! 743: } ! 744: #endif ! 745: ! 746: allo( p, q ); ! 747: # ifdef TMPSRET ! 748: /* not the best place in the world, but... */ ! 749: if (p->in.op == STCALL || p->in.op == UNARY STCALL) ! 750: expand(p, goal, TMPSRET, q); ! 751: #endif ! 752: expand( p, goal, q->cstring, q ); ! 753: reclaim( p, q->rewrite, goal ); ! 754: ! 755: /* now, if condition codes needed, test */ ! 756: if( c == CCC && p->tn.op != CCODES ) ! 757: { ! 758: cfix( p, CCC ); ! 759: if( p->tn.op != CCODES ) cerror( "ctest fails" ); ! 760: } ! 761: if( c>=0 && c<=NRGS && !istnode( p ) ) ! 762: { ! 763: cfix( p, NRGS ); ! 764: } ! 765: } ! 766: } ! 767: ! 768: SHTABLE sha; ! 769: ! 770: cfix( p, goal ) ! 771: NODE *p; ! 772: { ! 773: /* p is to be fixed according to goal (CCC or NRGS) */ ! 774: OPTAB *q; ! 775: NODE *pp; ! 776: int r; ! 777: ! 778: #ifndef NODBG ! 779: if(odebug > 4) ! 780: { ! 781: printf("CFIX: goal="); ! 782: prgoal(goal); ! 783: printf("\n"); ! 784: e2print(p); ! 785: } ! 786: #endif ! 787: if( goal == CCC ) ! 788: { ! 789: r = RESCC; ! 790: p->tn.goal = CCC; ! 791: } ! 792: else ! 793: { ! 794: r = (RESC1|RESC2|RESC3); ! 795: pp = getl( p ); ! 796: if( istnode( pp ) ) r |= RLEFT; ! 797: pp = getr( p ); ! 798: if( istnode( pp ) ) r |= RRIGHT; ! 799: } ! 800: ! 801: if( goal == CCC ) goal = FORCC; ! 802: else goal = INREG; ! 803: ! 804: for( q=0; q = match( p, q ); ) ! 805: { ! 806: /* takes the first match (may not be cheapest) */ ! 807: /* template writers, take note! */ ! 808: if( q->rewrite & r ) ! 809: { ! 810: /* generate the code on the spot */ ! 811: allo( p, q ); ! 812: # ifdef TMPSRET ! 813: /* likewise */ ! 814: if (p->in.op == STCALL || p->in.op == UNARY STCALL) ! 815: expand(p, goal, TMPSRET, q); ! 816: #endif ! 817: expand( p, goal, q->cstring, q ); ! 818: reclaim( p, q->rewrite, goal ); ! 819: return; ! 820: } ! 821: } ! 822: e2print(p); ! 823: cerror( "cfix trouble" ); ! 824: } ! 825: ! 826: ! 827: preff(c) ! 828: { ! 829: char buf[20]; ! 830: register char *p; ! 831: ! 832: p = c==CCC ? "CCC" : c==CTEMP ? "CTEMP" : c==CEFF ? "CEFF" : 0; ! 833: if(!p) ! 834: { ! 835: sprintf(buf,"0%o",c); ! 836: p = buf; ! 837: } ! 838: printf("%s",p); ! 839: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.