Return to regs.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / 11v

Annotation of researchv10no/cmd/adb/11v/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:        {"r5",  R5, 0},
                     21:        {"r4",  R4, 0},
                     22:        {"r3",  R3, 0},
                     23:        {"r2",  R2, 0},
                     24:        {"r1",  R1, 0},
                     25:        {"r0",  R0, 0},
                     26:        {NULL}
                     27: };
                     28: 
                     29: /*
                     30:  * the following are needed only to
                     31:  * make registers `addressable'
                     32:  * which is needed only so we can
                     33:  * examine register variables
                     34:  */
                     35: 
                     36: ADDR raddr[MAXREG - MINREG + 1];
                     37: int roffs[MAXREG - MINREG + 1] = {
                     38: #if NOTDEF
                     39:        R0, R1, R2, R3, R4, R5
                     40: #else
                     41:        0
                     42: #endif
                     43: };
                     44: 
                     45: /*
                     46:  * get/put registers
                     47:  * in our saved copies
                     48:  */
                     49: 
                     50: TREG
                     51: rget(r)
                     52: {
                     53:        register struct reglist *rp;
                     54: 
                     55:        for (rp = reglist; rp->rname; rp++)
                     56:                if (rp->roffs == r)
                     57:                        return (rp->rval);
                     58:        error("panic: rget");
                     59:        /* NOTREACHED */
                     60: }
                     61: 
                     62: rput(r, v)
                     63: TREG v;
                     64: {
                     65:        register struct reglist *rp;
                     66: 
                     67:        for (rp = reglist; rp->rname; rp++)
                     68:                if (rp->roffs == r) {
                     69:                        rp->rval = v;
                     70:                        return;
                     71:                }
                     72:        error("panic: rput");
                     73:        /* NOTREACHED */
                     74: }
                     75: 
                     76: /*
                     77:  * grab registers into saved copy
                     78:  * should be called before looking at the process
                     79:  */
                     80: 
                     81: rsnarf()
                     82: {
                     83:        register struct reglist *rp;
                     84: 
                     85:        for (rp = reglist; rp->rname; rp++) {
                     86:                rp->rval = 0;
                     87:                fget((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                     88:        }
                     89: }
                     90: 
                     91: /*
                     92:  * put registers back
                     93:  */
                     94: 
                     95: rrest()
                     96: {
                     97:        register struct reglist *rp;
                     98: 
                     99:        if (pid == 0)
                    100:                return;
                    101:        for (rp = &reglist[0]; rp->rname; rp++)
                    102:                fput((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                    103: }
                    104: 
                    105: /*
                    106:  * print the registers
                    107:  */
                    108: 
                    109: printregs(c)
                    110: char c;
                    111: {
                    112:        register struct reglist *rp;
                    113: 
                    114:        for (rp = reglist; rp->rname; rp++) {
                    115:                if (rp->rsys == 1 && c != 'R')
                    116:                        continue;
                    117:                printf("%-8R >%s\n", rtow(rp->rval), rp->rname);
                    118:        }
                    119:        printpc();
                    120: }
                    121: 
                    122: /*
                    123:  * translate a name to a magic register offset
                    124:  * the latter useful in rget/rput
                    125:  */
                    126: 
                    127: int
                    128: rname(n)
                    129: char *n;
                    130: {
                    131:        register struct reglist *rp;
                    132: 
                    133:        for (rp = reglist; rp->rname; rp++)
                    134:                if (strcmp(n, rp->rname) == 0)
                    135:                        return (rp->roffs);
                    136:        return (BADREG);
                    137: }

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