Return to defs.h CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoealign

Annotation of 43BSDTahoe/sys/tahoealign/defs.h, revision 1.1

1.1     ! root        1: /*     defs.h  1.1     86/07/20        */
        !             2: 
        !             3: #include "../tahoe/psl.h"
        !             4: 
        !             5: /************************************************/
        !             6: /*     Basic 6/32 machine definitions          */
        !             7: /************************************************/
        !             8: 
        !             9: #define        FALSE   0
        !            10: #define        TRUE    (~FALSE)
        !            11: #define READ   0
        !            12: #define WRITE  1
        !            13: 
        !            14: /*
        !            15:  * Some floatng point stuff.
        !            16:  */
        !            17: 
        !            18: #define exp(x)         ( (x) & 0x7f800000 )
        !            19: #define reserved(x)    ( (x) < 0  && (exp(x) == 0) )
        !            20: 
        !            21: /************************************************/
        !            22: /*                                             */
        !            23: /*     Opcodes description table stuff         */
        !            24: /*                                             */
        !            25: /************************************************/
        !            26: 
        !            27: struct operand_des     {               /* Operand descriptor in great table */
        !            28:                int     add_modes;      /* Allowed addressing modes */
        !            29:                int     length;         /* Length of this data (bytes) */
        !            30: };
        !            31: 
        !            32: #define        Add     1       /* Any address except PC relative & ablsolute */
        !            33: #define        Dir     2       /* Direct register */
        !            34: #define        Imm     4       /* Immediate datum */
        !            35: #define        Lit     8       /* Short literal */
        !            36: #define        Brd     0x10    /* Branch displacement */
        !            37: #define        Pcrel   0x20    /* PC relative allowed */
        !            38: #define        Abs     0x40    /* Absolute address allowed */
        !            39: #define        SPmode  0x80    /* The stack pointer was involved , -(sp) or (sp)+ */
        !            40: #define        ADDFIELD 0xff   /* Allowed addressing modes */
        !            41: 
        !            42: #define        W       0x100   /* Access is write */
        !            43: #define R      0x200   /* Access is 'read' */
        !            44: #define        Indx    0x400   /* Indexable base address */
        !            45: #define        NOVF    0x800   /* Inhibit overflow check when writing byte/word */
        !            46: #define FLP    0x1000  /* Floating point operand */
        !            47: 
        !            48: #define        M       (R|W)   /* Access is 'modify' */
        !            49: #define PR     (Pcrel|Abs)
        !            50: #define ADDR   (PR|Add)
        !            51: #define        ADI     (ADDR|Dir|Imm|Lit)
        !            52: #define        AD      (ADDR|Dir)
        !            53: #define        MAD     (M|ADDR|Dir)
        !            54: #define        WAD     (W|ADDR|Dir)
        !            55: #define WD     (W|Dir)
        !            56: #define NWAD   (NOVF|WAD)
        !            57: #define        NMAD    (NOVF|MAD)
        !            58: #define        RADI    (R|ADI) /* Readable datum */
        !            59: #define RAD    (R|AD)  /* Modify type access for destinations */
        !            60: #define RADF   (RAD|FLP)
        !            61: #define WADF   (WAD|FLP)
        !            62: 
        !            63: 
        !            64: 
        !            65: 
        !            66: struct opcode_des      {       /* One line in the big table */
        !            67:        int     (*routine)      ();             /* Handler for this opcode */
        !            68:        struct  operand_des operand[4];         /* Up to 4 operands */
        !            69: };
        !            70: 
        !            71: /************************************************/
        !            72: /*                                             */
        !            73: /*     Operand descriptor as returned          */
        !            74: /*     by the address mode decoder             */
        !            75: /*                                             */
        !            76: /************************************************/
        !            77: 
        !            78: struct oprnd {
        !            79:        long    mode;                   /* Add, Imm, Dir or Brd */
        !            80:        long    reg_number;             /* returned for Dir mode */
        !            81:        long    address;                /* Relevant for Add or Brd */
        !            82:        long    data;
        !            83:        long    data2;                  /* Up to 8 bytes returned */
        !            84:        long    length;                 /* Length of data manipulated */
        !            85: };
        !            86: 
        !            87: /************************************************/
        !            88: /*                                             */
        !            89: /*     Some PSL macros (usefull)               */
        !            90: /*                                             */
        !            91: /************************************************/
        !            92: #define        carry           (psl & PSL_C)
        !            93: #define        negative        (psl & PSL_N)
        !            94: #define overflow       (psl & PSL_V)
        !            95: #define zero           (psl & PSL_Z)
        !            96: 
        !            97: #define carry_1                psl |= PSL_C
        !            98: #define negative_1     psl |= PSL_N
        !            99: #define overflow_1     psl |= PSL_V
        !           100: #define zero_1         psl |= PSL_Z
        !           101: 
        !           102: #define carry_0                psl &= ~PSL_C
        !           103: #define negative_0     psl &= ~PSL_N
        !           104: #define overflow_0     psl &= ~PSL_V
        !           105: #define zero_0         psl &= ~PSL_Z
        !           106: 
        !           107: 
        !           108: struct oprnd           *operand ();
        !           109: struct opcode_des      Table[];
        !           110: 
        !           111: struct double_length
        !           112: {
        !           113:        int     low;
        !           114:        int     high;
        !           115: };
        !           116: 
        !           117: typedef        struct  double_length   quadword;
        !           118: 

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