Return to regs.c CVS log

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

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

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