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 }
2443