Return to reg1.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / n1 / i386

Annotation of coherent/b/bin/c/n1/i386/reg1.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * n1/i386/reg1.c
        !             3:  * Machine specific parts of the register allocator.
        !             4:  * i386.
        !             5:  */
        !             6: 
        !             7: #ifdef   vax
        !             8: #include "INC$LIB:cc1.h"
        !             9: #else
        !            10: #include "cc1.h"
        !            11: #endif
        !            12: 
        !            13: /*
        !            14:  * Select a register.
        !            15:  * The argument 'tp' is the tree.
        !            16:  * The argument 'c' is a context, which will be either 'PAIR' or 'ANY'.
        !            17:  * The 'flag' is true if ANY should be resolved.
        !            18:  */
        !            19: regselect(tp, c, flag) TREE *tp; int c, flag;
        !            20: {
        !            21:        register REGDESC        *rp;
        !            22:        register KIND           kind;
        !            23:        register PREGSET        busy;
        !            24:        register PERTYPE        *ptp;
        !            25: 
        !            26:        ptp = &pertype[tp->t_type];
        !            27:        if (c == PAIR)
        !            28:                kind = ptp->p_pair;
        !            29:        else if (flag==0)
        !            30:                return c;
        !            31:        kind = ptp->p_kind;
        !            32:        busy = curbusy;
        !            33:        for (rp = &reg[FRREG]; rp<&reg[NRREG]; ++rp) {
        !            34:                if ((rp->r_phys&busy) != 0)
        !            35:                        continue;
        !            36:                if (c == ANYL) {
        !            37:                        if ((rp->r_lvalue&kind) == 0)
        !            38:                                continue;
        !            39:                } else {
        !            40:                        if ((rp->r_rvalue&kind) == 0)
        !            41:                                continue;
        !            42:                }
        !            43:                if (bytereg(tp, tp->t_patp) && (rp->r_phys&~(BEAX|BEBX|BECX|BEDX))!=0)
        !            44:                        continue;
        !            45:                return (rp - &reg[0]);
        !            46:        }
        !            47:        return -1;
        !            48: }
        !            49: 
        !            50: /*
        !            51:  * Return true if register 'r' is a usable temporary for tree 'tp'.
        !            52:  */
        !            53: isusable(tp, c, r) register TREE *tp; int c; register int r;
        !            54: {
        !            55:        register int    op;
        !            56:        register KIND   kind;
        !            57: 
        !            58: #if !TINY
        !            59:        if (sflag > 2)
        !            60:                snapf("Isusable(%P, %C, %R)? ", tp, c, r);
        !            61: #endif
        !            62:        op = tp->t_op;
        !            63:        kind = pertype[tp->t_type].p_kind;
        !            64:        if (c == MLVALUE) {
        !            65:                if ((reg[r].r_lvalue&kind) == 0)
        !            66:                        goto no;
        !            67:        } else {
        !            68:                if ((reg[r].r_rvalue&kind) == 0)
        !            69:                        goto no;
        !            70:        }
        !            71:        if (bytereg(tp, tp->t_patp) && (reg[r].r_phys&~(BEAX|BEBX|BECX|BEDX))!=0)
        !            72:                goto no;
        !            73: #if !TINY
        !            74:        if (sflag > 2)
        !            75:                snapf("yes\n");
        !            76: #endif
        !            77:        return 1;
        !            78: no:
        !            79: #if !TINY
        !            80:        if (sflag > 2)
        !            81:                snapf("no\n");
        !            82: #endif
        !            83:        return 0;
        !            84: }
        !            85: 
        !            86: /*
        !            87:  * Test if a pattern requires a byte register.
        !            88:  * This prevents e.g. applying the LO LO macro to EDI or ESI.
        !            89:  * The first argument is archaic.
        !            90:  * dgc kludged the i8086 compiler source to look at tp
        !            91:  * to decide if the tree needed a byte register.
        !            92:  * steve added the PBYTE pattern flag for the i386 compiler,
        !            93:  * so bytereg() now looks at the pattern instead of at the tree.
        !            94:  * Only patterns with BYTE left or right arg types require byte registers.
        !            95:  * The tp argument is retained to maintain compatiblity
        !            96:  * with other machine-dependent sources, namely i8086.
        !            97:  */
        !            98: int
        !            99: bytereg(tp, patp) register TREE *tp; register PAT *patp;
        !           100: {
        !           101:        register INDEX index;
        !           102:        register TREE *rp;
        !           103: 
        !           104:        index = patp->p_flag;
        !           105:        return (index != 0 && (patcache[index-1] & PBYTE) != 0
        !           106:                && (isbyte(tp->t_lp->t_type)
        !           107:                  || ((rp = tp->t_rp) != NULL && isbyte(rp->t_type))));
        !           108: }
        !           109: 
        !           110: /* end of n1/i386/reg1.c */

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