source/src/vm/mame/emu/cpu/i86/modrm.h

   1 static struct\r
   2 {\r
   3         struct\r
   4         {\r
   5                 WREGS w[256];\r
   6                 BREGS b[256];\r
   7         } reg;\r
   8         struct\r
   9         {\r
  10                 WREGS w[256];\r
  11                 BREGS b[256];\r
  12         } RM;\r
  13 } Mod_RM;\r
  14 \r
  15 #define RegWord(ModRM) cpustate->regs.w[Mod_RM.reg.w[ModRM]]\r
  16 #define RegByte(ModRM) cpustate->regs.b[Mod_RM.reg.b[ModRM]]\r
  17 \r
  18 #define GetRMWord(ModRM) \\r
  19         ((ModRM) >= 0xc0 ? cpustate->regs.w[Mod_RM.RM.w[ModRM]] : ( (*GetEA[ModRM])(cpustate), ReadWord( cpustate->ea ) ))\r
  20 \r
  21 #define PutbackRMWord(ModRM,val) \\r
  22 { \\r
  23         if (ModRM >= 0xc0) cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val; \\r
  24         else WriteWord(cpustate->ea,val); \\r
  25 }\r
  26 \r
  27 #define GetnextRMWord ReadWord(cpustate->ea+2)\r
  28 \r
  29 #define GetRMWordOffset(offs) \\r
  30                 ReadWord(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))\r
  31 \r
  32 #define GetRMByteOffset(offs) \\r
  33                 ReadByte(cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs))\r
  34 \r
  35 #define PutRMWord(ModRM,val)                \\r
  36 {                                           \\r
  37         if (ModRM >= 0xc0)                      \\r
  38                 cpustate->regs.w[Mod_RM.RM.w[ModRM]]=val;   \\r
  39         else {                                  \\r
  40                 (*GetEA[ModRM])(cpustate);                  \\r
  41                 WriteWord( cpustate->ea ,val);              \\r
  42         }                                       \\r
  43 }\r
  44 \r
  45 #define PutRMWordOffset(offs, val) \\r
  46                 WriteWord( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)\r
  47 \r
  48 #define PutRMByteOffset(offs, val) \\r
  49                 WriteByte( cpustate->ea-cpustate->eo+(UINT16)(cpustate->eo+offs), val)\r
  50 \r
  51 #define PutImmRMWord(ModRM)                 \\r
  52 {                                           \\r
  53         WORD val;                               \\r
  54         if (ModRM >= 0xc0)                      \\r
  55                 FETCHWORD(cpustate->regs.w[Mod_RM.RM.w[ModRM]]) \\r
  56         else {                                  \\r
  57                 (*GetEA[ModRM])(cpustate);                  \\r
  58                 FETCHWORD(val)                      \\r
  59                 WriteWord( cpustate->ea , val);             \\r
  60         }                                       \\r
  61 }\r
  62 \r
  63 #define GetRMByte(ModRM) \\r
  64         ((ModRM) >= 0xc0 ? cpustate->regs.b[Mod_RM.RM.b[ModRM]] : ReadByte( (*GetEA[ModRM])(cpustate) ))\r
  65 \r
  66 #define PutRMByte(ModRM,val)                \\r
  67 {                                           \\r
  68         if (ModRM >= 0xc0)                      \\r
  69                 cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;   \\r
  70         else                                    \\r
  71                 WriteByte( (*GetEA[ModRM])(cpustate) ,val); \\r
  72 }\r
  73 \r
  74 #define PutImmRMByte(ModRM)                 \\r
  75 {                                           \\r
  76         if (ModRM >= 0xc0)                      \\r
  77                 cpustate->regs.b[Mod_RM.RM.b[ModRM]]=FETCH; \\r
  78         else {                                  \\r
  79                 (*GetEA[ModRM])(cpustate);                  \\r
  80                 WriteByte( cpustate->ea , FETCH );          \\r
  81         }                                       \\r
  82 }\r
  83 \r
  84 #define PutbackRMByte(ModRM,val)            \\r
  85 {                                           \\r
  86         if (ModRM >= 0xc0)                      \\r
  87                 cpustate->regs.b[Mod_RM.RM.b[ModRM]]=val;   \\r
  88         else                                    \\r
  89                 WriteByte(cpustate->ea,val);                    \\r
  90 }\r
  91 \r
  92 #define DEF_br8(dst,src)                    \\r
  93         unsigned ModRM = FETCHOP;               \\r
  94         unsigned src = RegByte(ModRM);          \\r
  95         unsigned dst = GetRMByte(ModRM)\r
  96 \r
  97 #define DEF_wr16(dst,src)                   \\r
  98         unsigned ModRM = FETCHOP;               \\r
  99         unsigned src = RegWord(ModRM);          \\r
 100         unsigned dst = GetRMWord(ModRM)\r
 101 \r
 102 #define DEF_r8b(dst,src)                    \\r
 103         unsigned ModRM = FETCHOP;               \\r
 104         unsigned dst = RegByte(ModRM);          \\r
 105         unsigned src = GetRMByte(ModRM)\r
 106 \r
 107 #define DEF_r16w(dst,src)                   \\r
 108         unsigned ModRM = FETCHOP;               \\r
 109         unsigned dst = RegWord(ModRM);          \\r
 110         unsigned src = GetRMWord(ModRM)\r
 111 \r
 112 #define DEF_ald8(dst,src)                   \\r
 113         unsigned src = FETCHOP;                 \\r
 114         unsigned dst = cpustate->regs.b[AL]\r
 115 \r
 116 #define DEF_axd16(dst,src)                  \\r
 117         unsigned src = FETCHOP;                 \\r
 118         unsigned dst = cpustate->regs.w[AX];            \\r
 119         src += (FETCH << 8)\r