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

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.