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     ! 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.