drivers/bios_emulator/x86emu/prim_ops.c

   1 /****************************************************************************
   2 *
   3 *                       Realmode X86 Emulator Library
   4 *
   5 *               Copyright (C) 1991-2004 SciTech Software, Inc.
   6 *                    Copyright (C) David Mosberger-Tang
   7 *                      Copyright (C) 1999 Egbert Eich
   8 *
   9 *  ========================================================================
  10 *
  11 *  Permission to use, copy, modify, distribute, and sell this software and
  12 *  its documentation for any purpose is hereby granted without fee,
  13 *  provided that the above copyright notice appear in all copies and that
  14 *  both that copyright notice and this permission notice appear in
  15 *  supporting documentation, and that the name of the authors not be used
  16 *  in advertising or publicity pertaining to distribution of the software
  17 *  without specific, written prior permission.  The authors makes no
  18 *  representations about the suitability of this software for any purpose.
  19 *  It is provided "as is" without express or implied warranty.
  20 *
  21 *  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  22 *  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  23 *  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  24 *  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  25 *  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  26 *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  27 *  PERFORMANCE OF THIS SOFTWARE.
  28 *
  29 *  ========================================================================
  30 *
  31 * Language:     ANSI C
  32 * Environment:  Any
  33 * Developer:    Kendall Bennett
  34 *
  35 * Description:  This file contains the code to implement the primitive
  36 *               machine operations used by the emulation code in ops.c
  37 *
  38 * Carry Chain Calculation
  39 *
  40 * This represents a somewhat expensive calculation which is
  41 * apparently required to emulate the setting of the OF343364 and AF flag.
  42 * The latter is not so important, but the former is.  The overflow
  43 * flag is the XOR of the top two bits of the carry chain for an
  44 * addition (similar for subtraction).  Since we do not want to
  45 * simulate the addition in a bitwise manner, we try to calculate the
  46 * carry chain given the two operands and the result.
  47 *
  48 * So, given the following table, which represents the addition of two
  49 * bits, we can derive a formula for the carry chain.
  50 *
  51 * a   b   cin   r     cout
  52 * 0   0   0     0     0
  53 * 0   0   1     1     0
  54 * 0   1   0     1     0
  55 * 0   1   1     0     1
  56 * 1   0   0     1     0
  57 * 1   0   1     0     1
  58 * 1   1   0     0     1
  59 * 1   1   1     1     1
  60 *
  61 * Construction of table for cout:
  62 *
  63 * ab
  64 * r  \  00   01   11  10
  65 * |------------------
  66 * 0  |   0    1    1   1
  67 * 1  |   0    0    1   0
  68 *
  69 * By inspection, one gets:  cc = ab +  r'(a + b)
  70 *
  71 * That represents alot of operations, but NO CHOICE....
  72 *
  73 * Borrow Chain Calculation.
  74 *
  75 * The following table represents the subtraction of two bits, from
  76 * which we can derive a formula for the borrow chain.
  77 *
  78 * a   b   bin   r     bout
  79 * 0   0   0     0     0
  80 * 0   0   1     1     1
  81 * 0   1   0     1     1
  82 * 0   1   1     0     1
  83 * 1   0   0     1     0
  84 * 1   0   1     0     0
  85 * 1   1   0     0     0
  86 * 1   1   1     1     1
  87 *
  88 * Construction of table for cout:
  89 *
  90 * ab
  91 * r  \  00   01   11  10
  92 * |------------------
  93 * 0  |   0    1    0   0
  94 * 1  |   1    1    1   0
  95 *
  96 * By inspection, one gets:  bc = a'b +  r(a' + b)
  97 *
  98 ****************************************************************************/
  99
 100 #include <common.h>
 101
 102 #define PRIM_OPS_NO_REDEFINE_ASM
 103 #include "x86emu/x86emui.h"
 104
 105 /*------------------------- Global Variables ------------------------------*/
 106
 107 static u32 x86emu_parity_tab[8] =
 108 {
 109     0x96696996,
 110     0x69969669,
 111     0x69969669,
 112     0x96696996,
 113     0x69969669,
 114     0x96696996,
 115     0x96696996,
 116     0x69969669,
 117 };
 118
 119 #define PARITY(x)   (((x86emu_parity_tab[(x) / 32] >> ((x) % 32)) & 1) == 0)
 120 #define XOR2(x)     (((x) ^ ((x)>>1)) & 0x1)
 121
 122 /*----------------------------- Implementation ----------------------------*/
 123
 124
 125 /*--------- Side effects helper functions -------*/
 126
 127 /****************************************************************************
 128 REMARKS:
 129 implements side efects for byte operations that don't overflow
 130 ****************************************************************************/
 131
 132 static void set_parity_flag(u32 res)
 133 {
 134     CONDITIONAL_SET_FLAG(PARITY(res & 0xFF), F_PF);
 135 }
 136
 137 static void set_szp_flags_8(u8 res)
 138 {
 139     CONDITIONAL_SET_FLAG(res & 0x80, F_SF);
 140     CONDITIONAL_SET_FLAG(res == 0, F_ZF);
 141     set_parity_flag(res);
 142 }
 143
 144 static void set_szp_flags_16(u16 res)
 145 {
 146     CONDITIONAL_SET_FLAG(res & 0x8000, F_SF);
 147     CONDITIONAL_SET_FLAG(res == 0, F_ZF);
 148     set_parity_flag(res);
 149 }
 150
 151 static void set_szp_flags_32(u32 res)
 152 {
 153     CONDITIONAL_SET_FLAG(res & 0x80000000, F_SF);
 154     CONDITIONAL_SET_FLAG(res == 0, F_ZF);
 155     set_parity_flag(res);
 156 }
 157
 158 static void no_carry_byte_side_eff(u8 res)
 159 {
 160     CLEAR_FLAG(F_OF);
 161     CLEAR_FLAG(F_CF);
 162     CLEAR_FLAG(F_AF);
 163     set_szp_flags_8(res);
 164 }
 165
 166 static void no_carry_word_side_eff(u16 res)
 167 {
 168     CLEAR_FLAG(F_OF);
 169     CLEAR_FLAG(F_CF);
 170     CLEAR_FLAG(F_AF);
 171     set_szp_flags_16(res);
 172 }
 173
 174 static void no_carry_long_side_eff(u32 res)
 175 {
 176     CLEAR_FLAG(F_OF);
 177     CLEAR_FLAG(F_CF);
 178     CLEAR_FLAG(F_AF);
 179     set_szp_flags_32(res);
 180 }
 181
 182 static void calc_carry_chain(int bits, u32 d, u32 s, u32 res, int set_carry)
 183 {
 184     u32 cc;
 185
 186     cc = (s & d) | ((~res) & (s | d));
 187     CONDITIONAL_SET_FLAG(XOR2(cc >> (bits - 2)), F_OF);
 188     CONDITIONAL_SET_FLAG(cc & 0x8, F_AF);
 189     if (set_carry) {
 190         CONDITIONAL_SET_FLAG(res & (1 << bits), F_CF);
 191     }
 192 }
 193
 194 static void calc_borrow_chain(int bits, u32 d, u32 s, u32 res, int set_carry)
 195 {
 196     u32 bc;
 197
 198     bc = (res & (~d | s)) | (~d & s);
 199     CONDITIONAL_SET_FLAG(XOR2(bc >> (bits - 2)), F_OF);
 200     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
 201     if (set_carry) {
 202         CONDITIONAL_SET_FLAG(bc & (1 << (bits - 1)), F_CF);
 203     }
 204 }
 205
 206 /****************************************************************************
 207 REMARKS:
 208 Implements the AAA instruction and side effects.
 209 ****************************************************************************/
 210 u16 aaa_word(u16 d)
 211 {
 212     u16 res;
 213     if ((d & 0xf) > 0x9 || ACCESS_FLAG(F_AF)) {
 214         d += 0x6;
 215         d += 0x100;
 216         SET_FLAG(F_AF);
 217         SET_FLAG(F_CF);
 218     } else {
 219         CLEAR_FLAG(F_CF);
 220         CLEAR_FLAG(F_AF);
 221     }
 222     res = (u16)(d & 0xFF0F);
 223     set_szp_flags_16(res);
 224     return res;
 225 }
 226
 227 /****************************************************************************
 228 REMARKS:
 229 Implements the AAA instruction and side effects.
 230 ****************************************************************************/
 231 u16 aas_word(u16 d)
 232 {
 233     u16 res;
 234     if ((d & 0xf) > 0x9 || ACCESS_FLAG(F_AF)) {
 235         d -= 0x6;
 236         d -= 0x100;
 237         SET_FLAG(F_AF);
 238         SET_FLAG(F_CF);
 239     } else {
 240         CLEAR_FLAG(F_CF);
 241         CLEAR_FLAG(F_AF);
 242     }
 243     res = (u16)(d & 0xFF0F);
 244     set_szp_flags_16(res);
 245     return res;
 246 }
 247
 248 /****************************************************************************
 249 REMARKS:
 250 Implements the AAD instruction and side effects.
 251 ****************************************************************************/
 252 u16 aad_word(u16 d)
 253 {
 254     u16 l;
 255     u8 hb, lb;
 256
 257     hb = (u8)((d >> 8) & 0xff);
 258     lb = (u8)((d & 0xff));
 259     l = (u16)((lb + 10 * hb) & 0xFF);
 260
 261     no_carry_byte_side_eff(l & 0xFF);
 262     return l;
 263 }
 264
 265 /****************************************************************************
 266 REMARKS:
 267 Implements the AAM instruction and side effects.
 268 ****************************************************************************/
 269 u16 aam_word(u8 d)
 270 {
 271     u16 h, l;
 272
 273     h = (u16)(d / 10);
 274     l = (u16)(d % 10);
 275     l |= (u16)(h << 8);
 276
 277     no_carry_byte_side_eff(l & 0xFF);
 278     return l;
 279 }
 280
 281 /****************************************************************************
 282 REMARKS:
 283 Implements the ADC instruction and side effects.
 284 ****************************************************************************/
 285 u8 adc_byte(u8 d, u8 s)
 286 {
 287     u32 res;   /* all operands in native machine order */
 288
 289     res = d + s;
 290     if (ACCESS_FLAG(F_CF)) res++;
 291
 292     set_szp_flags_8(res);
 293     calc_carry_chain(8,s,d,res,1);
 294
 295     return (u8)res;
 296 }
 297
 298 /****************************************************************************
 299 REMARKS:
 300 Implements the ADC instruction and side effects.
 301 ****************************************************************************/
 302 u16 adc_word(u16 d, u16 s)
 303 {
 304     u32 res;   /* all operands in native machine order */
 305
 306     res = d + s;
 307     if (ACCESS_FLAG(F_CF))
 308         res++;
 309
 310     set_szp_flags_16((u16)res);
 311     calc_carry_chain(16,s,d,res,1);
 312
 313     return (u16)res;
 314 }
 315
 316 /****************************************************************************
 317 REMARKS:
 318 Implements the ADC instruction and side effects.
 319 ****************************************************************************/
 320 u32 adc_long(u32 d, u32 s)
 321 {
 322     u32 lo;    /* all operands in native machine order */
 323     u32 hi;
 324     u32 res;
 325
 326     lo = (d & 0xFFFF) + (s & 0xFFFF);
 327     res = d + s;
 328
 329     if (ACCESS_FLAG(F_CF)) {
 330         lo++;
 331         res++;
 332     }
 333
 334     hi = (lo >> 16) + (d >> 16) + (s >> 16);
 335
 336     set_szp_flags_32(res);
 337     calc_carry_chain(32,s,d,res,0);
 338
 339     CONDITIONAL_SET_FLAG(hi & 0x10000, F_CF);
 340
 341     return res;
 342 }
 343
 344 /****************************************************************************
 345 REMARKS:
 346 Implements the ADD instruction and side effects.
 347 ****************************************************************************/
 348 u8 add_byte(u8 d, u8 s)
 349 {
 350     u32 res;   /* all operands in native machine order */
 351
 352     res = d + s;
 353     set_szp_flags_8((u8)res);
 354     calc_carry_chain(8,s,d,res,1);
 355
 356     return (u8)res;
 357 }
 358
 359 /****************************************************************************
 360 REMARKS:
 361 Implements the ADD instruction and side effects.
 362 ****************************************************************************/
 363 u16 add_word(u16 d, u16 s)
 364 {
 365     u32 res;   /* all operands in native machine order */
 366
 367     res = d + s;
 368     set_szp_flags_16((u16)res);
 369     calc_carry_chain(16,s,d,res,1);
 370
 371     return (u16)res;
 372 }
 373
 374 /****************************************************************************
 375 REMARKS:
 376 Implements the ADD instruction and side effects.
 377 ****************************************************************************/
 378 u32 add_long(u32 d, u32 s)
 379 {
 380     u32 res;
 381
 382     res = d + s;
 383     set_szp_flags_32(res);
 384     calc_carry_chain(32,s,d,res,0);
 385
 386     CONDITIONAL_SET_FLAG(res < d || res < s, F_CF);
 387
 388     return res;
 389 }
 390
 391 /****************************************************************************
 392 REMARKS:
 393 Implements the AND instruction and side effects.
 394 ****************************************************************************/
 395 u8 and_byte(u8 d, u8 s)
 396 {
 397     u8 res;    /* all operands in native machine order */
 398
 399     res = d & s;
 400
 401     no_carry_byte_side_eff(res);
 402     return res;
 403 }
 404
 405 /****************************************************************************
 406 REMARKS:
 407 Implements the AND instruction and side effects.
 408 ****************************************************************************/
 409 u16 and_word(u16 d, u16 s)
 410 {
 411     u16 res;   /* all operands in native machine order */
 412
 413     res = d & s;
 414
 415     no_carry_word_side_eff(res);
 416     return res;
 417 }
 418
 419 /****************************************************************************
 420 REMARKS:
 421 Implements the AND instruction and side effects.
 422 ****************************************************************************/
 423 u32 and_long(u32 d, u32 s)
 424 {
 425     u32 res;   /* all operands in native machine order */
 426
 427     res = d & s;
 428     no_carry_long_side_eff(res);
 429     return res;
 430 }
 431
 432 /****************************************************************************
 433 REMARKS:
 434 Implements the CMP instruction and side effects.
 435 ****************************************************************************/
 436 u8 cmp_byte(u8 d, u8 s)
 437 {
 438     u32 res;   /* all operands in native machine order */
 439
 440     res = d - s;
 441     set_szp_flags_8((u8)res);
 442     calc_borrow_chain(8, d, s, res, 1);
 443
 444     return d;
 445 }
 446
 447 /****************************************************************************
 448 REMARKS:
 449 Implements the CMP instruction and side effects.
 450 ****************************************************************************/
 451 u16 cmp_word(u16 d, u16 s)
 452 {
 453     u32 res;   /* all operands in native machine order */
 454
 455     res = d - s;
 456     set_szp_flags_16((u16)res);
 457     calc_borrow_chain(16, d, s, res, 1);
 458
 459     return d;
 460 }
 461
 462 /****************************************************************************
 463 REMARKS:
 464 Implements the CMP instruction and side effects.
 465 ****************************************************************************/
 466 u32 cmp_long(u32 d, u32 s)
 467 {
 468     u32 res;   /* all operands in native machine order */
 469
 470     res = d - s;
 471     set_szp_flags_32(res);
 472     calc_borrow_chain(32, d, s, res, 1);
 473
 474     return d;
 475 }
 476
 477 /****************************************************************************
 478 REMARKS:
 479 Implements the DAA instruction and side effects.
 480 ****************************************************************************/
 481 u8 daa_byte(u8 d)
 482 {
 483     u32 res = d;
 484     if ((d & 0xf) > 9 || ACCESS_FLAG(F_AF)) {
 485         res += 6;
 486         SET_FLAG(F_AF);
 487     }
 488     if (res > 0x9F || ACCESS_FLAG(F_CF)) {
 489         res += 0x60;
 490         SET_FLAG(F_CF);
 491     }
 492     set_szp_flags_8((u8)res);
 493     return (u8)res;
 494 }
 495
 496 /****************************************************************************
 497 REMARKS:
 498 Implements the DAS instruction and side effects.
 499 ****************************************************************************/
 500 u8 das_byte(u8 d)
 501 {
 502     if ((d & 0xf) > 9 || ACCESS_FLAG(F_AF)) {
 503         d -= 6;
 504         SET_FLAG(F_AF);
 505     }
 506     if (d > 0x9F || ACCESS_FLAG(F_CF)) {
 507         d -= 0x60;
 508         SET_FLAG(F_CF);
 509     }
 510     set_szp_flags_8(d);
 511     return d;
 512 }
 513
 514 /****************************************************************************
 515 REMARKS:
 516 Implements the DEC instruction and side effects.
 517 ****************************************************************************/
 518 u8 dec_byte(u8 d)
 519 {
 520     u32 res;   /* all operands in native machine order */
 521
 522     res = d - 1;
 523     set_szp_flags_8((u8)res);
 524     calc_borrow_chain(8, d, 1, res, 0);
 525
 526     return (u8)res;
 527 }
 528
 529 /****************************************************************************
 530 REMARKS:
 531 Implements the DEC instruction and side effects.
 532 ****************************************************************************/
 533 u16 dec_word(u16 d)
 534 {
 535     u32 res;   /* all operands in native machine order */
 536
 537     res = d - 1;
 538     set_szp_flags_16((u16)res);
 539     calc_borrow_chain(16, d, 1, res, 0);
 540
 541     return (u16)res;
 542 }
 543
 544 /****************************************************************************
 545 REMARKS:
 546 Implements the DEC instruction and side effects.
 547 ****************************************************************************/
 548 u32 dec_long(u32 d)
 549 {
 550     u32 res;   /* all operands in native machine order */
 551
 552     res = d - 1;
 553
 554     set_szp_flags_32(res);
 555     calc_borrow_chain(32, d, 1, res, 0);
 556
 557     return res;
 558 }
 559
 560 /****************************************************************************
 561 REMARKS:
 562 Implements the INC instruction and side effects.
 563 ****************************************************************************/
 564 u8 inc_byte(u8 d)
 565 {
 566     u32 res;   /* all operands in native machine order */
 567
 568     res = d + 1;
 569     set_szp_flags_8((u8)res);
 570     calc_carry_chain(8, d, 1, res, 0);
 571
 572     return (u8)res;
 573 }
 574
 575 /****************************************************************************
 576 REMARKS:
 577 Implements the INC instruction and side effects.
 578 ****************************************************************************/
 579 u16 inc_word(u16 d)
 580 {
 581     u32 res;   /* all operands in native machine order */
 582
 583     res = d + 1;
 584     set_szp_flags_16((u16)res);
 585     calc_carry_chain(16, d, 1, res, 0);
 586
 587     return (u16)res;
 588 }
 589
 590 /****************************************************************************
 591 REMARKS:
 592 Implements the INC instruction and side effects.
 593 ****************************************************************************/
 594 u32 inc_long(u32 d)
 595 {
 596     u32 res;   /* all operands in native machine order */
 597
 598     res = d + 1;
 599     set_szp_flags_32(res);
 600     calc_carry_chain(32, d, 1, res, 0);
 601
 602     return res;
 603 }
 604
 605 /****************************************************************************
 606 REMARKS:
 607 Implements the OR instruction and side effects.
 608 ****************************************************************************/
 609 u8 or_byte(u8 d, u8 s)
 610 {
 611     u8 res;    /* all operands in native machine order */
 612
 613     res = d | s;
 614     no_carry_byte_side_eff(res);
 615
 616     return res;
 617 }
 618
 619 /****************************************************************************
 620 REMARKS:
 621 Implements the OR instruction and side effects.
 622 ****************************************************************************/
 623 u16 or_word(u16 d, u16 s)
 624 {
 625     u16 res;   /* all operands in native machine order */
 626
 627     res = d | s;
 628     no_carry_word_side_eff(res);
 629     return res;
 630 }
 631
 632 /****************************************************************************
 633 REMARKS:
 634 Implements the OR instruction and side effects.
 635 ****************************************************************************/
 636 u32 or_long(u32 d, u32 s)
 637 {
 638     u32 res;   /* all operands in native machine order */
 639
 640     res = d | s;
 641     no_carry_long_side_eff(res);
 642     return res;
 643 }
 644
 645 /****************************************************************************
 646 REMARKS:
 647 Implements the OR instruction and side effects.
 648 ****************************************************************************/
 649 u8 neg_byte(u8 s)
 650 {
 651     u8 res;
 652
 653     CONDITIONAL_SET_FLAG(s != 0, F_CF);
 654     res = (u8)-s;
 655     set_szp_flags_8(res);
 656     calc_borrow_chain(8, 0, s, res, 0);
 657
 658     return res;
 659 }
 660
 661 /****************************************************************************
 662 REMARKS:
 663 Implements the OR instruction and side effects.
 664 ****************************************************************************/
 665 u16 neg_word(u16 s)
 666 {
 667     u16 res;
 668
 669     CONDITIONAL_SET_FLAG(s != 0, F_CF);
 670     res = (u16)-s;
 671     set_szp_flags_16((u16)res);
 672     calc_borrow_chain(16, 0, s, res, 0);
 673
 674     return res;
 675 }
 676
 677 /****************************************************************************
 678 REMARKS:
 679 Implements the OR instruction and side effects.
 680 ****************************************************************************/
 681 u32 neg_long(u32 s)
 682 {
 683     u32 res;
 684
 685     CONDITIONAL_SET_FLAG(s != 0, F_CF);
 686     res = (u32)-s;
 687     set_szp_flags_32(res);
 688     calc_borrow_chain(32, 0, s, res, 0);
 689
 690     return res;
 691 }
 692
 693 /****************************************************************************
 694 REMARKS:
 695 Implements the NOT instruction and side effects.
 696 ****************************************************************************/
 697 u8 not_byte(u8 s)
 698 {
 699     return ~s;
 700 }
 701
 702 /****************************************************************************
 703 REMARKS:
 704 Implements the NOT instruction and side effects.
 705 ****************************************************************************/
 706 u16 not_word(u16 s)
 707 {
 708     return ~s;
 709 }
 710
 711 /****************************************************************************
 712 REMARKS:
 713 Implements the NOT instruction and side effects.
 714 ****************************************************************************/
 715 u32 not_long(u32 s)
 716 {
 717     return ~s;
 718 }
 719
 720 /****************************************************************************
 721 REMARKS:
 722 Implements the RCL instruction and side effects.
 723 ****************************************************************************/
 724 u8 rcl_byte(u8 d, u8 s)
 725 {
 726     unsigned int res, cnt, mask, cf;
 727
 728     /* s is the rotate distance.  It varies from 0 - 8. */
 729     /* have
 730
 731        CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0
 732
 733        want to rotate through the carry by "s" bits.  We could
 734        loop, but that's inefficient.  So the width is 9,
 735        and we split into three parts:
 736
 737        The new carry flag   (was B_n)
 738        the stuff in B_n-1 .. B_0
 739        the stuff in B_7 .. B_n+1
 740
 741        The new rotate is done mod 9, and given this,
 742        for a rotation of n bits (mod 9) the new carry flag is
 743        then located n bits from the MSB.  The low part is
 744        then shifted up cnt bits, and the high part is or'd
 745        in.  Using CAPS for new values, and lowercase for the
 746        original values, this can be expressed as:
 747
 748        IF n > 0
 749        1) CF <-  b_(8-n)
 750        2) B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0
 751        3) B_(n-1) <- cf
 752        4) B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1))
 753      */
 754     res = d;
 755     if ((cnt = s % 9) != 0) {
 756         /* extract the new CARRY FLAG. */
 757         /* CF <-  b_(8-n)             */
 758         cf = (d >> (8 - cnt)) & 0x1;
 759
 760         /* get the low stuff which rotated
 761            into the range B_7 .. B_cnt */
 762         /* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0  */
 763         /* note that the right hand side done by the mask */
 764         res = (d << cnt) & 0xff;
 765
 766         /* now the high stuff which rotated around
 767            into the positions B_cnt-2 .. B_0 */
 768         /* B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1)) */
 769         /* shift it downward, 7-(n-2) = 9-n positions.
 770            and mask off the result before or'ing in.
 771          */
 772         mask = (1 << (cnt - 1)) - 1;
 773         res |= (d >> (9 - cnt)) & mask;
 774
 775         /* if the carry flag was set, or it in.  */
 776         if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
 777             /*  B_(n-1) <- cf */
 778             res |= 1 << (cnt - 1);
 779         }
 780         /* set the new carry flag, based on the variable "cf" */
 781         CONDITIONAL_SET_FLAG(cf, F_CF);
 782         /* OVERFLOW is set *IFF* cnt==1, then it is the
 783            xor of CF and the most significant bit.  Blecck. */
 784         /* parenthesized this expression since it appears to
 785            be causing OF to be misset */
 786         CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 6) & 0x2)),
 787                              F_OF);
 788
 789     }
 790     return (u8)res;
 791 }
 792
 793 /****************************************************************************
 794 REMARKS:
 795 Implements the RCL instruction and side effects.
 796 ****************************************************************************/
 797 u16 rcl_word(u16 d, u8 s)
 798 {
 799     unsigned int res, cnt, mask, cf;
 800
 801     res = d;
 802     if ((cnt = s % 17) != 0) {
 803         cf = (d >> (16 - cnt)) & 0x1;
 804         res = (d << cnt) & 0xffff;
 805         mask = (1 << (cnt - 1)) - 1;
 806         res |= (d >> (17 - cnt)) & mask;
 807         if (ACCESS_FLAG(F_CF)) {
 808             res |= 1 << (cnt - 1);
 809         }
 810         CONDITIONAL_SET_FLAG(cf, F_CF);
 811         CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 14) & 0x2)),
 812                              F_OF);
 813     }
 814     return (u16)res;
 815 }
 816
 817 /****************************************************************************
 818 REMARKS:
 819 Implements the RCL instruction and side effects.
 820 ****************************************************************************/
 821 u32 rcl_long(u32 d, u8 s)
 822 {
 823     u32 res, cnt, mask, cf;
 824
 825     res = d;
 826     if ((cnt = s % 33) != 0) {
 827         cf = (d >> (32 - cnt)) & 0x1;
 828         res = (d << cnt) & 0xffffffff;
 829         mask = (1 << (cnt - 1)) - 1;
 830         res |= (d >> (33 - cnt)) & mask;
 831         if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
 832             res |= 1 << (cnt - 1);
 833         }
 834         CONDITIONAL_SET_FLAG(cf, F_CF);
 835         CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 30) & 0x2)),
 836                              F_OF);
 837     }
 838     return res;
 839 }
 840
 841 /****************************************************************************
 842 REMARKS:
 843 Implements the RCR instruction and side effects.
 844 ****************************************************************************/
 845 u8 rcr_byte(u8 d, u8 s)
 846 {
 847     u32 res, cnt;
 848     u32 mask, cf, ocf = 0;
 849
 850     /* rotate right through carry */
 851     /*
 852        s is the rotate distance.  It varies from 0 - 8.
 853        d is the byte object rotated.
 854
 855        have
 856
 857        CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0
 858
 859        The new rotate is done mod 9, and given this,
 860        for a rotation of n bits (mod 9) the new carry flag is
 861        then located n bits from the LSB.  The low part is
 862        then shifted up cnt bits, and the high part is or'd
 863        in.  Using CAPS for new values, and lowercase for the
 864        original values, this can be expressed as:
 865
 866        IF n > 0
 867        1) CF <-  b_(n-1)
 868        2) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
 869        3) B_(8-n) <- cf
 870        4) B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0)
 871      */
 872     res = d;
 873     if ((cnt = s % 9) != 0) {
 874         /* extract the new CARRY FLAG. */
 875         /* CF <-  b_(n-1)              */
 876         if (cnt == 1) {
 877             cf = d & 0x1;
 878             /* note hackery here.  Access_flag(..) evaluates to either
 879                0 if flag not set
 880                non-zero if flag is set.
 881                doing access_flag(..) != 0 casts that into either
 882                0..1 in any representation of the flags register
 883                (i.e. packed bit array or unpacked.)
 884              */
 885             ocf = ACCESS_FLAG(F_CF) != 0;
 886         } else
 887             cf = (d >> (cnt - 1)) & 0x1;
 888
 889         /* B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_n  */
 890         /* note that the right hand side done by the mask
 891            This is effectively done by shifting the
 892            object to the right.  The result must be masked,
 893            in case the object came in and was treated
 894            as a negative number.  Needed??? */
 895
 896         mask = (1 << (8 - cnt)) - 1;
 897         res = (d >> cnt) & mask;
 898
 899         /* now the high stuff which rotated around
 900            into the positions B_cnt-2 .. B_0 */
 901         /* B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0) */
 902         /* shift it downward, 7-(n-2) = 9-n positions.
 903            and mask off the result before or'ing in.
 904          */
 905         res |= (d << (9 - cnt));
 906
 907         /* if the carry flag was set, or it in.  */
 908         if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
 909             /*  B_(8-n) <- cf */
 910             res |= 1 << (8 - cnt);
 911         }
 912         /* set the new carry flag, based on the variable "cf" */
 913         CONDITIONAL_SET_FLAG(cf, F_CF);
 914         /* OVERFLOW is set *IFF* cnt==1, then it is the
 915            xor of CF and the most significant bit.  Blecck. */
 916         /* parenthesized... */
 917         if (cnt == 1) {
 918             CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 6) & 0x2)),
 919                                  F_OF);
 920         }
 921     }
 922     return (u8)res;
 923 }
 924
 925 /****************************************************************************
 926 REMARKS:
 927 Implements the RCR instruction and side effects.
 928 ****************************************************************************/
 929 u16 rcr_word(u16 d, u8 s)
 930 {
 931     u32 res, cnt;
 932     u32 mask, cf, ocf = 0;
 933
 934     /* rotate right through carry */
 935     res = d;
 936     if ((cnt = s % 17) != 0) {
 937         if (cnt == 1) {
 938             cf = d & 0x1;
 939             ocf = ACCESS_FLAG(F_CF) != 0;
 940         } else
 941             cf = (d >> (cnt - 1)) & 0x1;
 942         mask = (1 << (16 - cnt)) - 1;
 943         res = (d >> cnt) & mask;
 944         res |= (d << (17 - cnt));
 945         if (ACCESS_FLAG(F_CF)) {
 946             res |= 1 << (16 - cnt);
 947         }
 948         CONDITIONAL_SET_FLAG(cf, F_CF);
 949         if (cnt == 1) {
 950             CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 14) & 0x2)),
 951                                  F_OF);
 952         }
 953     }
 954     return (u16)res;
 955 }
 956
 957 /****************************************************************************
 958 REMARKS:
 959 Implements the RCR instruction and side effects.
 960 ****************************************************************************/
 961 u32 rcr_long(u32 d, u8 s)
 962 {
 963     u32 res, cnt;
 964     u32 mask, cf, ocf = 0;
 965
 966     /* rotate right through carry */
 967     res = d;
 968     if ((cnt = s % 33) != 0) {
 969         if (cnt == 1) {
 970             cf = d & 0x1;
 971             ocf = ACCESS_FLAG(F_CF) != 0;
 972         } else
 973             cf = (d >> (cnt - 1)) & 0x1;
 974         mask = (1 << (32 - cnt)) - 1;
 975         res = (d >> cnt) & mask;
 976         if (cnt != 1)
 977             res |= (d << (33 - cnt));
 978         if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
 979             res |= 1 << (32 - cnt);
 980         }
 981         CONDITIONAL_SET_FLAG(cf, F_CF);
 982         if (cnt == 1) {
 983             CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 30) & 0x2)),
 984                                  F_OF);
 985         }
 986     }
 987     return res;
 988 }
 989
 990 /****************************************************************************
 991 REMARKS:
 992 Implements the ROL instruction and side effects.
 993 ****************************************************************************/
 994 u8 rol_byte(u8 d, u8 s)
 995 {
 996     unsigned int res, cnt, mask;
 997
 998     /* rotate left */
 999     /*
1000        s is the rotate distance.  It varies from 0 - 8.
1001        d is the byte object rotated.
1002
1003        have
1004
1005        CF  B_7 ... B_0
1006
1007        The new rotate is done mod 8.
1008        Much simpler than the "rcl" or "rcr" operations.
1009
1010        IF n > 0
1011        1) B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_(0)
1012        2) B_(n-1) .. B_(0) <-  b_(7) .. b_(8-n)
1013      */
1014     res = d;
1015     if ((cnt = s % 8) != 0) {
1016         /* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_(0) */
1017         res = (d << cnt);
1018
1019         /* B_(n-1) .. B_(0) <-  b_(7) .. b_(8-n) */
1020         mask = (1 << cnt) - 1;
1021         res |= (d >> (8 - cnt)) & mask;
1022
1023         /* set the new carry flag, Note that it is the low order
1024            bit of the result!!!                               */
1025         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1026         /* OVERFLOW is set *IFF* s==1, then it is the
1027            xor of CF and the most significant bit.  Blecck. */
1028         CONDITIONAL_SET_FLAG(s == 1 &&
1029                              XOR2((res & 0x1) + ((res >> 6) & 0x2)),
1030                              F_OF);
1031     } if (s != 0) {
1032         /* set the new carry flag, Note that it is the low order
1033            bit of the result!!!                               */
1034         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1035     }
1036     return (u8)res;
1037 }
1038
1039 /****************************************************************************
1040 REMARKS:
1041 Implements the ROL instruction and side effects.
1042 ****************************************************************************/
1043 u16 rol_word(u16 d, u8 s)
1044 {
1045     unsigned int res, cnt, mask;
1046
1047     res = d;
1048     if ((cnt = s % 16) != 0) {
1049         res = (d << cnt);
1050         mask = (1 << cnt) - 1;
1051         res |= (d >> (16 - cnt)) & mask;
1052         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1053         CONDITIONAL_SET_FLAG(s == 1 &&
1054                              XOR2((res & 0x1) + ((res >> 14) & 0x2)),
1055                              F_OF);
1056     } if (s != 0) {
1057         /* set the new carry flag, Note that it is the low order
1058            bit of the result!!!                               */
1059         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1060     }
1061     return (u16)res;
1062 }
1063
1064 /****************************************************************************
1065 REMARKS:
1066 Implements the ROL instruction and side effects.
1067 ****************************************************************************/
1068 u32 rol_long(u32 d, u8 s)
1069 {
1070     u32 res, cnt, mask;
1071
1072     res = d;
1073     if ((cnt = s % 32) != 0) {
1074         res = (d << cnt);
1075         mask = (1 << cnt) - 1;
1076         res |= (d >> (32 - cnt)) & mask;
1077         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1078         CONDITIONAL_SET_FLAG(s == 1 &&
1079                              XOR2((res & 0x1) + ((res >> 30) & 0x2)),
1080                              F_OF);
1081     } if (s != 0) {
1082         /* set the new carry flag, Note that it is the low order
1083            bit of the result!!!                               */
1084         CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
1085     }
1086     return res;
1087 }
1088
1089 /****************************************************************************
1090 REMARKS:
1091 Implements the ROR instruction and side effects.
1092 ****************************************************************************/
1093 u8 ror_byte(u8 d, u8 s)
1094 {
1095     unsigned int res, cnt, mask;
1096
1097     /* rotate right */
1098     /*
1099        s is the rotate distance.  It varies from 0 - 8.
1100        d is the byte object rotated.
1101
1102        have
1103
1104        B_7 ... B_0
1105
1106        The rotate is done mod 8.
1107
1108        IF n > 0
1109        1) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
1110        2) B_(7) .. B_(8-n) <-  b_(n-1) .. b_(0)
1111      */
1112     res = d;
1113     if ((cnt = s % 8) != 0) {           /* not a typo, do nada if cnt==0 */
1114         /* B_(7) .. B_(8-n) <-  b_(n-1) .. b_(0) */
1115         res = (d << (8 - cnt));
1116
1117         /* B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n) */
1118         mask = (1 << (8 - cnt)) - 1;
1119         res |= (d >> (cnt)) & mask;
1120
1121         /* set the new carry flag, Note that it is the low order
1122            bit of the result!!!                               */
1123         CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
1124         /* OVERFLOW is set *IFF* s==1, then it is the
1125            xor of the two most significant bits.  Blecck. */
1126         CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 6), F_OF);
1127     } else if (s != 0) {
1128         /* set the new carry flag, Note that it is the low order
1129            bit of the result!!!                               */
1130         CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
1131     }
1132     return (u8)res;
1133 }
1134
1135 /****************************************************************************
1136 REMARKS:
1137 Implements the ROR instruction and side effects.
1138 ****************************************************************************/
1139 u16 ror_word(u16 d, u8 s)
1140 {
1141     unsigned int res, cnt, mask;
1142
1143     res = d;
1144     if ((cnt = s % 16) != 0) {
1145         res = (d << (16 - cnt));
1146         mask = (1 << (16 - cnt)) - 1;
1147         res |= (d >> (cnt)) & mask;
1148         CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
1149         CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 14), F_OF);
1150     } else if (s != 0) {
1151         /* set the new carry flag, Note that it is the low order
1152            bit of the result!!!                               */
1153         CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
1154     }
1155     return (u16)res;
1156 }
1157
1158 /****************************************************************************
1159 REMARKS:
1160 Implements the ROR instruction and side effects.
1161 ****************************************************************************/
1162 u32 ror_long(u32 d, u8 s)
1163 {
1164     u32 res, cnt, mask;
1165
1166     res = d;
1167     if ((cnt = s % 32) != 0) {
1168         res = (d << (32 - cnt));
1169         mask = (1 << (32 - cnt)) - 1;
1170         res |= (d >> (cnt)) & mask;
1171         CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
1172         CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 30), F_OF);
1173     } else if (s != 0) {
1174         /* set the new carry flag, Note that it is the low order
1175            bit of the result!!!                               */
1176         CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
1177     }
1178     return res;
1179 }
1180
1181 /****************************************************************************
1182 REMARKS:
1183 Implements the SHL instruction and side effects.
1184 ****************************************************************************/
1185 u8 shl_byte(u8 d, u8 s)
1186 {
1187     unsigned int cnt, res, cf;
1188
1189     if (s < 8) {
1190         cnt = s % 8;
1191
1192         /* last bit shifted out goes into carry flag */
1193         if (cnt > 0) {
1194             res = d << cnt;
1195             cf = d & (1 << (8 - cnt));
1196             CONDITIONAL_SET_FLAG(cf, F_CF);
1197             set_szp_flags_8((u8)res);
1198         } else {
1199             res = (u8) d;
1200         }
1201
1202         if (cnt == 1) {
1203             /* Needs simplification. */
1204             CONDITIONAL_SET_FLAG(
1205                                     (((res & 0x80) == 0x80) ^
1206                                      (ACCESS_FLAG(F_CF) != 0)),
1207             /* was (M.x86.R_FLG&F_CF)==F_CF)), */
1208                                     F_OF);
1209         } else {
1210             CLEAR_FLAG(F_OF);
1211         }
1212     } else {
1213         res = 0;
1214         CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80, F_CF);
1215         CLEAR_FLAG(F_OF);
1216         CLEAR_FLAG(F_SF);
1217         SET_FLAG(F_PF);
1218         SET_FLAG(F_ZF);
1219     }
1220     return (u8)res;
1221 }
1222
1223 /****************************************************************************
1224 REMARKS:
1225 Implements the SHL instruction and side effects.
1226 ****************************************************************************/
1227 u16 shl_word(u16 d, u8 s)
1228 {
1229     unsigned int cnt, res, cf;
1230
1231     if (s < 16) {
1232         cnt = s % 16;
1233         if (cnt > 0) {
1234             res = d << cnt;
1235             cf = d & (1 << (16 - cnt));
1236             CONDITIONAL_SET_FLAG(cf, F_CF);
1237             set_szp_flags_16((u16)res);
1238         } else {
1239             res = (u16) d;
1240         }
1241
1242         if (cnt == 1) {
1243             CONDITIONAL_SET_FLAG(
1244                                     (((res & 0x8000) == 0x8000) ^
1245                                      (ACCESS_FLAG(F_CF) != 0)),
1246                                     F_OF);
1247         } else {
1248             CLEAR_FLAG(F_OF);
1249         }
1250     } else {
1251         res = 0;
1252         CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
1253         CLEAR_FLAG(F_OF);
1254         CLEAR_FLAG(F_SF);
1255         SET_FLAG(F_PF);
1256         SET_FLAG(F_ZF);
1257     }
1258     return (u16)res;
1259 }
1260
1261 /****************************************************************************
1262 REMARKS:
1263 Implements the SHL instruction and side effects.
1264 ****************************************************************************/
1265 u32 shl_long(u32 d, u8 s)
1266 {
1267     unsigned int cnt, res, cf;
1268
1269     if (s < 32) {
1270         cnt = s % 32;
1271         if (cnt > 0) {
1272             res = d << cnt;
1273             cf = d & (1 << (32 - cnt));
1274             CONDITIONAL_SET_FLAG(cf, F_CF);
1275             set_szp_flags_32((u32)res);
1276         } else {
1277             res = d;
1278         }
1279         if (cnt == 1) {
1280             CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
1281                                   (ACCESS_FLAG(F_CF) != 0)), F_OF);
1282         } else {
1283             CLEAR_FLAG(F_OF);
1284         }
1285     } else {
1286         res = 0;
1287         CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
1288         CLEAR_FLAG(F_OF);
1289         CLEAR_FLAG(F_SF);
1290         SET_FLAG(F_PF);
1291         SET_FLAG(F_ZF);
1292     }
1293     return res;
1294 }
1295
1296 /****************************************************************************
1297 REMARKS:
1298 Implements the SHR instruction and side effects.
1299 ****************************************************************************/
1300 u8 shr_byte(u8 d, u8 s)
1301 {
1302     unsigned int cnt, res, cf;
1303
1304     if (s < 8) {
1305         cnt = s % 8;
1306         if (cnt > 0) {
1307             cf = d & (1 << (cnt - 1));
1308             res = d >> cnt;
1309             CONDITIONAL_SET_FLAG(cf, F_CF);
1310             set_szp_flags_8((u8)res);
1311         } else {
1312             res = (u8) d;
1313         }
1314
1315         if (cnt == 1) {
1316             CONDITIONAL_SET_FLAG(XOR2(res >> 6), F_OF);
1317         } else {
1318             CLEAR_FLAG(F_OF);
1319         }
1320     } else {
1321         res = 0;
1322         CONDITIONAL_SET_FLAG((d >> (s-1)) & 0x1, F_CF);
1323         CLEAR_FLAG(F_OF);
1324         CLEAR_FLAG(F_SF);
1325         SET_FLAG(F_PF);
1326         SET_FLAG(F_ZF);
1327     }
1328     return (u8)res;
1329 }
1330
1331 /****************************************************************************
1332 REMARKS:
1333 Implements the SHR instruction and side effects.
1334 ****************************************************************************/
1335 u16 shr_word(u16 d, u8 s)
1336 {
1337     unsigned int cnt, res, cf;
1338
1339     if (s < 16) {
1340         cnt = s % 16;
1341         if (cnt > 0) {
1342             cf = d & (1 << (cnt - 1));
1343             res = d >> cnt;
1344             CONDITIONAL_SET_FLAG(cf, F_CF);
1345             set_szp_flags_16((u16)res);
1346         } else {
1347             res = d;
1348         }
1349
1350         if (cnt == 1) {
1351             CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
1352         } else {
1353             CLEAR_FLAG(F_OF);
1354         }
1355     } else {
1356         res = 0;
1357         CLEAR_FLAG(F_CF);
1358         CLEAR_FLAG(F_OF);
1359         SET_FLAG(F_ZF);
1360         CLEAR_FLAG(F_SF);
1361         CLEAR_FLAG(F_PF);
1362     }
1363     return (u16)res;
1364 }
1365
1366 /****************************************************************************
1367 REMARKS:
1368 Implements the SHR instruction and side effects.
1369 ****************************************************************************/
1370 u32 shr_long(u32 d, u8 s)
1371 {
1372     unsigned int cnt, res, cf;
1373
1374     if (s < 32) {
1375         cnt = s % 32;
1376         if (cnt > 0) {
1377             cf = d & (1 << (cnt - 1));
1378             res = d >> cnt;
1379             CONDITIONAL_SET_FLAG(cf, F_CF);
1380             set_szp_flags_32((u32)res);
1381         } else {
1382             res = d;
1383         }
1384         if (cnt == 1) {
1385             CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
1386         } else {
1387             CLEAR_FLAG(F_OF);
1388         }
1389     } else {
1390         res = 0;
1391         CLEAR_FLAG(F_CF);
1392         CLEAR_FLAG(F_OF);
1393         SET_FLAG(F_ZF);
1394         CLEAR_FLAG(F_SF);
1395         CLEAR_FLAG(F_PF);
1396     }
1397     return res;
1398 }
1399
1400 /****************************************************************************
1401 REMARKS:
1402 Implements the SAR instruction and side effects.
1403 ****************************************************************************/
1404 u8 sar_byte(u8 d, u8 s)
1405 {
1406     unsigned int cnt, res, cf, mask, sf;
1407
1408     res = d;
1409     sf = d & 0x80;
1410     cnt = s % 8;
1411     if (cnt > 0 && cnt < 8) {
1412         mask = (1 << (8 - cnt)) - 1;
1413         cf = d & (1 << (cnt - 1));
1414         res = (d >> cnt) & mask;
1415         CONDITIONAL_SET_FLAG(cf, F_CF);
1416         if (sf) {
1417             res |= ~mask;
1418         }
1419         set_szp_flags_8((u8)res);
1420     } else if (cnt >= 8) {
1421         if (sf) {
1422             res = 0xff;
1423             SET_FLAG(F_CF);
1424             CLEAR_FLAG(F_ZF);
1425             SET_FLAG(F_SF);
1426             SET_FLAG(F_PF);
1427         } else {
1428             res = 0;
1429             CLEAR_FLAG(F_CF);
1430             SET_FLAG(F_ZF);
1431             CLEAR_FLAG(F_SF);
1432             CLEAR_FLAG(F_PF);
1433         }
1434     }
1435     return (u8)res;
1436 }
1437
1438 /****************************************************************************
1439 REMARKS:
1440 Implements the SAR instruction and side effects.
1441 ****************************************************************************/
1442 u16 sar_word(u16 d, u8 s)
1443 {
1444     unsigned int cnt, res, cf, mask, sf;
1445
1446     sf = d & 0x8000;
1447     cnt = s % 16;
1448     res = d;
1449     if (cnt > 0 && cnt < 16) {
1450         mask = (1 << (16 - cnt)) - 1;
1451         cf = d & (1 << (cnt - 1));
1452         res = (d >> cnt) & mask;
1453         CONDITIONAL_SET_FLAG(cf, F_CF);
1454         if (sf) {
1455             res |= ~mask;
1456         }
1457         set_szp_flags_16((u16)res);
1458     } else if (cnt >= 16) {
1459         if (sf) {
1460             res = 0xffff;
1461             SET_FLAG(F_CF);
1462             CLEAR_FLAG(F_ZF);
1463             SET_FLAG(F_SF);
1464             SET_FLAG(F_PF);
1465         } else {
1466             res = 0;
1467             CLEAR_FLAG(F_CF);
1468             SET_FLAG(F_ZF);
1469             CLEAR_FLAG(F_SF);
1470             CLEAR_FLAG(F_PF);
1471         }
1472     }
1473     return (u16)res;
1474 }
1475
1476 /****************************************************************************
1477 REMARKS:
1478 Implements the SAR instruction and side effects.
1479 ****************************************************************************/
1480 u32 sar_long(u32 d, u8 s)
1481 {
1482     u32 cnt, res, cf, mask, sf;
1483
1484     sf = d & 0x80000000;
1485     cnt = s % 32;
1486     res = d;
1487     if (cnt > 0 && cnt < 32) {
1488         mask = (1 << (32 - cnt)) - 1;
1489         cf = d & (1 << (cnt - 1));
1490         res = (d >> cnt) & mask;
1491         CONDITIONAL_SET_FLAG(cf, F_CF);
1492         if (sf) {
1493             res |= ~mask;
1494         }
1495         set_szp_flags_32(res);
1496     } else if (cnt >= 32) {
1497         if (sf) {
1498             res = 0xffffffff;
1499             SET_FLAG(F_CF);
1500             CLEAR_FLAG(F_ZF);
1501             SET_FLAG(F_SF);
1502             SET_FLAG(F_PF);
1503         } else {
1504             res = 0;
1505             CLEAR_FLAG(F_CF);
1506             SET_FLAG(F_ZF);
1507             CLEAR_FLAG(F_SF);
1508             CLEAR_FLAG(F_PF);
1509         }
1510     }
1511     return res;
1512 }
1513
1514 /****************************************************************************
1515 REMARKS:
1516 Implements the SHLD instruction and side effects.
1517 ****************************************************************************/
1518 u16 shld_word (u16 d, u16 fill, u8 s)
1519 {
1520     unsigned int cnt, res, cf;
1521
1522     if (s < 16) {
1523         cnt = s % 16;
1524         if (cnt > 0) {
1525             res = (d << cnt) | (fill >> (16-cnt));
1526             cf = d & (1 << (16 - cnt));
1527             CONDITIONAL_SET_FLAG(cf, F_CF);
1528             set_szp_flags_16((u16)res);
1529         } else {
1530             res = d;
1531         }
1532         if (cnt == 1) {
1533             CONDITIONAL_SET_FLAG((((res & 0x8000) == 0x8000) ^
1534                                   (ACCESS_FLAG(F_CF) != 0)), F_OF);
1535         } else {
1536             CLEAR_FLAG(F_OF);
1537         }
1538     } else {
1539         res = 0;
1540         CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
1541         CLEAR_FLAG(F_OF);
1542         CLEAR_FLAG(F_SF);
1543         SET_FLAG(F_PF);
1544         SET_FLAG(F_ZF);
1545     }
1546     return (u16)res;
1547 }
1548
1549 /****************************************************************************
1550 REMARKS:
1551 Implements the SHLD instruction and side effects.
1552 ****************************************************************************/
1553 u32 shld_long (u32 d, u32 fill, u8 s)
1554 {
1555     unsigned int cnt, res, cf;
1556
1557     if (s < 32) {
1558         cnt = s % 32;
1559         if (cnt > 0) {
1560             res = (d << cnt) | (fill >> (32-cnt));
1561             cf = d & (1 << (32 - cnt));
1562             CONDITIONAL_SET_FLAG(cf, F_CF);
1563             set_szp_flags_32((u32)res);
1564         } else {
1565             res = d;
1566         }
1567         if (cnt == 1) {
1568             CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
1569                                   (ACCESS_FLAG(F_CF) != 0)), F_OF);
1570         } else {
1571             CLEAR_FLAG(F_OF);
1572         }
1573     } else {
1574         res = 0;
1575         CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
1576         CLEAR_FLAG(F_OF);
1577         CLEAR_FLAG(F_SF);
1578         SET_FLAG(F_PF);
1579         SET_FLAG(F_ZF);
1580     }
1581     return res;
1582 }
1583
1584 /****************************************************************************
1585 REMARKS:
1586 Implements the SHRD instruction and side effects.
1587 ****************************************************************************/
1588 u16 shrd_word (u16 d, u16 fill, u8 s)
1589 {
1590     unsigned int cnt, res, cf;
1591
1592     if (s < 16) {
1593         cnt = s % 16;
1594         if (cnt > 0) {
1595             cf = d & (1 << (cnt - 1));
1596             res = (d >> cnt) | (fill << (16 - cnt));
1597             CONDITIONAL_SET_FLAG(cf, F_CF);
1598             set_szp_flags_16((u16)res);
1599         } else {
1600             res = d;
1601         }
1602
1603         if (cnt == 1) {
1604             CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
1605         } else {
1606             CLEAR_FLAG(F_OF);
1607         }
1608     } else {
1609         res = 0;
1610         CLEAR_FLAG(F_CF);
1611         CLEAR_FLAG(F_OF);
1612         SET_FLAG(F_ZF);
1613         CLEAR_FLAG(F_SF);
1614         CLEAR_FLAG(F_PF);
1615     }
1616     return (u16)res;
1617 }
1618
1619 /****************************************************************************
1620 REMARKS:
1621 Implements the SHRD instruction and side effects.
1622 ****************************************************************************/
1623 u32 shrd_long (u32 d, u32 fill, u8 s)
1624 {
1625     unsigned int cnt, res, cf;
1626
1627     if (s < 32) {
1628         cnt = s % 32;
1629         if (cnt > 0) {
1630             cf = d & (1 << (cnt - 1));
1631             res = (d >> cnt) | (fill << (32 - cnt));
1632             CONDITIONAL_SET_FLAG(cf, F_CF);
1633             set_szp_flags_32((u32)res);
1634         } else {
1635             res = d;
1636         }
1637         if (cnt == 1) {
1638             CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
1639         } else {
1640             CLEAR_FLAG(F_OF);
1641         }
1642     } else {
1643         res = 0;
1644         CLEAR_FLAG(F_CF);
1645         CLEAR_FLAG(F_OF);
1646         SET_FLAG(F_ZF);
1647         CLEAR_FLAG(F_SF);
1648         CLEAR_FLAG(F_PF);
1649     }
1650     return res;
1651 }
1652
1653 /****************************************************************************
1654 REMARKS:
1655 Implements the SBB instruction and side effects.
1656 ****************************************************************************/
1657 u8 sbb_byte(u8 d, u8 s)
1658 {
1659     u32 res;   /* all operands in native machine order */
1660     u32 bc;
1661
1662     if (ACCESS_FLAG(F_CF))
1663         res = d - s - 1;
1664     else
1665         res = d - s;
1666     set_szp_flags_8((u8)res);
1667
1668     /* calculate the borrow chain.  See note at top */
1669     bc = (res & (~d | s)) | (~d & s);
1670     CONDITIONAL_SET_FLAG(bc & 0x80, F_CF);
1671     CONDITIONAL_SET_FLAG(XOR2(bc >> 6), F_OF);
1672     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1673     return (u8)res;
1674 }
1675
1676 /****************************************************************************
1677 REMARKS:
1678 Implements the SBB instruction and side effects.
1679 ****************************************************************************/
1680 u16 sbb_word(u16 d, u16 s)
1681 {
1682     u32 res;   /* all operands in native machine order */
1683     u32 bc;
1684
1685     if (ACCESS_FLAG(F_CF))
1686         res = d - s - 1;
1687     else
1688         res = d - s;
1689     set_szp_flags_16((u16)res);
1690
1691     /* calculate the borrow chain.  See note at top */
1692     bc = (res & (~d | s)) | (~d & s);
1693     CONDITIONAL_SET_FLAG(bc & 0x8000, F_CF);
1694     CONDITIONAL_SET_FLAG(XOR2(bc >> 14), F_OF);
1695     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1696     return (u16)res;
1697 }
1698
1699 /****************************************************************************
1700 REMARKS:
1701 Implements the SBB instruction and side effects.
1702 ****************************************************************************/
1703 u32 sbb_long(u32 d, u32 s)
1704 {
1705     u32 res;   /* all operands in native machine order */
1706     u32 bc;
1707
1708     if (ACCESS_FLAG(F_CF))
1709         res = d - s - 1;
1710     else
1711         res = d - s;
1712
1713     set_szp_flags_32(res);
1714
1715     /* calculate the borrow chain.  See note at top */
1716     bc = (res & (~d | s)) | (~d & s);
1717     CONDITIONAL_SET_FLAG(bc & 0x80000000, F_CF);
1718     CONDITIONAL_SET_FLAG(XOR2(bc >> 30), F_OF);
1719     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1720     return res;
1721 }
1722
1723 /****************************************************************************
1724 REMARKS:
1725 Implements the SUB instruction and side effects.
1726 ****************************************************************************/
1727 u8 sub_byte(u8 d, u8 s)
1728 {
1729     u32 res;   /* all operands in native machine order */
1730     u32 bc;
1731
1732     res = d - s;
1733     set_szp_flags_8((u8)res);
1734
1735     /* calculate the borrow chain.  See note at top */
1736     bc = (res & (~d | s)) | (~d & s);
1737     CONDITIONAL_SET_FLAG(bc & 0x80, F_CF);
1738     CONDITIONAL_SET_FLAG(XOR2(bc >> 6), F_OF);
1739     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1740     return (u8)res;
1741 }
1742
1743 /****************************************************************************
1744 REMARKS:
1745 Implements the SUB instruction and side effects.
1746 ****************************************************************************/
1747 u16 sub_word(u16 d, u16 s)
1748 {
1749     u32 res;   /* all operands in native machine order */
1750     u32 bc;
1751
1752     res = d - s;
1753     set_szp_flags_16((u16)res);
1754
1755     /* calculate the borrow chain.  See note at top */
1756     bc = (res & (~d | s)) | (~d & s);
1757     CONDITIONAL_SET_FLAG(bc & 0x8000, F_CF);
1758     CONDITIONAL_SET_FLAG(XOR2(bc >> 14), F_OF);
1759     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1760     return (u16)res;
1761 }
1762
1763 /****************************************************************************
1764 REMARKS:
1765 Implements the SUB instruction and side effects.
1766 ****************************************************************************/
1767 u32 sub_long(u32 d, u32 s)
1768 {
1769     u32 res;   /* all operands in native machine order */
1770     u32 bc;
1771
1772     res = d - s;
1773     set_szp_flags_32(res);
1774
1775     /* calculate the borrow chain.  See note at top */
1776     bc = (res & (~d | s)) | (~d & s);
1777     CONDITIONAL_SET_FLAG(bc & 0x80000000, F_CF);
1778     CONDITIONAL_SET_FLAG(XOR2(bc >> 30), F_OF);
1779     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
1780     return res;
1781 }
1782
1783 /****************************************************************************
1784 REMARKS:
1785 Implements the TEST instruction and side effects.
1786 ****************************************************************************/
1787 void test_byte(u8 d, u8 s)
1788 {
1789     u32 res;   /* all operands in native machine order */
1790
1791     res = d & s;
1792
1793     CLEAR_FLAG(F_OF);
1794     set_szp_flags_8((u8)res);
1795     /* AF == dont care */
1796     CLEAR_FLAG(F_CF);
1797 }
1798
1799 /****************************************************************************
1800 REMARKS:
1801 Implements the TEST instruction and side effects.
1802 ****************************************************************************/
1803 void test_word(u16 d, u16 s)
1804 {
1805     u32 res;   /* all operands in native machine order */
1806
1807     res = d & s;
1808
1809     CLEAR_FLAG(F_OF);
1810     set_szp_flags_16((u16)res);
1811     /* AF == dont care */
1812     CLEAR_FLAG(F_CF);
1813 }
1814
1815 /****************************************************************************
1816 REMARKS:
1817 Implements the TEST instruction and side effects.
1818 ****************************************************************************/
1819 void test_long(u32 d, u32 s)
1820 {
1821     u32 res;   /* all operands in native machine order */
1822
1823     res = d & s;
1824
1825     CLEAR_FLAG(F_OF);
1826     set_szp_flags_32(res);
1827     /* AF == dont care */
1828     CLEAR_FLAG(F_CF);
1829 }
1830
1831 /****************************************************************************
1832 REMARKS:
1833 Implements the XOR instruction and side effects.
1834 ****************************************************************************/
1835 u8 xor_byte(u8 d, u8 s)
1836 {
1837     u8 res;    /* all operands in native machine order */
1838
1839     res = d ^ s;
1840     no_carry_byte_side_eff(res);
1841     return res;
1842 }
1843
1844 /****************************************************************************
1845 REMARKS:
1846 Implements the XOR instruction and side effects.
1847 ****************************************************************************/
1848 u16 xor_word(u16 d, u16 s)
1849 {
1850     u16 res;   /* all operands in native machine order */
1851
1852     res = d ^ s;
1853     no_carry_word_side_eff(res);
1854     return res;
1855 }
1856
1857 /****************************************************************************
1858 REMARKS:
1859 Implements the XOR instruction and side effects.
1860 ****************************************************************************/
1861 u32 xor_long(u32 d, u32 s)
1862 {
1863     u32 res;   /* all operands in native machine order */
1864
1865     res = d ^ s;
1866     no_carry_long_side_eff(res);
1867     return res;
1868 }
1869
1870 /****************************************************************************
1871 REMARKS:
1872 Implements the IMUL instruction and side effects.
1873 ****************************************************************************/
1874 void imul_byte(u8 s)
1875 {
1876     s16 res = (s16)((s8)M.x86.R_AL * (s8)s);
1877
1878     M.x86.R_AX = res;
1879     if (((M.x86.R_AL & 0x80) == 0 && M.x86.R_AH == 0x00) ||
1880         ((M.x86.R_AL & 0x80) != 0 && M.x86.R_AH == 0xFF)) {
1881         CLEAR_FLAG(F_CF);
1882         CLEAR_FLAG(F_OF);
1883     } else {
1884         SET_FLAG(F_CF);
1885         SET_FLAG(F_OF);
1886     }
1887 }
1888
1889 /****************************************************************************
1890 REMARKS:
1891 Implements the IMUL instruction and side effects.
1892 ****************************************************************************/
1893 void imul_word(u16 s)
1894 {
1895     s32 res = (s16)M.x86.R_AX * (s16)s;
1896
1897     M.x86.R_AX = (u16)res;
1898     M.x86.R_DX = (u16)(res >> 16);
1899     if (((M.x86.R_AX & 0x8000) == 0 && M.x86.R_DX == 0x0000) ||
1900         ((M.x86.R_AX & 0x8000) != 0 && M.x86.R_DX == 0xFFFF)) {
1901         CLEAR_FLAG(F_CF);
1902         CLEAR_FLAG(F_OF);
1903     } else {
1904         SET_FLAG(F_CF);
1905         SET_FLAG(F_OF);
1906     }
1907 }
1908
1909 /****************************************************************************
1910 REMARKS:
1911 Implements the IMUL instruction and side effects.
1912 ****************************************************************************/
1913 void imul_long_direct(u32 *res_lo, u32* res_hi,u32 d, u32 s)
1914 {
1915 #ifdef  __HAS_LONG_LONG__
1916     s64 res = (s32)d * (s32)s;
1917
1918     *res_lo = (u32)res;
1919     *res_hi = (u32)(res >> 32);
1920 #else
1921     u32 d_lo,d_hi,d_sign;
1922     u32 s_lo,s_hi,s_sign;
1923     u32 rlo_lo,rlo_hi,rhi_lo;
1924
1925     if ((d_sign = d & 0x80000000) != 0)
1926         d = -d;
1927     d_lo = d & 0xFFFF;
1928     d_hi = d >> 16;
1929     if ((s_sign = s & 0x80000000) != 0)
1930         s = -s;
1931     s_lo = s & 0xFFFF;
1932     s_hi = s >> 16;
1933     rlo_lo = d_lo * s_lo;
1934     rlo_hi = (d_hi * s_lo + d_lo * s_hi) + (rlo_lo >> 16);
1935     rhi_lo = d_hi * s_hi + (rlo_hi >> 16);
1936     *res_lo = (rlo_hi << 16) | (rlo_lo & 0xFFFF);
1937     *res_hi = rhi_lo;
1938     if (d_sign != s_sign) {
1939         d = ~*res_lo;
1940         s = (((d & 0xFFFF) + 1) >> 16) + (d >> 16);
1941         *res_lo = ~*res_lo+1;
1942         *res_hi = ~*res_hi+(s >> 16);
1943         }
1944 #endif
1945 }
1946
1947 /****************************************************************************
1948 REMARKS:
1949 Implements the IMUL instruction and side effects.
1950 ****************************************************************************/
1951 void imul_long(u32 s)
1952 {
1953     imul_long_direct(&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,s);
1954     if (((M.x86.R_EAX & 0x80000000) == 0 && M.x86.R_EDX == 0x00000000) ||
1955         ((M.x86.R_EAX & 0x80000000) != 0 && M.x86.R_EDX == 0xFFFFFFFF)) {
1956         CLEAR_FLAG(F_CF);
1957         CLEAR_FLAG(F_OF);
1958     } else {
1959         SET_FLAG(F_CF);
1960         SET_FLAG(F_OF);
1961     }
1962 }
1963
1964 /****************************************************************************
1965 REMARKS:
1966 Implements the MUL instruction and side effects.
1967 ****************************************************************************/
1968 void mul_byte(u8 s)
1969 {
1970     u16 res = (u16)(M.x86.R_AL * s);
1971
1972     M.x86.R_AX = res;
1973     if (M.x86.R_AH == 0) {
1974         CLEAR_FLAG(F_CF);
1975         CLEAR_FLAG(F_OF);
1976     } else {
1977         SET_FLAG(F_CF);
1978         SET_FLAG(F_OF);
1979     }
1980 }
1981
1982 /****************************************************************************
1983 REMARKS:
1984 Implements the MUL instruction and side effects.
1985 ****************************************************************************/
1986 void mul_word(u16 s)
1987 {
1988     u32 res = M.x86.R_AX * s;
1989
1990     M.x86.R_AX = (u16)res;
1991     M.x86.R_DX = (u16)(res >> 16);
1992     if (M.x86.R_DX == 0) {
1993         CLEAR_FLAG(F_CF);
1994         CLEAR_FLAG(F_OF);
1995     } else {
1996         SET_FLAG(F_CF);
1997         SET_FLAG(F_OF);
1998     }
1999 }
2000
2001 /****************************************************************************
2002 REMARKS:
2003 Implements the MUL instruction and side effects.
2004 ****************************************************************************/
2005 void mul_long(u32 s)
2006 {
2007 #ifdef  __HAS_LONG_LONG__
2008     u64 res = (u32)M.x86.R_EAX * (u32)s;
2009
2010     M.x86.R_EAX = (u32)res;
2011     M.x86.R_EDX = (u32)(res >> 32);
2012 #else
2013     u32 a,a_lo,a_hi;
2014     u32 s_lo,s_hi;
2015     u32 rlo_lo,rlo_hi,rhi_lo;
2016
2017     a = M.x86.R_EAX;
2018     a_lo = a & 0xFFFF;
2019     a_hi = a >> 16;
2020     s_lo = s & 0xFFFF;
2021     s_hi = s >> 16;
2022     rlo_lo = a_lo * s_lo;
2023     rlo_hi = (a_hi * s_lo + a_lo * s_hi) + (rlo_lo >> 16);
2024     rhi_lo = a_hi * s_hi + (rlo_hi >> 16);
2025     M.x86.R_EAX = (rlo_hi << 16) | (rlo_lo & 0xFFFF);
2026     M.x86.R_EDX = rhi_lo;
2027 #endif
2028     if (M.x86.R_EDX == 0) {
2029         CLEAR_FLAG(F_CF);
2030         CLEAR_FLAG(F_OF);
2031     } else {
2032         SET_FLAG(F_CF);
2033         SET_FLAG(F_OF);
2034     }
2035 }
2036
2037 /****************************************************************************
2038 REMARKS:
2039 Implements the IDIV instruction and side effects.
2040 ****************************************************************************/
2041 void idiv_byte(u8 s)
2042 {
2043     s32 dvd, div, mod;
2044
2045     dvd = (s16)M.x86.R_AX;
2046     if (s == 0) {
2047         x86emu_intr_raise(0);
2048         return;
2049     }
2050     div = dvd / (s8)s;
2051     mod = dvd % (s8)s;
2052     if (abs(div) > 0x7f) {
2053         x86emu_intr_raise(0);
2054         return;
2055     }
2056     M.x86.R_AL = (s8) div;
2057     M.x86.R_AH = (s8) mod;
2058 }
2059
2060 /****************************************************************************
2061 REMARKS:
2062 Implements the IDIV instruction and side effects.
2063 ****************************************************************************/
2064 void idiv_word(u16 s)
2065 {
2066     s32 dvd, div, mod;
2067
2068     dvd = (((s32)M.x86.R_DX) << 16) | M.x86.R_AX;
2069     if (s == 0) {
2070         x86emu_intr_raise(0);
2071         return;
2072     }
2073     div = dvd / (s16)s;
2074     mod = dvd % (s16)s;
2075     if (abs(div) > 0x7fff) {
2076         x86emu_intr_raise(0);
2077         return;
2078     }
2079     CLEAR_FLAG(F_CF);
2080     CLEAR_FLAG(F_SF);
2081     CONDITIONAL_SET_FLAG(div == 0, F_ZF);
2082     set_parity_flag(mod);
2083
2084     M.x86.R_AX = (u16)div;
2085     M.x86.R_DX = (u16)mod;
2086 }
2087
2088 /****************************************************************************
2089 REMARKS:
2090 Implements the IDIV instruction and side effects.
2091 ****************************************************************************/
2092 void idiv_long(u32 s)
2093 {
2094 #ifdef  __HAS_LONG_LONG__
2095     s64 dvd, div, mod;
2096
2097     dvd = (((s64)M.x86.R_EDX) << 32) | M.x86.R_EAX;
2098     if (s == 0) {
2099         x86emu_intr_raise(0);
2100         return;
2101     }
2102     div = dvd / (s32)s;
2103     mod = dvd % (s32)s;
2104     if (abs(div) > 0x7fffffff) {
2105         x86emu_intr_raise(0);
2106         return;
2107     }
2108 #else
2109     s32 div = 0, mod;
2110     s32 h_dvd = M.x86.R_EDX;
2111     u32 l_dvd = M.x86.R_EAX;
2112     u32 abs_s = s & 0x7FFFFFFF;
2113     u32 abs_h_dvd = h_dvd & 0x7FFFFFFF;
2114     u32 h_s = abs_s >> 1;
2115     u32 l_s = abs_s << 31;
2116     int counter = 31;
2117     int carry;
2118
2119     if (s == 0) {
2120         x86emu_intr_raise(0);
2121         return;
2122     }
2123     do {
2124         div <<= 1;
2125         carry = (l_dvd >= l_s) ? 0 : 1;
2126
2127         if (abs_h_dvd < (h_s + carry)) {
2128             h_s >>= 1;
2129             l_s = abs_s << (--counter);
2130             continue;
2131         } else {
2132             abs_h_dvd -= (h_s + carry);
2133             l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
2134                 : (l_dvd - l_s);
2135             h_s >>= 1;
2136             l_s = abs_s << (--counter);
2137             div |= 1;
2138             continue;
2139         }
2140
2141     } while (counter > -1);
2142     /* overflow */
2143     if (abs_h_dvd || (l_dvd > abs_s)) {
2144         x86emu_intr_raise(0);
2145         return;
2146     }
2147     /* sign */
2148     div |= ((h_dvd & 0x10000000) ^ (s & 0x10000000));
2149     mod = l_dvd;
2150
2151 #endif
2152     CLEAR_FLAG(F_CF);
2153     CLEAR_FLAG(F_AF);
2154     CLEAR_FLAG(F_SF);
2155     SET_FLAG(F_ZF);
2156     set_parity_flag(mod);
2157
2158     M.x86.R_EAX = (u32)div;
2159     M.x86.R_EDX = (u32)mod;
2160 }
2161
2162 /****************************************************************************
2163 REMARKS:
2164 Implements the DIV instruction and side effects.
2165 ****************************************************************************/
2166 void div_byte(u8 s)
2167 {
2168     u32 dvd, div, mod;
2169
2170     dvd = M.x86.R_AX;
2171     if (s == 0) {
2172         x86emu_intr_raise(0);
2173         return;
2174     }
2175     div = dvd / (u8)s;
2176     mod = dvd % (u8)s;
2177     if (abs(div) > 0xff) {
2178         x86emu_intr_raise(0);
2179         return;
2180     }
2181     M.x86.R_AL = (u8)div;
2182     M.x86.R_AH = (u8)mod;
2183 }
2184
2185 /****************************************************************************
2186 REMARKS:
2187 Implements the DIV instruction and side effects.
2188 ****************************************************************************/
2189 void div_word(u16 s)
2190 {
2191     u32 dvd, div, mod;
2192
2193     dvd = (((u32)M.x86.R_DX) << 16) | M.x86.R_AX;
2194     if (s == 0) {
2195         x86emu_intr_raise(0);
2196         return;
2197     }
2198     div = dvd / (u16)s;
2199     mod = dvd % (u16)s;
2200     if (abs(div) > 0xffff) {
2201         x86emu_intr_raise(0);
2202         return;
2203     }
2204     CLEAR_FLAG(F_CF);
2205     CLEAR_FLAG(F_SF);
2206     CONDITIONAL_SET_FLAG(div == 0, F_ZF);
2207     set_parity_flag(mod);
2208
2209     M.x86.R_AX = (u16)div;
2210     M.x86.R_DX = (u16)mod;
2211 }
2212
2213 /****************************************************************************
2214 REMARKS:
2215 Implements the DIV instruction and side effects.
2216 ****************************************************************************/
2217 void div_long(u32 s)
2218 {
2219 #ifdef  __HAS_LONG_LONG__
2220     u64 dvd, div, mod;
2221
2222     dvd = (((u64)M.x86.R_EDX) << 32) | M.x86.R_EAX;
2223     if (s == 0) {
2224         x86emu_intr_raise(0);
2225         return;
2226     }
2227     div = dvd / (u32)s;
2228     mod = dvd % (u32)s;
2229     if (abs(div) > 0xffffffff) {
2230         x86emu_intr_raise(0);
2231         return;
2232     }
2233 #else
2234     s32 div = 0, mod;
2235     s32 h_dvd = M.x86.R_EDX;
2236     u32 l_dvd = M.x86.R_EAX;
2237
2238     u32 h_s = s;
2239     u32 l_s = 0;
2240     int counter = 32;
2241     int carry;
2242
2243     if (s == 0) {
2244         x86emu_intr_raise(0);
2245         return;
2246     }
2247     do {
2248         div <<= 1;
2249         carry = (l_dvd >= l_s) ? 0 : 1;
2250
2251         if (h_dvd < (h_s + carry)) {
2252             h_s >>= 1;
2253             l_s = s << (--counter);
2254             continue;
2255         } else {
2256             h_dvd -= (h_s + carry);
2257             l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
2258                 : (l_dvd - l_s);
2259             h_s >>= 1;
2260             l_s = s << (--counter);
2261             div |= 1;
2262             continue;
2263         }
2264
2265     } while (counter > -1);
2266     /* overflow */
2267     if (h_dvd || (l_dvd > s)) {
2268         x86emu_intr_raise(0);
2269         return;
2270     }
2271     mod = l_dvd;
2272 #endif
2273     CLEAR_FLAG(F_CF);
2274     CLEAR_FLAG(F_AF);
2275     CLEAR_FLAG(F_SF);
2276     SET_FLAG(F_ZF);
2277     set_parity_flag(mod);
2278
2279     M.x86.R_EAX = (u32)div;
2280     M.x86.R_EDX = (u32)mod;
2281 }
2282
2283 /****************************************************************************
2284 REMARKS:
2285 Implements the IN string instruction and side effects.
2286 ****************************************************************************/
2287
2288 static void single_in(int size)
2289 {
2290     if(size == 1)
2291         store_data_byte_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inb)(M.x86.R_DX));
2292     else if (size == 2)
2293         store_data_word_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inw)(M.x86.R_DX));
2294     else
2295         store_data_long_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inl)(M.x86.R_DX));
2296 }
2297
2298 void ins(int size)
2299 {
2300     int inc = size;
2301
2302     if (ACCESS_FLAG(F_DF)) {
2303         inc = -size;
2304     }
2305     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
2306         /* dont care whether REPE or REPNE */
2307         /* in until CX is ZERO. */
2308         u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
2309                      M.x86.R_ECX : M.x86.R_CX);
2310
2311         while (count--) {
2312           single_in(size);
2313           M.x86.R_DI += inc;
2314           }
2315         M.x86.R_CX = 0;
2316         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2317             M.x86.R_ECX = 0;
2318         }
2319         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
2320     } else {
2321         single_in(size);
2322         M.x86.R_DI += inc;
2323     }
2324 }
2325
2326 /****************************************************************************
2327 REMARKS:
2328 Implements the OUT string instruction and side effects.
2329 ****************************************************************************/
2330
2331 static void single_out(int size)
2332 {
2333      if(size == 1)
2334        (*sys_outb)(M.x86.R_DX,fetch_data_byte_abs(M.x86.R_ES, M.x86.R_SI));
2335      else if (size == 2)
2336        (*sys_outw)(M.x86.R_DX,fetch_data_word_abs(M.x86.R_ES, M.x86.R_SI));
2337      else
2338        (*sys_outl)(M.x86.R_DX,fetch_data_long_abs(M.x86.R_ES, M.x86.R_SI));
2339 }
2340
2341 void outs(int size)
2342 {
2343     int inc = size;
2344
2345     if (ACCESS_FLAG(F_DF)) {
2346         inc = -size;
2347     }
2348     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
2349         /* dont care whether REPE or REPNE */
2350         /* out until CX is ZERO. */
2351         u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
2352                      M.x86.R_ECX : M.x86.R_CX);
2353         while (count--) {
2354           single_out(size);
2355           M.x86.R_SI += inc;
2356           }
2357         M.x86.R_CX = 0;
2358         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2359             M.x86.R_ECX = 0;
2360         }
2361         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
2362     } else {
2363         single_out(size);
2364         M.x86.R_SI += inc;
2365     }
2366 }
2367
2368 /****************************************************************************
2369 PARAMETERS:
2370 addr    - Address to fetch word from
2371
2372 REMARKS:
2373 Fetches a word from emulator memory using an absolute address.
2374 ****************************************************************************/
2375 u16 mem_access_word(int addr)
2376 {
2377 DB( if (CHECK_MEM_ACCESS())
2378       x86emu_check_mem_access(addr);)
2379     return (*sys_rdw)(addr);
2380 }
2381
2382 /****************************************************************************
2383 REMARKS:
2384 Pushes a word onto the stack.
2385
2386 NOTE: Do not inline this, as (*sys_wrX) is already inline!
2387 ****************************************************************************/
2388 void push_word(u16 w)
2389 {
2390 DB( if (CHECK_SP_ACCESS())
2391       x86emu_check_sp_access();)
2392     M.x86.R_SP -= 2;
2393     (*sys_wrw)(((u32)M.x86.R_SS << 4)  + M.x86.R_SP, w);
2394 }
2395
2396 /****************************************************************************
2397 REMARKS:
2398 Pushes a long onto the stack.
2399
2400 NOTE: Do not inline this, as (*sys_wrX) is already inline!
2401 ****************************************************************************/
2402 void push_long(u32 w)
2403 {
2404 DB( if (CHECK_SP_ACCESS())
2405       x86emu_check_sp_access();)
2406     M.x86.R_SP -= 4;
2407     (*sys_wrl)(((u32)M.x86.R_SS << 4)  + M.x86.R_SP, w);
2408 }
2409
2410 /****************************************************************************
2411 REMARKS:
2412 Pops a word from the stack.
2413
2414 NOTE: Do not inline this, as (*sys_rdX) is already inline!
2415 ****************************************************************************/
2416 u16 pop_word(void)
2417 {
2418     u16 res;
2419
2420 DB( if (CHECK_SP_ACCESS())
2421       x86emu_check_sp_access();)
2422     res = (*sys_rdw)(((u32)M.x86.R_SS << 4)  + M.x86.R_SP);
2423     M.x86.R_SP += 2;
2424     return res;
2425 }
2426
2427 /****************************************************************************
2428 REMARKS:
2429 Pops a long from the stack.
2430
2431 NOTE: Do not inline this, as (*sys_rdX) is already inline!
2432 ****************************************************************************/
2433 u32 pop_long(void)
2434 {
2435     u32 res;
2436
2437 DB( if (CHECK_SP_ACCESS())
2438       x86emu_check_sp_access();)
2439     res = (*sys_rdl)(((u32)M.x86.R_SS << 4)  + M.x86.R_SP);
2440     M.x86.R_SP += 4;
2441     return res;
2442 }