Return to 2.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libmach

Annotation of lucent/sys/src/libmach/2.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * 68020 definition
                      3:  */
                      4: #include <u.h>
                      5: #include "/68020/include/ureg.h"
                      6: #include <bio.h>
                      7: #include <mach.h>
                      8: 
                      9: #define        MAXREG  0
                     10: #define        MINREG  0
                     11: 
                     12: /*
                     13:  * 68020 register offsets relative to beginning of ublock
                     14:  */
                     15: #define        USIZE           8192            /* size of the user block */
                     16: #define        UREG(x)         (USIZE-(2+4+2+(8+8+1+1)*4)+(ulong)(x))
                     17: #define        FCTL(x)         (0x0000+4+216+(x)*4)
                     18: #define        FREG(x)         (0x0000+4+216+12+(x)*12)
                     19: #define        SCALLOFF        (0x0000+4+216+108)
                     20: 
                     21: #define        REGOFF(x)       (UREG(&((struct Ureg *) 0)->x))
                     22: 
                     23: #define        VO      REGOFF(vo)              /* vo, 2 bytes */
                     24: #define        SR      REGOFF(sr)              /* sr, 2 bytes */
                     25: 
                     26: #define        R0      REGOFF(r0)
                     27: #define        PC      REGOFF(pc)
                     28: #define        DBMAGIC REGOFF(magic)
                     29: #define        SP      REGOFF(usp)
                     30: 
                     31: /*
                     32:  *     68020 register set
                     33:  */
                     34: Reglist m68020reglist[] = {
                     35:        {"VO",          VO,             RINT,   'x'},
                     36:        {"SR",          SR,             RINT,   'x'},
                     37:        {"MAGIC",       DBMAGIC,        RINT,   'X'},
                     38:        {"PC",          PC,             RINT,   'X'},
                     39:        {"A7",          SP,             RINT,   'X'},
                     40:        {"KSP",         REGOFF(sp),     RINT,   'X'},
                     41:        {"A6",          REGOFF(a6),     RINT,   'X'},
                     42:        {"A5",          REGOFF(a5),     RINT,   'X'},
                     43:        {"A4",          REGOFF(a4),     RINT,   'X'},
                     44:        {"A3",          REGOFF(a3),     RINT,   'X'},
                     45:        {"A2",          REGOFF(a2),     RINT,   'X'},
                     46:        {"A1",          REGOFF(a1),     RINT,   'X'},
                     47:        {"A0",          REGOFF(a0),     RINT,   'X'},
                     48:        {"R7",          REGOFF(r7),     RINT,   'X'},
                     49:        {"R6",          REGOFF(r6),     RINT,   'X'},
                     50:        {"R5",          REGOFF(r5),     RINT,   'X'},
                     51:        {"R4",          REGOFF(r4),     RINT,   'X'},
                     52:        {"R3",          REGOFF(r3),     RINT,   'X'},
                     53:        {"R2",          REGOFF(r2),     RINT,   'X'},
                     54:        {"R1",          REGOFF(r1),     RINT,   'X'},
                     55:        {"R0",          REGOFF(r0),     RINT,   'X'},
                     56:        {"FPCR",        FCTL(0),        RFLT,   'X'},
                     57:        {"FPSR",        FCTL(1),        RFLT,   'X'},
                     58:        {"FPIAR",       FCTL(2),        RFLT,   'X'},
                     59:        {"F0",          FREG(0),        RFLT,   '8'},
                     60:        {"F1",          FREG(1),        RFLT,   '8'},
                     61:        {"F2",          FREG(2),        RFLT,   '8'},
                     62:        {"F3",          FREG(3),        RFLT,   '8'},
                     63:        {"F4",          FREG(4),        RFLT,   '8'},
                     64:        {"F5",          FREG(5),        RFLT,   '8'},
                     65:        {"F6",          FREG(6),        RFLT,   '8'},
                     66:        {"F7",          FREG(7),        RFLT,   '8'},
                     67:        {0}
                     68: };
                     69: 
                     70: Mach m68020 =
                     71: {
                     72:        "68020",
                     73:        M68020,         /* machine type */
                     74:        m68020reglist,  /* register list */
                     75:        MINREG,         /* minimum register */
                     76:        MAXREG,         /* maximum register */
                     77:        "PC",
                     78:        "A7",
                     79:        0,              /* link register */
                     80:        R0,             /* return register */
                     81:        0x2000,         /* page size */
                     82:        0x80000000,     /* kernel base */
                     83:        0,              /* kernel text mask */
                     84:        0,              /* offset of ksp in /proc/proc */
                     85:        4,              /* correction to ksp value */
                     86:        4,              /* offset of kpc in /proc/proc */
                     87:        0,              /* correction to kpc value */
                     88:        SCALLOFF,       /* offset in ublk of syscall #*/
                     89:        2,              /* quantization of pc */
                     90:        "a6base",       /* static base register name */
                     91:        0,              /* value */
                     92:        4,              /* szaddr */
                     93:        4,              /* szreg */
                     94:        4,              /* szfloat */
                     95:        8,              /* szdouble */
                     96: };

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