Return to reg.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / alef / k

Annotation of lucent/sys/src/alef/k/reg.c, revision 1.1

1.1     ! root        1: #include <u.h>
        !             2: #include <libc.h>
        !             3: #include <bio.h>
        !             4: #include <ctype.h>
        !             5: #define Extern extern
        !             6: #include "parl.h"
        !             7: #include "globl.h"
        !             8: 
        !             9: int regmap[65];
        !            10: 
        !            11: void
        !            12: reginit(void)
        !            13: {
        !            14:        regmap[Retfreg]++;
        !            15:        regmap[Retireg]++;
        !            16:        regmap[Reglink]++;
        !            17:        regmap[Regtmp]++;
        !            18: 
        !            19:        privreg = Pregs;
        !            20: }
        !            21: 
        !            22: void
        !            23: regcheck(void)
        !            24: {
        !            25:        int r, e;
        !            26: 
        !            27:        e = 0;
        !            28:        for(r = Ireg; r < Maxireg; r++)
        !            29:                if(regmap[r]) {
        !            30:                        switch(r) {
        !            31:                        default:
        !            32:                                print("R%d still used\n", r);
        !            33:                                e++;
        !            34:                                break;
        !            35:                        case Retfreg:
        !            36:                        case Retireg:
        !            37:                        case Reglink:
        !            38:                        case Regtmp:
        !            39:                                break;
        !            40:                        }
        !            41:                }
        !            42: 
        !            43:        for(r = Freg; r < Maxfreg; r++)
        !            44:                if(regmap[r] && (r != Retfreg || regmap[Retfreg] != 1)) {
        !            45:                        print("F%d still used\n", r);
        !            46:                        e++;
        !            47:                }
        !            48:        if(e)
        !            49:                fatal("regcheck %P", curfunc);
        !            50: }
        !            51: 
        !            52: void
        !            53: reg(Node *n, Type *t, Node *use)
        !            54: {
        !            55:        int r, j;
        !            56:        static int ireg;
        !            57: 
        !            58:        switch(t->type) {
        !            59:        default:
        !            60:                fatal("reg: bad type %T", t);
        !            61: 
        !            62:        case TINT:
        !            63:        case TUINT:
        !            64:        case TSINT:
        !            65:        case TSUINT:
        !            66:        case TCHAR:
        !            67:        case TIND:
        !            68:        case TCHANNEL:
        !            69:                if(use && use->type == OREGISTER && use->reg < Freg) {
        !            70:                        r = use->reg;
        !            71:                        break;
        !            72:                }
        !            73:                j = ireg+Ireg;
        !            74:                for(r = Ireg; r < Maxireg; r++) {
        !            75:                        if(j >= Maxireg)
        !            76:                                j = Ireg;
        !            77:                        if(regmap[j] == 0) {
        !            78:                                r = j;
        !            79:                                break;
        !            80:                        }
        !            81:                        j++;
        !            82:                }
        !            83:                if(r >= Maxireg)
        !            84:                        fatal("No int registers");
        !            85:                break;
        !            86: 
        !            87:        case TFLOAT:
        !            88:                if(use && use->type == OREGISTER && use->reg >= Freg) {
        !            89:                        r = use->reg;
        !            90:                        break;
        !            91:                }
        !            92: 
        !            93:                j = ireg*2+Freg;
        !            94:                for(r = Freg; r < Maxfreg; r += 2) {
        !            95:                        if(j >= Maxfreg)
        !            96:                                j = Ireg;
        !            97:                        if(regmap[j] == 0) {
        !            98:                                r = j;
        !            99:                                break;
        !           100:                        }
        !           101:                        j += 2;
        !           102:                }
        !           103:                if(r >= Maxfreg)
        !           104:                        fatal("No float registers");
        !           105:                break;
        !           106:        }
        !           107:        ireg++;
        !           108:        if(ireg > 5)
        !           109:                ireg = 0;
        !           110:        regmap[r]++;
        !           111:        n->reg = r;
        !           112:        n->type = OREGISTER;
        !           113:        n->islval = 11;
        !           114:        n->sun = 0;
        !           115:        n->t = t;
        !           116: }
        !           117: 
        !           118: Node*
        !           119: regtmp(void)
        !           120: {
        !           121:        Node *n;
        !           122:        int r;
        !           123: 
        !           124:        n = an(OREGISTER, ZeroN, ZeroN);
        !           125:        n->t = builtype[TINT];
        !           126:        n->islval = 11;
        !           127:        n->sun = 0;
        !           128: 
        !           129:        for(r = Ireg; r < Maxireg; r++)
        !           130:                if(regmap[r] == 0) {
        !           131:                        n->reg = r;
        !           132:                        regmap[r]++;
        !           133:                        return n;
        !           134:                }
        !           135:        fatal("No int registers");
        !           136:        return ZeroN;   
        !           137: }
        !           138: 
        !           139: Node*
        !           140: regn(int nr)
        !           141: {
        !           142:        Node *n;
        !           143: 
        !           144:        n = an(OREGISTER, ZeroN, ZeroN);
        !           145:        if(nr >= Freg)
        !           146:                n->t = builtype[TFLOAT];
        !           147:        else
        !           148:                n->t = builtype[TINT];
        !           149:        n->islval = 11;
        !           150:        n->sun = 0;
        !           151:        n->reg = nr;
        !           152:        return n;
        !           153: }
        !           154: 
        !           155: void
        !           156: regret(Node *n, Type*t)
        !           157: {
        !           158:        int r;
        !           159: 
        !           160:        switch(t->type) {
        !           161:        default:
        !           162:                fatal("regret: bad type %T", t);
        !           163: 
        !           164:        case TINT:
        !           165:        case TUINT:
        !           166:        case TSINT:
        !           167:        case TSUINT:
        !           168:        case TCHAR:
        !           169:        case TIND:
        !           170:        case TCHANNEL:
        !           171:                r = Retireg;
        !           172:                break;
        !           173: 
        !           174:        case TFLOAT:
        !           175:                r = Retfreg;
        !           176:                break;
        !           177:        }
        !           178:        regmap[r]++;
        !           179:        n->reg = r;
        !           180:        n->type = OREGISTER;
        !           181:        n->t = t;
        !           182: }
        !           183: 
        !           184: void
        !           185: regfree(Node *n)
        !           186: {
        !           187:        if(regmap[n->reg] <= 0)
        !           188:                fatal("regfree");
        !           189: 
        !           190:        regmap[n->reg]--;
        !           191: }
        !           192: 
        !           193: /*
        !           194:  * look for a constant which fits in a sparc immediate
        !           195:  */
        !           196: int
        !           197: immed(Node *n)
        !           198: {
        !           199:        long ival;
        !           200: 
        !           201:        if(n->type != OCONST || n->t->type == TFLOAT)
        !           202:                return 0;
        !           203: 
        !           204:        ival = n->ival;
        !           205:        if(ival >= -(1<<12) && ival < (1<<12))
        !           206:                return 1;
        !           207: 
        !           208:        return 0;
        !           209: }
        !           210: 
        !           211: /*
        !           212:  * Return the name of an activation argument
        !           213:  */
        !           214: Node*
        !           215: atvnode(Type *t)
        !           216: {
        !           217:        int o;
        !           218:        Node *n;
        !           219: 
        !           220:        n = an(OREGISTER, ZeroN, ZeroN);
        !           221:        n->reg = ratv.reg;
        !           222:        n->ival = 0;
        !           223:        n->t = at(TIND, t);
        !           224: 
        !           225:        o = align(ratv.ival, builtype[TINT]);
        !           226:        ratv.ival = o+t->size;
        !           227:        if(ratv.ival > maxframe)
        !           228:                maxframe = ratv.ival;
        !           229: 
        !           230:        /* Adjust offset within int for smaller types */
        !           231:        switch(t->type) {
        !           232:        case TSINT:
        !           233:        case TSUINT:
        !           234:                o += Shortfoff;
        !           235:                break;
        !           236: 
        !           237:        case TCHAR:
        !           238:                o += Charfoff;
        !           239:                break;
        !           240:        }
        !           241: 
        !           242:        n = an(OADD, n, con(o));
        !           243:        n->t = n->left->t;
        !           244:        n = an(OIND, n, ZeroN);
        !           245:        n->t = t;
        !           246: 
        !           247:        sucalc(n);
        !           248:        return n;
        !           249: }
        !           250: 
        !           251: /*
        !           252:  * Make a node to alias an argument
        !           253:  */
        !           254: Node*
        !           255: argnode(Type *t)
        !           256: {
        !           257:        Node *n;
        !           258:        int o;
        !           259: 
        !           260:        if(atv)
        !           261:                return atvnode(t);
        !           262: 
        !           263:        n = an(ONAME, ZeroN, ZeroN);
        !           264:        n->t = t;
        !           265:        n->ti = ati(t, Argument);
        !           266:        args = align(args, builtype[TINT]);
        !           267:        o = args;
        !           268: 
        !           269:        /* Adjust offset within int for smaller types */
        !           270:        switch(t->type) {
        !           271:        case TSINT:
        !           272:        case TSUINT:
        !           273:                o += Shortfoff;
        !           274:                break;
        !           275: 
        !           276:        case TCHAR:
        !           277:                o += Charfoff;
        !           278:                break;
        !           279:        }
        !           280: 
        !           281:        n->ti->offset = o;
        !           282:        args += t->size;
        !           283: 
        !           284:        sucalc(n);
        !           285:        return n;
        !           286: }
        !           287: 
        !           288: Node*
        !           289: paramnode(Type *t)
        !           290: {
        !           291:        Node *n;
        !           292: 
        !           293:        USED(t);
        !           294: 
        !           295:        while(tip->class != Parameter)
        !           296:                tip = tip->dcllist;
        !           297: 
        !           298:        n = an(ONAME, ZeroN, ZeroN);
        !           299:        n->sym = tip->s;
        !           300:        n->ti = tip;
        !           301:        n->t = tip->t;
        !           302: 
        !           303:        /* for next time */
        !           304:        tip = tip->dcllist;
        !           305: 
        !           306:        sucalc(n);
        !           307:        return n;
        !           308: }
        !           309: 
        !           310: /*
        !           311:  * Make a stack temporary node and allocate space in the frame
        !           312:  */
        !           313: Node*
        !           314: stknode(Type *o)
        !           315: {
        !           316:        Node *n;
        !           317:        char buf[10];
        !           318: 
        !           319:        n = an(ONAME, ZeroN, ZeroN);
        !           320:        n->sym = malloc(sizeof(Sym));
        !           321:        n->ti = ati(o, Automatic);
        !           322:        n->t = o;
        !           323: 
        !           324:        sprint(buf, ".t%d", stmp++);
        !           325:        n->sym->name = strdup(buf);
        !           326: 
        !           327:        /* Allocate the space */
        !           328:        frame = align(frame, o);
        !           329:        frame += o->size;
        !           330: 
        !           331:        n->ti->offset = -frame;
        !           332:        sucalc(n);
        !           333:        return n;
        !           334: }
        !           335: 
        !           336: Node*
        !           337: internnode(Type *o)
        !           338: {
        !           339:        Node *n;
        !           340:        char buf[10];
        !           341: 
        !           342:        n = an(ONAME, ZeroN, ZeroN);
        !           343:        n->sym = malloc(sizeof(Sym));
        !           344:        n->t = at(o->type, 0);
        !           345:        n->t->class = Internal;
        !           346:        n->ti = ati(n->t, Internal);
        !           347: 
        !           348:        sprint(buf, ".i%d", stmp++);
        !           349:        n->sym->name = strdup(buf);
        !           350: 
        !           351:        n->ti->offset = 0;
        !           352:        sucalc(n);
        !           353: 
        !           354:        n->init = ZeroN;
        !           355:        gendata(n);
        !           356: 
        !           357:        return n;
        !           358: }
        !           359: 
        !           360: Node*
        !           361: con(int i)
        !           362: {
        !           363:        Node *c;
        !           364: 
        !           365:        c = an(OCONST, ZeroN, ZeroN);
        !           366:        c->t = builtype[TINT];
        !           367:        c->ival = i;
        !           368: 
        !           369:        return c;
        !           370: }
        !           371: 
        !           372: Node*
        !           373: conf(double d)
        !           374: {
        !           375:        Node *c;
        !           376: 
        !           377:        c = an(OCONST, ZeroN, ZeroN);
        !           378:        c->t = builtype[TFLOAT];
        !           379:        c->fval = d;
        !           380: 
        !           381:        return c;
        !           382: }

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