Return to regs.c CVS log

Up to [Research Unix] / researchv8dc / cmd / adb

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

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