op-i386.c

   1 /*
   2  *  i386 micro operations
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include "exec-i386.h"
  21
  22 /* NOTE: data are not static to force relocation generation by GCC */
  23
  24 uint8_t parity_table[256] = {
  25     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  26     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  27     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  28     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  29     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  30     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  31     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  32     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  33     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  34     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  35     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  36     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  37     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  38     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  39     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  40     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  41     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  42     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  43     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  44     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  45     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  46     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  47     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  48     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  49     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  50     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  51     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  52     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  53     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  54     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  55     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  56     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  57 };
  58
  59 /* modulo 17 table */
  60 const uint8_t rclw_table[32] = {
  61     0, 1, 2, 3, 4, 5, 6, 7,
  62     8, 9,10,11,12,13,14,15,
  63    16, 0, 1, 2, 3, 4, 5, 6,
  64     7, 8, 9,10,11,12,13,14,
  65 };
  66
  67 /* modulo 9 table */
  68 const uint8_t rclb_table[32] = {
  69     0, 1, 2, 3, 4, 5, 6, 7,
  70     8, 0, 1, 2, 3, 4, 5, 6,
  71     7, 8, 0, 1, 2, 3, 4, 5,
  72     6, 7, 8, 0, 1, 2, 3, 4,
  73 };
  74
  75 #ifdef USE_X86LDOUBLE
  76 /* an array of Intel 80-bit FP constants, to be loaded via integer ops */
  77 typedef unsigned short f15ld[5];
  78 const f15ld f15rk[] =
  79 {
  80 /*0*/   {0x0000,0x0000,0x0000,0x0000,0x0000},
  81 /*1*/   {0x0000,0x0000,0x0000,0x8000,0x3fff},
  82 /*pi*/  {0xc235,0x2168,0xdaa2,0xc90f,0x4000},
  83 /*lg2*/ {0xf799,0xfbcf,0x9a84,0x9a20,0x3ffd},
  84 /*ln2*/ {0x79ac,0xd1cf,0x17f7,0xb172,0x3ffe},
  85 /*l2e*/ {0xf0bc,0x5c17,0x3b29,0xb8aa,0x3fff},
  86 /*l2t*/ {0x8afe,0xcd1b,0x784b,0xd49a,0x4000}
  87 };
  88 #else
  89 /* the same, 64-bit version */
  90 typedef unsigned short f15ld[4];
  91 const f15ld f15rk[] =
  92 {
  93 #ifndef WORDS_BIGENDIAN
  94 /*0*/   {0x0000,0x0000,0x0000,0x0000},
  95 /*1*/   {0x0000,0x0000,0x0000,0x3ff0},
  96 /*pi*/  {0x2d18,0x5444,0x21fb,0x4009},
  97 /*lg2*/ {0x79ff,0x509f,0x4413,0x3fd3},
  98 /*ln2*/ {0x39ef,0xfefa,0x2e42,0x3fe6},
  99 /*l2e*/ {0x82fe,0x652b,0x1547,0x3ff7},
 100 /*l2t*/ {0xa371,0x0979,0x934f,0x400a}
 101 #else
 102 /*0*/   {0x0000,0x0000,0x0000,0x0000},
 103 /*1*/   {0x3ff0,0x0000,0x0000,0x0000},
 104 /*pi*/  {0x4009,0x21fb,0x5444,0x2d18},
 105 /*lg2*/ {0x3fd3,0x4413,0x509f,0x79ff},
 106 /*ln2*/ {0x3fe6,0x2e42,0xfefa,0x39ef},
 107 /*l2e*/ {0x3ff7,0x1547,0x652b,0x82fe},
 108 /*l2t*/ {0x400a,0x934f,0x0979,0xa371}
 109 #endif
 110 };
 111 #endif
 112
 113 /* n must be a constant to be efficient */
 114 static inline int lshift(int x, int n)
 115 {
 116     if (n >= 0)
 117         return x << n;
 118     else
 119         return x >> (-n);
 120 }
 121
 122 /* exception support */
 123 /* NOTE: not static to force relocation generation by GCC */
 124 void raise_exception(int exception_index)
 125 {
 126     env->exception_index = exception_index;
 127     longjmp(env->jmp_env, 1);
 128 }
 129
 130 /* we define the various pieces of code used by the JIT */
 131
 132 #define REG EAX
 133 #define REGNAME _EAX
 134 #include "opreg_template.h"
 135 #undef REG
 136 #undef REGNAME
 137
 138 #define REG ECX
 139 #define REGNAME _ECX
 140 #include "opreg_template.h"
 141 #undef REG
 142 #undef REGNAME
 143
 144 #define REG EDX
 145 #define REGNAME _EDX
 146 #include "opreg_template.h"
 147 #undef REG
 148 #undef REGNAME
 149
 150 #define REG EBX
 151 #define REGNAME _EBX
 152 #include "opreg_template.h"
 153 #undef REG
 154 #undef REGNAME
 155
 156 #define REG ESP
 157 #define REGNAME _ESP
 158 #include "opreg_template.h"
 159 #undef REG
 160 #undef REGNAME
 161
 162 #define REG EBP
 163 #define REGNAME _EBP
 164 #include "opreg_template.h"
 165 #undef REG
 166 #undef REGNAME
 167
 168 #define REG ESI
 169 #define REGNAME _ESI
 170 #include "opreg_template.h"
 171 #undef REG
 172 #undef REGNAME
 173
 174 #define REG EDI
 175 #define REGNAME _EDI
 176 #include "opreg_template.h"
 177 #undef REG
 178 #undef REGNAME
 179
 180 /* operations */
 181
 182 void OPPROTO op_addl_T0_T1_cc(void)
 183 {
 184     CC_SRC = T0;
 185     T0 += T1;
 186     CC_DST = T0;
 187 }
 188
 189 void OPPROTO op_orl_T0_T1_cc(void)
 190 {
 191     T0 |= T1;
 192     CC_DST = T0;
 193 }
 194
 195 void OPPROTO op_andl_T0_T1_cc(void)
 196 {
 197     T0 &= T1;
 198     CC_DST = T0;
 199 }
 200
 201 void OPPROTO op_subl_T0_T1_cc(void)
 202 {
 203     CC_SRC = T0;
 204     T0 -= T1;
 205     CC_DST = T0;
 206 }
 207
 208 void OPPROTO op_xorl_T0_T1_cc(void)
 209 {
 210     T0 ^= T1;
 211     CC_DST = T0;
 212 }
 213
 214 void OPPROTO op_cmpl_T0_T1_cc(void)
 215 {
 216     CC_SRC = T0;
 217     CC_DST = T0 - T1;
 218 }
 219
 220 void OPPROTO op_notl_T0(void)
 221 {
 222     T0 = ~T0;
 223 }
 224
 225 void OPPROTO op_negl_T0_cc(void)
 226 {
 227     CC_SRC = 0;
 228     T0 = -T0;
 229     CC_DST = T0;
 230 }
 231
 232 void OPPROTO op_incl_T0_cc(void)
 233 {
 234     CC_SRC = cc_table[CC_OP].compute_c();
 235     T0++;
 236     CC_DST = T0;
 237 }
 238
 239 void OPPROTO op_decl_T0_cc(void)
 240 {
 241     CC_SRC = cc_table[CC_OP].compute_c();
 242     T0--;
 243     CC_DST = T0;
 244 }
 245
 246 void OPPROTO op_testl_T0_T1_cc(void)
 247 {
 248     CC_DST = T0 & T1;
 249 }
 250
 251 void OPPROTO op_bswapl_T0(void)
 252 {
 253     T0 = bswap32(T0);
 254 }
 255
 256 /* multiply/divide */
 257 void OPPROTO op_mulb_AL_T0(void)
 258 {
 259     unsigned int res;
 260     res = (uint8_t)EAX * (uint8_t)T0;
 261     EAX = (EAX & 0xffff0000) | res;
 262     CC_SRC = (res & 0xff00);
 263 }
 264
 265 void OPPROTO op_imulb_AL_T0(void)
 266 {
 267     int res;
 268     res = (int8_t)EAX * (int8_t)T0;
 269     EAX = (EAX & 0xffff0000) | (res & 0xffff);
 270     CC_SRC = (res != (int8_t)res);
 271 }
 272
 273 void OPPROTO op_mulw_AX_T0(void)
 274 {
 275     unsigned int res;
 276     res = (uint16_t)EAX * (uint16_t)T0;
 277     EAX = (EAX & 0xffff0000) | (res & 0xffff);
 278     EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
 279     CC_SRC = res >> 16;
 280 }
 281
 282 void OPPROTO op_imulw_AX_T0(void)
 283 {
 284     int res;
 285     res = (int16_t)EAX * (int16_t)T0;
 286     EAX = (EAX & 0xffff0000) | (res & 0xffff);
 287     EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
 288     CC_SRC = (res != (int16_t)res);
 289 }
 290
 291 void OPPROTO op_mull_EAX_T0(void)
 292 {
 293     uint64_t res;
 294     res = (uint64_t)((uint32_t)EAX) * (uint64_t)((uint32_t)T0);
 295     EAX = res;
 296     EDX = res >> 32;
 297     CC_SRC = res >> 32;
 298 }
 299
 300 void OPPROTO op_imull_EAX_T0(void)
 301 {
 302     int64_t res;
 303     res = (int64_t)((int32_t)EAX) * (int64_t)((int32_t)T0);
 304     EAX = res;
 305     EDX = res >> 32;
 306     CC_SRC = (res != (int32_t)res);
 307 }
 308
 309 void OPPROTO op_imulw_T0_T1(void)
 310 {
 311     int res;
 312     res = (int16_t)T0 * (int16_t)T1;
 313     T0 = res;
 314     CC_SRC = (res != (int16_t)res);
 315 }
 316
 317 void OPPROTO op_imull_T0_T1(void)
 318 {
 319     int64_t res;
 320     res = (int64_t)((int32_t)T0) * (int64_t)((int32_t)T1);
 321     T0 = res;
 322     CC_SRC = (res != (int32_t)res);
 323 }
 324
 325 /* division, flags are undefined */
 326 /* XXX: add exceptions for overflow & div by zero */
 327 void OPPROTO op_divb_AL_T0(void)
 328 {
 329     unsigned int num, den, q, r;
 330
 331     num = (EAX & 0xffff);
 332     den = (T0 & 0xff);
 333     q = (num / den) & 0xff;
 334     r = (num % den) & 0xff;
 335     EAX = (EAX & 0xffff0000) | (r << 8) | q;
 336 }
 337
 338 void OPPROTO op_idivb_AL_T0(void)
 339 {
 340     int num, den, q, r;
 341
 342     num = (int16_t)EAX;
 343     den = (int8_t)T0;
 344     q = (num / den) & 0xff;
 345     r = (num % den) & 0xff;
 346     EAX = (EAX & 0xffff0000) | (r << 8) | q;
 347 }
 348
 349 void OPPROTO op_divw_AX_T0(void)
 350 {
 351     unsigned int num, den, q, r;
 352
 353     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
 354     den = (T0 & 0xffff);
 355     q = (num / den) & 0xffff;
 356     r = (num % den) & 0xffff;
 357     EAX = (EAX & 0xffff0000) | q;
 358     EDX = (EDX & 0xffff0000) | r;
 359 }
 360
 361 void OPPROTO op_idivw_AX_T0(void)
 362 {
 363     int num, den, q, r;
 364
 365     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
 366     den = (int16_t)T0;
 367     q = (num / den) & 0xffff;
 368     r = (num % den) & 0xffff;
 369     EAX = (EAX & 0xffff0000) | q;
 370     EDX = (EDX & 0xffff0000) | r;
 371 }
 372
 373 void OPPROTO op_divl_EAX_T0(void)
 374 {
 375     unsigned int den, q, r;
 376     uint64_t num;
 377
 378     num = EAX | ((uint64_t)EDX << 32);
 379     den = T0;
 380     q = (num / den);
 381     r = (num % den);
 382     EAX = q;
 383     EDX = r;
 384 }
 385
 386 void OPPROTO op_idivl_EAX_T0(void)
 387 {
 388     int den, q, r;
 389     int64_t num;
 390
 391     num = EAX | ((uint64_t)EDX << 32);
 392     den = T0;
 393     q = (num / den);
 394     r = (num % den);
 395     EAX = q;
 396     EDX = r;
 397 }
 398
 399 /* constant load */
 400
 401 void OPPROTO op_movl_T0_im(void)
 402 {
 403     T0 = PARAM1;
 404 }
 405
 406 void OPPROTO op_movl_T1_im(void)
 407 {
 408     T1 = PARAM1;
 409 }
 410
 411 void OPPROTO op_movl_A0_im(void)
 412 {
 413     A0 = PARAM1;
 414 }
 415
 416 void OPPROTO op_addl_A0_im(void)
 417 {
 418     A0 += PARAM1;
 419 }
 420
 421 void OPPROTO op_andl_A0_ffff(void)
 422 {
 423     A0 = A0 & 0xffff;
 424 }
 425
 426 /* memory access */
 427
 428 void OPPROTO op_ldub_T0_A0(void)
 429 {
 430     T0 = ldub((uint8_t *)A0);
 431 }
 432
 433 void OPPROTO op_ldsb_T0_A0(void)
 434 {
 435     T0 = ldsb((int8_t *)A0);
 436 }
 437
 438 void OPPROTO op_lduw_T0_A0(void)
 439 {
 440     T0 = lduw((uint8_t *)A0);
 441 }
 442
 443 void OPPROTO op_ldsw_T0_A0(void)
 444 {
 445     T0 = ldsw((int8_t *)A0);
 446 }
 447
 448 void OPPROTO op_ldl_T0_A0(void)
 449 {
 450     T0 = ldl((uint8_t *)A0);
 451 }
 452
 453 void OPPROTO op_ldub_T1_A0(void)
 454 {
 455     T1 = ldub((uint8_t *)A0);
 456 }
 457
 458 void OPPROTO op_ldsb_T1_A0(void)
 459 {
 460     T1 = ldsb((int8_t *)A0);
 461 }
 462
 463 void OPPROTO op_lduw_T1_A0(void)
 464 {
 465     T1 = lduw((uint8_t *)A0);
 466 }
 467
 468 void OPPROTO op_ldsw_T1_A0(void)
 469 {
 470     T1 = ldsw((int8_t *)A0);
 471 }
 472
 473 void OPPROTO op_ldl_T1_A0(void)
 474 {
 475     T1 = ldl((uint8_t *)A0);
 476 }
 477
 478 void OPPROTO op_stb_T0_A0(void)
 479 {
 480     stb((uint8_t *)A0, T0);
 481 }
 482
 483 void OPPROTO op_stw_T0_A0(void)
 484 {
 485     stw((uint8_t *)A0, T0);
 486 }
 487
 488 void OPPROTO op_stl_T0_A0(void)
 489 {
 490     stl((uint8_t *)A0, T0);
 491 }
 492
 493 /* used for bit operations */
 494
 495 void OPPROTO op_add_bitw_A0_T1(void)
 496 {
 497     A0 += ((int32_t)T1 >> 4) << 1;
 498 }
 499
 500 void OPPROTO op_add_bitl_A0_T1(void)
 501 {
 502     A0 += ((int32_t)T1 >> 5) << 2;
 503 }
 504
 505 /* indirect jump */
 506
 507 void OPPROTO op_jmp_T0(void)
 508 {
 509     PC = T0;
 510 }
 511
 512 void OPPROTO op_jmp_im(void)
 513 {
 514     PC = PARAM1;
 515 }
 516
 517 void OPPROTO op_int_im(void)
 518 {
 519     PC = PARAM1;
 520     raise_exception(EXCP0D_GPF);
 521 }
 522
 523 void OPPROTO op_int3(void)
 524 {
 525     PC = PARAM1;
 526     raise_exception(EXCP03_INT3);
 527 }
 528
 529 void OPPROTO op_into(void)
 530 {
 531     int eflags;
 532     eflags = cc_table[CC_OP].compute_all();
 533     if (eflags & CC_O) {
 534         PC = PARAM1;
 535         raise_exception(EXCP04_INTO);
 536     } else {
 537         PC = PARAM2;
 538     }
 539 }
 540
 541 /* string ops */
 542
 543 #define ldul ldl
 544
 545 #define SHIFT 0
 546 #include "ops_template.h"
 547 #undef SHIFT
 548
 549 #define SHIFT 1
 550 #include "ops_template.h"
 551 #undef SHIFT
 552
 553 #define SHIFT 2
 554 #include "ops_template.h"
 555 #undef SHIFT
 556
 557 /* sign extend */
 558
 559 void OPPROTO op_movsbl_T0_T0(void)
 560 {
 561     T0 = (int8_t)T0;
 562 }
 563
 564 void OPPROTO op_movzbl_T0_T0(void)
 565 {
 566     T0 = (uint8_t)T0;
 567 }
 568
 569 void OPPROTO op_movswl_T0_T0(void)
 570 {
 571     T0 = (int16_t)T0;
 572 }
 573
 574 void OPPROTO op_movzwl_T0_T0(void)
 575 {
 576     T0 = (uint16_t)T0;
 577 }
 578
 579 void OPPROTO op_movswl_EAX_AX(void)
 580 {
 581     EAX = (int16_t)EAX;
 582 }
 583
 584 void OPPROTO op_movsbw_AX_AL(void)
 585 {
 586     EAX = (EAX & 0xffff0000) | ((int8_t)EAX & 0xffff);
 587 }
 588
 589 void OPPROTO op_movslq_EDX_EAX(void)
 590 {
 591     EDX = (int32_t)EAX >> 31;
 592 }
 593
 594 void OPPROTO op_movswl_DX_AX(void)
 595 {
 596     EDX = (EDX & 0xffff0000) | (((int16_t)EAX >> 15) & 0xffff);
 597 }
 598
 599 /* push/pop */
 600 /* XXX: add 16 bit operand/16 bit seg variants */
 601
 602 void op_pushl_T0(void)
 603 {
 604     uint32_t offset;
 605     offset = ESP - 4;
 606     stl((void *)offset, T0);
 607     /* modify ESP after to handle exceptions correctly */
 608     ESP = offset;
 609 }
 610
 611 void op_pushl_T1(void)
 612 {
 613     uint32_t offset;
 614     offset = ESP - 4;
 615     stl((void *)offset, T1);
 616     /* modify ESP after to handle exceptions correctly */
 617     ESP = offset;
 618 }
 619
 620 void op_popl_T0(void)
 621 {
 622     T0 = ldl((void *)ESP);
 623     ESP += 4;
 624 }
 625
 626 void op_addl_ESP_im(void)
 627 {
 628     ESP += PARAM1;
 629 }
 630
 631 void op_pushal(void)
 632 {
 633     uint8_t *sp;
 634     sp = (void *)(ESP - 32);
 635     stl(sp, EDI);
 636     stl(sp + 4, ESI);
 637     stl(sp + 8, EBP);
 638     stl(sp + 12, ESP);
 639     stl(sp + 16, EBX);
 640     stl(sp + 20, EDX);
 641     stl(sp + 24, ECX);
 642     stl(sp + 28, EAX);
 643     ESP = (unsigned long)sp;
 644 }
 645
 646 void op_pushaw(void)
 647 {
 648     uint8_t *sp;
 649     sp = (void *)(ESP - 16);
 650     stw(sp, EDI);
 651     stw(sp + 2, ESI);
 652     stw(sp + 4, EBP);
 653     stw(sp + 6, ESP);
 654     stw(sp + 8, EBX);
 655     stw(sp + 10, EDX);
 656     stw(sp + 12, ECX);
 657     stw(sp + 14, EAX);
 658     ESP = (unsigned long)sp;
 659 }
 660
 661 void op_popal(void)
 662 {
 663     uint8_t *sp;
 664     sp = (void *)ESP;
 665     EDI = ldl(sp);
 666     ESI = ldl(sp + 4);
 667     EBP = ldl(sp + 8);
 668     EBX = ldl(sp + 16);
 669     EDX = ldl(sp + 20);
 670     ECX = ldl(sp + 24);
 671     EAX = ldl(sp + 28);
 672     ESP = (unsigned long)sp + 32;
 673 }
 674
 675 void op_popaw(void)
 676 {
 677     uint8_t *sp;
 678     sp = (void *)ESP;
 679     EDI = ldl(sp);
 680     ESI = ldl(sp + 2);
 681     EBP = ldl(sp + 4);
 682     EBX = ldl(sp + 8);
 683     EDX = ldl(sp + 10);
 684     ECX = ldl(sp + 12);
 685     EAX = ldl(sp + 14);
 686     ESP = (unsigned long)sp + 16;
 687 }
 688
 689 void op_enterl(void)
 690 {
 691     unsigned int bp, frame_temp, level;
 692     uint8_t *sp;
 693
 694     sp = (void *)ESP;
 695     bp = EBP;
 696     sp -= 4;
 697     stl(sp, bp);
 698     frame_temp = (unsigned int)sp;
 699     level = PARAM2;
 700     if (level) {
 701         while (level--) {
 702             bp -= 4;
 703             sp -= 4;
 704             stl(sp, bp);
 705         }
 706         sp -= 4;
 707         stl(sp, frame_temp);
 708     }
 709     EBP = frame_temp;
 710     sp -= PARAM1;
 711     ESP = (int)sp;
 712 }
 713
 714 /* rdtsc */
 715 #ifndef __i386__
 716 uint64_t emu_time;
 717 #endif
 718 void op_rdtsc(void)
 719 {
 720     uint64_t val;
 721 #ifdef __i386__
 722     asm("rdtsc" : "=A" (val));
 723 #else
 724     /* better than nothing: the time increases */
 725     val = emu_time++;
 726 #endif
 727     EAX = val;
 728     EDX = val >> 32;
 729 }
 730
 731 /* bcd */
 732
 733 /* XXX: exception */
 734 void OPPROTO op_aam(void)
 735 {
 736     int base = PARAM1;
 737     int al, ah;
 738     al = EAX & 0xff;
 739     ah = al / base;
 740     al = al % base;
 741     EAX = (EAX & ~0xffff) | al | (ah << 8);
 742     CC_DST = al;
 743 }
 744
 745 void OPPROTO op_aad(void)
 746 {
 747     int base = PARAM1;
 748     int al, ah;
 749     al = EAX & 0xff;
 750     ah = (EAX >> 8) & 0xff;
 751     al = ((ah * base) + al) & 0xff;
 752     EAX = (EAX & ~0xffff) | al;
 753     CC_DST = al;
 754 }
 755
 756 void OPPROTO op_aaa(void)
 757 {
 758     int icarry;
 759     int al, ah, af;
 760     int eflags;
 761
 762     eflags = cc_table[CC_OP].compute_all();
 763     af = eflags & CC_A;
 764     al = EAX & 0xff;
 765     ah = (EAX >> 8) & 0xff;
 766
 767     icarry = (al > 0xf9);
 768     if (((al & 0x0f) > 9 ) || af) {
 769         al = (al + 6) & 0x0f;
 770         ah = (ah + 1 + icarry) & 0xff;
 771         eflags |= CC_C | CC_A;
 772     } else {
 773         eflags &= ~(CC_C | CC_A);
 774         al &= 0x0f;
 775     }
 776     EAX = (EAX & ~0xffff) | al | (ah << 8);
 777     CC_SRC = eflags;
 778 }
 779
 780 void OPPROTO op_aas(void)
 781 {
 782     int icarry;
 783     int al, ah, af;
 784     int eflags;
 785
 786     eflags = cc_table[CC_OP].compute_all();
 787     af = eflags & CC_A;
 788     al = EAX & 0xff;
 789     ah = (EAX >> 8) & 0xff;
 790
 791     icarry = (al < 6);
 792     if (((al & 0x0f) > 9 ) || af) {
 793         al = (al - 6) & 0x0f;
 794         ah = (ah - 1 - icarry) & 0xff;
 795         eflags |= CC_C | CC_A;
 796     } else {
 797         eflags &= ~(CC_C | CC_A);
 798         al &= 0x0f;
 799     }
 800     EAX = (EAX & ~0xffff) | al | (ah << 8);
 801     CC_SRC = eflags;
 802 }
 803
 804 void OPPROTO op_daa(void)
 805 {
 806     int al, af, cf;
 807     int eflags;
 808
 809     eflags = cc_table[CC_OP].compute_all();
 810     cf = eflags & CC_C;
 811     af = eflags & CC_A;
 812     al = EAX & 0xff;
 813
 814     eflags = 0;
 815     if (((al & 0x0f) > 9 ) || af) {
 816         al = (al + 6) & 0xff;
 817         eflags |= CC_A;
 818     }
 819     if ((al > 0x9f) || cf) {
 820         al = (al + 0x60) & 0xff;
 821         eflags |= CC_C;
 822     }
 823     EAX = (EAX & ~0xff) | al;
 824     /* well, speed is not an issue here, so we compute the flags by hand */
 825     eflags |= (al == 0) << 6; /* zf */
 826     eflags |= parity_table[al]; /* pf */
 827     eflags |= (al & 0x80); /* sf */
 828     CC_SRC = eflags;
 829 }
 830
 831 void OPPROTO op_das(void)
 832 {
 833     int al, al1, af, cf;
 834     int eflags;
 835
 836     eflags = cc_table[CC_OP].compute_all();
 837     cf = eflags & CC_C;
 838     af = eflags & CC_A;
 839     al = EAX & 0xff;
 840
 841     eflags = 0;
 842     al1 = al;
 843     if (((al & 0x0f) > 9 ) || af) {
 844         eflags |= CC_A;
 845         if (al < 6 || cf)
 846             eflags |= CC_C;
 847         al = (al - 6) & 0xff;
 848     }
 849     if ((al1 > 0x99) || cf) {
 850         al = (al - 0x60) & 0xff;
 851         eflags |= CC_C;
 852     }
 853     EAX = (EAX & ~0xff) | al;
 854     /* well, speed is not an issue here, so we compute the flags by hand */
 855     eflags |= (al == 0) << 6; /* zf */
 856     eflags |= parity_table[al]; /* pf */
 857     eflags |= (al & 0x80); /* sf */
 858     CC_SRC = eflags;
 859 }
 860
 861 /* segment handling */
 862
 863 void load_seg(int seg_reg, int selector)
 864 {
 865     SegmentCache *sc;
 866     SegmentDescriptorTable *dt;
 867     int index;
 868     uint32_t e1, e2;
 869     uint8_t *ptr;
 870
 871     env->segs[seg_reg] = selector;
 872     sc = &env->seg_cache[seg_reg];
 873     if (env->vm86) {
 874         sc->base = (void *)(selector << 4);
 875         sc->limit = 0xffff;
 876         sc->seg_32bit = 0;
 877     } else {
 878         if (selector & 0x4)
 879             dt = &env->ldt;
 880         else
 881             dt = &env->gdt;
 882         index = selector & ~7;
 883         if ((index + 7) > dt->limit)
 884             raise_exception(EXCP0D_GPF);
 885         ptr = dt->base + index;
 886         e1 = ldl(ptr);
 887         e2 = ldl(ptr + 4);
 888         sc->base = (void *)((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
 889         sc->limit = (e1 & 0xffff) | (e2 & 0x000f0000);
 890         if (e2 & (1 << 23))
 891             sc->limit = (sc->limit << 12) | 0xfff;
 892         sc->seg_32bit = (e2 >> 22) & 1;
 893 #if 0
 894         fprintf(logfile, "load_seg: sel=0x%04x base=0x%08lx limit=0x%08lx seg_32bit=%d\n",
 895                 selector, (unsigned long)sc->base, sc->limit, sc->seg_32bit);
 896 #endif
 897     }
 898 }
 899
 900 void OPPROTO op_movl_seg_T0(void)
 901 {
 902     load_seg(PARAM1, T0 & 0xffff);
 903 }
 904
 905 void OPPROTO op_movl_T0_seg(void)
 906 {
 907     T0 = env->segs[PARAM1];
 908 }
 909
 910 void OPPROTO op_addl_A0_seg(void)
 911 {
 912     A0 += *(unsigned long *)((char *)env + PARAM1);
 913 }
 914
 915 /* flags handling */
 916
 917 /* slow jumps cases (compute x86 flags) */
 918 void OPPROTO op_jo_cc(void)
 919 {
 920     int eflags;
 921     eflags = cc_table[CC_OP].compute_all();
 922     if (eflags & CC_O)
 923         PC = PARAM1;
 924     else
 925         PC = PARAM2;
 926     FORCE_RET();
 927 }
 928
 929 void OPPROTO op_jb_cc(void)
 930 {
 931     if (cc_table[CC_OP].compute_c())
 932         PC = PARAM1;
 933     else
 934         PC = PARAM2;
 935     FORCE_RET();
 936 }
 937
 938 void OPPROTO op_jz_cc(void)
 939 {
 940     int eflags;
 941     eflags = cc_table[CC_OP].compute_all();
 942     if (eflags & CC_Z)
 943         PC = PARAM1;
 944     else
 945         PC = PARAM2;
 946     FORCE_RET();
 947 }
 948
 949 void OPPROTO op_jbe_cc(void)
 950 {
 951     int eflags;
 952     eflags = cc_table[CC_OP].compute_all();
 953     if (eflags & (CC_Z | CC_C))
 954         PC = PARAM1;
 955     else
 956         PC = PARAM2;
 957     FORCE_RET();
 958 }
 959
 960 void OPPROTO op_js_cc(void)
 961 {
 962     int eflags;
 963     eflags = cc_table[CC_OP].compute_all();
 964     if (eflags & CC_S)
 965         PC = PARAM1;
 966     else
 967         PC = PARAM2;
 968     FORCE_RET();
 969 }
 970
 971 void OPPROTO op_jp_cc(void)
 972 {
 973     int eflags;
 974     eflags = cc_table[CC_OP].compute_all();
 975     if (eflags & CC_P)
 976         PC = PARAM1;
 977     else
 978         PC = PARAM2;
 979     FORCE_RET();
 980 }
 981
 982 void OPPROTO op_jl_cc(void)
 983 {
 984     int eflags;
 985     eflags = cc_table[CC_OP].compute_all();
 986     if ((eflags ^ (eflags >> 4)) & 0x80)
 987         PC = PARAM1;
 988     else
 989         PC = PARAM2;
 990     FORCE_RET();
 991 }
 992
 993 void OPPROTO op_jle_cc(void)
 994 {
 995     int eflags;
 996     eflags = cc_table[CC_OP].compute_all();
 997     if (((eflags ^ (eflags >> 4)) & 0x80) || (eflags & CC_Z))
 998         PC = PARAM1;
 999     else
1000         PC = PARAM2;
1001     FORCE_RET();
1002 }
1003
1004 /* slow set cases (compute x86 flags) */
1005 void OPPROTO op_seto_T0_cc(void)
1006 {
1007     int eflags;
1008     eflags = cc_table[CC_OP].compute_all();
1009     T0 = (eflags >> 11) & 1;
1010 }
1011
1012 void OPPROTO op_setb_T0_cc(void)
1013 {
1014     T0 = cc_table[CC_OP].compute_c();
1015 }
1016
1017 void OPPROTO op_setz_T0_cc(void)
1018 {
1019     int eflags;
1020     eflags = cc_table[CC_OP].compute_all();
1021     T0 = (eflags >> 6) & 1;
1022 }
1023
1024 void OPPROTO op_setbe_T0_cc(void)
1025 {
1026     int eflags;
1027     eflags = cc_table[CC_OP].compute_all();
1028     T0 = (eflags & (CC_Z | CC_C)) != 0;
1029 }
1030
1031 void OPPROTO op_sets_T0_cc(void)
1032 {
1033     int eflags;
1034     eflags = cc_table[CC_OP].compute_all();
1035     T0 = (eflags >> 7) & 1;
1036 }
1037
1038 void OPPROTO op_setp_T0_cc(void)
1039 {
1040     int eflags;
1041     eflags = cc_table[CC_OP].compute_all();
1042     T0 = (eflags >> 2) & 1;
1043 }
1044
1045 void OPPROTO op_setl_T0_cc(void)
1046 {
1047     int eflags;
1048     eflags = cc_table[CC_OP].compute_all();
1049     T0 = ((eflags ^ (eflags >> 4)) >> 7) & 1;
1050 }
1051
1052 void OPPROTO op_setle_T0_cc(void)
1053 {
1054     int eflags;
1055     eflags = cc_table[CC_OP].compute_all();
1056     T0 = (((eflags ^ (eflags >> 4)) & 0x80) || (eflags & CC_Z)) != 0;
1057 }
1058
1059 void OPPROTO op_xor_T0_1(void)
1060 {
1061     T0 ^= 1;
1062 }
1063
1064 void OPPROTO op_set_cc_op(void)
1065 {
1066     CC_OP = PARAM1;
1067 }
1068
1069 void OPPROTO op_movl_eflags_T0(void)
1070 {
1071     CC_SRC = T0;
1072     DF = 1 - (2 * ((T0 >> 10) & 1));
1073 }
1074
1075 /* XXX: compute only O flag */
1076 void OPPROTO op_movb_eflags_T0(void)
1077 {
1078     int of;
1079     of = cc_table[CC_OP].compute_all() & CC_O;
1080     CC_SRC = T0 | of;
1081 }
1082
1083 void OPPROTO op_movl_T0_eflags(void)
1084 {
1085     T0 = cc_table[CC_OP].compute_all();
1086     T0 |= (DF & DIRECTION_FLAG);
1087 }
1088
1089 void OPPROTO op_cld(void)
1090 {
1091     DF = 1;
1092 }
1093
1094 void OPPROTO op_std(void)
1095 {
1096     DF = -1;
1097 }
1098
1099 void OPPROTO op_clc(void)
1100 {
1101     int eflags;
1102     eflags = cc_table[CC_OP].compute_all();
1103     eflags &= ~CC_C;
1104     CC_SRC = eflags;
1105 }
1106
1107 void OPPROTO op_stc(void)
1108 {
1109     int eflags;
1110     eflags = cc_table[CC_OP].compute_all();
1111     eflags |= CC_C;
1112     CC_SRC = eflags;
1113 }
1114
1115 void OPPROTO op_cmc(void)
1116 {
1117     int eflags;
1118     eflags = cc_table[CC_OP].compute_all();
1119     eflags ^= CC_C;
1120     CC_SRC = eflags;
1121 }
1122
1123 void OPPROTO op_salc(void)
1124 {
1125     int cf;
1126     cf = cc_table[CC_OP].compute_c();
1127     EAX = (EAX & ~0xff) | ((-cf) & 0xff);
1128 }
1129
1130 static int compute_all_eflags(void)
1131 {
1132     return CC_SRC;
1133 }
1134
1135 static int compute_c_eflags(void)
1136 {
1137     return CC_SRC & CC_C;
1138 }
1139
1140 static int compute_c_mul(void)
1141 {
1142     int cf;
1143     cf = (CC_SRC != 0);
1144     return cf;
1145 }
1146
1147 static int compute_all_mul(void)
1148 {
1149     int cf, pf, af, zf, sf, of;
1150     cf = (CC_SRC != 0);
1151     pf = 0; /* undefined */
1152     af = 0; /* undefined */
1153     zf = 0; /* undefined */
1154     sf = 0; /* undefined */
1155     of = cf << 11;
1156     return cf | pf | af | zf | sf | of;
1157 }
1158
1159 CCTable cc_table[CC_OP_NB] = {
1160     [CC_OP_DYNAMIC] = { /* should never happen */ },
1161
1162     [CC_OP_EFLAGS] = { compute_all_eflags, compute_c_eflags },
1163
1164     [CC_OP_MUL] = { compute_all_mul, compute_c_mul },
1165
1166     [CC_OP_ADDB] = { compute_all_addb, compute_c_addb },
1167     [CC_OP_ADDW] = { compute_all_addw, compute_c_addw  },
1168     [CC_OP_ADDL] = { compute_all_addl, compute_c_addl  },
1169
1170     [CC_OP_ADCB] = { compute_all_adcb, compute_c_adcb },
1171     [CC_OP_ADCW] = { compute_all_adcw, compute_c_adcw  },
1172     [CC_OP_ADCL] = { compute_all_adcl, compute_c_adcl  },
1173
1174     [CC_OP_SUBB] = { compute_all_subb, compute_c_subb  },
1175     [CC_OP_SUBW] = { compute_all_subw, compute_c_subw  },
1176     [CC_OP_SUBL] = { compute_all_subl, compute_c_subl  },
1177
1178     [CC_OP_SBBB] = { compute_all_sbbb, compute_c_sbbb  },
1179     [CC_OP_SBBW] = { compute_all_sbbw, compute_c_sbbw  },
1180     [CC_OP_SBBL] = { compute_all_sbbl, compute_c_sbbl  },
1181
1182     [CC_OP_LOGICB] = { compute_all_logicb, compute_c_logicb },
1183     [CC_OP_LOGICW] = { compute_all_logicw, compute_c_logicw },
1184     [CC_OP_LOGICL] = { compute_all_logicl, compute_c_logicl },
1185
1186     [CC_OP_INCB] = { compute_all_incb, compute_c_incl },
1187     [CC_OP_INCW] = { compute_all_incw, compute_c_incl },
1188     [CC_OP_INCL] = { compute_all_incl, compute_c_incl },
1189
1190     [CC_OP_DECB] = { compute_all_decb, compute_c_incl },
1191     [CC_OP_DECW] = { compute_all_decw, compute_c_incl },
1192     [CC_OP_DECL] = { compute_all_decl, compute_c_incl },
1193
1194     [CC_OP_SHLB] = { compute_all_shlb, compute_c_shll },
1195     [CC_OP_SHLW] = { compute_all_shlw, compute_c_shll },
1196     [CC_OP_SHLL] = { compute_all_shll, compute_c_shll },
1197
1198     [CC_OP_SARB] = { compute_all_sarb, compute_c_shll },
1199     [CC_OP_SARW] = { compute_all_sarw, compute_c_shll },
1200     [CC_OP_SARL] = { compute_all_sarl, compute_c_shll },
1201 };
1202
1203 /* floating point support */
1204
1205 #ifdef USE_X86LDOUBLE
1206 /* use long double functions */
1207 #define lrint lrintl
1208 #define llrint llrintl
1209 #define fabs fabsl
1210 #define sin sinl
1211 #define cos cosl
1212 #define sqrt sqrtl
1213 #define pow powl
1214 #define log logl
1215 #define tan tanl
1216 #define atan2 atan2l
1217 #define floor floorl
1218 #define ceil ceill
1219 #define rint rintl
1220 #endif
1221
1222 extern int lrint(CPU86_LDouble x);
1223 extern int64_t llrint(CPU86_LDouble x);
1224 extern CPU86_LDouble fabs(CPU86_LDouble x);
1225 extern CPU86_LDouble sin(CPU86_LDouble x);
1226 extern CPU86_LDouble cos(CPU86_LDouble x);
1227 extern CPU86_LDouble sqrt(CPU86_LDouble x);
1228 extern CPU86_LDouble pow(CPU86_LDouble, CPU86_LDouble);
1229 extern CPU86_LDouble log(CPU86_LDouble x);
1230 extern CPU86_LDouble tan(CPU86_LDouble x);
1231 extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble);
1232 extern CPU86_LDouble floor(CPU86_LDouble x);
1233 extern CPU86_LDouble ceil(CPU86_LDouble x);
1234 extern CPU86_LDouble rint(CPU86_LDouble x);
1235
1236 #define RC_MASK         0xc00
1237 #define RC_NEAR         0x000
1238 #define RC_DOWN         0x400
1239 #define RC_UP           0x800
1240 #define RC_CHOP         0xc00
1241
1242 #define MAXTAN 9223372036854775808.0
1243
1244 #ifdef USE_X86LDOUBLE
1245
1246 /* only for x86 */
1247 typedef union {
1248     long double d;
1249     struct {
1250         unsigned long long lower;
1251         unsigned short upper;
1252     } l;
1253 } CPU86_LDoubleU;
1254
1255 /* the following deal with x86 long double-precision numbers */
1256 #define MAXEXPD 0x7fff
1257 #define EXPBIAS 16383
1258 #define EXPD(fp)        (fp.l.upper & 0x7fff)
1259 #define SIGND(fp)       ((fp.l.upper) & 0x8000)
1260 #define MANTD(fp)       (fp.l.lower)
1261 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) | EXPBIAS
1262
1263 #else
1264
1265 typedef union {
1266     double d;
1267 #ifndef WORDS_BIGENDIAN
1268     struct {
1269         unsigned long lower;
1270         long upper;
1271     } l;
1272 #else
1273     struct {
1274         long upper;
1275         unsigned long lower;
1276     } l;
1277 #endif
1278     long long ll;
1279 } CPU86_LDoubleU;
1280
1281 /* the following deal with IEEE double-precision numbers */
1282 #define MAXEXPD 0x7ff
1283 #define EXPBIAS 1023
1284 #define EXPD(fp)        (((fp.l.upper) >> 20) & 0x7FF)
1285 #define SIGND(fp)       ((fp.l.upper) & 0x80000000)
1286 #define MANTD(fp)       (fp.ll & ((1LL << 52) - 1))
1287 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) | (EXPBIAS << 20)
1288 #endif
1289
1290 /* fp load FT0 */
1291
1292 void OPPROTO op_flds_FT0_A0(void)
1293 {
1294     FT0 = ldfl((void *)A0);
1295 }
1296
1297 void OPPROTO op_fldl_FT0_A0(void)
1298 {
1299     FT0 = ldfq((void *)A0);
1300 }
1301
1302 void OPPROTO op_fild_FT0_A0(void)
1303 {
1304     FT0 = (CPU86_LDouble)ldsw((void *)A0);
1305 }
1306
1307 void OPPROTO op_fildl_FT0_A0(void)
1308 {
1309     FT0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1310 }
1311
1312 void OPPROTO op_fildll_FT0_A0(void)
1313 {
1314     FT0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1315 }
1316
1317 /* fp load ST0 */
1318
1319 void OPPROTO op_flds_ST0_A0(void)
1320 {
1321     ST0 = ldfl((void *)A0);
1322 }
1323
1324 void OPPROTO op_fldl_ST0_A0(void)
1325 {
1326     ST0 = ldfq((void *)A0);
1327 }
1328
1329 #ifdef USE_X86LDOUBLE
1330 void OPPROTO op_fldt_ST0_A0(void)
1331 {
1332     ST0 = *(long double *)A0;
1333 }
1334 #else
1335 void helper_fldt_ST0_A0(void)
1336 {
1337     CPU86_LDoubleU temp;
1338     int upper, e;
1339     /* mantissa */
1340     upper = lduw((uint8_t *)A0 + 8);
1341     /* XXX: handle overflow ? */
1342     e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
1343     e |= (upper >> 4) & 0x800; /* sign */
1344     temp.ll = ((ldq((void *)A0) >> 11) & ((1LL << 52) - 1)) | ((uint64_t)e << 52);
1345     ST0 = temp.d;
1346 }
1347
1348 void OPPROTO op_fldt_ST0_A0(void)
1349 {
1350     helper_fldt_ST0_A0();
1351 }
1352 #endif
1353
1354 void OPPROTO op_fild_ST0_A0(void)
1355 {
1356     ST0 = (CPU86_LDouble)ldsw((void *)A0);
1357 }
1358
1359 void OPPROTO op_fildl_ST0_A0(void)
1360 {
1361     ST0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1362 }
1363
1364 void OPPROTO op_fildll_ST0_A0(void)
1365 {
1366     ST0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1367 }
1368
1369 /* fp store */
1370
1371 void OPPROTO op_fsts_ST0_A0(void)
1372 {
1373     stfl((void *)A0, (float)ST0);
1374 }
1375
1376 void OPPROTO op_fstl_ST0_A0(void)
1377 {
1378     stfq((void *)A0, (double)ST0);
1379 }
1380
1381 #ifdef USE_X86LDOUBLE
1382 void OPPROTO op_fstt_ST0_A0(void)
1383 {
1384     *(long double *)A0 = ST0;
1385 }
1386 #else
1387 void helper_fstt_ST0_A0(void)
1388 {
1389     CPU86_LDoubleU temp;
1390     int e;
1391     temp.d = ST0;
1392     /* mantissa */
1393     stq((void *)A0, (MANTD(temp) << 11) | (1LL << 63));
1394     /* exponent + sign */
1395     e = EXPD(temp) - EXPBIAS + 16383;
1396     e |= SIGND(temp) >> 16;
1397     stw((uint8_t *)A0 + 8, e);
1398 }
1399
1400 void OPPROTO op_fstt_ST0_A0(void)
1401 {
1402     helper_fstt_ST0_A0();
1403 }
1404 #endif
1405
1406 void OPPROTO op_fist_ST0_A0(void)
1407 {
1408     int val;
1409     val = lrint(ST0);
1410     stw((void *)A0, val);
1411 }
1412
1413 void OPPROTO op_fistl_ST0_A0(void)
1414 {
1415     int val;
1416     val = lrint(ST0);
1417     stl((void *)A0, val);
1418 }
1419
1420 void OPPROTO op_fistll_ST0_A0(void)
1421 {
1422     int64_t val;
1423     val = llrint(ST0);
1424     stq((void *)A0, val);
1425 }
1426
1427 /* BCD ops */
1428
1429 #define MUL10(iv) ( iv + iv + (iv << 3) )
1430
1431 void helper_fbld_ST0_A0(void)
1432 {
1433     uint8_t *seg;
1434     CPU86_LDouble fpsrcop;
1435     int m32i;
1436     unsigned int v;
1437
1438     /* in this code, seg/m32i will be used as temporary ptr/int */
1439     seg = (uint8_t *)A0 + 8;
1440     v = ldub(seg--);
1441     /* XXX: raise exception */
1442     if (v != 0)
1443         return;
1444     v = ldub(seg--);
1445     /* XXX: raise exception */
1446     if ((v & 0xf0) != 0)
1447         return;
1448     m32i = v;  /* <-- d14 */
1449     v = ldub(seg--);
1450     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d13 */
1451     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d12 */
1452     v = ldub(seg--);
1453     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d11 */
1454     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d10 */
1455     v = ldub(seg--);
1456     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d9 */
1457     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d8 */
1458     fpsrcop = ((CPU86_LDouble)m32i) * 100000000.0;
1459
1460     v = ldub(seg--);
1461     m32i = (v >> 4);  /* <-- d7 */
1462     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d6 */
1463     v = ldub(seg--);
1464     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d5 */
1465     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d4 */
1466     v = ldub(seg--);
1467     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d3 */
1468     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d2 */
1469     v = ldub(seg);
1470     m32i = MUL10(m32i) + (v >> 4);  /* <-- val * 10 + d1 */
1471     m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d0 */
1472     fpsrcop += ((CPU86_LDouble)m32i);
1473     if ( ldub(seg+9) & 0x80 )
1474         fpsrcop = -fpsrcop;
1475     ST0 = fpsrcop;
1476 }
1477
1478 void OPPROTO op_fbld_ST0_A0(void)
1479 {
1480     helper_fbld_ST0_A0();
1481 }
1482
1483 void helper_fbst_ST0_A0(void)
1484 {
1485     CPU86_LDouble fptemp;
1486     CPU86_LDouble fpsrcop;
1487     int v;
1488     uint8_t *mem_ref, *mem_end;
1489
1490     fpsrcop = rint(ST0);
1491     mem_ref = (uint8_t *)A0;
1492     mem_end = mem_ref + 8;
1493     if ( fpsrcop < 0.0 ) {
1494         stw(mem_end, 0x8000);
1495         fpsrcop = -fpsrcop;
1496     } else {
1497         stw(mem_end, 0x0000);
1498     }
1499     while (mem_ref < mem_end) {
1500         if (fpsrcop == 0.0)
1501             break;
1502         fptemp = floor(fpsrcop/10.0);
1503         v = ((int)(fpsrcop - fptemp*10.0));
1504         if  (fptemp == 0.0)  {
1505             stb(mem_ref++, v);
1506             break;
1507         }
1508         fpsrcop = fptemp;
1509         fptemp = floor(fpsrcop/10.0);
1510         v |= (((int)(fpsrcop - fptemp*10.0)) << 4);
1511         stb(mem_ref++, v);
1512         fpsrcop = fptemp;
1513     }
1514     while (mem_ref < mem_end) {
1515         stb(mem_ref++, 0);
1516     }
1517 }
1518
1519 void OPPROTO op_fbst_ST0_A0(void)
1520 {
1521     helper_fbst_ST0_A0();
1522 }
1523
1524 /* FPU move */
1525
1526 static inline void fpush(void)
1527 {
1528     env->fpstt = (env->fpstt - 1) & 7;
1529     env->fptags[env->fpstt] = 0; /* validate stack entry */
1530 }
1531
1532 static inline void fpop(void)
1533 {
1534     env->fptags[env->fpstt] = 1; /* invvalidate stack entry */
1535     env->fpstt = (env->fpstt + 1) & 7;
1536 }
1537
1538 void OPPROTO op_fpush(void)
1539 {
1540     fpush();
1541 }
1542
1543 void OPPROTO op_fpop(void)
1544 {
1545     fpop();
1546 }
1547
1548 void OPPROTO op_fdecstp(void)
1549 {
1550     env->fpstt = (env->fpstt - 1) & 7;
1551     env->fpus &= (~0x4700);
1552 }
1553
1554 void OPPROTO op_fincstp(void)
1555 {
1556     env->fpstt = (env->fpstt + 1) & 7;
1557     env->fpus &= (~0x4700);
1558 }
1559
1560 void OPPROTO op_fmov_ST0_FT0(void)
1561 {
1562     ST0 = FT0;
1563 }
1564
1565 void OPPROTO op_fmov_FT0_STN(void)
1566 {
1567     FT0 = ST(PARAM1);
1568 }
1569
1570 void OPPROTO op_fmov_ST0_STN(void)
1571 {
1572     ST0 = ST(PARAM1);
1573 }
1574
1575 void OPPROTO op_fmov_STN_ST0(void)
1576 {
1577     ST(PARAM1) = ST0;
1578 }
1579
1580 void OPPROTO op_fxchg_ST0_STN(void)
1581 {
1582     CPU86_LDouble tmp;
1583     tmp = ST(PARAM1);
1584     ST(PARAM1) = ST0;
1585     ST0 = tmp;
1586 }
1587
1588 /* FPU operations */
1589
1590 /* XXX: handle nans */
1591 void OPPROTO op_fcom_ST0_FT0(void)
1592 {
1593     env->fpus &= (~0x4500);     /* (C3,C2,C0) <-- 000 */
1594     if (ST0 < FT0)
1595         env->fpus |= 0x100;     /* (C3,C2,C0) <-- 001 */
1596     else if (ST0 == FT0)
1597         env->fpus |= 0x4000; /* (C3,C2,C0) <-- 100 */
1598     FORCE_RET();
1599 }
1600
1601 /* XXX: handle nans */
1602 void OPPROTO op_fucom_ST0_FT0(void)
1603 {
1604     env->fpus &= (~0x4500);     /* (C3,C2,C0) <-- 000 */
1605     if (ST0 < FT0)
1606         env->fpus |= 0x100;     /* (C3,C2,C0) <-- 001 */
1607     else if (ST0 == FT0)
1608         env->fpus |= 0x4000; /* (C3,C2,C0) <-- 100 */
1609     FORCE_RET();
1610 }
1611
1612 void OPPROTO op_fadd_ST0_FT0(void)
1613 {
1614     ST0 += FT0;
1615 }
1616
1617 void OPPROTO op_fmul_ST0_FT0(void)
1618 {
1619     ST0 *= FT0;
1620 }
1621
1622 void OPPROTO op_fsub_ST0_FT0(void)
1623 {
1624     ST0 -= FT0;
1625 }
1626
1627 void OPPROTO op_fsubr_ST0_FT0(void)
1628 {
1629     ST0 = FT0 - ST0;
1630 }
1631
1632 void OPPROTO op_fdiv_ST0_FT0(void)
1633 {
1634     ST0 /= FT0;
1635 }
1636
1637 void OPPROTO op_fdivr_ST0_FT0(void)
1638 {
1639     ST0 = FT0 / ST0;
1640 }
1641
1642 /* fp operations between STN and ST0 */
1643
1644 void OPPROTO op_fadd_STN_ST0(void)
1645 {
1646     ST(PARAM1) += ST0;
1647 }
1648
1649 void OPPROTO op_fmul_STN_ST0(void)
1650 {
1651     ST(PARAM1) *= ST0;
1652 }
1653
1654 void OPPROTO op_fsub_STN_ST0(void)
1655 {
1656     ST(PARAM1) -= ST0;
1657 }
1658
1659 void OPPROTO op_fsubr_STN_ST0(void)
1660 {
1661     CPU86_LDouble *p;
1662     p = &ST(PARAM1);
1663     *p = ST0 - *p;
1664 }
1665
1666 void OPPROTO op_fdiv_STN_ST0(void)
1667 {
1668     ST(PARAM1) /= ST0;
1669 }
1670
1671 void OPPROTO op_fdivr_STN_ST0(void)
1672 {
1673     CPU86_LDouble *p;
1674     p = &ST(PARAM1);
1675     *p = ST0 / *p;
1676 }
1677
1678 /* misc FPU operations */
1679 void OPPROTO op_fchs_ST0(void)
1680 {
1681     ST0 = -ST0;
1682 }
1683
1684 void OPPROTO op_fabs_ST0(void)
1685 {
1686     ST0 = fabs(ST0);
1687 }
1688
1689 void helper_fxam_ST0(void)
1690 {
1691     CPU86_LDoubleU temp;
1692     int expdif;
1693
1694     temp.d = ST0;
1695
1696     env->fpus &= (~0x4700);  /* (C3,C2,C1,C0) <-- 0000 */
1697     if (SIGND(temp))
1698         env->fpus |= 0x200; /* C1 <-- 1 */
1699
1700     expdif = EXPD(temp);
1701     if (expdif == MAXEXPD) {
1702         if (MANTD(temp) == 0)
1703             env->fpus |=  0x500 /*Infinity*/;
1704         else
1705             env->fpus |=  0x100 /*NaN*/;
1706     } else if (expdif == 0) {
1707         if (MANTD(temp) == 0)
1708             env->fpus |=  0x4000 /*Zero*/;
1709         else
1710             env->fpus |= 0x4400 /*Denormal*/;
1711     } else {
1712         env->fpus |= 0x400;
1713     }
1714 }
1715
1716 void OPPROTO op_fxam_ST0(void)
1717 {
1718     helper_fxam_ST0();
1719 }
1720
1721 void OPPROTO op_fld1_ST0(void)
1722 {
1723     ST0 = *(CPU86_LDouble *)&f15rk[1];
1724 }
1725
1726 void OPPROTO op_fldl2t_ST0(void)
1727 {
1728     ST0 = *(CPU86_LDouble *)&f15rk[6];
1729 }
1730
1731 void OPPROTO op_fldl2e_ST0(void)
1732 {
1733     ST0 = *(CPU86_LDouble *)&f15rk[5];
1734 }
1735
1736 void OPPROTO op_fldpi_ST0(void)
1737 {
1738     ST0 = *(CPU86_LDouble *)&f15rk[2];
1739 }
1740
1741 void OPPROTO op_fldlg2_ST0(void)
1742 {
1743     ST0 = *(CPU86_LDouble *)&f15rk[3];
1744 }
1745
1746 void OPPROTO op_fldln2_ST0(void)
1747 {
1748     ST0 = *(CPU86_LDouble *)&f15rk[4];
1749 }
1750
1751 void OPPROTO op_fldz_ST0(void)
1752 {
1753     ST0 = *(CPU86_LDouble *)&f15rk[0];
1754 }
1755
1756 void OPPROTO op_fldz_FT0(void)
1757 {
1758     ST0 = *(CPU86_LDouble *)&f15rk[0];
1759 }
1760
1761 void helper_f2xm1(void)
1762 {
1763     ST0 = pow(2.0,ST0) - 1.0;
1764 }
1765
1766 void helper_fyl2x(void)
1767 {
1768     CPU86_LDouble fptemp;
1769
1770     fptemp = ST0;
1771     if (fptemp>0.0){
1772         fptemp = log(fptemp)/log(2.0);   /* log2(ST) */
1773         ST1 *= fptemp;
1774         fpop();
1775     } else {
1776         env->fpus &= (~0x4700);
1777         env->fpus |= 0x400;
1778     }
1779 }
1780
1781 void helper_fptan(void)
1782 {
1783     CPU86_LDouble fptemp;
1784
1785     fptemp = ST0;
1786     if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
1787         env->fpus |= 0x400;
1788     } else {
1789         ST0 = tan(fptemp);
1790         fpush();
1791         ST0 = 1.0;
1792         env->fpus &= (~0x400);  /* C2 <-- 0 */
1793         /* the above code is for  |arg| < 2**52 only */
1794     }
1795 }
1796
1797 void helper_fpatan(void)
1798 {
1799     CPU86_LDouble fptemp, fpsrcop;
1800
1801     fpsrcop = ST1;
1802     fptemp = ST0;
1803     ST1 = atan2(fpsrcop,fptemp);
1804     fpop();
1805 }
1806
1807 void helper_fxtract(void)
1808 {
1809     CPU86_LDoubleU temp;
1810     unsigned int expdif;
1811
1812     temp.d = ST0;
1813     expdif = EXPD(temp) - EXPBIAS;
1814     /*DP exponent bias*/
1815     ST0 = expdif;
1816     fpush();
1817     BIASEXPONENT(temp);
1818     ST0 = temp.d;
1819 }
1820
1821 void helper_fprem1(void)
1822 {
1823     CPU86_LDouble dblq, fpsrcop, fptemp;
1824     CPU86_LDoubleU fpsrcop1, fptemp1;
1825     int expdif;
1826     int q;
1827
1828     fpsrcop = ST0;
1829     fptemp = ST1;
1830     fpsrcop1.d = fpsrcop;
1831     fptemp1.d = fptemp;
1832     expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
1833     if (expdif < 53) {
1834         dblq = fpsrcop / fptemp;
1835         dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
1836         ST0 = fpsrcop - fptemp*dblq;
1837         q = (int)dblq; /* cutting off top bits is assumed here */
1838         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
1839                                 /* (C0,C1,C3) <-- (q2,q1,q0) */
1840         env->fpus |= (q&0x4) << 6; /* (C0) <-- q2 */
1841         env->fpus |= (q&0x2) << 8; /* (C1) <-- q1 */
1842         env->fpus |= (q&0x1) << 14; /* (C3) <-- q0 */
1843     } else {
1844         env->fpus |= 0x400;  /* C2 <-- 1 */
1845         fptemp = pow(2.0, expdif-50);
1846         fpsrcop = (ST0 / ST1) / fptemp;
1847         /* fpsrcop = integer obtained by rounding to the nearest */
1848         fpsrcop = (fpsrcop-floor(fpsrcop) < ceil(fpsrcop)-fpsrcop)?
1849             floor(fpsrcop): ceil(fpsrcop);
1850         ST0 -= (ST1 * fpsrcop * fptemp);
1851     }
1852 }
1853
1854 void helper_fprem(void)
1855 {
1856     CPU86_LDouble dblq, fpsrcop, fptemp;
1857     CPU86_LDoubleU fpsrcop1, fptemp1;
1858     int expdif;
1859     int q;
1860
1861     fpsrcop = ST0;
1862     fptemp = ST1;
1863     fpsrcop1.d = fpsrcop;
1864     fptemp1.d = fptemp;
1865     expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
1866     if ( expdif < 53 ) {
1867         dblq = fpsrcop / fptemp;
1868         dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
1869         ST0 = fpsrcop - fptemp*dblq;
1870         q = (int)dblq; /* cutting off top bits is assumed here */
1871         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
1872                                 /* (C0,C1,C3) <-- (q2,q1,q0) */
1873         env->fpus |= (q&0x4) << 6; /* (C0) <-- q2 */
1874         env->fpus |= (q&0x2) << 8; /* (C1) <-- q1 */
1875         env->fpus |= (q&0x1) << 14; /* (C3) <-- q0 */
1876     } else {
1877         env->fpus |= 0x400;  /* C2 <-- 1 */
1878         fptemp = pow(2.0, expdif-50);
1879         fpsrcop = (ST0 / ST1) / fptemp;
1880         /* fpsrcop = integer obtained by chopping */
1881         fpsrcop = (fpsrcop < 0.0)?
1882             -(floor(fabs(fpsrcop))): floor(fpsrcop);
1883         ST0 -= (ST1 * fpsrcop * fptemp);
1884     }
1885 }
1886
1887 void helper_fyl2xp1(void)
1888 {
1889     CPU86_LDouble fptemp;
1890
1891     fptemp = ST0;
1892     if ((fptemp+1.0)>0.0) {
1893         fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
1894         ST1 *= fptemp;
1895         fpop();
1896     } else {
1897         env->fpus &= (~0x4700);
1898         env->fpus |= 0x400;
1899     }
1900 }
1901
1902 void helper_fsqrt(void)
1903 {
1904     CPU86_LDouble fptemp;
1905
1906     fptemp = ST0;
1907     if (fptemp<0.0) {
1908         env->fpus &= (~0x4700);  /* (C3,C2,C1,C0) <-- 0000 */
1909         env->fpus |= 0x400;
1910     }
1911     ST0 = sqrt(fptemp);
1912 }
1913
1914 void helper_fsincos(void)
1915 {
1916     CPU86_LDouble fptemp;
1917
1918     fptemp = ST0;
1919     if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
1920         env->fpus |= 0x400;
1921     } else {
1922         ST0 = sin(fptemp);
1923         fpush();
1924         ST0 = cos(fptemp);
1925         env->fpus &= (~0x400);  /* C2 <-- 0 */
1926         /* the above code is for  |arg| < 2**63 only */
1927     }
1928 }
1929
1930 void helper_frndint(void)
1931 {
1932     ST0 = rint(ST0);
1933 }
1934
1935 void helper_fscale(void)
1936 {
1937     CPU86_LDouble fpsrcop, fptemp;
1938
1939     fpsrcop = 2.0;
1940     fptemp = pow(fpsrcop,ST1);
1941     ST0 *= fptemp;
1942 }
1943
1944 void helper_fsin(void)
1945 {
1946     CPU86_LDouble fptemp;
1947
1948     fptemp = ST0;
1949     if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
1950         env->fpus |= 0x400;
1951     } else {
1952         ST0 = sin(fptemp);
1953         env->fpus &= (~0x400);  /* C2 <-- 0 */
1954         /* the above code is for  |arg| < 2**53 only */
1955     }
1956 }
1957
1958 void helper_fcos(void)
1959 {
1960     CPU86_LDouble fptemp;
1961
1962     fptemp = ST0;
1963     if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
1964         env->fpus |= 0x400;
1965     } else {
1966         ST0 = cos(fptemp);
1967         env->fpus &= (~0x400);  /* C2 <-- 0 */
1968         /* the above code is for  |arg5 < 2**63 only */
1969     }
1970 }
1971
1972 /* associated heplers to reduce generated code length and to simplify
1973    relocation (FP constants are usually stored in .rodata section) */
1974
1975 void OPPROTO op_f2xm1(void)
1976 {
1977     helper_f2xm1();
1978 }
1979
1980 void OPPROTO op_fyl2x(void)
1981 {
1982     helper_fyl2x();
1983 }
1984
1985 void OPPROTO op_fptan(void)
1986 {
1987     helper_fptan();
1988 }
1989
1990 void OPPROTO op_fpatan(void)
1991 {
1992     helper_fpatan();
1993 }
1994
1995 void OPPROTO op_fxtract(void)
1996 {
1997     helper_fxtract();
1998 }
1999
2000 void OPPROTO op_fprem1(void)
2001 {
2002     helper_fprem1();
2003 }
2004
2005
2006 void OPPROTO op_fprem(void)
2007 {
2008     helper_fprem();
2009 }
2010
2011 void OPPROTO op_fyl2xp1(void)
2012 {
2013     helper_fyl2xp1();
2014 }
2015
2016 void OPPROTO op_fsqrt(void)
2017 {
2018     helper_fsqrt();
2019 }
2020
2021 void OPPROTO op_fsincos(void)
2022 {
2023     helper_fsincos();
2024 }
2025
2026 void OPPROTO op_frndint(void)
2027 {
2028     helper_frndint();
2029 }
2030
2031 void OPPROTO op_fscale(void)
2032 {
2033     helper_fscale();
2034 }
2035
2036 void OPPROTO op_fsin(void)
2037 {
2038     helper_fsin();
2039 }
2040
2041 void OPPROTO op_fcos(void)
2042 {
2043     helper_fcos();
2044 }
2045
2046 void OPPROTO op_fnstsw_A0(void)
2047 {
2048     int fpus;
2049     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2050     stw((void *)A0, fpus);
2051 }
2052
2053 void OPPROTO op_fnstsw_EAX(void)
2054 {
2055     int fpus;
2056     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2057     EAX = (EAX & 0xffff0000) | fpus;
2058 }
2059
2060 void OPPROTO op_fnstcw_A0(void)
2061 {
2062     stw((void *)A0, env->fpuc);
2063 }
2064
2065 void OPPROTO op_fldcw_A0(void)
2066 {
2067     int rnd_type;
2068     env->fpuc = lduw((void *)A0);
2069     /* set rounding mode */
2070     switch(env->fpuc & RC_MASK) {
2071     default:
2072     case RC_NEAR:
2073         rnd_type = FE_TONEAREST;
2074         break;
2075     case RC_DOWN:
2076         rnd_type = FE_DOWNWARD;
2077         break;
2078     case RC_UP:
2079         rnd_type = FE_UPWARD;
2080         break;
2081     case RC_CHOP:
2082         rnd_type = FE_TOWARDZERO;
2083         break;
2084     }
2085     fesetround(rnd_type);
2086 }
2087