Return to reg0.c CVS log

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

Annotation of coherent/b/bin/c/n1/reg0.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * This file contains the
                      3:  * machine independent parts of register
                      4:  * allocation. Most has to do with
                      5:  * extracting information from the register
                      6:  * tables.
                      7:  */
                      8: #ifdef   vax
                      9: #include "INC$LIB:cc1.h"
                     10: #else
                     11: #include "cc1.h"
                     12: #endif
                     13: 
                     14: /*
                     15:  * Get the name of the
                     16:  * high order half of a register pair.
                     17:  */
                     18: hihalf(r)
                     19: {
                     20:        return (reg[r].r_hihalf);
                     21: }
                     22: 
                     23: /*
                     24:  * Get the name of the
                     25:  * low half of a register pair.
                     26:  */
                     27: lohalf(r)
                     28: {
                     29:        return (reg[r].r_lohalf);
                     30: }
                     31: 
                     32: /*
                     33:  * Get the name of the register
                     34:  * pair that encloses the specified
                     35:  * register.
                     36:  */
                     37: enpair(r)
                     38: {
                     39:        return (reg[r].r_enpair);
                     40: }
                     41: 
                     42: /*
                     43:  * Check if a register is busy by
                     44:  * looking to see if any bits are set in
                     45:  * the busy mask.
                     46:  */
                     47: isbusy(r)
                     48: {
                     49:        if ((reg[r].r_phys&curbusy) != 0)
                     50:                return (1);
                     51:        return (0);
                     52: }
                     53: 
                     54: /*
                     55:  * Turn on the busy bits for register
                     56:  * `r' in the busy mask.
                     57:  */
                     58: setbusy(r)
                     59: {
                     60:        curbusy |= reg[r].r_phys;
                     61: }
                     62: 
                     63: /*
                     64:  * Turn off the busy bits for register
                     65:  * `r' in the busy mask.
                     66:  */
                     67: clrbusy(r)
                     68: {
                     69:        curbusy &= ~reg[r].r_phys;
                     70: }
                     71: 
                     72: /*
                     73:  * Allocate a register. The
                     74:  * register will be able to hold the
                     75:  * result type of tree `tp'.
                     76:  * Registers in the `used' set will
                     77:  * be avoided.
                     78:  * Flag = 0 means rvalue temp.
                     79:  * Flag = 1 means offset temp.
                     80:  * Flag = 2 means index  temp.
                     81:  * The register name is returned. A
                     82:  * -1 is returned if no register is
                     83:  * available.
                     84:  */
                     85: rallo(tp, used, flag)
                     86: TREE *tp;
                     87: register PREGSET used;
                     88: {
                     89:        register REGDESC *rp;
                     90:        register KIND kind;
                     91: 
                     92:        kind  = pertype[tp->t_type].p_kind;
                     93:        used |= curbusy;
                     94:        if (flag != 2)
                     95:                used |= curxreg;
                     96:        rp = &reg[NRREG];
                     97:        while (--rp >= &reg[FRREG]) {
                     98:                if ((rp->r_phys&used) != 0)
                     99:                        continue;
                    100:                if (flag == 0) {
                    101:                        if ((rp->r_rvalue&kind) == 0)
                    102:                                continue;
                    103:                } else {
                    104:                        if ((rp->r_lvalue&kind) == 0)
                    105:                                continue;
                    106:                }
                    107:                return (rp - &reg[0]);
                    108:        }
                    109:        return (-1);
                    110: }
                    111: 
                    112: /*
                    113:  * This routine figures out the
                    114:  * register name that gets passed down to
                    115:  * a subordinate. The first argument `s'
                    116:  * is a selector. The second is the current
                    117:  * temp. 
                    118:  */
                    119: reguse(selreg, tmpreg)
                    120: register selreg;
                    121: register tmpreg;
                    122: {
                    123:        if (selreg == TEMP)
                    124:                selreg = tmpreg;
                    125:        else if (selreg == LOTEMP)
                    126:                selreg = lohalf(tmpreg);
                    127:        else if (selreg == HITEMP)
                    128:                selreg = hihalf(tmpreg);
                    129:        return (selreg);
                    130: }

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