fpu/fpu_load_store.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: fpu_load_store.cc,v 1.21 2008/04/26 19:56:48 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //   Copyright (c) 2003 Stanislav Shwartsman
   6 //          Written by Stanislav Shwartsman [sshwarts at sourceforge net]
   7 //
   8 //  This library is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2 of the License, or (at your option) any later version.
  12 //
  13 //  This library is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 //  Lesser General Public License for more details.
  17 //
  18 //  You should have received a copy of the GNU Lesser General Public
  19 //  License along with this library; if not, write to the Free Software
  20 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 //
  22 /////////////////////////////////////////////////////////////////////////
  23
  24 #define NEED_CPU_REG_SHORTCUTS 1
  25 #include "bochs.h"
  26 #include "cpu/cpu.h"
  27 #define LOG_THIS BX_CPU_THIS_PTR
  28
  29 #if BX_SUPPORT_FPU
  30
  31 extern float_status_t FPU_pre_exception_handling(Bit16u control_word);
  32
  33 #include "softfloatx80.h"
  34
  35 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FLD_STi(bxInstruction_c *i)
  36 {
  37 #if BX_SUPPORT_FPU
  38   BX_CPU_THIS_PTR prepareFPU(i);
  39
  40   clear_C1();
  41
  42   if (! IS_TAG_EMPTY(-1))
  43   {
  44       BX_CPU_THIS_PTR FPU_stack_overflow();
  45       return;
  46   }
  47
  48   if (IS_TAG_EMPTY(i->rm()))
  49   {
  50      BX_CPU_THIS_PTR FPU_stack_underflow(0);
  51      return;
  52   }
  53
  54   int sti_tag = BX_CPU_THIS_PTR the_i387.FPU_gettagi(i->rm());
  55   floatx80 sti_reg = BX_READ_FPU_REG(i->rm());
  56
  57   BX_CPU_THIS_PTR the_i387.FPU_push();
  58   BX_WRITE_FPU_REGISTER_AND_TAG(sti_reg, sti_tag, 0);
  59 #else
  60   BX_INFO(("FLD_STi: required FPU, configure --enable-fpu"));
  61 #endif
  62 }
  63
  64 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FLD_SINGLE_REAL(bxInstruction_c *i)
  65 {
  66 #if BX_SUPPORT_FPU
  67   BX_CPU_THIS_PTR prepareFPU(i);
  68
  69   float32 load_reg = read_virtual_dword(i->seg(), RMAddr(i));
  70
  71   clear_C1();
  72
  73   if (! IS_TAG_EMPTY(-1)) {
  74       BX_CPU_THIS_PTR FPU_stack_overflow();
  75       return;
  76   }
  77
  78   float_status_t status =
  79      FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
  80
  81   // convert to floatx80 format
  82   floatx80 result = float32_to_floatx80(load_reg, status);
  83
  84   if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
  85      return;
  86
  87   BX_CPU_THIS_PTR the_i387.FPU_push();
  88   BX_WRITE_FPU_REG(result, 0);
  89 #else
  90   BX_INFO(("FLD_SINGLE_REAL: required FPU, configure --enable-fpu"));
  91 #endif
  92 }
  93
  94 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FLD_DOUBLE_REAL(bxInstruction_c *i)
  95 {
  96 #if BX_SUPPORT_FPU
  97   BX_CPU_THIS_PTR prepareFPU(i);
  98
  99   float64 load_reg = read_virtual_qword(i->seg(), RMAddr(i));
 100
 101   clear_C1();
 102
 103   if (! IS_TAG_EMPTY(-1)) {
 104       BX_CPU_THIS_PTR FPU_stack_overflow();
 105       return;
 106   }
 107
 108   float_status_t status =
 109      FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 110
 111   // convert to floatx80 format
 112   floatx80 result = float64_to_floatx80(load_reg, status);
 113
 114   if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 115      return;
 116
 117   BX_CPU_THIS_PTR the_i387.FPU_push();
 118   BX_WRITE_FPU_REG(result, 0);
 119 #else
 120   BX_INFO(("FLD_DOUBLE_REAL: required FPU, configure --enable-fpu"));
 121 #endif
 122 }
 123
 124 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FLD_EXTENDED_REAL(bxInstruction_c *i)
 125 {
 126 #if BX_SUPPORT_FPU
 127   BX_CPU_THIS_PTR prepareFPU(i);
 128
 129   floatx80 result;
 130   read_virtual_tword(i->seg(), RMAddr(i), &result);
 131
 132   clear_C1();
 133
 134   if (! IS_TAG_EMPTY(-1)) {
 135       BX_CPU_THIS_PTR FPU_stack_overflow();
 136       return;
 137   }
 138
 139   BX_CPU_THIS_PTR the_i387.FPU_push();
 140
 141   BX_WRITE_FPU_REG(result, 0);
 142 #else
 143   BX_INFO(("FLD_EXTENDED_REAL: required FPU, configure --enable-fpu"));
 144 #endif
 145 }
 146
 147 /* DF /0 */
 148 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FILD_WORD_INTEGER(bxInstruction_c *i)
 149 {
 150 #if BX_SUPPORT_FPU
 151   BX_CPU_THIS_PTR prepareFPU(i);
 152
 153   Bit16s load_reg = (Bit16s) read_virtual_word(i->seg(), RMAddr(i));
 154
 155   clear_C1();
 156
 157   if (! IS_TAG_EMPTY(-1)) {
 158       BX_CPU_THIS_PTR FPU_stack_overflow();
 159       return;
 160   }
 161
 162   floatx80 result = int32_to_floatx80((Bit32s) load_reg);
 163   BX_CPU_THIS_PTR the_i387.FPU_push();
 164   BX_WRITE_FPU_REG(result, 0);
 165 #else
 166   BX_INFO(("FILD_WORD_INTEGER: required FPU, configure --enable-fpu"));
 167 #endif
 168 }
 169
 170 /* DB /0 */
 171 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FILD_DWORD_INTEGER(bxInstruction_c *i)
 172 {
 173 #if BX_SUPPORT_FPU
 174   BX_CPU_THIS_PTR prepareFPU(i);
 175
 176   Bit32s load_reg = (Bit32s) read_virtual_dword(i->seg(), RMAddr(i));
 177
 178   clear_C1();
 179
 180   if (! IS_TAG_EMPTY(-1)) {
 181       BX_CPU_THIS_PTR FPU_stack_overflow();
 182       return;
 183   }
 184
 185   floatx80 result = int32_to_floatx80(load_reg);
 186   BX_CPU_THIS_PTR the_i387.FPU_push();
 187   BX_WRITE_FPU_REG(result, 0);
 188 #else
 189   BX_INFO(("FILD_DWORD_INTEGER: required FPU, configure --enable-fpu"));
 190 #endif
 191 }
 192
 193 /* DF /5 */
 194 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FILD_QWORD_INTEGER(bxInstruction_c *i)
 195 {
 196 #if BX_SUPPORT_FPU
 197   BX_CPU_THIS_PTR prepareFPU(i);
 198
 199   Bit64s load_reg = (Bit64s) read_virtual_qword(i->seg(), RMAddr(i));
 200
 201   clear_C1();
 202
 203   if (! IS_TAG_EMPTY(-1)) {
 204       BX_CPU_THIS_PTR FPU_stack_overflow();
 205       return;
 206   }
 207
 208   floatx80 result = int64_to_floatx80(load_reg);
 209   BX_CPU_THIS_PTR the_i387.FPU_push();
 210   BX_WRITE_FPU_REG(result, 0);
 211 #else
 212   BX_INFO(("FILD_QWORD_INTEGER: required FPU, configure --enable-fpu"));
 213 #endif
 214 }
 215
 216 /* DF /4 */
 217 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FBLD_PACKED_BCD(bxInstruction_c *i)
 218 {
 219 #if BX_SUPPORT_FPU
 220   BX_CPU_THIS_PTR prepareFPU(i);
 221
 222   // read packed bcd from memory
 223   Bit16u hi2 = read_virtual_word (i->seg(), RMAddr(i) + 8);
 224   Bit64u lo8 = read_virtual_qword(i->seg(), RMAddr(i));
 225
 226   clear_C1();
 227
 228   if (! IS_TAG_EMPTY(-1))
 229   {
 230       BX_CPU_THIS_PTR FPU_stack_overflow();
 231       return;
 232   }
 233
 234   // convert packed BCD to 64-bit integer
 235   Bit64s scale = 1;
 236   Bit64s val64 = 0;
 237
 238   for (int n = 0; n < 16; n++)
 239   {
 240     val64 += (lo8 & 0x0F) * scale;
 241     lo8 >>= 4;
 242     scale *= 10;
 243   }
 244
 245   val64 += (hi2 & 0x0F) * scale;
 246   val64 += ((hi2>>4) & 0x0F) * scale * 10;
 247
 248   floatx80 result = int64_to_floatx80(val64);
 249   if (hi2 & 0x8000)     // set negative
 250       floatx80_chs(result);
 251
 252   BX_CPU_THIS_PTR the_i387.FPU_push();
 253   BX_WRITE_FPU_REG(result, 0);
 254 #else
 255   BX_INFO(("FBLD_PACKED_BCD: required FPU, configure --enable-fpu"));
 256 #endif
 257 }
 258
 259 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FST_STi(bxInstruction_c *i)
 260 {
 261 #if BX_SUPPORT_FPU
 262   BX_CPU_THIS_PTR prepareFPU(i);
 263
 264   int pop_stack = i->nnn() & 1;
 265   // handle special case of FSTP opcode @ 0xDF 0xD0..D7
 266   if (i->b1() == 0xdf)
 267     pop_stack = 1;
 268
 269   int st0_tag = BX_CPU_THIS_PTR the_i387.FPU_gettagi(0);
 270   if (st0_tag == FPU_Tag_Empty)
 271   {
 272      BX_CPU_THIS_PTR FPU_stack_underflow(i->rm(), pop_stack);
 273      return;
 274   }
 275
 276   floatx80 st0_reg = BX_READ_FPU_REG(0);
 277
 278   BX_WRITE_FPU_REGISTER_AND_TAG(st0_reg, st0_tag, i->rm());
 279   if (pop_stack)
 280      BX_CPU_THIS_PTR the_i387.FPU_pop();
 281 #else
 282   BX_INFO(("FST(P)_STi: required FPU, configure --enable-fpu"));
 283 #endif
 284 }
 285
 286 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FST_SINGLE_REAL(bxInstruction_c *i)
 287 {
 288 #if BX_SUPPORT_FPU
 289   BX_CPU_THIS_PTR prepareFPU(i);
 290
 291   float32 save_reg = float32_default_nan; /* The masked response */
 292
 293   int pop_stack = i->nnn() & 1;
 294
 295   if (IS_TAG_EMPTY(0))
 296   {
 297      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 298
 299      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 300         return;
 301   }
 302   else
 303   {
 304      float_status_t status =
 305          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 306
 307      save_reg = floatx80_to_float32(BX_READ_FPU_REG(0), status);
 308
 309      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 310         return;
 311   }
 312
 313   write_virtual_dword(i->seg(), RMAddr(i), save_reg);
 314
 315   if (pop_stack)
 316      BX_CPU_THIS_PTR the_i387.FPU_pop();
 317 #else
 318   BX_INFO(("FST(P)_SINGLE_REAL: required FPU, configure --enable-fpu"));
 319 #endif
 320 }
 321
 322 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FST_DOUBLE_REAL(bxInstruction_c *i)
 323 {
 324 #if BX_SUPPORT_FPU
 325   BX_CPU_THIS_PTR prepareFPU(i);
 326
 327   float64 save_reg = float64_default_nan; /* The masked response */
 328
 329   int pop_stack = i->nnn() & 1;
 330
 331   if (IS_TAG_EMPTY(0))
 332   {
 333      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 334
 335      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 336         return;
 337   }
 338   else
 339   {
 340      float_status_t status =
 341          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 342
 343      save_reg = floatx80_to_float64(BX_READ_FPU_REG(0), status);
 344
 345      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 346         return;
 347   }
 348
 349   write_virtual_qword(i->seg(), RMAddr(i), save_reg);
 350
 351   if (pop_stack)
 352      BX_CPU_THIS_PTR the_i387.FPU_pop();
 353 #else
 354   BX_INFO(("FST(P)_DOUBLE_REAL: required FPU, configure --enable-fpu"));
 355 #endif
 356 }
 357
 358 /* DB /7 */
 359 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FSTP_EXTENDED_REAL(bxInstruction_c *i)
 360 {
 361 #if BX_SUPPORT_FPU
 362   BX_CPU_THIS_PTR prepareFPU(i);
 363
 364   floatx80 save_reg = floatx80_default_nan; /* The masked response */
 365
 366   if (IS_TAG_EMPTY(0))
 367   {
 368      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 369
 370      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 371         return;
 372   }
 373   else
 374   {
 375      save_reg = BX_READ_FPU_REG(0);
 376   }
 377
 378   write_virtual_tword(i->seg(), RMAddr(i), &save_reg);
 379
 380   BX_CPU_THIS_PTR the_i387.FPU_pop();
 381 #else
 382   BX_INFO(("FSTP_EXTENDED_REAL: required FPU, configure --enable-fpu"));
 383 #endif
 384 }
 385
 386 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FIST_WORD_INTEGER(bxInstruction_c *i)
 387 {
 388 #if BX_SUPPORT_FPU
 389   BX_CPU_THIS_PTR prepareFPU(i);
 390
 391   Bit16s save_reg = int16_indefinite;
 392
 393   int pop_stack = i->nnn() & 1;
 394
 395   clear_C1();
 396
 397   if (IS_TAG_EMPTY(0))
 398   {
 399      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 400
 401      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 402         return;
 403   }
 404   else
 405   {
 406       float_status_t status =
 407          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 408
 409       save_reg = floatx80_to_int16(BX_READ_FPU_REG(0), status);
 410
 411       if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 412         return;
 413   }
 414
 415   write_virtual_word(i->seg(), RMAddr(i), (Bit16u)(save_reg));
 416
 417   if (pop_stack)
 418      BX_CPU_THIS_PTR the_i387.FPU_pop();
 419 #else
 420   BX_INFO(("FIST(P)_WORD_INTEGER: required FPU, configure --enable-fpu"));
 421 #endif
 422 }
 423
 424 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FIST_DWORD_INTEGER(bxInstruction_c *i)
 425 {
 426 #if BX_SUPPORT_FPU
 427   BX_CPU_THIS_PTR prepareFPU(i);
 428
 429   Bit32s save_reg = int32_indefinite; /* The masked response */
 430
 431   int pop_stack = i->nnn() & 1;
 432
 433   clear_C1();
 434
 435   if (IS_TAG_EMPTY(0))
 436   {
 437      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 438
 439      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 440         return;
 441   }
 442   else
 443   {
 444      float_status_t status =
 445          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 446
 447      save_reg = floatx80_to_int32(BX_READ_FPU_REG(0), status);
 448
 449      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 450          return;
 451   }
 452
 453   write_virtual_dword(i->seg(), RMAddr(i), (Bit32u)(save_reg));
 454
 455   if (pop_stack)
 456      BX_CPU_THIS_PTR the_i387.FPU_pop();
 457 #else
 458   BX_INFO(("FIST(P)_DWORD_INTEGER: required FPU, configure --enable-fpu"));
 459 #endif
 460 }
 461
 462 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FISTP_QWORD_INTEGER(bxInstruction_c *i)
 463 {
 464 #if BX_SUPPORT_FPU
 465   BX_CPU_THIS_PTR prepareFPU(i);
 466
 467   Bit64s save_reg = int64_indefinite; /* The masked response */
 468
 469   clear_C1();
 470
 471   if (IS_TAG_EMPTY(0))
 472   {
 473      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 474
 475      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 476         return;
 477   }
 478   else
 479   {
 480      float_status_t status =
 481          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 482
 483      save_reg = floatx80_to_int64(BX_READ_FPU_REG(0), status);
 484
 485      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 486          return;
 487   }
 488
 489   write_virtual_qword(i->seg(), RMAddr(i), (Bit64u)(save_reg));
 490   BX_CPU_THIS_PTR the_i387.FPU_pop();
 491 #else
 492   BX_INFO(("FISTP_QWORD_INTEGER: required FPU, configure --enable-fpu"));
 493 #endif
 494 }
 495
 496 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FBSTP_PACKED_BCD(bxInstruction_c *i)
 497 {
 498 #if BX_SUPPORT_FPU
 499   BX_CPU_THIS_PTR prepareFPU(i);
 500
 501   /*
 502    * The packed BCD integer indefinite encoding (FFFFC000000000000000H)
 503    * is stored in response to a masked floating-point invalid-operation
 504    * exception.
 505    */
 506   Bit16u save_reg_hi = 0xFFFF;
 507   Bit64u save_reg_lo = BX_CONST64(0xC000000000000000);
 508
 509   clear_C1();
 510
 511   if (IS_TAG_EMPTY(0))
 512   {
 513      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 514
 515      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 516         return;
 517   }
 518   else
 519   {
 520      float_status_t status =
 521         FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 522
 523      Bit64s save_val = floatx80_to_int64(BX_READ_FPU_REG(0), status);
 524
 525      int sign = (save_val < 0);
 526      if (sign)
 527         save_val = -save_val;
 528
 529      if (save_val > BX_CONST64(999999999999999999))
 530      {
 531         float_raise(status, float_flag_invalid);
 532      }
 533
 534      if (! (status.float_exception_flags & float_flag_invalid))
 535      {
 536         save_reg_hi = (sign) ? 0x8000 : 0;
 537         save_reg_lo = 0;
 538
 539         for (int i=0; i<16; i++)
 540         {
 541            save_reg_lo += ((Bit64u)(save_val % 10)) << (4*i);
 542            save_val /= 10;
 543         }
 544
 545         save_reg_hi += (Bit16u)(save_val % 10);
 546         save_val /= 10;
 547         save_reg_hi += (Bit16u)(save_val % 10) << 4;
 548     }
 549
 550     /* check for fpu arithmetic exceptions */
 551     if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 552         return;
 553   }
 554
 555   // write packed bcd to memory
 556   write_virtual_qword(i->seg(), RMAddr(i),     save_reg_lo);
 557   write_virtual_word (i->seg(), RMAddr(i) + 8, save_reg_hi);
 558
 559   BX_CPU_THIS_PTR the_i387.FPU_pop();
 560 #else
 561   BX_INFO(("FBSTP_PACKED_BCD: required FPU, configure --enable-fpu"));
 562 #endif
 563 }
 564
 565 /* DF /1 */
 566 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FISTTP16(bxInstruction_c *i)
 567 {
 568 #if BX_SUPPORT_SSE >= 3
 569   BX_CPU_THIS_PTR prepareFPU(i);
 570
 571   Bit16s save_reg = int16_indefinite; /* The masked response */
 572
 573   clear_C1();
 574
 575   if (IS_TAG_EMPTY(0))
 576   {
 577      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 578
 579      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 580         return;
 581   }
 582   else
 583   {
 584       float_status_t status =
 585          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 586
 587       save_reg = floatx80_to_int16_round_to_zero(BX_READ_FPU_REG(0), status);
 588
 589       if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 590         return;
 591   }
 592
 593   write_virtual_word(i->seg(), RMAddr(i), (Bit16u)(save_reg));
 594   BX_CPU_THIS_PTR the_i387.FPU_pop();
 595 #else
 596   BX_INFO(("FISTTP16: required SSE3, use --enable-sse option"));
 597   UndefinedOpcode(i);
 598 #endif
 599 }
 600
 601 /* DB /1 */
 602 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FISTTP32(bxInstruction_c *i)
 603 {
 604 #if BX_SUPPORT_SSE >= 3
 605   BX_CPU_THIS_PTR prepareFPU(i);
 606
 607   Bit32s save_reg = int32_indefinite; /* The masked response */
 608
 609   clear_C1();
 610
 611   if (IS_TAG_EMPTY(0))
 612   {
 613      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 614
 615      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 616         return;
 617   }
 618   else
 619   {
 620      float_status_t status =
 621          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 622
 623      save_reg = floatx80_to_int32_round_to_zero(BX_READ_FPU_REG(0), status);
 624
 625      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 626          return;
 627   }
 628
 629   write_virtual_dword(i->seg(), RMAddr(i), (Bit32u)(save_reg));
 630   BX_CPU_THIS_PTR the_i387.FPU_pop();
 631 #else
 632   BX_INFO(("FISTTP32: required SSE3, use --enable-sse option"));
 633   UndefinedOpcode(i);
 634 #endif
 635 }
 636
 637 /* DD /1 */
 638 void BX_CPP_AttrRegparmN(1) BX_CPU_C::FISTTP64(bxInstruction_c *i)
 639 {
 640 #if BX_SUPPORT_SSE >= 3
 641   BX_CPU_THIS_PTR prepareFPU(i);
 642
 643   Bit64s save_reg = int64_indefinite; /* The masked response */
 644
 645   clear_C1();
 646
 647   if (IS_TAG_EMPTY(0))
 648   {
 649      BX_CPU_THIS_PTR FPU_exception(FPU_EX_Stack_Underflow);
 650
 651      if (! (BX_CPU_THIS_PTR the_i387.is_IA_masked()))
 652         return;
 653   }
 654   else
 655   {
 656      float_status_t status =
 657          FPU_pre_exception_handling(BX_CPU_THIS_PTR the_i387.get_control_word());
 658
 659      save_reg = floatx80_to_int64_round_to_zero(BX_READ_FPU_REG(0), status);
 660
 661      if (BX_CPU_THIS_PTR FPU_exception(status.float_exception_flags))
 662          return;
 663   }
 664
 665   write_virtual_qword(i->seg(), RMAddr(i), (Bit64u)(save_reg));
 666   BX_CPU_THIS_PTR the_i387.FPU_pop();
 667 #else
 668   BX_INFO(("FISTTP64: required SSE3, use --enable-sse option"));
 669   UndefinedOpcode(i);
 670 #endif
 671 }
 672
 673 #endif