![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optutil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / optim|
Return to optutil.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / optim |
1.1 ! root 1: /* @(#) optutil.c: 1.3 3/27/84 */ ! 2: /* optutil.c ! 3: ** ! 4: ** Optimizer utilities for 3B code improver (PCI). ! 5: ** ! 6: ** ! 7: ** This module contains utility routines for the various peephole ! 8: ** window optimizations. ! 9: */ ! 10: ! 11: /* #include <ctype.h> -- optim.h takes care of this */ ! 12: /* #include "defs" -- optim.h takes care of this; machine-dependent defs */ ! 13: #include "optim.h" /* machine independent optimizer defs */ ! 14: ! 15: extern long atol(); ! 16: /* isreg -- is operand string a register reference? ! 17: ** ! 18: ** This routine tells whether an operand string is a register reference. ! 19: */ ! 20: ! 21: boolean ! 22: isreg(s) ! 23: char * s; /* operand string */ ! 24: { ! 25: /* assume operand is a register reference if it begins with a % */ ! 26: ! 27: return(*s == '%'); ! 28: } ! 29: ! 30: ! 31: ! 32: /* isnib -- is operand a nibble? ! 33: ** ! 34: ** This routine tests an operand string and tells whether it is an ! 35: ** immediate operand that can fit in a nibble (4 bits). ! 36: */ ! 37: ! 38: boolean ! 39: isnib(s) ! 40: char * s; /* operand string to check */ ! 41: { ! 42: long x; /* temporary to hold value */ ! 43: ! 44: /* Return true if the operand begins with a '&', it is numeric, ! 45: ** and the numeric value is between 0 and 15. ! 46: */ ! 47: ! 48: return( *s == '&' /* begins with & */ ! 49: && isdigit(*++s) /* operand is numeric */ ! 50: && (x = atol(s)) >= 0 /* is positive */ ! 51: && x <= 15 /* and <= 15 */ ! 52: ); ! 53: } ! 54: /* isnegnib -- is operand a negative nibble? ! 55: ** ! 56: ** This routine tests whether an operand string is an immediate operand ! 57: ** with a value between -1 and -15. Another condition tested is that ! 58: ** the minus sign immediately follows an '&'. (This condition is ! 59: ** important if the operand is overwritten.) ! 60: */ ! 61: ! 62: boolean ! 63: isnegnib(s) ! 64: char * s; /* operand string */ ! 65: { ! 66: long n; /* temporary operand value */ ! 67: ! 68: return( ! 69: s != NULL ! 70: && *s++ == '&' /* operand starts with & */ ! 71: && *s++ == '-' /* followed by - */ ! 72: && isdigit(*s) /* operand is numeric */ ! 73: && 1 <= (n = atol(s)) /* (positive) value between 1... */ ! 74: && n <= 15 /* and 15 */ ! 75: ); ! 76: } ! 77: /* getbit -- get bit number for power of 2 ! 78: ** ! 79: ** This routine tests whether an operand is a power of 2. If not, it ! 80: ** returns -1. Otherwise it returns a bit number, which is also the ! 81: ** exponent of 2. ! 82: */ ! 83: ! 84: int ! 85: getbit(s) ! 86: char * s; /* pointer to operand string */ ! 87: { ! 88: int bit = 0; /* initialize bit number for later */ ! 89: long n; /* numeric value of operand */ ! 90: boolean isnumlit(); ! 91: ! 92: if ( (! isnumlit(s)) || (n = atol(s+1)) < 0 ) ! 93: return(-1); /* check for numeric literal with ! 94: ** good value ! 95: */ ! 96: ! 97: /* This test really works, although it looks suspicious. A power of two ! 98: ** has only one bit set, so that value minus one has all of the bits to ! 99: ** the right of the original bit set. Anding them together gives zero. ! 100: ** No other value yields zero. ! 101: */ ! 102: ! 103: if ( ( n & (n-1) ) != 0) ! 104: return(-1); /* not a power of 2 */ ! 105: ! 106: /* Shift right until the word is zero */ ! 107: ! 108: while ((n = n>>1) != 0) ! 109: bit++; /* bump bit number each time */ ! 110: ! 111: return(bit); /* return bit number */ ! 112: } ! 113: /* insert -- insert new instruction node ! 114: ** ! 115: ** This routine inserts a new instruction node after the one pointed ! 116: ** to. The fields in the node are initialized to null values. ! 117: */ ! 118: ! 119: NODE * /* return pointer to the new node */ ! 120: insert(pn) ! 121: NODE * pn; /* node to add pointer after */ ! 122: { ! 123: NODE * Saveop(); /* in machine-independent part */ ! 124: NODE * new = Saveop(0,"",0,GHOST); /* create isolated node, init. */ ! 125: ! 126: APPNODE(new,pn); /* append new node after current */ ! 127: ! 128: return(new); /* return pointer to the new one */ ! 129: } ! 130: /* chgop -- change op code number and op code string in node ! 131: ** ! 132: ** This routine changes the op code information in a node. The ! 133: ** operand information is unaffected. ! 134: */ ! 135: ! 136: void ! 137: chgop(n,op,op_code) ! 138: NODE * n; /* pointer to node to change */ ! 139: int op; /* op code number */ ! 140: char * op_code; /* pointer to op code string */ ! 141: { ! 142: n->op = op; /* set op code number */ ! 143: n->opcode = op_code; /* and string */ ! 144: return; ! 145: } ! 146: /* copyopn -- copy operand string ! 147: ** ! 148: ** This routine duplicates an operand string in a new piece of memory. ! 149: ** The caller can specify a +/- number of additional bytes required, ! 150: ** as well as an offset for copying. ! 151: */ ! 152: ! 153: char * /* return duplicate string */ ! 154: copyopn(s,extra,offset) ! 155: char * s; /* original operand string */ ! 156: int extra; /* number of extra (or fewer) chars */ ! 157: int offset; /* offset in original operand from ! 158: ** which to start copying. ! 159: */ ! 160: { ! 161: int len = strlen(s) + extra; /* length of duplicate */ ! 162: char * stemp; /* future duplicate string */ ! 163: ! 164: if (len <= 0) ! 165: return(NULL); /* deleted everything */ ! 166: ! 167: stemp = getspace(len+1); /* get new string (+1 for null byte) */ ! 168: return(strcpy(stemp,s+offset)); /* return copy */ ! 169: } ! 170: /* isdyadic -- is instruction dyadic ! 171: ** ! 172: ** This routine tells whether an instruction is dyadic according ! 173: ** to the following conditions: ! 174: ** ! 175: ** 1. It takes two operands. ! 176: ** 2. It reads the first operand, writes the second. ! 177: ** 3. It sets the condition codes according to the value stored in ! 178: ** the second operand. ! 179: ** 4. The operands have normal address mode meanings: disallow, ! 180: ** for example, MOVAW, which does address arithmetic of op1. ! 181: */ ! 182: ! 183: boolean ! 184: isdyadic(n) ! 185: NODE * n; /* instruction node to test */ ! 186: { ! 187: switch(n->op) /* dispatch on op code number */ ! 188: { ! 189: case MCOMW: ! 190: case MOVZBH: ! 191: case MOVZBW: ! 192: case MOVZHW: ! 193: case ANDW2: ! 194: case ORW2: ! 195: case XORW2: ! 196: case LLSW2: ! 197: case LRSW2: ! 198: case MOVW: ! 199: case MOVBBH: ! 200: case MOVBBW: ! 201: case MOVBHW: ! 202: case MOVTHB: ! 203: case MOVTWB: ! 204: case MOVTWH: ! 205: case MNEGW: ! 206: case ADDW2: ! 207: case SUBW2: ! 208: case MULW2: ! 209: case UMULW2: ! 210: case DIVW2: ! 211: case UDIVW2: ! 212: case UMODW2: ! 213: case ALSW2: ! 214: case ARSW2: ! 215: return(true); /* all of these are dyadic */ ! 216: default: ! 217: return(false); /* others are not */ ! 218: } ! 219: } ! 220: /* istriadic -- is instruction triadic? ! 221: ** ! 222: ** This routine serves a similar function to isdyadic, except that ! 223: ** it also returns the related dyadic op code number and string. ! 224: ** The only instructions included here are the obvious ones. They ! 225: ** are assumed to have integer operands (by callers). ! 226: */ ! 227: ! 228: /* define macro to use below */ ! 229: ! 230: #define CHANGE(op,new,newst) case op: *pnewop=new;*pnewopcode=newst;break; ! 231: ! 232: ! 233: boolean ! 234: istriadic(n,pnewop,pnewopcode) ! 235: NODE * n; /* node to test */ ! 236: int * pnewop; /* place to put equiv. dyadic # */ ! 237: char ** pnewopcode; /* place to put equiv. dyadic string */ ! 238: { ! 239: switch (n->op) /* dispatch on op code number */ ! 240: { ! 241: CHANGE(ADDW3,ADDW2,"addw2"); ! 242: CHANGE(SUBW3,SUBW2,"subw2"); ! 243: CHANGE(MULW3,MULW2,"mulw2"); ! 244: CHANGE(UMULW3,UMULW2,"umulw2"); ! 245: CHANGE(DIVW3,DIVW2,"divw2"); ! 246: CHANGE(UDIVW3,UDIVW2,"udivw2"); ! 247: CHANGE(MODW3,MODW2,"modw2"); ! 248: CHANGE(UMODW3,UMODW2,"umodw2"); ! 249: CHANGE(ALSW3,ALSW2,"alsw2"); ! 250: CHANGE(ARSW3,ARSW2,"arsw2"); ! 251: CHANGE(ANDW3,ANDW2,"andw2"); ! 252: CHANGE(ORW3,ORW2,"orw2"); ! 253: CHANGE(XORW3,XORW2,"xorw2"); ! 254: CHANGE(LLSW3,LLSW2,"llsw2"); ! 255: CHANGE(LRSW3,LRSW2,"lrsw2"); ! 256: default: /* for op codes not found */ ! 257: return(false); ! 258: } ! 259: return(true); /* found op code */ ! 260: } ! 261: /* totriadic -- can dyadic be made triadic? ! 262: ** ! 263: ** This routine checks a dyadic instruction to see if it can be ! 264: ** made triadic. If so, it returns the opcode number and string ! 265: ** for the corresponding triadic. Totriadic is really the inverse ! 266: ** of istriadic. ! 267: */ ! 268: ! 269: boolean ! 270: totriadic(n,pnewop,pnewopcode) ! 271: NODE * n; /* node to test */ ! 272: int * pnewop; /* place to put equiv. triadic # */ ! 273: char ** pnewopcode; /* place to put equiv. triadic string */ ! 274: { ! 275: switch (n->op) /* dispatch on op code number */ ! 276: { ! 277: CHANGE(ADDW2,ADDW3,"addw3"); ! 278: CHANGE(SUBW2,SUBW3,"subw3"); ! 279: CHANGE(MULW2,MULW3,"mulw3"); ! 280: CHANGE(UMULW2,UMULW3,"umulw3"); ! 281: CHANGE(DIVW2,DIVW3,"divw3"); ! 282: CHANGE(UDIVW2,UDIVW3,"udivw3"); ! 283: CHANGE(MODW2,MODW3,"modw3"); ! 284: CHANGE(UMODW2,UMODW3,"umodw3"); ! 285: CHANGE(ALSW2,ALSW3,"alsw3"); ! 286: CHANGE(ARSW2,ARSW3,"arsw3"); ! 287: CHANGE(ANDW2,ANDW3,"andw3"); ! 288: CHANGE(ORW2,ORW3,"orw3"); ! 289: CHANGE(XORW2,XORW3,"xorw3"); ! 290: CHANGE(LLSW2,LLSW3,"llsw3"); ! 291: CHANGE(LRSW2,LRSW3,"lrsw3"); ! 292: default: /* for op codes not found */ ! 293: return(false); ! 294: } ! 295: return(true); /* found op code */ ! 296: } ! 297: /* makelive -- make register live ! 298: ** ! 299: ** This routine marks a register operand as live. ! 300: */ ! 301: ! 302: void ! 303: makelive(s,n) ! 304: char * s; /* operand string (to %r0) */ ! 305: NODE * n; /* pointer to node to enliven */ ! 306: { ! 307: n->nlive |= setreg(s); ! 308: return; ! 309: } ! 310: ! 311: ! 312: ! 313: /* makedead -- make register dead ! 314: ** ! 315: ** This routine marks a register operand as dead. ! 316: */ ! 317: ! 318: void ! 319: makedead(s,n) ! 320: char * s; /* operand string (to %rn) */ ! 321: NODE * n; /* pointer to node to kill */ ! 322: { ! 323: n->nlive &= ~ setreg(s); ! 324: return; ! 325: } ! 326: /* isindex -- is operand an index off a register? ! 327: ** ! 328: ** This routine checks whether an operand string is of the ! 329: ** form: ! 330: ** ! 331: ** n(%rn) ! 332: ** ! 333: ** and whether it uses a designated register. ! 334: ** ! 335: ** Actually, it cheats: it just checks for an initial digit or sign followed ! 336: ** by a (. In fact the ( test is a cheat, because we just check to see ! 337: ** if there's a ( in the string. ! 338: */ ! 339: ! 340: boolean ! 341: isindex(s,r) ! 342: char * s; /* operand string to test */ ! 343: char * r; /* register operand string to check ! 344: ** for ! 345: */ ! 346: ! 347: { ! 348: char * strchr(); ! 349: ! 350: if(*s == '*') ! 351: s++; ! 352: return( ! 353: usesreg(s,r) ! 354: && (isdigit(*s) || *s == '-') /* could be leading sign, too */ ! 355: && strchr(s,'(') != (char *) 0 ! 356: ); ! 357: } ! 358: /* ismove -- is instruction a move? ! 359: ** ! 360: ** This routine determines whether an instruction is a move-type. ! 361: ** There is a multiplicity of move instructions which copy, zero- ! 362: ** or sign-extend, and truncate. This routine returns the natural ! 363: ** size of the source and destination operands. ! 364: */ ! 365: ! 366: boolean ! 367: ismove(n,srcsize,dstsize) ! 368: NODE * n; /* pointer to instruction node */ ! 369: int * srcsize; /* place to put size of source ! 370: ** operand (in bytes) ! 371: */ ! 372: int * dstsize; /* place to put size of destination */ ! 373: { ! 374: register int srctemp = 1; /* temporary source size */ ! 375: register int dsttemp = 4; /* temporary destination size */ ! 376: /* Initial values chosen on basis of most common value of each. */ ! 377: ! 378: switch (n->op) /* dispatch on op-code number */ ! 379: { ! 380: case MOVZBH: ! 381: dsttemp = 2; break; ! 382: case MOVZBW: ! 383: break; ! 384: case MOVZHW: ! 385: srctemp = 2; break; ! 386: ! 387: case MOVB: ! 388: dsttemp = 1; break; ! 389: case MOVH: ! 390: srctemp = 2; dsttemp = 2; break; ! 391: case MOVW: ! 392: srctemp = 4; break; ! 393: ! 394: case MOVBBH: ! 395: dsttemp = 2; break; ! 396: case MOVBBW: ! 397: break; ! 398: case MOVBHW: ! 399: srctemp = 2; break; ! 400: ! 401: case MOVTHB: ! 402: srctemp = 2; dsttemp = 1; break; ! 403: case MOVTWB: ! 404: srctemp = 4; dsttemp = 1; break; ! 405: case MOVTWH: ! 406: srctemp = 4; dsttemp = 2; break; ! 407: default: ! 408: return(false); /* not a move instruction */ ! 409: } ! 410: *srcsize = srctemp; /* copy out correct values */ ! 411: *dstsize = dsttemp; ! 412: return(true); /* found a move */ ! 413: } ! 414: /* iszoffset -- is operand zero offset from register ! 415: ** ! 416: ** This routine determines whether a given operand is an indexed ! 417: ** operation from a designated register, where the index is zero. ! 418: */ ! 419: ! 420: boolean ! 421: iszoffset(operand,reg) ! 422: register char * operand; /* operand string */ ! 423: char * reg; /* register string */ ! 424: { ! 425: ! 426: /* We use a quick and dirty strategy here: we test the operand for ! 427: ** zero, followed by (, with matching register numbers in the right ! 428: ** place. We assume register designations are "%rn". ! 429: */ ! 430: ! 431: return( ! 432: *operand == '0' ! 433: && *(operand+1) == '(' ! 434: && *(operand+4) == *(reg+2) ! 435: ); ! 436: } ! 437: /* exchange -- exchange node and successor ! 438: ** ! 439: ** This routine reverses the linkages of two nodes so the first is ! 440: ** the second and the second is the first. ! 441: */ ! 442: ! 443: void ! 444: exchange(first) ! 445: NODE * first; /* pointer to first of two nodes */ ! 446: { ! 447: ! 448: /* This can probably be done with fewer temporaries, but it's a lot ! 449: ** easier to understand what's going on this way.... ! 450: */ ! 451: ! 452: NODE * prev = first->back; /* predecessor of first node */ ! 453: NODE * second = first->forw; /* second node of pair to exchange */ ! 454: NODE * next = second->forw; /* successor of second node */ ! 455: ! 456: prev->forw = second; /* second will now be first */ ! 457: second->back = prev; ! 458: ! 459: first->forw = next; /* successor of old first is now ! 460: ** 'next' ! 461: */ ! 462: next->back=first; /* 'next's' predecessor now 'first' */ ! 463: ! 464: second->forw = first; ! 465: first->back = second; /* re-link connection of node pair */ ! 466: ! 467: return; ! 468: } ! 469: /* doindirect -- resolve indirect references ! 470: ** ! 471: ** This routine changes variable references of the form ! 472: ** 0(%rn) ! 473: ** to ! 474: ** *var ! 475: ** where possible. Its purpose is to make it possible to discard a ! 476: ** register load. ! 477: ** ! 478: ** Here's the scenario: we're handed an instruction, the name of the ! 479: ** register whose zero-index use we want to change, and the real location ! 480: ** of the variable. For example, in the sequence ! 481: ** ! 482: ** movw xyz,%r0 ! 483: ** addw2 0(%r0),%r1 ! 484: ** ! 485: ** the instruction we would be handed is the addw2, the register would be ! 486: ** %r0, and the real location of the variable is 'xyz'. ! 487: ** ! 488: ** Complications: ! 489: ** 1. The register must be dead after the instruction. ! 490: ** 2. We want to change all such references in the instruction. ! 491: ** 3. If there are any other uses of the register than a zero ! 492: ** index, like actually using the register contents or ! 493: ** using an index other than zero (e.g., 4(%r0)), we ! 494: ** can't make the transformation, since we're going to ! 495: ** eliminate the preceding register load. ! 496: ** 4. ... except that if the destination of a triadic instruction or ! 497: ** move is the register it's safe to proceed. ! 498: ** ! 499: ** One, possibly unsafe assumption: ! 500: ** The algorithm assumes that unused operands in an instruction (like ! 501: ** operands 3 and 4 in a dyadic) are always NULL. We also assume that ! 502: ** an instruction has a "destination" (returned by 'dst') if and only ! 503: ** if it can alter something. We further assume that the destination ! 504: ** is always the last operand. ! 505: */ ! 506: ! 507: boolean /* true if the transformation ! 508: ** was made ! 509: */ ! 510: doindirect(n,reg,repl) ! 511: NODE * n; /* instruction node to examine */ ! 512: char * reg; /* register (string) to look for */ ! 513: char * repl; /* operand string to use */ ! 514: { ! 515: boolean first = true; /* if examining first real operand */ ! 516: int indmask = 0; /* will have bits set telling which ! 517: ** operands to change ! 518: */ ! 519: int i; /* loop index */ ! 520: char * operand; /* current operand */ ! 521: int src,dest; /* for ismove (but unused) */ ! 522: /* Begin: check whether transformation can be made, note which operands ! 523: ** to change if so. ! 524: */ ! 525: ! 526: if ( ! 527: isret(n) /* will show register dead, which ! 528: ** will confuse us ! 529: */ ! 530: || ! ( ! 531: isdead(reg,n) /* reg must be dead after n */ ! 532: || ( ismove(n,&src,&dest) && samereg(n->op2,reg) ) ! 533: ) /* unless set by this inst. as move */ ! 534: || *repl == '*' /* can't do it if replacement is ! 535: ** already an indirect... ! 536: */ ! 537: || *repl == '&' /* or an immediate */ ! 538: ) ! 539: return(false); /* can't do it */ ! 540: ! 541: /* Now scan operands for things that can't be transformed. We do this ! 542: ** backward from higher numbered operands on the assumption that a ! 543: ** destination, which we treat differently, is the highest numbered ! 544: ** non-null operand. ! 545: */ ! 546: ! 547: for ( i = MAXOPS; i > 0; i-- ) ! 548: { ! 549: int opn; /* op code number in istriadic */ ! 550: char * opst; /* op code string in istriadic */ ! 551: ! 552: if ( (operand = n->ops[i]) != NULL ) ! 553: { /* found an operand */ ! 554: if (iszoffset(operand,reg)) /* this is what we want! */ ! 555: indmask |= 1<<i; /* remember where it is */ ! 556: ! 557: /* otherwise can only use register if this is the last ! 558: ** operand (but the first we'll find) and the instruction ! 559: ** is triadic ! 560: */ ! 561: ! 562: else if ( ! 563: ! ( samereg(operand,reg) ! 564: && first ! 565: && ( ! 566: istriadic(n,&opn,&opst) ! 567: || ismove(n,&src,&dest) ! 568: ) ! 569: ) ! 570: && usesreg(operand,reg) ! 571: ) ! 572: return(false); /* bad use of register */ ! 573: ! 574: first = false; /* no longer looking at first (last) ! 575: ** operand ! 576: */ ! 577: } ! 578: } ! 579: /* Reaching here, we have successfully scanned all operands without ! 580: ** finding any register references that violate the required conditions. ! 581: */ ! 582: ! 583: if (indmask == 0) /* if no register references... */ ! 584: return(false); /* say we didn't change anything */ ! 585: if ( !isiros(repl) ) return( false ); /* check for mmio */ ! 586: /* Now we're ready to do the actual transformations. If the replacement ! 587: ** operand is a register reference, we create a new operand reference ! 588: ** of the form: ! 589: ** 0(reg) --> 0(repl) ! 590: ** ! 591: ** Otherwise we have a vanilla operand. Rewrite it as ! 592: ** ! 593: ** 0(reg) --> *repl ! 594: */ ! 595: ! 596: { /* for some more variables */ ! 597: char * indstring; /* new operand string */ ! 598: int extra; /* number of extra chars in xform */ ! 599: char * format; /* sprintf format string for xform */ ! 600: ! 601: if (isreg(repl)) /* replacement is also reference */ ! 602: { ! 603: format = "0(%s)"; /* to form 0(repl) */ ! 604: extra = 3; /* for 0 ( ) */ ! 605: } ! 606: else ! 607: { ! 608: format = "*%s"; /* rewrite as *repl */ ! 609: extra = 1; /* prepend * only */ ! 610: } ! 611: ! 612: indstring = getspace(strlen(repl) + extra + 1); ! 613: /* allocate space + 1 for null */ ! 614: (void) sprintf(indstring,format,repl); ! 615: /* build replacement */ ! 616: ! 617: wchange(); /* Finally! About to make changes */ ! 618: ! 619: /* loop through operands, replacing ones whose bit is set in mask */ ! 620: ! 621: for ( i = MAXOPS; i > 0; i-- ) ! 622: { ! 623: if ( (indmask & (1<<i)) != 0) ! 624: n->ops[i] = indstring; /* stick in replacement string */ ! 625: } ! 626: ! 627: return(true); /* say we changed stuff */ ! 628: } /* end extra block */ ! 629: } ! 630: /* isnumlit -- is operand a numeric literal ! 631: ** ! 632: ** This routine tests operand strings for the form ! 633: ** ! 634: ** &[-]n ! 635: ** ! 636: ** where n is a positive integer. ! 637: */ ! 638: ! 639: boolean ! 640: isnumlit(s) ! 641: char * s; /* pointer to operand string */ ! 642: { ! 643: if (*s++ != '&') ! 644: return(false); ! 645: ! 646: if (*s == '-') /* sign okay */ ! 647: s++; ! 648: ! 649: while (*s != '\0') /* check for all digits */ ! 650: if ( ! isdigit(*s++) ) ! 651: return(false); ! 652: ! 653: return(true); /* passed all tests */ ! 654: } ! 655: /* usesvar -- does first operand use second? ! 656: ** ! 657: ** This routine is a generalization of "usesreg": it returns true ! 658: ** if the first operand uses the second. An example is ! 659: ** v1 = "*p", v2 = "p". v1 uses the contents of v2. ! 660: */ ! 661: ! 662: boolean ! 663: usesvar(v1,v2) ! 664: char * v1; /* using operand */ ! 665: char * v2; /* used operand */ ! 666: { ! 667: if (isreg(v2) && usesreg(v1,v2)) ! 668: return(true); /* handle register case specially */ ! 669: ! 670: if (*v1 == '*') /* check for initial indirect */ ! 671: v1++; ! 672: ! 673: return(strcmp(v1,v2) == 0); /* result is result of compare */ ! 674: } ! 675: ! 676: ! 677: /* These routines try to preserve the line number information. ! 678: The criterion for saving or discarding line number information is ! 679: that the state of the machine from a C point of view should be the ! 680: same at any given line both before and after the optimization. ! 681: If it would not be then the line number is deleted. ! 682: The exceptions to the above are that the state of the condition codes ! 683: and of dead registers is ignored. ! 684: ! 685: May 1983 */ ! 686: ! 687: /* NOTE: All instruction nodes that these routines assume will be tossed ! 688: have their uniqids set to IDVAL. For example, in the merges, ! 689: the uniqids of the original instructions are set to IDVAL ! 690: and then the uniqid of the resultant instruction is computed. ! 691: This has the effect of setting the uniqid of the instruction ! 692: not corresponding to the resultant to IDVAL. This fact is used ! 693: in some instances where lnmrginst2 is called -- see w2opt.c */ ! 694: ! 695: /* delete instruction -- save line number ! 696: if the instruction below has no line number or has a line number ! 697: greater than the present instruction, the present number ! 698: is transfered down */ ! 699: ! 700: void ! 701: ldelin(nodep) ! 702: NODE * nodep; ! 703: { ! 704: if(nodep->uniqid == IDVAL) ! 705: return; ! 706: ! 707: if(nodep->forw != &ntail && ! 708: (nodep->forw->uniqid > nodep->uniqid ! 709: || nodep->forw->uniqid == IDVAL)) ! 710: nodep->forw->uniqid = nodep->uniqid; ! 711: ! 712: nodep->uniqid = IDVAL; ! 713: ! 714: } ! 715: ! 716: /* more conservative version of lndelinst that does not overwrite ! 717: line numbers below */ ! 718: void ! 719: ldelin2(nodep) ! 720: NODE *nodep; ! 721: { ! 722: if(nodep == IDVAL) ! 723: return; ! 724: ! 725: if(nodep->forw != &ntail && nodep->forw->uniqid == IDVAL) ! 726: nodep->forw->uniqid = nodep->uniqid; ! 727: ! 728: nodep->uniqid = IDVAL; ! 729: ! 730: } ! 731: ! 732: ! 733: /* exchange instructions ! 734: The line number of the first instruction, if any, is given to the ! 735: second instruction. The line number of the second instruction is ! 736: deleted. */ ! 737: void ! 738: lexchin(nodep1,nodep2) ! 739: NODE *nodep1, *nodep2; ! 740: { ! 741: if(nodep1->uniqid != IDVAL) { ! 742: nodep2->uniqid = nodep1->uniqid; ! 743: nodep1->uniqid = IDVAL; ! 744: } ! 745: else { ! 746: nodep2->uniqid = IDVAL; ! 747: } ! 748: } ! 749: ! 750: ! 751: /* merge instructions - case 1 ! 752: The result instruction is given the line number of the ! 753: top instruction, if it exists, or else it is given the line ! 754: number of the bottom instruction. */ ! 755: void ! 756: lmrgin1(nodep1,nodep2,resnode) ! 757: NODE *nodep1, *nodep2, *resnode; ! 758: { ! 759: IDTYPE val1, val2; ! 760: ! 761: val1 = nodep1->uniqid; ! 762: val2 = nodep2->uniqid; ! 763: ! 764: nodep1->uniqid = nodep2->uniqid = IDVAL; ! 765: ! 766: if(val1 != IDVAL) ! 767: resnode->uniqid = val1; ! 768: else ! 769: resnode->uniqid = val2; ! 770: ! 771: } ! 772: ! 773: ! 774: /* instruction merge - case 2 ! 775: The resultant instruction is given the line number of the ! 776: top instruction, if it exists, else it is not given a line number */ ! 777: void ! 778: lmrgin2(nodep1,nodep2,resnode) ! 779: NODE *nodep1, *nodep2, *resnode; ! 780: { ! 781: IDTYPE val1; ! 782: ! 783: val1 = nodep1->uniqid; ! 784: ! 785: nodep1->uniqid = nodep2->uniqid = IDVAL; ! 786: ! 787: resnode->uniqid = val1; ! 788: ! 789: } ! 790: ! 791: /* instruction merge - case 3 ! 792: The resultant instruction is given the line number of the first ! 793: instruction, if it exists. The instruction below the pair to be ! 794: merged is given the line number of the second instruction, ! 795: if it exists */ ! 796: void ! 797: lmrgin3(nodep1,nodep2,resnode) ! 798: NODE *nodep1, *nodep2, *resnode; ! 799: { ! 800: IDTYPE val1; ! 801: ! 802: ldelin2(nodep2); ! 803: ! 804: val1 = nodep1->uniqid; ! 805: ! 806: nodep1->uniqid = nodep2->uniqid = IDVAL; ! 807: ! 808: resnode->uniqid = val1; ! 809: } ! 810: ! 811: /* isiros -- is operand either immediate, register or on stack? ! 812: ** ! 813: ** This routine returns true if the the operand ! 814: ** pointed to by its argument has address mode ! 815: ** ! 816: ** immediate, ! 817: ** register, or ! 818: ** offset from a stack pointer (fp, ap, or sp). ! 819: ** ! 820: ** This test is provided for checking operands to see whether they ! 821: ** can be memory mapped i/o references. ! 822: */ ! 823: ! 824: boolean ! 825: isiros( op ) ! 826: char *op; ! 827: { ! 828: return( *op == '&' || ! 829: *op == '%' || ! 830: ( *op != '*' && ! 831: ( usesreg( op, "%fp" ) || ! 832: usesreg( op, "%ap" ) || ! 833: usesreg( op, "%sp" ) ! 834: ) ! 835: ) ! 836: ); ! 837: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.