Return to regs.c CVS log

Up to [Research Unix] / researchv9 / cmd / adb / vax

Annotation of researchv9/cmd/adb/vax/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: #include <sys/param.h>
                      9: 
                     10: struct reglist {
                     11:        char    *rname;
                     12:        short   roffs;
                     13:        short   rsys;
                     14:        TREG    rval;
                     15: };
                     16: 
                     17: struct reglist reglist[] = {
                     18:        {"p1lr", P1LR, 1},
                     19:        {"p1br", P1BR, 1},
                     20:        {"p0lr", P0LR, 1},
                     21:        {"p0br", P0BR, 1},
                     22:        {"ksp", KSP, 1},
                     23:        {"esp", ESP, 1},
                     24:        {"ssp", SSP, 1},
                     25: #define        FW      7       /* first register we may write */
                     26:        {"psl", PSL, 0},
                     27:        {"pc",  PC, 0},
                     28:        {"sp",  USP, 0},
                     29:        {"fp",  FP, 0},
                     30:        {"ap",  AP, 0},
                     31:        {"r11", R11, 0},
                     32:        {"r10", R10, 0},
                     33:        {"r9",  R9, 0},
                     34:        {"r8",  R8, 0},
                     35:        {"r7",  R7, 0},
                     36:        {"r6",  R6, 0},
                     37:        {"r5",  R5, 0},
                     38:        {"r4",  R4, 0},
                     39:        {"r3",  R3, 0},
                     40:        {"r2",  R2, 0},
                     41:        {"r1",  R1, 0},
                     42:        {"r0",  R0, 0},
                     43:        {NULL}
                     44: };
                     45: 
                     46: /*
                     47:  * the following are needed only to
                     48:  * make registers `addressable'
                     49:  * which is needed only so we can
                     50:  * examine register variables
                     51:  */
                     52: 
                     53: ADDR raddr[MAXREG - MINREG + 1];
                     54: int roffs[MAXREG - MINREG + 1] = {
                     55:        R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11
                     56: };
                     57: 
                     58: /*
                     59:  * get/put registers
                     60:  * in our saved copies
                     61:  */
                     62: 
                     63: TREG
                     64: rget(r)
                     65: {
                     66:        register struct reglist *rp;
                     67: 
                     68:        for (rp = reglist; rp->rname; rp++)
                     69:                if (rp->roffs == r)
                     70:                        return (rp->rval);
                     71:        error("panic: rget");
                     72:        /* NOTREACHED */
                     73: }
                     74: 
                     75: rput(r, v)
                     76: TREG v;
                     77: {
                     78:        register struct reglist *rp;
                     79: 
                     80:        for (rp = reglist; rp->rname; rp++)
                     81:                if (rp->roffs == r) {
                     82:                        rp->rval = v;
                     83:                        return;
                     84:                }
                     85:        error("panic: rput");
                     86:        /* NOTREACHED */
                     87: }
                     88: 
                     89: /*
                     90:  * grab registers into saved copy
                     91:  * should be called before looking at the process
                     92:  */
                     93: 
                     94: rsnarf()
                     95: {
                     96:        register struct reglist *rp;
                     97: 
                     98:        for (rp = reglist; rp->rname; rp++) {
                     99:                rp->rval = 0;
                    100:                fget((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                    101:        }
                    102: }
                    103: 
                    104: /*
                    105:  * put registers back
                    106:  */
                    107: 
                    108: rrest()
                    109: {
                    110:        register struct reglist *rp;
                    111: 
                    112:        if (pid == 0)
                    113:                return;
                    114:        for (rp = &reglist[FW]; rp->rname; rp++)
                    115:                fput((ADDR)rp->roffs, CORF|UBLKSP, (char *)&rp->rval, SZREG);
                    116: }
                    117: 
                    118: /*
                    119:  * print the registers
                    120:  */
                    121: 
                    122: printregs(c)
                    123: char c;
                    124: {
                    125:        register struct reglist *rp;
                    126: 
                    127:        for (rp = reglist; rp->rname; rp++) {
                    128:                if (rp->rsys == 1 && c != 'R')
                    129:                        continue;
                    130:                printf("%-8R >%s\n", rtow(rp->rval), rp->rname);
                    131:        }
                    132:        printpc();
                    133: }
                    134: 
                    135: /*
                    136:  * translate a name to a magic register offset
                    137:  * the latter useful in rget/rput
                    138:  */
                    139: 
                    140: int
                    141: rname(n)
                    142: char *n;
                    143: {
                    144:        register struct reglist *rp;
                    145: 
                    146:        for (rp = reglist; rp->rname; rp++)
                    147:                if (strcmp(n, rp->rname) == 0)
                    148:                        return (rp->roffs);
                    149:        return (BADREG);
                    150: }

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