Return to code.c CVS log

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

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

1.1       root        1: /*
                      2:  * C compiler.
                      3:  * Code driver (sel, out)
                      4:  */
                      5: #ifdef   vax
                      6: #include "INC$LIB:cc1.h"
                      7: #else
                      8: #include "cc1.h"
                      9: #endif
                     10: 
                     11: PREGSET        curbusy;
                     12: PREGSET        curxreg;
                     13: PREGSET        maxbusy;
                     14: int    nstorelist;
                     15: TREE   *storelist[NSTORE];
                     16: 
                     17: /*
                     18:  * Generate code for an
                     19:  * expression. The argument `tp' is
                     20:  * a pointer to a marked tree. 
                     21:  * The context is `c'. If `c' is MFLOW
                     22:  * then `r' is a truth sense and `n'
                     23:  * is a label.
                     24:  */
                     25: code(tp, c, s, n)
                     26: TREE *tp;
                     27: register s;
                     28: {
                     29:        register TREE *ap;
                     30: 
                     31:        ap = tp;
                     32:        walk(ap, amd);
                     33: #if !TINY
                     34:        if (sflag) snapf("%W%E", "Before select", ap);
                     35: #endif
                     36:        if (c != MFLOW) {
                     37:                s = ANYR;
                     38:                if (c == MSWITCH) {
                     39:                        s = SWREG;
                     40:                        c = MRVALUE;
                     41:                }
                     42:                if (c == MRETURN) {
                     43:                        s = pertype[ap->t_type].p_frreg;
                     44:                        c = pertype[ap->t_type].p_frcxt;
                     45:                }
                     46:        }
                     47:        curtemp = maxauto;
                     48:        curbusy = regbusy;
                     49:        curxreg = 0;
                     50:        nstorelist = 0;
                     51:        if (code1(&tp, c, s) != 0) {
                     52:                ap = tp;
                     53: #if !TINY
                     54:                if (sflag) snapf("%W%E%W", "After select", ap, NULL);
                     55: #endif
                     56:                output(ap, c, s, n);
                     57:        } else
                     58:                nomatch(tp);
                     59: }
                     60: 
                     61: nomatch(tp)
                     62: TREE *tp;
                     63: {
                     64: #if !TINY
                     65:        snapf("%W%E%W", "No match", tp, NULL);
                     66:        if (! sflag)
                     67: #endif
                     68:        cbotch("no match, op=%d", tp->t_op);
                     69: }
                     70: 
                     71: /*
                     72:  * Select the node pointed to by tpp
                     73:  * and any stores generated by its selection.
                     74:  * Prepend the store nodes onto tpp with
                     75:  * COMMA's and store the result node into tpp.
                     76:  * This routine makes side effects happen
                     77:  * in the right places.
                     78:  * A failure to select is fatal.
                     79:  */
                     80: code1(tpp, c, r)
                     81: TREE **tpp;
                     82: {
                     83:        register TREE   *ap;
                     84:        int     match;
                     85:        PREGSET savbusy;
                     86:        PREGSET savxreg;
                     87:        int     savstor;
                     88: 
                     89:        ap = *tpp;
                     90:        match = 1;
                     91:        savbusy = curbusy;
                     92:        savxreg = curxreg;
                     93:        savstor = nstorelist;
                     94: 
                     95: #if !TINY
                     96:        if (sflag > 1) snapf("%W%E", "Before code1", ap);
                     97: #endif
                     98:        if (select(ap, c, r) == 0) {
                     99:                /* nomatch(ap); */
                    100:                match = 0;
                    101:        }
                    102: 
                    103:        if (savstor < nstorelist) {
                    104:                register int i;
                    105:                PREGSET used;
                    106:                REGNAME rreg;
                    107:                int     type;
                    108:                int     size;
                    109: 
                    110:                used = ap->t_used;
                    111:                rreg = ap->t_rreg;
                    112:                type = ap->t_type;
                    113:                size = ap->t_size;
                    114:                for (i = savstor; i < nstorelist; i += 1) {
                    115:                        curbusy = savbusy;
                    116:                        curxreg = 0;
                    117:                        ap = storelist[i];
                    118:                        if (select(ap, MEFFECT, ANYR) == 0) {
                    119:                                /* nomatch(ap); */
                    120:                                match = 0;
                    121:                        }
                    122: #if !TINY
                    123:                        if (sflag > 2)
                    124:                                snapf("%W%E%W", "Stored node", ap, NULL);
                    125: #endif
                    126:                        used |= ap->t_used;
                    127:                        ap = leftnode(COMMA, ap, type, size);
                    128:                        ap->t_used = used;
                    129:                        ap->t_rreg = rreg;
                    130:                        ap->t_rp = *tpp;
                    131:                        *tpp = ap;
                    132:                }
                    133:        }
                    134:        if (curtemp > maxtemp)
                    135:                maxtemp = curtemp;
                    136:        maxbusy |= ap->t_used;
                    137:        curbusy = savbusy;
                    138:        curxreg = savxreg;
                    139:        nstorelist = savstor;
                    140:        return (match);
                    141: }
                    142: 
                    143: 

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