Return to definitions.h CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoe

Annotation of cci/sys/tahoe/definitions.h, revision 1.1.1.1

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

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