Return to w3opt.c CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / optim

Annotation of researchv9/jerq/sgs/optim/w3opt.c, revision 1.1

1.1     ! root        1: /* @(#) w3opt.c: 1.4 3/27/84                           */
        !             2: /* w3opt.c
        !             3: **
        !             4: **     3B20S three-instruction window improver
        !             5: **
        !             6: **
        !             7: **
        !             8: ** This module contains improvements for three instruction windows,
        !             9: ** of which there aren't many.
        !            10: */
        !            11: 
        !            12: /* #include "defs" -- optim.h takes care of this */
        !            13: #include "optim.h"
        !            14: #include "optutil.h"
        !            15: /* w3opt -- 3-instruction peephole window */
        !            16: 
        !            17: boolean                                        /* true if changes made */
        !            18: w3opt(pf,pl)
        !            19: register NODE * pf;                    /* pointer to first inst. in window */
        !            20: register NODE * pl;                    /* pointer to last inst. in window */
        !            21: {
        !            22:     register NODE * pm = pf->forw;     /* point at middle node */
        !            23: 
        !            24:     int cop1 = pf->op;                 /* op code number of first inst. */
        !            25:     int cop2 = pm->op;                 /* op code number of second */
        !            26:     int cop3 = pl->op;                 /* ... of third */
        !            27: 
        !            28:     int src1 ;                         /* size (bytes) of source of move */
        !            29:     int dst1;                          /* size of destination of move */
        !            30: /* *p++ improvement
        !            31: **
        !            32: ** This improvement rearranges things to facilitate a later 2-instruction
        !            33: ** improvement.  We're looking for the kind of code the compiler generates
        !            34: ** (naively) for *p++.  We want to make an indirect reference possible:
        !            35: **
        !            36: **     movw    O1,R            ->      movw O1,R
        !            37: **     addw2   &n,O1           ->      movX 0(R),O2
        !            38: **     movX    0(R),O2         ->      addw2 &n,O1
        !            39: **
        !            40: ** or
        !            41: **     movw    O1,R            ->      movw O1,R
        !            42: **     addw2   &n,O1           ->      movX O2,0(R)
        !            43: **     movX    O2,0(R)         ->      addw2 &n,O1
        !            44: **
        !            45: **     if O1 is not a register used by O2
        !            46: **     if instruction following movX is not conditional branch, since
        !            47: **       we're setting different condition codes than before
        !            48: **     in the first case, O2 cannot be a register used by O1.
        !            49: **
        !            50: ** Note that this transformation is always correct because:
        !            51: **
        !            52: **     1.  O1 could not use R, or the first 2 instructions wouldn't work.
        !            53: **     2.  O2 can use or set R without problems.
        !            54: */
        !            55: 
        !            56:     if (
        !            57:            cop1 == MOVW
        !            58:        &&  cop2 == ADDW2
        !            59:        &&  ismove(pl,&src1,&dst1)
        !            60:        &&  isreg(pf->op2)
        !            61:        &&  *pm->op1 == '&'             /* immediate operand */
        !            62:        &&  strcmp(pf->op1,pm->op2) == 0
        !            63:        &&  isdeadcc( pl )
        !            64:        &&  ! usesvar(pm->op2,pl->op2)  /* O1 can't use O2 */
        !            65:        )
        !            66:     {
        !            67:        char * R = pf->op2;             /* point at register string */
        !            68:        char * O1 = pf->op1;            /* point at first operand */
        !            69:        char * O2;                      /* second operand */
        !            70: 
        !            71:        if (
        !            72:                (   ( O2 = pl->op2, iszoffset(pl->op1,R) ) /* test 0(R) */
        !            73:                ||  ( O2 = pl->op1, iszoffset(pl->op2,R) )
        !            74:                )
        !            75:            &&  ! usesvar(O2,O1)        /* O2 can't use O1 */
        !            76:            &&  ( isiros( O1 ) || isiros( O2 ) )
        !            77:                                        /* safe for mmio */
        !            78:            )
        !            79:        {
        !            80:            wchange();                  /* change the window */
        !            81:            lexchin(pm,pl);             /* preserve line number info */
        !            82:            exchange(pm);               /* exchange the last two nodes */
        !            83:            swplivecc(pm,pl);       /* swap live/dead info on condtion codes */
        !            84:            return(true);
        !            85:        }
        !            86:     }
        !            87: /* Remove redundant compares (see, also w2opt)
        !            88: **
        !            89: ** On the 3B20S, some instructions do not set all of the result
        !            90: ** indicators correctly.  Consequently it is only safe to remove
        !            91: ** a compare against zero if the following conditional jump only
        !            92: ** tests those bits which are set.  The canonical 3 instruction
        !            93: ** sequence is:
        !            94: **
        !            95: **     op O1,O2[,O3]
        !            96: **     cmpX O[2|3],&0
        !            97: **     jcond foo
        !            98: **
        !            99: ** For the instructions we test here, the only valid conditions to
        !           100: ** jump on are equal (zero) and not equal (non-zero).
        !           101: ** Note that signed tests are picked up correctly in w2opt for those
        !           102: ** instructions that generate correct result indicators.
        !           103: */
        !           104: 
        !           105:     if (
        !           106:            (cop2 == CMPW || cop2 == CMPH || cop2 == CMPB)
        !           107:        &&  strcmp(pm->op2,"&0") == 0
        !           108:        &&  strcmp(dst(pf),pm->op1) == 0
        !           109:        &&  (cop3 == JE || cop3 == JZ || cop3 == JNE || cop3 == JNZ)
        !           110:        &&  (MCOMB <= cop1 && cop1 <= UMODW3)
        !           111:        &&  stype(cop1) == stype(cop2)
        !           112:        &&  isiros(pm->op1)             /* safe from mmio */
        !           113:        )
        !           114:     {
        !           115:        wchange();
        !           116:        ldelin2(pm);                    /* preserve line number info */
        !           117:        mvlivecc(pm);       /* preserve live/dead info on condtion codes */
        !           118:        DELNODE(pm);                    /* delete the compare */
        !           119:        return(true);
        !           120:     }
        !           121:     return(false);
        !           122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.