Return to 8.c CVS log

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

Annotation of lucent/sys/src/libmach/8.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * 386 definition
        !             3:  */
        !             4: #include <u.h>
        !             5: #include <bio.h>
        !             6: #include "/386/include/ureg.h"
        !             7: #include <mach.h>
        !             8: 
        !             9: #define        MINREG  0
        !            10: #define        MAXREG  0
        !            11: 
        !            12: #define USIZE          0x1000
        !            13: #define USER_REG(x)    (USIZE-((19)*4)+(ulong)(x))
        !            14: #define FP_CTL(x)      (0x0000+4+4*(x))
        !            15: #define FP_REG(x)      (0x0000+4+7*4+10*(x))
        !            16: #define        SCALLOFF        (0x0000+4+108)
        !            17: 
        !            18: #define        REGOFF(x)       (USER_REG(&((struct Ureg *) 0)->x))
        !            19: 
        !            20: #define PC             REGOFF(pc)
        !            21: #define SP             REGOFF(sp)
        !            22: #define        AX              REGOFF(ax)
        !            23: 
        !            24: Reglist i386reglist[] = {
        !            25:        {"DI",          REGOFF(di),     RINT, 'X'},
        !            26:        {"SI",          REGOFF(si),     RINT, 'X'},
        !            27:        {"BP",          REGOFF(bp),     RINT, 'X'},
        !            28:        {"BX",          REGOFF(bx),     RINT, 'X'},
        !            29:        {"DX",          REGOFF(dx),     RINT, 'X'},
        !            30:        {"CX",          REGOFF(cx),     RINT, 'X'},
        !            31:        {"AX",          REGOFF(ax),     RINT, 'X'},
        !            32:        {"GS",          REGOFF(gs),     RINT, 'X'},
        !            33:        {"FS",          REGOFF(fs),     RINT, 'X'},
        !            34:        {"ES",          REGOFF(es),     RINT, 'X'},
        !            35:        {"DS",          REGOFF(ds),     RINT, 'X'},
        !            36:        {"TRAP",        REGOFF(trap),   RINT, 'X'},
        !            37:        {"ECODE",       REGOFF(ecode),  RINT, 'X'},
        !            38:        {"PC",          PC,             RINT, 'X'},
        !            39:        {"CS",          REGOFF(cs),     RINT, 'X'},
        !            40:        {"EFLAGS",      REGOFF(flags),  RINT, 'X'},
        !            41:        {"SP",          SP,             RINT, 'X'},
        !            42:        {"SS",          REGOFF(ss),     RINT, 'X'},
        !            43: 
        !            44:        {"E0",          FP_CTL(0),      RFLT, 'X'},
        !            45:        {"E1",          FP_CTL(1),      RFLT, 'X'},
        !            46:        {"E2",          FP_CTL(2),      RFLT, 'X'},
        !            47:        {"E3",          FP_CTL(3),      RFLT, 'X'},
        !            48:        {"E4",          FP_CTL(4),      RFLT, 'X'},
        !            49:        {"E5",          FP_CTL(5),      RFLT, 'X'},
        !            50:        {"E6",          FP_CTL(6),      RFLT, 'X'},
        !            51:        {"F0",          FP_REG(7),      RFLT, '3'},
        !            52:        {"F1",          FP_REG(6),      RFLT, '3'},
        !            53:        {"F2",          FP_REG(5),      RFLT, '3'},
        !            54:        {"F3",          FP_REG(4),      RFLT, '3'},
        !            55:        {"F4",          FP_REG(3),      RFLT, '3'},
        !            56:        {"F5",          FP_REG(2),      RFLT, '3'},
        !            57:        {"F6",          FP_REG(1),      RFLT, '3'},
        !            58:        {"F7",          FP_REG(0),      RFLT, '3'},
        !            59:        {  0 }
        !            60: };
        !            61: 
        !            62: Mach mi386 =
        !            63: {
        !            64:        "386",
        !            65:        MI386,          /* machine type */
        !            66:        i386reglist,    /* register list */
        !            67:        MINREG,         /* minimum register */
        !            68:        MAXREG,         /* maximum register */
        !            69:        "PC",
        !            70:        "SP",
        !            71:        0,              /* link register */
        !            72:        AX,             /* return reg */
        !            73:        0x1000,         /* page size */
        !            74:        0x80100000,     /* kernel base */
        !            75:        0,              /* kernel text mask */
        !            76:        0,              /* offset of ksp in /proc/proc */
        !            77:        4,              /* correction to ksp value */
        !            78:        4,              /* offset of kpc in /proc/proc */
        !            79:        0,              /* correction to kpc value */
        !            80:        SCALLOFF,       /* offset in ublk to sys call # */
        !            81:        1,              /* quantization of pc */
        !            82:        "setSB",        /* static base register name (bogus anyways) */
        !            83:        0,              /* value */
        !            84:        4,              /* szaddr */
        !            85:        4,              /* szreg */
        !            86:        4,              /* szfloat */
        !            87:        8,              /* szdouble */
        !            88: };

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