cpu/bit.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: bit.cc,v 1.59 2008/08/11 18:53:23 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 #if BX_CPU_LEVEL >= 3
  34
  35 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETO_EbM(bxInstruction_c *i)
  36 {
  37   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  38
  39   Bit8u result_8 = getB_OF();
  40   write_virtual_byte(i->seg(), eaddr, result_8);
  41 }
  42
  43 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETO_EbR(bxInstruction_c *i)
  44 {
  45   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), getB_OF());
  46 }
  47
  48 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNO_EbM(bxInstruction_c *i)
  49 {
  50   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  51
  52   Bit8u result_8 = !getB_OF();
  53   write_virtual_byte(i->seg(), eaddr, result_8);
  54 }
  55
  56 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNO_EbR(bxInstruction_c *i)
  57 {
  58   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !getB_OF());
  59 }
  60
  61 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETB_EbM(bxInstruction_c *i)
  62 {
  63   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  64
  65   Bit8u result_8 = getB_CF();
  66   write_virtual_byte(i->seg(), eaddr, result_8);
  67 }
  68
  69 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETB_EbR(bxInstruction_c *i)
  70 {
  71   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), getB_CF());
  72 }
  73
  74 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNB_EbM(bxInstruction_c *i)
  75 {
  76   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  77
  78   Bit8u result_8 = !getB_CF();
  79   write_virtual_byte(i->seg(), eaddr, result_8);
  80 }
  81
  82 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNB_EbR(bxInstruction_c *i)
  83 {
  84   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !getB_CF());
  85 }
  86
  87 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETZ_EbM(bxInstruction_c *i)
  88 {
  89   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  90
  91   Bit8u result_8 = getB_ZF();
  92   write_virtual_byte(i->seg(), eaddr, result_8);
  93 }
  94
  95 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETZ_EbR(bxInstruction_c *i)
  96 {
  97   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), getB_ZF());
  98 }
  99
 100 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNZ_EbM(bxInstruction_c *i)
 101 {
 102   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 103
 104   Bit8u result_8 = !getB_ZF();
 105   write_virtual_byte(i->seg(), eaddr, result_8);
 106 }
 107
 108 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNZ_EbR(bxInstruction_c *i)
 109 {
 110   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !getB_ZF());
 111 }
 112
 113 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETBE_EbM(bxInstruction_c *i)
 114 {
 115   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 116
 117   Bit8u result_8 = (getB_CF() | getB_ZF());
 118   write_virtual_byte(i->seg(), eaddr, result_8);
 119 }
 120
 121 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETBE_EbR(bxInstruction_c *i)
 122 {
 123   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), (getB_CF() | getB_ZF()));
 124 }
 125
 126 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNBE_EbM(bxInstruction_c *i)
 127 {
 128   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 129
 130   Bit8u result_8 = !(getB_CF() | getB_ZF());
 131   write_virtual_byte(i->seg(), eaddr, result_8);
 132 }
 133
 134 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNBE_EbR(bxInstruction_c *i)
 135 {
 136   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !(getB_CF() | getB_ZF()));
 137 }
 138
 139 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETS_EbM(bxInstruction_c *i)
 140 {
 141   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 142
 143   Bit8u result_8 = getB_SF();
 144   write_virtual_byte(i->seg(), eaddr, result_8);
 145 }
 146
 147 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETS_EbR(bxInstruction_c *i)
 148 {
 149   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), getB_SF());
 150 }
 151
 152 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNS_EbM(bxInstruction_c *i)
 153 {
 154   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 155
 156   Bit8u result_8 = !getB_SF();
 157   write_virtual_byte(i->seg(), eaddr, result_8);
 158 }
 159
 160 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNS_EbR(bxInstruction_c *i)
 161 {
 162   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !getB_SF());
 163 }
 164
 165 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETP_EbM(bxInstruction_c *i)
 166 {
 167   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 168
 169   Bit8u result_8 = getB_PF();
 170   write_virtual_byte(i->seg(), eaddr, result_8);
 171 }
 172
 173 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETP_EbR(bxInstruction_c *i)
 174 {
 175   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), getB_PF());
 176 }
 177
 178 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNP_EbM(bxInstruction_c *i)
 179 {
 180   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 181
 182   Bit8u result_8 = !getB_PF();
 183   write_virtual_byte(i->seg(), eaddr, result_8);
 184 }
 185
 186 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNP_EbR(bxInstruction_c *i)
 187 {
 188   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !getB_PF());
 189 }
 190
 191 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETL_EbM(bxInstruction_c *i)
 192 {
 193   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 194
 195   Bit8u result_8 = (getB_SF() ^ getB_OF());
 196   write_virtual_byte(i->seg(), eaddr, result_8);
 197 }
 198
 199 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETL_EbR(bxInstruction_c *i)
 200 {
 201   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), (getB_SF() ^ getB_OF()));
 202 }
 203
 204 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNL_EbM(bxInstruction_c *i)
 205 {
 206   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 207
 208   Bit8u result_8 = !(getB_SF() ^ getB_OF());
 209   write_virtual_byte(i->seg(), eaddr, result_8);
 210 }
 211
 212 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNL_EbR(bxInstruction_c *i)
 213 {
 214   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), !(getB_SF() ^ getB_OF()));
 215 }
 216
 217 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETLE_EbM(bxInstruction_c *i)
 218 {
 219   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 220
 221   Bit8u result_8 = getB_ZF() | (getB_SF() ^ getB_OF());
 222   write_virtual_byte(i->seg(), eaddr, result_8);
 223 }
 224
 225 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETLE_EbR(bxInstruction_c *i)
 226 {
 227   Bit8u result_8 = getB_ZF() | (getB_SF() ^ getB_OF());
 228   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
 229 }
 230
 231 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNLE_EbM(bxInstruction_c *i)
 232 {
 233   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 234
 235   Bit8u result_8 = !(getB_ZF() | (getB_SF() ^ getB_OF()));
 236   write_virtual_byte(i->seg(), eaddr, result_8);
 237 }
 238
 239 void BX_CPP_AttrRegparmN(1) BX_CPU_C::SETNLE_EbR(bxInstruction_c *i)
 240 {
 241   Bit8u result_8 = !(getB_ZF() | (getB_SF() ^ getB_OF()));
 242   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
 243 }
 244
 245 void BX_CPP_AttrRegparmN(1) BX_CPU_C::BSWAP_ERX(bxInstruction_c *i)
 246 {
 247 #if BX_CPU_LEVEL >= 4
 248   Bit32u val32, b0, b1, b2, b3;
 249
 250   if (i->os32L() == 0) {
 251     BX_ERROR(("BSWAP with 16-bit opsize: undefined behavior !"));
 252   }
 253
 254   val32 = BX_READ_32BIT_REG(i->opcodeReg());
 255   b0 = val32 & 0xff; val32 >>= 8;
 256   b1 = val32 & 0xff; val32 >>= 8;
 257   b2 = val32 & 0xff; val32 >>= 8;
 258   b3 = val32;
 259   val32 = (b0<<24) | (b1<<16) | (b2<<8) | b3;
 260
 261   BX_WRITE_32BIT_REGZ(i->opcodeReg(), val32);
 262 #else
 263   BX_INFO(("BSWAP_ERX: required CPU >= 4, use --enable-cpu-level=4 option"));
 264   exception(BX_UD_EXCEPTION, 0, 0);
 265 #endif
 266 }
 267
 268 #if BX_SUPPORT_X86_64
 269 void BX_CPP_AttrRegparmN(1) BX_CPU_C::BSWAP_RRX(bxInstruction_c *i)
 270 {
 271   Bit64u val64, b0, b1, b2, b3, b4, b5, b6, b7;
 272
 273   val64 = BX_READ_64BIT_REG(i->opcodeReg());
 274   b0 = val64 & 0xff; val64 >>= 8;
 275   b1 = val64 & 0xff; val64 >>= 8;
 276   b2 = val64 & 0xff; val64 >>= 8;
 277   b3 = val64 & 0xff; val64 >>= 8;
 278   b4 = val64 & 0xff; val64 >>= 8;
 279   b5 = val64 & 0xff; val64 >>= 8;
 280   b6 = val64 & 0xff; val64 >>= 8;
 281   b7 = val64;
 282   val64 = (b0<<56) | (b1<<48) | (b2<<40) | (b3<<32) | (b4<<24) | (b4<<16) | (b4<<8) | b7;
 283
 284   BX_WRITE_64BIT_REG(i->opcodeReg(), val64);
 285 }
 286 #endif
 287
 288 // 3-byte opcodes
 289 #if (BX_SUPPORT_SSE >= 4) || (BX_SUPPORT_SSE >= 3 && BX_SUPPORT_SSE_EXTENSION > 0)
 290
 291 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_GwEw(bxInstruction_c *i)
 292 {
 293 #if BX_SUPPORT_MOVBE
 294   Bit16u val16, b0, b1;
 295
 296   if (i->modC0()) {
 297     val16 = BX_READ_16BIT_REG(i->rm());
 298   }
 299   else {
 300     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 301     val16 = read_virtual_word(i->seg(), eaddr);
 302   }
 303
 304   b0 = val16 & 0xff; val16 >>= 8;
 305   b1 = val16;
 306   val16 = (b1<<8) | b0;
 307
 308   BX_WRITE_16BIT_REG(i->nnn(), val16);
 309 #else
 310   BX_INFO(("MOVBE_GwEw: required MOVBE support, use --enable-movbe option"));
 311   exception(BX_UD_EXCEPTION, 0, 0);
 312 #endif
 313 }
 314
 315 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_EwGw(bxInstruction_c *i)
 316 {
 317 #if BX_SUPPORT_MOVBE
 318   Bit16u val16 = BX_READ_16BIT_REG(i->nnn()), b0, b1;
 319
 320   b0 = val16 & 0xff; val16 >>= 8;
 321   b1 = val16;
 322   val16 = (b1<<8) | b0;
 323
 324   if (i->modC0()) {
 325     BX_WRITE_16BIT_REG(i->rm(), val16);
 326   }
 327   else {
 328     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 329     write_virtual_word(i->seg(), eaddr, val16);
 330   }
 331 #else
 332   BX_INFO(("MOVBE_EwGw: required MOVBE support, use --enable-movbe option"));
 333   exception(BX_UD_EXCEPTION, 0, 0);
 334 #endif
 335 }
 336
 337 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_GdEd(bxInstruction_c *i)
 338 {
 339 #if BX_SUPPORT_MOVBE
 340   Bit32u val32, b0, b1, b2, b3;
 341
 342   if (i->modC0()) {
 343     val32 = BX_READ_32BIT_REG(i->rm());
 344   }
 345   else {
 346     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 347     val32 = read_virtual_dword(i->seg(), eaddr);
 348   }
 349
 350   b0 = val32 & 0xff; val32 >>= 8;
 351   b1 = val32 & 0xff; val32 >>= 8;
 352   b2 = val32 & 0xff; val32 >>= 8;
 353   b3 = val32;
 354   val32 = (b0<<24) | (b1<<16) | (b2<<8) | b3;
 355
 356   BX_WRITE_32BIT_REGZ(i->nnn(), val32);
 357 #else
 358   BX_INFO(("MOVBE_GdEd: required MOVBE support, use --enable-movbe option"));
 359   exception(BX_UD_EXCEPTION, 0, 0);
 360 #endif
 361 }
 362
 363 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_EdGd(bxInstruction_c *i)
 364 {
 365 #if BX_SUPPORT_MOVBE
 366   Bit32u val32 = BX_READ_32BIT_REG(i->nnn()), b0, b1, b2, b3;
 367
 368   b0 = val32 & 0xff; val32 >>= 8;
 369   b1 = val32 & 0xff; val32 >>= 8;
 370   b2 = val32 & 0xff; val32 >>= 8;
 371   b3 = val32;
 372   val32 = (b0<<24) | (b1<<16) | (b2<<8) | b3;
 373
 374   if (i->modC0()) {
 375     BX_WRITE_32BIT_REGZ(i->rm(), val32);
 376   }
 377   else {
 378     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 379     write_virtual_dword(i->seg(), eaddr, val32);
 380   }
 381 #else
 382   BX_INFO(("MOVBE_EdGd: required MOVBE support, use --enable-movbe option"));
 383   exception(BX_UD_EXCEPTION, 0, 0);
 384 #endif
 385 }
 386
 387 #if BX_SUPPORT_X86_64
 388
 389 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_GqEq(bxInstruction_c *i)
 390 {
 391 #if BX_SUPPORT_MOVBE
 392   Bit64u val64, b0, b1, b2, b3, b4, b5, b6, b7;
 393
 394   if (i->modC0()) {
 395     val64 = BX_READ_64BIT_REG(i->rm());
 396   }
 397   else {
 398     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 399     val64 = read_virtual_qword(i->seg(), eaddr);
 400   }
 401
 402   b0 = val64 & 0xff; val64 >>= 8;
 403   b1 = val64 & 0xff; val64 >>= 8;
 404   b2 = val64 & 0xff; val64 >>= 8;
 405   b3 = val64 & 0xff; val64 >>= 8;
 406   b4 = val64 & 0xff; val64 >>= 8;
 407   b5 = val64 & 0xff; val64 >>= 8;
 408   b6 = val64 & 0xff; val64 >>= 8;
 409   b7 = val64;
 410   val64 = (b0<<56) | (b1<<48) | (b2<<40) | (b3<<32) | (b4<<24) | (b4<<16) | (b4<<8) | b7;
 411
 412   BX_WRITE_64BIT_REG(i->nnn(), val64);
 413 #else
 414   BX_INFO(("MOVBE_GqEq: required MOVBE support, use --enable-movbe option"));
 415   exception(BX_UD_EXCEPTION, 0, 0);
 416 #endif
 417 }
 418
 419 void BX_CPP_AttrRegparmN(1) BX_CPU_C::MOVBE_EqGq(bxInstruction_c *i)
 420 {
 421 #if BX_SUPPORT_MOVBE
 422   Bit64u val64 = BX_READ_64BIT_REG(i->nnn());
 423   Bit64u b0, b1, b2, b3, b4, b5, b6, b7;
 424
 425   b0 = val64 & 0xff; val64 >>= 8;
 426   b1 = val64 & 0xff; val64 >>= 8;
 427   b2 = val64 & 0xff; val64 >>= 8;
 428   b3 = val64 & 0xff; val64 >>= 8;
 429   b4 = val64 & 0xff; val64 >>= 8;
 430   b5 = val64 & 0xff; val64 >>= 8;
 431   b6 = val64 & 0xff; val64 >>= 8;
 432   b7 = val64;
 433   val64 = (b0<<56) | (b1<<48) | (b2<<40) | (b3<<32) | (b4<<24) | (b4<<16) | (b4<<8) | b7;
 434
 435   if (i->modC0()) {
 436     BX_WRITE_64BIT_REG(i->rm(), val64);
 437   }
 438   else {
 439     bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 440     write_virtual_qword(i->seg(), eaddr, val64);
 441   }
 442 #else
 443   BX_INFO(("MOVBE_EqGq: required MOVBE support, use --enable-movbe option"));
 444   exception(BX_UD_EXCEPTION, 0, 0);
 445 #endif
 446 }
 447
 448 #endif // (BX_SUPPORT_X86_64)
 449
 450 #endif // (BX_SUPPORT_SSE >= 4) || (BX_SUPPORT_SSE >= 3 && BX_SUPPORT_SSE_EXTENSION > 0)
 451
 452 #endif // (BX_CPU_LEVEL >= 3)