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