cpu/arith8.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: arith8.cc,v 1.39 2006/03/26 18:58:00 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::ADD_EbGb(bxInstruction_c *i)
  35 {
  36   Bit8u op2, op1, sum;
  37
  38   op2 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
  39
  40   if (i->modC0()) {
  41     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
  42     sum = op1 + op2;
  43     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
  44   }
  45   else {
  46     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
  47     sum = op1 + op2;
  48     write_RMW_virtual_byte(sum);
  49   }
  50
  51   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
  52 }
  53
  54 void BX_CPU_C::ADD_GbEb(bxInstruction_c *i)
  55 {
  56   Bit8u op1, op2, sum;
  57
  58   op1 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
  59
  60   if (i->modC0()) {
  61     op2 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
  62     sum = op1 + op2;
  63   }
  64   else {
  65     read_virtual_byte(i->seg(), RMAddr(i), &op2);
  66     sum = op1 + op2;
  67   }
  68
  69   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
  70
  71   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
  72 }
  73
  74 void BX_CPU_C::ADD_ALIb(bxInstruction_c *i)
  75 {
  76   Bit8u op1, op2, sum;
  77
  78   op1 = AL;
  79   op2 = i->Ib();
  80   sum = op1 + op2;
  81   AL = sum;
  82
  83   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
  84 }
  85
  86 void BX_CPU_C::ADC_EbGb(bxInstruction_c *i)
  87 {
  88   Bit8u op2, op1, sum;
  89   bx_bool temp_CF = getB_CF();
  90
  91   op2 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
  92
  93   if (i->modC0()) {
  94     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
  95     sum = op1 + op2 + temp_CF;
  96     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
  97   }
  98   else {
  99     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 100     sum = op1 + op2 + temp_CF;
 101     write_RMW_virtual_byte(sum);
 102   }
 103
 104   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 105 }
 106
 107 void BX_CPU_C::ADC_GbEb(bxInstruction_c *i)
 108 {
 109   Bit8u op1, op2, sum;
 110   bx_bool temp_CF = getB_CF();
 111
 112   op1 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 113
 114   if (i->modC0()) {
 115     op2 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 116   }
 117   else {
 118     read_virtual_byte(i->seg(), RMAddr(i), &op2);
 119   }
 120
 121   sum = op1 + op2 + temp_CF;
 122
 123   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 124
 125   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), sum);
 126 }
 127
 128 void BX_CPU_C::ADC_ALIb(bxInstruction_c *i)
 129 {
 130   Bit8u op1, op2, sum;
 131   bx_bool temp_CF = getB_CF();
 132
 133   op1 = AL;
 134   op2 = i->Ib();
 135   sum = op1 + op2 + temp_CF;
 136   AL = sum;
 137
 138   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 139 }
 140
 141 void BX_CPU_C::SBB_EbGb(bxInstruction_c *i)
 142 {
 143   Bit8u op2_8, op1_8, diff_8;
 144   bx_bool temp_CF = getB_CF();
 145
 146   op2_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 147
 148   if (i->modC0()) {
 149     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 150     diff_8 = op1_8 - (op2_8 + temp_CF);
 151     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 152   }
 153   else {
 154     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 155     diff_8 = op1_8 - (op2_8 + temp_CF);
 156     write_RMW_virtual_byte(diff_8);
 157   }
 158
 159   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 160 }
 161
 162 void BX_CPU_C::SBB_GbEb(bxInstruction_c *i)
 163 {
 164   Bit8u op1_8, op2_8, diff_8;
 165   bx_bool temp_CF = getB_CF();
 166
 167   op1_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 168
 169   if (i->modC0()) {
 170     op2_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 171   }
 172   else {
 173     read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 174   }
 175
 176   diff_8 = op1_8 - (op2_8 + temp_CF);
 177
 178   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 179
 180   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 181 }
 182
 183 void BX_CPU_C::SBB_ALIb(bxInstruction_c *i)
 184 {
 185   Bit8u op1_8, op2_8, diff_8;
 186   bx_bool temp_CF = getB_CF();
 187
 188   op1_8 = AL;
 189   op2_8 = i->Ib();
 190   diff_8 = op1_8 - (op2_8 + temp_CF);
 191   AL = diff_8;
 192
 193   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 194 }
 195
 196 void BX_CPU_C::SBB_EbIb(bxInstruction_c *i)
 197 {
 198   Bit8u op2_8, op1_8, diff_8;
 199   bx_bool temp_CF = getB_CF();
 200
 201   op2_8 = i->Ib();
 202
 203   if (i->modC0()) {
 204     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 205     diff_8 = op1_8 - (op2_8 + temp_CF);
 206     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 207   }
 208   else {
 209     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 210     diff_8 = op1_8 - (op2_8 + temp_CF);
 211     write_RMW_virtual_byte(diff_8);
 212   }
 213
 214   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
 215 }
 216
 217 void BX_CPU_C::SUB_EbGb(bxInstruction_c *i)
 218 {
 219   Bit8u op2_8, op1_8, diff_8;
 220
 221   op2_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 222
 223   if (i->modC0()) {
 224     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 225     diff_8 = op1_8 - op2_8;
 226     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 227   }
 228   else {
 229     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 230     diff_8 = op1_8 - op2_8;
 231     write_RMW_virtual_byte(diff_8);
 232   }
 233
 234   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
 235 }
 236
 237 void BX_CPU_C::SUB_GbEb(bxInstruction_c *i)
 238 {
 239   Bit8u op1_8, op2_8, diff_8;
 240
 241   op1_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 242
 243   if (i->modC0()) {
 244     op2_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 245   }
 246   else {
 247     read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 248   }
 249
 250   diff_8 = op1_8 - op2_8;
 251
 252   BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), diff_8);
 253
 254   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
 255 }
 256
 257 void BX_CPU_C::SUB_ALIb(bxInstruction_c *i)
 258 {
 259   Bit8u op1_8, op2_8, diff_8;
 260
 261   op1_8 = AL;
 262   op2_8 = i->Ib();
 263   diff_8 = op1_8 - op2_8;
 264   AL = diff_8;
 265
 266   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
 267 }
 268
 269 void BX_CPU_C::CMP_EbGb(bxInstruction_c *i)
 270 {
 271   Bit8u op2_8, op1_8;
 272
 273   op2_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 274
 275   if (i->modC0()) {
 276     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 277   }
 278   else {
 279     read_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 280   }
 281
 282 #if defined(BX_HostAsm_Cmp8)
 283   Bit32u flags32;
 284   asmCmp8(op1_8, op2_8, flags32);
 285   setEFlagsOSZAPC(flags32);
 286 #else
 287   Bit8u diff_8 = op1_8 - op2_8;
 288   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_COMPARE8);
 289 #endif
 290 }
 291
 292 void BX_CPU_C::CMP_GbEb(bxInstruction_c *i)
 293 {
 294   Bit8u op1_8, op2_8;
 295
 296   op1_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 297
 298   if (i->modC0()) {
 299     op2_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 300   }
 301   else {
 302     read_virtual_byte(i->seg(), RMAddr(i), &op2_8);
 303   }
 304
 305 #if defined(BX_HostAsm_Cmp8)
 306   Bit32u flags32;
 307   asmCmp8(op1_8, op2_8, flags32);
 308   setEFlagsOSZAPC(flags32);
 309 #else
 310   Bit8u diff_8 = op1_8 - op2_8;
 311   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_COMPARE8);
 312 #endif
 313 }
 314
 315 void BX_CPU_C::CMP_ALIb(bxInstruction_c *i)
 316 {
 317   Bit8u op1_8 = AL;
 318   Bit8u op2_8 = i->Ib();
 319
 320 #if defined(BX_HostAsm_Cmp8)
 321   Bit32u flags32;
 322   asmCmp8(op1_8, op2_8, flags32);
 323   setEFlagsOSZAPC(flags32);
 324 #else
 325   Bit8u diff_8 = op1_8 - op2_8;
 326   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_COMPARE8);
 327 #endif
 328 }
 329
 330 void BX_CPU_C::XADD_EbGb(bxInstruction_c *i)
 331 {
 332 #if (BX_CPU_LEVEL >= 4) || (BX_CPU_LEVEL_HACKED >= 4)
 333   Bit8u op2, op1, sum;
 334
 335   /* XADD dst(r/m8), src(r8)
 336    * temp <-- src + dst         | sum = op2 + op1
 337    * src  <-- dst               | op2 = op1
 338    * dst  <-- tmp               | op1 = sum
 339    */
 340
 341   op2 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 342
 343   if (i->modC0()) {
 344     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 345     sum = op1 + op2;
 346     // and write destination into source
 347     // Note: if both op1 & op2 are registers, the last one written
 348     //       should be the sum, as op1 & op2 may be the same register.
 349     //       For example:  XADD AL, AL
 350     BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);
 351     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 352   }
 353   else {
 354     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 355     sum = op1 + op2;
 356     write_RMW_virtual_byte(sum);
 357     /* and write destination into source */
 358     BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);
 359   }
 360
 361   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
 362 #else
 363   BX_INFO(("XADD_EbGb: not supported on < 80486"));
 364   UndefinedOpcode(i);
 365 #endif
 366 }
 367
 368 void BX_CPU_C::ADD_EbIb(bxInstruction_c *i)
 369 {
 370   Bit8u op2, op1, sum;
 371
 372   op2 = i->Ib();
 373
 374   if (i->modC0()) {
 375     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 376     sum = op1 + op2;
 377     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 378   }
 379   else {
 380     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 381     sum = op1 + op2;
 382     write_RMW_virtual_byte(sum);
 383   }
 384
 385   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
 386 }
 387
 388 void BX_CPU_C::ADC_EbIb(bxInstruction_c *i)
 389 {
 390   Bit8u op2, op1, sum;
 391   bx_bool temp_CF = getB_CF();
 392
 393   op2 = i->Ib();
 394
 395   if (i->modC0()) {
 396     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 397     sum = op1 + op2 + temp_CF;
 398     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), sum);
 399   }
 400   else {
 401     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 402     sum = op1 + op2 + temp_CF;
 403     write_RMW_virtual_byte(sum);
 404   }
 405
 406   SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
 407 }
 408
 409 void BX_CPU_C::SUB_EbIb(bxInstruction_c *i)
 410 {
 411   Bit8u op2_8, op1_8, diff_8;
 412
 413   op2_8 = i->Ib();
 414
 415   if (i->modC0()) {
 416     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 417     diff_8 = op1_8 - op2_8;
 418     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 419   }
 420   else {
 421     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 422     diff_8 = op1_8 - op2_8;
 423     write_RMW_virtual_byte(diff_8);
 424   }
 425
 426   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
 427 }
 428
 429 void BX_CPU_C::CMP_EbIb(bxInstruction_c *i)
 430 {
 431   Bit8u op2_8, op1_8;
 432
 433   op2_8 = i->Ib();
 434
 435   if (i->modC0()) {
 436     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 437   }
 438   else {
 439     read_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 440   }
 441
 442 #if defined(BX_HostAsm_Cmp8)
 443   Bit32u flags32;
 444   asmCmp8(op1_8, op2_8, flags32);
 445   setEFlagsOSZAPC(flags32);
 446 #else
 447   Bit8u diff_8 = op1_8 - op2_8;
 448   SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_COMPARE8);
 449 #endif
 450 }
 451
 452 void BX_CPU_C::NEG_Eb(bxInstruction_c *i)
 453 {
 454   Bit8u op1_8, diff_8;
 455
 456   if (i->modC0()) {
 457     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 458     diff_8 = -op1_8;
 459     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), diff_8);
 460   }
 461   else {
 462     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 463     diff_8 = -op1_8;
 464     write_RMW_virtual_byte(diff_8);
 465   }
 466
 467   SET_FLAGS_OSZAPC_RESULT_8(diff_8, BX_INSTR_NEG8);
 468 }
 469
 470 void BX_CPU_C::INC_Eb(bxInstruction_c *i)
 471 {
 472   Bit8u op1;
 473
 474   if (i->modC0()) {
 475     op1 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 476     op1++;
 477     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1);
 478   }
 479   else {
 480     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
 481     op1++;
 482     write_RMW_virtual_byte(op1);
 483   }
 484
 485   SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
 486 }
 487
 488 void BX_CPU_C::DEC_Eb(bxInstruction_c *i)
 489 {
 490   Bit8u op1_8;
 491
 492   if (i->modC0()) {
 493     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 494     op1_8--;
 495     BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1_8);
 496   }
 497   else {
 498     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 499     op1_8--;
 500     write_RMW_virtual_byte(op1_8);
 501   }
 502
 503   SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
 504 }
 505
 506 void BX_CPU_C::CMPXCHG_EbGb(bxInstruction_c *i)
 507 {
 508 #if (BX_CPU_LEVEL >= 4) || (BX_CPU_LEVEL_HACKED >= 4)
 509   Bit8u op2_8, op1_8, diff_8;
 510
 511   if (i->modC0()) {
 512     op1_8 = BX_READ_8BIT_REGx(i->rm(),i->extend8bitL());
 513   }
 514   else {
 515     read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
 516   }
 517
 518   diff_8 = AL - op1_8;
 519
 520   SET_FLAGS_OSZAPC_8(AL, op1_8, diff_8, BX_INSTR_COMPARE8);
 521
 522   if (diff_8 == 0) {  // if accumulator == dest
 523     // dest <-- src
 524     op2_8 = BX_READ_8BIT_REGx(i->nnn(),i->extend8bitL());
 525
 526     if (i->modC0()) {
 527       BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op2_8);
 528     }
 529     else {
 530       write_RMW_virtual_byte(op2_8);
 531     }
 532   }
 533   else {
 534     // accumulator <-- dest
 535     AL = op1_8;
 536   }
 537
 538 #else
 539   BX_INFO(("CMPXCHG_EbGb: not supported for cpulevel <= 3"));
 540   UndefinedOpcode(i);
 541 #endif
 542 }