Return to regs.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / g

Annotation of researchv10no/cmd/adb/g/regs.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * code to keep track of registers
                      3:  */
                      4: 
                      5: #include "defs.h"
                      6: #include "regs.h"
                      7: #include "space.h"
                      8: 
                      9: struct reglist {
                     10:        char    *rname;
                     11:        short   roffs;
                     12:        short   rsys;
                     13:        TREG    rval;
                     14: };
                     15: 
                     16: struct reglist reglist[] = {
                     17:        {"ps",  PS, 0},
                     18:        {"pc",  PC, 0},
                     19:        {"sp",  SP, 0},
                     20:        {"fp",  A6, 0},
                     21:        {"a5",  A5, 0},
                     22:        {"a4",  A4, 0},
                     23:        {"a3",  A3, 0},
                     24:        {"a2",  A2, 0},
                     25:        {"a1",  A1, 0},
                     26:        {"a0",  A0, 0},
                     27:        {"d7",  D7, 0},
                     28:        {"d6",  D6, 0},
                     29:        {"d5",  D5, 0},
                     30:        {"d4",  D4, 0},
                     31:        {"d3",  D3, 0},
                     32:        {"d2",  D2, 0},
                     33:        {"d1",  D1, 0},
                     34:        {"d0",  D0, 0},
                     35:        {NULL}
                     36: };
                     37: 
                     38: /*
                     39:  * the following are needed only to
                     40:  * make registers `addressable'
                     41:  * which is needed only so we can
                     42:  * examine register variables
                     43:  */
                     44: 
                     45: ADDR raddr[MAXREG - MINREG + 1];
                     46: int roffs[MAXREG - MINREG + 1] = {
                     47: #if NOTDEF
                     48:        R0, R1, R2, R3, R4, R5
                     49: #else
                     50:        0
                     51: #endif
                     52: };
                     53: 
                     54: /*
                     55:  * get/put registers
                     56:  * in our saved copies
                     57:  */
                     58: 
                     59: TREG
                     60: rget(r)
                     61: {
                     62:        register struct reglist *rp;
                     63: 
                     64:        for (rp = reglist; rp->rname; rp++)
                     65:                if (rp->roffs == r)
                     66:                        return (rp->rval);
                     67:        error("panic: rget");
                     68:        /* NOTREACHED */
                     69: }
                     70: 
                     71: rput(r, v)
                     72: TREG v;
                     73: {
                     74:        register struct reglist *rp;
                     75: 
                     76:        for (rp = reglist; rp->rname; rp++)
                     77:                if (rp->roffs == r) {
                     78:                        rp->rval = v;
                     79:                        return;
                     80:                }
                     81:        error("panic: rput");
                     82:        /* NOTREACHED */
                     83: }
                     84: 
                     85: /*
                     86:  * grab registers into saved copy
                     87:  * should be called before looking at the process
                     88:  */
                     89: 
                     90: rsnarf()
                     91: {
                     92:        register struct reglist *rp;
                     93: 
                     94:        for (rp = reglist+1; rp->rname; rp++) {
                     95:                rp->rval = 0;
                     96:                fget((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                     97:        }
                     98:        reglist[0].rval = (WORD)sget((ADDR)PS, CORF|UBLKSP);
                     99: }
                    100: 
                    101: /*
                    102:  * put registers back
                    103:  */
                    104: 
                    105: rrest()
                    106: {
                    107:        register struct reglist *rp;
                    108: 
                    109:        if (pid == 0)
                    110:                return;
                    111:        for (rp = reglist+1; rp->rname; rp++)
                    112:                fput((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                    113:        sput((ADDR)PS, CORF|UBLKSP, (TSHORT)reglist[0].rval);
                    114: }
                    115: 
                    116: /*
                    117:  * print the registers
                    118:  */
                    119: 
                    120: printregs(c)
                    121: char c;
                    122: {
                    123:        register struct reglist *rp;
                    124: 
                    125:        for (rp = reglist; rp->rname; rp++) {
                    126:                if (rp->rsys == 1 && c != 'R')
                    127:                        continue;
                    128:                printf("%-8R >%s\n", rtow(rp->rval), rp->rname);
                    129:        }
                    130:        printpc();
                    131: }
                    132: 
                    133: /*
                    134:  * translate a name to a magic register offset
                    135:  * the latter useful in rget/rput
                    136:  */
                    137: 
                    138: int
                    139: rname(n)
                    140: char *n;
                    141: {
                    142:        register struct reglist *rp;
                    143: 
                    144:        for (rp = reglist; rp->rname; rp++)
                    145:                if (strcmp(n, rp->rname) == 0)
                    146:                        return (rp->roffs);
                    147:        return (BADREG);
                    148: }

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