Return to regs.c CVS log

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

Annotation of researchv9/cmd/adb/sun/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: #include <sys/dir.h>
                     10: #include <sys/user.h>
                     11: 
                     12: struct reglist {
                     13:        char    *rname;
                     14:        short   roffs;
                     15:        TREG    rval;
                     16: };
                     17: 
                     18: struct reglist reglist[] = {
                     19:        {"pc",  PC},
                     20:        {"ps",  PS},
                     21:        {"sp",  AR7},
                     22:        {"a6",  AR6},
                     23:        {"a5",  AR5},
                     24:        {"a4",  AR4},
                     25:        {"a3",  AR3},
                     26:        {"a2",  AR2},
                     27:        {"a1",  AR1},
                     28:        {"a0",  AR0},
                     29:        {"d7",  R7},
                     30:        {"d6",  R6},
                     31:        {"d5",  R5},
                     32:        {"d4",  R4},
                     33:        {"d3",  R3},
                     34:        {"d2",  R2},
                     35:        {"d1",  R1},
                     36:        {"d0",  R0},
                     37:        {NULL}
                     38: };
                     39: 
                     40: /*
                     41:  * the following are needed only to
                     42:  * make registers `addressable'
                     43:  * which is needed only so we can
                     44:  * examine register variables
                     45:  */
                     46: 
                     47: ADDR raddr[MAXREG - MINREG + 1];
                     48: int roffs[MAXREG - MINREG + 1] = {
                     49:        R0, R1, R2, R3, R4, R5, R6, R7, AR0, AR1, AR2, AR3, AR4, AR5, AR6,
                     50:        SP, PS, PC
                     51: };
                     52: 
                     53: /*
                     54:  * get/put registers
                     55:  * in our saved copies
                     56:  */
                     57: 
                     58: TREG
                     59: rget(r)
                     60: {
                     61:        register struct reglist *rp;
                     62: 
                     63:        for (rp = reglist; rp->rname; rp++)
                     64:                if (rp->roffs == r)
                     65:                        return (rp->rval);
                     66:        error("panic: rget");
                     67:        /* NOTREACHED */
                     68: }
                     69: 
                     70: rput(r, v)
                     71: TREG v;
                     72: {
                     73:        register struct reglist *rp;
                     74: 
                     75:        for (rp = reglist; rp->rname; rp++)
                     76:                if (rp->roffs == r) {
                     77:                        rp->rval = v;
                     78:                        return;
                     79:                }
                     80:        error("panic: rput");
                     81:        /* NOTREACHED */
                     82: }
                     83: 
                     84: /*
                     85:  * grab registers into saved copy
                     86:  * should be called before looking at the process
                     87:  */
                     88: 
                     89: rsnarf()
                     90: {
                     91:        register struct reglist *rp;
                     92:        struct user u;
                     93:        int *ip;
                     94: 
                     95:        fget((ADDR)0, CORF|UBLKSP, (char *)&u, sizeof(u));
                     96:        ip = (int *)(((int)u.u_ar0) & 0x1fff);
                     97:        for (rp = reglist; rp->rname; rp++) {
                     98:                rp->rval = 0;
                     99:                fget((ADDR)&ip[rp->roffs], CORF|UBLKSP,
                    100:                        (char *)&rp->rval, SZREG);
                    101:        }
                    102: }
                    103: 
                    104: /*
                    105:  * put registers back
                    106:  */
                    107: 
                    108: rrest()
                    109: {
                    110:        register struct reglist *rp;
                    111:        struct user u;
                    112:        int *ip;
                    113: 
                    114:        if (pid == 0)
                    115:                return;
                    116:        fget((ADDR)0, CORF|UBLKSP, (char *)&u, sizeof(u));
                    117:        ip = (int *)(((int)u.u_ar0) & 0x1fff);
                    118:        for (rp = reglist; rp->rname; rp++)
                    119:                fput((ADDR)&ip[rp->roffs], CORF|UBLKSP,
                    120:                        (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:        int tab = 0;
                    132: 
                    133:        for (rp = reglist; rp->rname; rp++) {
                    134:                printf("%-8R >%s", rtow(rp->rval), rp->rname);
                    135:                tab = !tab;
                    136:                if (tab)
                    137:                        printf("\t");
                    138:                else
                    139:                        printf("\n");
                    140:        }
                    141:        if (tab)
                    142:                printf("\n");
                    143:        printpc();
                    144: }
                    145: 
                    146: /*
                    147:  * translate a name to a magic register offset
                    148:  * the latter useful in rget/rput
                    149:  */
                    150: 
                    151: int
                    152: rname(n)
                    153: char *n;
                    154: {
                    155:        register struct reglist *rp;
                    156: 
                    157:        for (rp = reglist; rp->rname; rp++)
                    158:                if (strcmp(n, rp->rname) == 0)
                    159:                        return (rp->roffs);
                    160:        return (BADREG);
                    161: }

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