cpu/logical16.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: logical16.cc,v 1.26 2007/04/17 21:38:51 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2001  MandrakeSoft S.A.
   6 //
   7 //    MandrakeSoft S.A.
   8 //    43, rue d'Aboukir
   9 //    75002 Paris - France
  10 //    http://www.linux-mandrake.com/
  11 //    http://www.mandrakesoft.com/
  12 //
  13 //  This library is free software; you can redistribute it and/or
  14 //  modify it under the terms of the GNU Lesser General Public
  15 //  License as published by the Free Software Foundation; either
  16 //  version 2 of the License, or (at your option) any later version.
  17 //
  18 //  This library is distributed in the hope that it will be useful,
  19 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 //  Lesser General Public License for more details.
  22 //
  23 //  You should have received a copy of the GNU Lesser General Public
  24 //  License along with this library; if not, write to the Free Software
  25 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26
  27
  28 #define NEED_CPU_REG_SHORTCUTS 1
  29 #include "bochs.h"
  30 #include "cpu.h"
  31 #define LOG_THIS BX_CPU_THIS_PTR
  32
  33
  34 void BX_CPU_C::XOR_EwGw(bxInstruction_c *i)
  35 {
  36   Bit16u op2_16, op1_16, result_16;
  37
  38   op2_16 = BX_READ_16BIT_REG(i->nnn());
  39
  40   if (i->modC0()) {
  41     op1_16 = BX_READ_16BIT_REG(i->rm());
  42
  43 #if defined(BX_HostAsm_Xor16)
  44     Bit32u flags32;
  45     asmXor16(result_16, op1_16, op2_16, flags32);
  46     setEFlagsOSZAPC(flags32);
  47 #else
  48     result_16 = op1_16 ^ op2_16;
  49 #endif
  50     BX_WRITE_16BIT_REG(i->rm(), result_16);
  51   }
  52   else {
  53     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
  54 #if defined(BX_HostAsm_Xor16)
  55     Bit32u flags32;
  56     asmXor16(result_16, op1_16, op2_16, flags32);
  57     setEFlagsOSZAPC(flags32);
  58 #else
  59     result_16 = op1_16 ^ op2_16;
  60 #endif
  61     write_RMW_virtual_word(result_16);
  62   }
  63
  64 #if !defined(BX_HostAsm_Xor16)
  65   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
  66 #endif
  67 }
  68
  69 void BX_CPU_C::XOR_GwEw(bxInstruction_c *i)
  70 {
  71   Bit16u op1_16, op2_16, result_16;
  72   unsigned nnn = i->nnn();
  73
  74   op1_16 = BX_READ_16BIT_REG(nnn);
  75
  76   if (i->modC0()) {
  77     op2_16 = BX_READ_16BIT_REG(i->rm());
  78   }
  79   else {
  80     read_virtual_word(i->seg(), RMAddr(i), &op2_16);
  81   }
  82
  83   result_16 = op1_16 ^ op2_16;
  84
  85   BX_WRITE_16BIT_REG(nnn, result_16);
  86
  87   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
  88 }
  89
  90 void BX_CPU_C::XOR_AXIw(bxInstruction_c *i)
  91 {
  92   Bit16u op1_16, op2_16, result_16;
  93
  94   op1_16 = AX;
  95   op2_16 = i->Iw();
  96   result_16 = op1_16 ^ op2_16;
  97   AX = result_16;
  98
  99   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 100 }
 101
 102 void BX_CPU_C::XOR_EwIw(bxInstruction_c *i)
 103 {
 104   Bit16u op2_16, op1_16, result_16;
 105
 106   op2_16 = i->Iw();
 107
 108   if (i->modC0()) {
 109     op1_16 = BX_READ_16BIT_REG(i->rm());
 110     result_16 = op1_16 ^ op2_16;
 111     BX_WRITE_16BIT_REG(i->rm(), result_16);
 112   }
 113   else {
 114     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 115     result_16 = op1_16 ^ op2_16;
 116     write_RMW_virtual_word(result_16);
 117   }
 118
 119   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 120 }
 121
 122 void BX_CPU_C::OR_EwIw(bxInstruction_c *i)
 123 {
 124   Bit16u op2_16, op1_16, result_16;
 125
 126   op2_16 = i->Iw();
 127
 128   if (i->modC0()) {
 129     op1_16 = BX_READ_16BIT_REG(i->rm());
 130     result_16 = op1_16 | op2_16;
 131     BX_WRITE_16BIT_REG(i->rm(), result_16);
 132   }
 133   else {
 134     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 135     result_16 = op1_16 | op2_16;
 136     write_RMW_virtual_word(result_16);
 137   }
 138
 139   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 140 }
 141
 142 void BX_CPU_C::NOT_Ew(bxInstruction_c *i)
 143 {
 144   Bit16u op1_16, result_16;
 145
 146   if (i->modC0()) {
 147     op1_16 = BX_READ_16BIT_REG(i->rm());
 148     result_16 = ~op1_16;
 149     BX_WRITE_16BIT_REG(i->rm(), result_16);
 150   }
 151   else {
 152     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 153     result_16 = ~op1_16;
 154     write_RMW_virtual_word(result_16);
 155   }
 156 }
 157
 158 void BX_CPU_C::OR_EwGw(bxInstruction_c *i)
 159 {
 160   Bit16u op2_16, op1_16, result_16;
 161
 162   op2_16 = BX_READ_16BIT_REG(i->nnn());
 163
 164   if (i->modC0()) {
 165     op1_16 = BX_READ_16BIT_REG(i->rm());
 166     result_16 = op1_16 | op2_16;
 167     BX_WRITE_16BIT_REG(i->rm(), result_16);
 168   }
 169   else {
 170     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 171     result_16 = op1_16 | op2_16;
 172     write_RMW_virtual_word(result_16);
 173   }
 174
 175   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 176 }
 177
 178 void BX_CPU_C::OR_GwEw(bxInstruction_c *i)
 179 {
 180   Bit16u op1_16, op2_16, result_16;
 181
 182   op1_16 = BX_READ_16BIT_REG(i->nnn());
 183
 184   if (i->modC0()) {
 185     op2_16 = BX_READ_16BIT_REG(i->rm());
 186   }
 187   else {
 188     read_virtual_word(i->seg(), RMAddr(i), &op2_16);
 189   }
 190
 191 #if defined(BX_HostAsm_Or16)
 192   Bit32u flags32;
 193   asmOr16(result_16, op1_16, op2_16, flags32);
 194   setEFlagsOSZAPC(flags32);
 195 #else
 196   result_16 = op1_16 | op2_16;
 197   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 198 #endif
 199
 200   BX_WRITE_16BIT_REG(i->nnn(), result_16);
 201 }
 202
 203 void BX_CPU_C::OR_AXIw(bxInstruction_c *i)
 204 {
 205   Bit16u op1_16, op2_16, result_16;
 206
 207   op1_16 = AX;
 208   op2_16 = i->Iw();
 209   result_16 = op1_16 | op2_16;
 210   AX = result_16;
 211
 212   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 213 }
 214
 215 void BX_CPU_C::AND_EwGw(bxInstruction_c *i)
 216 {
 217   Bit16u op2_16, op1_16, result_16;
 218
 219   op2_16 = BX_READ_16BIT_REG(i->nnn());
 220
 221   if (i->modC0()) {
 222     op1_16 = BX_READ_16BIT_REG(i->rm());
 223
 224 #if defined(BX_HostAsm_And16)
 225     Bit32u flags32;
 226     asmAnd16(result_16, op1_16, op2_16, flags32);
 227     setEFlagsOSZAPC(flags32);
 228 #else
 229     result_16 = op1_16 & op2_16;
 230 #endif
 231
 232     BX_WRITE_16BIT_REG(i->rm(), result_16);
 233   }
 234   else {
 235     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 236
 237 #if defined(BX_HostAsm_And16)
 238     Bit32u flags32;
 239     asmAnd16(result_16, op1_16, op2_16, flags32);
 240     setEFlagsOSZAPC(flags32);
 241 #else
 242     result_16 = op1_16 & op2_16;
 243 #endif
 244
 245     write_RMW_virtual_word(result_16);
 246   }
 247
 248 #if !defined(BX_HostAsm_And16)
 249   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 250 #endif
 251 }
 252
 253 void BX_CPU_C::AND_GwEw(bxInstruction_c *i)
 254 {
 255   Bit16u op1_16, op2_16, result_16;
 256
 257   op1_16 = BX_READ_16BIT_REG(i->nnn());
 258
 259   if (i->modC0()) {
 260     op2_16 = BX_READ_16BIT_REG(i->rm());
 261   }
 262   else {
 263     read_virtual_word(i->seg(), RMAddr(i), &op2_16);
 264   }
 265
 266 #if defined(BX_HostAsm_And16)
 267   Bit32u flags32;
 268   asmAnd16(result_16, op1_16, op2_16, flags32);
 269   setEFlagsOSZAPC(flags32);
 270 #else
 271   result_16 = op1_16 & op2_16;
 272   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 273 #endif
 274
 275   BX_WRITE_16BIT_REG(i->nnn(), result_16);
 276 }
 277
 278 void BX_CPU_C::AND_AXIw(bxInstruction_c *i)
 279 {
 280   Bit16u op1_16, op2_16, result_16;
 281
 282   op1_16 = AX;
 283   op2_16 = i->Iw();
 284
 285 #if defined(BX_HostAsm_And16)
 286   Bit32u flags32;
 287   asmAnd16(result_16, op1_16, op2_16, flags32);
 288   setEFlagsOSZAPC(flags32);
 289 #else
 290   result_16 = op1_16 & op2_16;
 291   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 292 #endif
 293
 294   AX = result_16;
 295 }
 296
 297 void BX_CPU_C::AND_EwIw(bxInstruction_c *i)
 298 {
 299   Bit16u op2_16, op1_16, result_16;
 300
 301   op2_16 = i->Iw();
 302
 303   if (i->modC0()) {
 304     op1_16 = BX_READ_16BIT_REG(i->rm());
 305
 306 #if defined(BX_HostAsm_And16)
 307     Bit32u flags32;
 308     asmAnd16(result_16, op1_16, op2_16, flags32);
 309     setEFlagsOSZAPC(flags32);
 310 #else
 311     result_16 = op1_16 & op2_16;
 312 #endif
 313
 314     BX_WRITE_16BIT_REG(i->rm(), result_16);
 315   }
 316   else {
 317     read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
 318
 319 #if defined(BX_HostAsm_And16)
 320     Bit32u flags32;
 321     asmAnd16(result_16, op1_16, op2_16, flags32);
 322     setEFlagsOSZAPC(flags32);
 323 #else
 324     result_16 = op1_16 & op2_16;
 325 #endif
 326
 327     write_RMW_virtual_word(result_16);
 328   }
 329
 330 #if !defined(BX_HostAsm_And16)
 331   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 332 #endif
 333 }
 334
 335 void BX_CPU_C::TEST_EwGw(bxInstruction_c *i)
 336 {
 337   Bit16u op2_16, op1_16;
 338
 339   op2_16 = BX_READ_16BIT_REG(i->nnn());
 340
 341   if (i->modC0()) {
 342     op1_16 = BX_READ_16BIT_REG(i->rm());
 343   }
 344   else {
 345     read_virtual_word(i->seg(), RMAddr(i), &op1_16);
 346   }
 347
 348 #if defined(BX_HostAsm_Test16)
 349   Bit32u flags32;
 350   asmTest16(op1_16, op2_16, flags32);
 351   setEFlagsOSZAPC(flags32);
 352 #else
 353   Bit16u result_16 = op1_16 & op2_16;
 354   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 355 #endif
 356 }
 357
 358 void BX_CPU_C::TEST_AXIw(bxInstruction_c *i)
 359 {
 360   Bit16u op2_16, op1_16;
 361
 362   op1_16 = AX;
 363   op2_16 = i->Iw();
 364
 365 #if defined(BX_HostAsm_Test16)
 366   Bit32u flags32;
 367   asmTest16(op1_16, op2_16, flags32);
 368   setEFlagsOSZAPC(flags32);
 369 #else
 370   Bit16u result_16 = op1_16 & op2_16;
 371   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 372 #endif
 373 }
 374
 375 void BX_CPU_C::TEST_EwIw(bxInstruction_c *i)
 376 {
 377   Bit16u op2_16, op1_16;
 378
 379   op2_16 = i->Iw();
 380
 381   if (i->modC0()) {
 382     op1_16 = BX_READ_16BIT_REG(i->rm());
 383   }
 384   else {
 385     read_virtual_word(i->seg(), RMAddr(i), &op1_16);
 386   }
 387
 388 #if defined(BX_HostAsm_Test16)
 389   Bit32u flags32;
 390   asmTest16(op1_16, op2_16, flags32);
 391   setEFlagsOSZAPC(flags32);
 392 #else
 393   Bit16u result_16 = op1_16 & op2_16;
 394   SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
 395 #endif
 396 }