cpu/arith8.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: arith8.cc,v 1.49 2007/12/01 16:45:16 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
  29 #define NEED_CPU_REG_SHORTCUTS 1
  30 #include "bochs.h"
  31 #include "cpu.h"
  32 #define LOG_THIS BX_CPU_THIS_PTR
  33
  34
  35 void BX_CPU_C::ADD_EbGbM(bxInstruction_c *i)
  36 {
  37   Bit8u op1, op2, sum;
  38
  39   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
  40   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
  41   sum = op1 + op2;
  42   write_RMW_virtual_byte(sum);
  43
  44   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
  45 }
  46
  47 void BX_CPU_C::ADD_EbGbR(bxInstruction_c *i)
  48 {
  49   Bit8u op1, op2, sum;
  50
  51   op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
  52   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
  53   sum = op1 + op2;
  54   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
  55
  56   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
  57 }
  58
  59 void BX_CPU_C::ADD_GbEbM(bxInstruction_c *i)
  60 {
  61   Bit8u op1, op2, sum;
  62
  63   op1 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
  64   read_virtual_byte(i->seg(), RMAddr(i), &op2);
  65   sum = op1 + op2;
  66   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
  67
  68   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
  69 }
  70
  71 void BX_CPU_C::ADD_GbEbR(bxInstruction_c *i)
  72 {
  73   Bit8u op1, op2, sum;
  74
  75   op1 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
  76   op2 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
  77   sum = op1 + op2;
  78   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
  79
  80   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
  81 }
  82
  83 void BX_CPU_C::ADD_ALIb(bxInstruction_c *i)
  84 {
  85   Bit8u op1, op2, sum;
  86
  87   op1 = AL;
  88   op2 = i->Ib();
  89   sum = op1 + op2;
  90   AL = sum;
  91
  92   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
  93 }
  94
  95 void BX_CPU_C::ADC_EbGbM(bxInstruction_c *i)
  96 {
  97   Bit8u op1, op2, sum;
  98   bx_bool temp_CF = getB_CF();
  99
 100   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 101   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 102   sum = op1 + op2 + temp_CF;
 103   write_RMW_virtual_byte(sum);
 104
 105   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 106 }
 107
 108 void BX_CPU_C::ADC_EbGbR(bxInstruction_c *i)
 109 {
 110   Bit8u op1, op2, sum;
 111   bx_bool temp_CF = getB_CF();
 112
 113   op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 114   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 115   sum = op1 + op2 + temp_CF;
 116   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 117
 118   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 119 }
 120
 121 void BX_CPU_C::ADC_GbEbM(bxInstruction_c *i)
 122 {
 123   Bit8u op1, op2, sum;
 124   bx_bool temp_CF = getB_CF();
 125
 126   op1 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 127   read_virtual_byte(i->seg(), RMAddr(i), &op2);
 128   sum = op1 + op2 + temp_CF;
 129   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
 130
 131   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 132 }
 133
 134 void BX_CPU_C::ADC_GbEbR(bxInstruction_c *i)
 135 {
 136   Bit8u op1, op2, sum;
 137   bx_bool temp_CF = getB_CF();
 138
 139   op1 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 140   op2 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 141   sum = op1 + op2 + temp_CF;
 142   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
 143
 144   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 145 }
 146
 147 void BX_CPU_C::ADC_ALIb(bxInstruction_c *i)
 148 {
 149   Bit8u op1, op2, sum;
 150   bx_bool temp_CF = getB_CF();
 151
 152   op1 = AL;
 153   op2 = i->Ib();
 154   sum = op1 + op2 + temp_CF;
 155   AL = sum;
 156
 157   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 158 }
 159
 160 void BX_CPU_C::SBB_EbGbM(bxInstruction_c *i)
 161 {
 162   Bit8u op1_8, op2_8, diff_8;
 163   bx_bool temp_CF = getB_CF();
 164
 165   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 166   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 167   diff_8 = op1_8 - (op2_8 + temp_CF);
 168   write_RMW_virtual_byte(diff_8);
 169
 170   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 171 }
 172
 173 void BX_CPU_C::SBB_EbGbR(bxInstruction_c *i)
 174 {
 175   Bit8u op1_8, op2_8, diff_8;
 176   bx_bool temp_CF = getB_CF();
 177
 178   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 179   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 180   diff_8 = op1_8 - (op2_8 + temp_CF);
 181   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 182
 183   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 184 }
 185
 186 void BX_CPU_C::SBB_GbEbM(bxInstruction_c *i)
 187 {
 188   Bit8u op1_8, op2_8, diff_8;
 189   bx_bool temp_CF = getB_CF();
 190
 191   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 192   read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 193   diff_8 = op1_8 - (op2_8 + temp_CF);
 194   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 195
 196   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 197 }
 198
 199 void BX_CPU_C::SBB_GbEbR(bxInstruction_c *i)
 200 {
 201   Bit8u op1_8, op2_8, diff_8;
 202   bx_bool temp_CF = getB_CF();
 203
 204   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 205   op2_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 206   diff_8 = op1_8 - (op2_8 + temp_CF);
 207   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 208
 209   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 210 }
 211
 212 void BX_CPU_C::SBB_ALIb(bxInstruction_c *i)
 213 {
 214   Bit8u op1_8, op2_8, diff_8;
 215   bx_bool temp_CF = getB_CF();
 216
 217   op1_8 = AL;
 218   op2_8 = i->Ib();
 219   diff_8 = op1_8 - (op2_8 + temp_CF);
 220   AL = diff_8;
 221
 222   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 223 }
 224
 225 void BX_CPU_C::SBB_EbIbM(bxInstruction_c *i)
 226 {
 227   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 228   bx_bool temp_CF = getB_CF();
 229
 230   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 231   diff_8 = op1_8 - (op2_8 + temp_CF);
 232   write_RMW_virtual_byte(diff_8);
 233
 234   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 235 }
 236
 237 void BX_CPU_C::SBB_EbIbR(bxInstruction_c *i)
 238 {
 239   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 240   bx_bool temp_CF = getB_CF();
 241
 242   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 243   diff_8 = op1_8 - (op2_8 + temp_CF);
 244   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 245
 246   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 247 }
 248
 249 void BX_CPU_C::SUB_EbGbM(bxInstruction_c *i)
 250 {
 251   Bit8u op1_8, op2_8, diff_8;
 252
 253   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 254   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 255   diff_8 = op1_8 - op2_8;
 256   write_RMW_virtual_byte(diff_8);
 257
 258   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 259 }
 260
 261 void BX_CPU_C::SUB_EbGbR(bxInstruction_c *i)
 262 {
 263   Bit8u op1_8, op2_8, diff_8;
 264
 265   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 266   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 267   diff_8 = op1_8 - op2_8;
 268   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 269
 270   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 271 }
 272
 273 void BX_CPU_C::SUB_GbEbM(bxInstruction_c *i)
 274 {
 275   Bit8u op1_8, op2_8, diff_8;
 276
 277   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 278   read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 279   diff_8 = op1_8 - op2_8;
 280   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 281
 282   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 283 }
 284
 285 void BX_CPU_C::SUB_GbEbR(bxInstruction_c *i)
 286 {
 287   Bit8u op1_8, op2_8, diff_8;
 288
 289   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 290   op2_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 291   diff_8 = op1_8 - op2_8;
 292   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 293
 294   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 295 }
 296
 297 void BX_CPU_C::SUB_ALIb(bxInstruction_c *i)
 298 {
 299   Bit8u op1_8, op2_8, diff_8;
 300
 301   op1_8 = AL;
 302   op2_8 = i->Ib();
 303   diff_8 = op1_8 - op2_8;
 304   AL = diff_8;
 305
 306   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 307 }
 308
 309 void BX_CPU_C::CMP_EbGbM(bxInstruction_c *i)
 310 {
 311   Bit8u op1_8, op2_8, diff_8;
 312
 313   read_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 314   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 315   diff_8 = op1_8 - op2_8;
 316
 317   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 318 }
 319
 320 void BX_CPU_C::CMP_EbGbR(bxInstruction_c *i)
 321 {
 322   Bit8u op1_8, op2_8, diff_8;
 323
 324   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 325   op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 326   diff_8 = op1_8 - op2_8;
 327
 328   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 329 }
 330
 331 void BX_CPU_C::CMP_GbEbM(bxInstruction_c *i)
 332 {
 333   Bit8u op1_8, op2_8, diff_8;
 334
 335   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 336   read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 337   diff_8 = op1_8 - op2_8;
 338
 339   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 340 }
 341
 342 void BX_CPU_C::CMP_GbEbR(bxInstruction_c *i)
 343 {
 344   Bit8u op1_8, op2_8, diff_8;
 345
 346   op1_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 347   op2_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 348   diff_8 = op1_8 - op2_8;
 349
 350   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 351 }
 352
 353 void BX_CPU_C::CMP_ALIb(bxInstruction_c *i)
 354 {
 355   Bit8u op1_8, op2_8, diff_8;
 356
 357   op1_8 = AL;
 358   op2_8 = i->Ib();
 359   diff_8 = op1_8 - op2_8;
 360
 361   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 362 }
 363
 364 void BX_CPU_C::XADD_EbGbM(bxInstruction_c *i)
 365 {
 366 #if BX_CPU_LEVEL >= 4
 367   Bit8u op1, op2, sum;
 368
 369   /* XADD dst(r/m8), src(r8)
 370    * temp <-- src + dst         | sum = op2 + op1
 371    * src  <-- dst               | op2 = op1
 372    * dst  <-- tmp               | op1 = sum
 373    */
 374
 375   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 376   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 377   sum = op1 + op2;
 378   write_RMW_virtual_byte(sum);
 379
 380   /* and write destination into source */
 381   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);
 382
 383   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
 384 #else
 385   BX_INFO(("XADD_EbGb: not supported on < 80486"));
 386   UndefinedOpcode(i);
 387 #endif
 388 }
 389
 390 void BX_CPU_C::XADD_EbGbR(bxInstruction_c *i)
 391 {
 392 #if BX_CPU_LEVEL >= 4
 393   Bit8u op1, op2, sum;
 394
 395   /* XADD dst(r/m8), src(r8)
 396    * temp <-- src + dst         | sum = op2 + op1
 397    * src  <-- dst               | op2 = op1
 398    * dst  <-- tmp               | op1 = sum
 399    */
 400
 401   op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 402   op2 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 403   sum = op1 + op2;
 404
 405   // and write destination into source
 406   // Note: if both op1 & op2 are registers, the last one written
 407   //       should be the sum, as op1 & op2 may be the same register.
 408   //       For example:  XADD AL, AL
 409   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);
 410   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 411
 412   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
 413 #else
 414   BX_INFO(("XADD_EbGb: not supported on < 80486"));
 415   UndefinedOpcode(i);
 416 #endif
 417 }
 418
 419 void BX_CPU_C::ADD_EbIbM(bxInstruction_c *i)
 420 {
 421   Bit8u op1, op2 = i->Ib(), sum;
 422
 423   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 424   sum = op1 + op2;
 425   write_RMW_virtual_byte(sum);
 426
 427   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
 428 }
 429
 430 void BX_CPU_C::ADD_EbIbR(bxInstruction_c *i)
 431 {
 432   Bit8u op1, op2 = i->Ib(), sum;
 433
 434   op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 435   sum = op1 + op2;
 436   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 437
 438   SET_FLAGS_OSZAPC_ADD_8(op1, op2, sum);
 439 }
 440
 441 void BX_CPU_C::ADC_EbIbM(bxInstruction_c *i)
 442 {
 443   Bit8u op1, op2 = i->Ib(), sum;
 444   bx_bool temp_CF = getB_CF();
 445
 446   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 447   sum = op1 + op2 + temp_CF;
 448   write_RMW_virtual_byte(sum);
 449
 450   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 451 }
 452
 453 void BX_CPU_C::ADC_EbIbR(bxInstruction_c *i)
 454 {
 455   Bit8u op1, op2 = i->Ib(), sum;
 456   bx_bool temp_CF = getB_CF();
 457
 458   op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 459   sum = op1 + op2 + temp_CF;
 460   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 461
 462   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 463 }
 464
 465 void BX_CPU_C::SUB_EbIbM(bxInstruction_c *i)
 466 {
 467   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 468
 469   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 470   diff_8 = op1_8 - op2_8;
 471   write_RMW_virtual_byte(diff_8);
 472
 473   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 474 }
 475
 476 void BX_CPU_C::SUB_EbIbR(bxInstruction_c *i)
 477 {
 478   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 479
 480   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 481   diff_8 = op1_8 - op2_8;
 482   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 483
 484   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 485 }
 486
 487 void BX_CPU_C::CMP_EbIbM(bxInstruction_c *i)
 488 {
 489   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 490
 491   read_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 492   diff_8 = op1_8 - op2_8;
 493
 494   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 495 }
 496
 497 void BX_CPU_C::CMP_EbIbR(bxInstruction_c *i)
 498 {
 499   Bit8u op1_8, op2_8 = i->Ib(), diff_8;
 500
 501   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 502   diff_8 = op1_8 - op2_8;
 503   SET_FLAGS_OSZAPC_SUB_8(op1_8, op2_8, diff_8);
 504 }
 505
 506 void BX_CPU_C::NEG_EbM(bxInstruction_c *i)
 507 {
 508   Bit8u op1_8;
 509
 510   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 511   op1_8 = -op1_8;
 512   write_RMW_virtual_byte(op1_8);
 513
 514   SET_FLAGS_OSZAPC_RESULT_8(op1_8, BX_INSTR_NEG8);
 515 }
 516
 517 void BX_CPU_C::NEG_EbR(bxInstruction_c *i)
 518 {
 519   Bit8u op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 520   op1_8 = -op1_8;
 521   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1_8);
 522
 523   SET_FLAGS_OSZAPC_RESULT_8(op1_8, BX_INSTR_NEG8);
 524 }
 525
 526 void BX_CPU_C::INC_EbM(bxInstruction_c *i)
 527 {
 528   Bit8u op1;
 529
 530   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 531   op1++;
 532   write_RMW_virtual_byte(op1);
 533
 534   SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
 535 }
 536
 537 void BX_CPU_C::INC_EbR(bxInstruction_c *i)
 538 {
 539   Bit8u op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 540   op1++;
 541   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1);
 542
 543   SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
 544 }
 545
 546 void BX_CPU_C::DEC_EbM(bxInstruction_c *i)
 547 {
 548   Bit8u op1_8;
 549
 550   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 551   op1_8--;
 552   write_RMW_virtual_byte(op1_8);
 553
 554   SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
 555 }
 556
 557 void BX_CPU_C::DEC_EbR(bxInstruction_c *i)
 558 {
 559   Bit8u op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 560   op1_8--;
 561   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1_8);
 562
 563   SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
 564 }
 565
 566 void BX_CPU_C::CMPXCHG_EbGbM(bxInstruction_c *i)
 567 {
 568 #if BX_CPU_LEVEL >= 4
 569   Bit8u op1_8, op2_8, diff_8;
 570
 571   read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 572   diff_8 = AL - op1_8;
 573   SET_FLAGS_OSZAPC_SUB_8(AL, op1_8, diff_8);
 574
 575   if (diff_8 == 0) {  // if accumulator == dest
 576     // dest <-- src
 577     op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 578     write_RMW_virtual_byte(op2_8);
 579   }
 580   else {
 581     // accumulator <-- dest
 582     AL = op1_8;
 583   }
 584
 585 #else
 586   BX_INFO(("CMPXCHG_EbGb: not supported for cpulevel <= 3"));
 587   UndefinedOpcode(i);
 588 #endif
 589 }
 590
 591 void BX_CPU_C::CMPXCHG_EbGbR(bxInstruction_c *i)
 592 {
 593 #if BX_CPU_LEVEL >= 4
 594   Bit8u op1_8, op2_8, diff_8;
 595
 596   op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
 597   diff_8 = AL - op1_8;
 598   SET_FLAGS_OSZAPC_SUB_8(AL, op1_8, diff_8);
 599
 600   if (diff_8 == 0) {  // if accumulator == dest
 601     // dest <-- src
 602     op2_8 = BX_READ_8BIT_REGx(i->nnn(), i->extend8bitL());
 603     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op2_8);
 604   }
 605   else {
 606     // accumulator <-- dest
 607     AL = op1_8;
 608   }
 609
 610 #else
 611   BX_INFO(("CMPXCHG_EbGb: not supported for cpulevel <= 3"));
 612   UndefinedOpcode(i);
 613 #endif
 614 }