mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

support lazy flags for SHRD instruction

Browse Source
This commit is contained in:
Stanislav Shwartsman 2005-10-13 20:21:35 +00:00
parent 7022be46f5
commit 7c1374a2ec
5 changed files with 83 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
bochs/cpu/lazy_flags.cc
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: lazy_flags.cc,v 1.27 2004-09-04 10:21:15 sshwarts Exp $ // $Id: lazy_flags.cc,v 1.28 2005-10-13 20:21:35 sshwarts Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2001 MandrakeSoft S.A. // Copyright (C) 2001 MandrakeSoft S.A.
@ -23,14 +23,14 @@
// You should have received a copy of the GNU Lesser General Public // You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software // License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
/////////////////////////////////////////////////////////////////////////
#define NEED_CPU_REG_SHORTCUTS 1 #define NEED_CPU_REG_SHORTCUTS 1
#include "bochs.h" #include "bochs.h"
#define LOG_THIS BX_CPU_THIS_PTR #define LOG_THIS BX_CPU_THIS_PTR
bx_bool BX_CPU_C::get_CFLazy(void) bx_bool BX_CPU_C::get_CFLazy(void)
{ {
unsigned cf; unsigned cf;
@ -123,17 +123,17 @@ bx_bool BX_CPU_C::get_CFLazy(void)
break; break;
#endif #endif
case BX_INSTR_NEG8: case BX_INSTR_NEG8:
cf = BX_CPU_THIS_PTR oszapc.result_8 != 0; cf = (BX_CPU_THIS_PTR oszapc.result_8 != 0);
break; break;
case BX_INSTR_NEG16: case BX_INSTR_NEG16:
cf = BX_CPU_THIS_PTR oszapc.result_16 != 0; cf = (BX_CPU_THIS_PTR oszapc.result_16 != 0);
break; break;
case BX_INSTR_NEG32: case BX_INSTR_NEG32:
cf = BX_CPU_THIS_PTR oszapc.result_32 != 0; cf = (BX_CPU_THIS_PTR oszapc.result_32 != 0);
break; break;
#if BX_SUPPORT_X86_64 #if BX_SUPPORT_X86_64
case BX_INSTR_NEG64: case BX_INSTR_NEG64:
cf = BX_CPU_THIS_PTR oszapc.result_64 != 0; cf = (BX_CPU_THIS_PTR oszapc.result_64 != 0);
break; break;
#endif #endif
case BX_INSTR_LOGIC8: case BX_INSTR_LOGIC8:
@ -173,12 +173,14 @@ bx_bool BX_CPU_C::get_CFLazy(void)
} }
break; break;
case BX_INSTR_SHR16: case BX_INSTR_SHR16:
case BX_INSTR_SHRD16:
cf = cf =
(BX_CPU_THIS_PTR oszapc.op1_16 >> (BX_CPU_THIS_PTR oszapc.op1_16 >>
(BX_CPU_THIS_PTR oszapc.op2_16 - 1)) & 0x01; (BX_CPU_THIS_PTR oszapc.op2_16 - 1)) & 0x01;
break; break;
case BX_INSTR_SAR32: case BX_INSTR_SAR32:
case BX_INSTR_SHR32: case BX_INSTR_SHR32:
case BX_INSTR_SHRD32:
cf = cf =
(BX_CPU_THIS_PTR oszapc.op1_32 >> (BX_CPU_THIS_PTR oszapc.op1_32 >>
(BX_CPU_THIS_PTR oszapc.op2_32 - 1)) & 0x01; (BX_CPU_THIS_PTR oszapc.op2_32 - 1)) & 0x01;
@ -186,6 +188,7 @@ bx_bool BX_CPU_C::get_CFLazy(void)
#if BX_SUPPORT_X86_64 #if BX_SUPPORT_X86_64
case BX_INSTR_SAR64: case BX_INSTR_SAR64:
case BX_INSTR_SHR64: case BX_INSTR_SHR64:
case BX_INSTR_SHRD64:
cf = cf =
(BX_CPU_THIS_PTR oszapc.op1_64 >> (BX_CPU_THIS_PTR oszapc.op1_64 >>
(BX_CPU_THIS_PTR oszapc.op2_64 - 1)) & 0x01; (BX_CPU_THIS_PTR oszapc.op2_64 - 1)) & 0x01;
@ -196,20 +199,20 @@ bx_bool BX_CPU_C::get_CFLazy(void)
cf = cf =
(BX_CPU_THIS_PTR oszapc.op1_8 >> (BX_CPU_THIS_PTR oszapc.op1_8 >>
(8 - BX_CPU_THIS_PTR oszapc.op2_8)) & 0x01; (8 - BX_CPU_THIS_PTR oszapc.op2_8)) & 0x01;
} }
else { else {
cf = 0; cf = 0;
} }
break; break;
case BX_INSTR_SHL16: case BX_INSTR_SHL16:
if (BX_CPU_THIS_PTR oszapc.op2_16 <= 16) { if (BX_CPU_THIS_PTR oszapc.op2_16 <= 16) {
cf = cf =
(BX_CPU_THIS_PTR oszapc.op1_16 >> (BX_CPU_THIS_PTR oszapc.op1_16 >>
(16 - BX_CPU_THIS_PTR oszapc.op2_16)) & 0x01; (16 - BX_CPU_THIS_PTR oszapc.op2_16)) & 0x01;
} }
else { else {
cf = 0; cf = 0;
} }
break; break;
case BX_INSTR_SHL32: case BX_INSTR_SHL32:
cf = cf =
@ -267,7 +270,7 @@ bx_bool BX_CPU_C::get_CFLazy(void)
cf = 0; // Keep compiler quiet. cf = 0; // Keep compiler quiet.
BX_PANIC(("get_CF: OSZAPC: unknown instr %u", BX_PANIC(("get_CF: OSZAPC: unknown instr %u",
(unsigned) BX_CPU_THIS_PTR oszapc.instr)); (unsigned) BX_CPU_THIS_PTR oszapc.instr));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xfffff0; BX_CPU_THIS_PTR lf_flags_status &= 0xfffff0;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<0); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<0);
BX_CPU_THIS_PTR eflags.val32 |= (!!cf)<<0; BX_CPU_THIS_PTR eflags.val32 |= (!!cf)<<0;
@ -276,7 +279,7 @@ bx_bool BX_CPU_C::get_CFLazy(void)
default: default:
BX_PANIC(("get_CF: unknown case")); BX_PANIC(("get_CF: unknown case"));
return(0); return(0);
} }
} }
bx_bool BX_CPU_C::get_AFLazy(void) bx_bool BX_CPU_C::get_AFLazy(void)
@ -348,6 +351,7 @@ bx_bool BX_CPU_C::get_AFLazy(void)
case BX_INSTR_BITSCAN64: case BX_INSTR_BITSCAN64:
case BX_INSTR_SAR64: case BX_INSTR_SAR64:
case BX_INSTR_SHR64: case BX_INSTR_SHR64:
case BX_INSTR_SHRD64:
case BX_INSTR_SHL64: case BX_INSTR_SHL64:
case BX_INSTR_IMUL64: case BX_INSTR_IMUL64:
case BX_INSTR_MUL64: case BX_INSTR_MUL64:
@ -358,6 +362,8 @@ bx_bool BX_CPU_C::get_AFLazy(void)
case BX_INSTR_SHR8: case BX_INSTR_SHR8:
case BX_INSTR_SHR16: case BX_INSTR_SHR16:
case BX_INSTR_SHR32: case BX_INSTR_SHR32:
case BX_INSTR_SHRD16:
case BX_INSTR_SHRD32:
case BX_INSTR_SHL8: case BX_INSTR_SHL8:
case BX_INSTR_SHL16: case BX_INSTR_SHL16:
case BX_INSTR_SHL32: case BX_INSTR_SHL32:
@ -373,7 +379,7 @@ bx_bool BX_CPU_C::get_AFLazy(void)
af = 0; // Keep compiler quiet. af = 0; // Keep compiler quiet.
BX_PANIC(("get_AF: OSZAPC: unknown instr %u", BX_PANIC(("get_AF: OSZAPC: unknown instr %u",
(unsigned) BX_CPU_THIS_PTR oszapc.instr)); (unsigned) BX_CPU_THIS_PTR oszapc.instr));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff; BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4; BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
@ -413,7 +419,7 @@ bx_bool BX_CPU_C::get_AFLazy(void)
af = 0; // Keep compiler quiet. af = 0; // Keep compiler quiet.
BX_PANIC(("get_AF: OSZAP: unknown instr %u", BX_PANIC(("get_AF: OSZAP: unknown instr %u",
(unsigned) BX_CPU_THIS_PTR oszap.instr)); (unsigned) BX_CPU_THIS_PTR oszap.instr));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff; BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4; BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
@ -422,7 +428,7 @@ bx_bool BX_CPU_C::get_AFLazy(void)
default: default:
BX_PANIC(("get_AF: unknown case")); BX_PANIC(("get_AF: unknown case"));
return(0); return(0);
} }
} }
bx_bool BX_CPU_C::get_ZFLazy(void) bx_bool BX_CPU_C::get_ZFLazy(void)
@ -451,6 +457,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
case BX_INSTR_NEG16: case BX_INSTR_NEG16:
case BX_INSTR_SAR16: case BX_INSTR_SAR16:
case BX_INSTR_SHR16: case BX_INSTR_SHR16:
case BX_INSTR_SHRD16:
case BX_INSTR_SHL16: case BX_INSTR_SHL16:
zf = (BX_CPU_THIS_PTR oszapc.result_16 == 0); zf = (BX_CPU_THIS_PTR oszapc.result_16 == 0);
break; break;
@ -462,6 +469,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
case BX_INSTR_NEG32: case BX_INSTR_NEG32:
case BX_INSTR_SAR32: case BX_INSTR_SAR32:
case BX_INSTR_SHR32: case BX_INSTR_SHR32:
case BX_INSTR_SHRD32:
case BX_INSTR_SHL32: case BX_INSTR_SHL32:
zf = (BX_CPU_THIS_PTR oszapc.result_32 == 0); zf = (BX_CPU_THIS_PTR oszapc.result_32 == 0);
break; break;
@ -474,6 +482,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
case BX_INSTR_NEG64: case BX_INSTR_NEG64:
case BX_INSTR_SAR64: case BX_INSTR_SAR64:
case BX_INSTR_SHR64: case BX_INSTR_SHR64:
case BX_INSTR_SHRD64:
case BX_INSTR_SHL64: case BX_INSTR_SHL64:
zf = (BX_CPU_THIS_PTR oszapc.result_64 == 0); zf = (BX_CPU_THIS_PTR oszapc.result_64 == 0);
break; break;
@ -506,7 +515,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
default: default:
zf = 0; zf = 0;
BX_PANIC(("get_ZF: OSZAPC: unknown instr")); BX_PANIC(("get_ZF: OSZAPC: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff; BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1. BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
@ -535,7 +544,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
default: default:
zf = 0; zf = 0;
BX_PANIC(("get_ZF: OSZAP: unknown instr")); BX_PANIC(("get_ZF: OSZAP: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff; BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1. BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
@ -544,7 +553,7 @@ bx_bool BX_CPU_C::get_ZFLazy(void)
default: default:
BX_PANIC(("get_ZF: unknown case")); BX_PANIC(("get_ZF: unknown case"));
return(0); return(0);
} }
} }
bx_bool BX_CPU_C::get_SFLazy(void) bx_bool BX_CPU_C::get_SFLazy(void)
@ -573,6 +582,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
case BX_INSTR_NEG16: case BX_INSTR_NEG16:
case BX_INSTR_SAR16: case BX_INSTR_SAR16:
case BX_INSTR_SHR16: case BX_INSTR_SHR16:
case BX_INSTR_SHRD16:
case BX_INSTR_SHL16: case BX_INSTR_SHL16:
case BX_INSTR_BITSCAN16: case BX_INSTR_BITSCAN16:
sf = (BX_CPU_THIS_PTR oszapc.result_16 >= 0x8000); sf = (BX_CPU_THIS_PTR oszapc.result_16 >= 0x8000);
@ -585,6 +595,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
case BX_INSTR_NEG32: case BX_INSTR_NEG32:
case BX_INSTR_SAR32: case BX_INSTR_SAR32:
case BX_INSTR_SHR32: case BX_INSTR_SHR32:
case BX_INSTR_SHRD32:
case BX_INSTR_SHL32: case BX_INSTR_SHL32:
case BX_INSTR_BITSCAN32: case BX_INSTR_BITSCAN32:
sf = (BX_CPU_THIS_PTR oszapc.result_32 >= 0x80000000); sf = (BX_CPU_THIS_PTR oszapc.result_32 >= 0x80000000);
@ -598,6 +609,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
case BX_INSTR_NEG64: case BX_INSTR_NEG64:
case BX_INSTR_SAR64: case BX_INSTR_SAR64:
case BX_INSTR_SHR64: case BX_INSTR_SHR64:
case BX_INSTR_SHRD64:
case BX_INSTR_SHL64: case BX_INSTR_SHL64:
case BX_INSTR_BITSCAN64: case BX_INSTR_BITSCAN64:
sf = (BX_CPU_THIS_PTR oszapc.result_64 >= BX_CONST64(0x8000000000000000)); sf = (BX_CPU_THIS_PTR oszapc.result_64 >= BX_CONST64(0x8000000000000000));
@ -624,7 +636,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
default: default:
sf = 0; // Keep compiler quiet. sf = 0; // Keep compiler quiet.
BX_PANIC(("get_SF: OSZAPC: unknown instr")); BX_PANIC(("get_SF: OSZAPC: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff; BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7; BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
@ -653,7 +665,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
default: default:
sf = 0; // Keep compiler quiet. sf = 0; // Keep compiler quiet.
BX_PANIC(("get_SF: OSZAP: unknown instr")); BX_PANIC(("get_SF: OSZAP: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff; BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7; BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
@ -662,7 +674,7 @@ bx_bool BX_CPU_C::get_SFLazy(void)
default: default:
BX_PANIC(("get_SF: unknown case")); BX_PANIC(("get_SF: unknown case"));
return(0); return(0);
} }
} }
bx_bool BX_CPU_C::get_OFLazy(void) bx_bool BX_CPU_C::get_OFLazy(void)
@ -792,6 +804,23 @@ bx_bool BX_CPU_C::get_OFLazy(void)
else else
of = 0; /* undocumented, but hardware really does it */ of = 0; /* undocumented, but hardware really does it */
break; break;
#endif
case BX_INSTR_SHRD16:
/* undocumented, but this formula works right for any shift count */
of = (((BX_CPU_THIS_PTR oszapc.result_16 << 1) ^
BX_CPU_THIS_PTR oszapc.result_16) & 0x8000) > 0;
break;
case BX_INSTR_SHRD32:
/* undocumented, but this formula works right for any shift count */
of = (((BX_CPU_THIS_PTR oszapc.result_32 << 1) ^
BX_CPU_THIS_PTR oszapc.result_32) & 0x80000000) > 0;
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_SHRD64:
/* undocumented, but this formula works right for any shift count */
of = (((BX_CPU_THIS_PTR oszapc.result_64 << 1) ^
BX_CPU_THIS_PTR oszapc.result_64) & BX_CONST64(0x8000000000000000)) > 0;
break;
#endif #endif
case BX_INSTR_SHL8: case BX_INSTR_SHL8:
if (BX_CPU_THIS_PTR oszapc.op2_8 == 1) if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
@ -874,7 +903,7 @@ bx_bool BX_CPU_C::get_OFLazy(void)
default: default:
of = 0; // Keep compiler happy. of = 0; // Keep compiler happy.
BX_PANIC(("get_OF: OSZAPC: unknown instr")); BX_PANIC(("get_OF: OSZAPC: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff; BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11; BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
@ -883,37 +912,37 @@ bx_bool BX_CPU_C::get_OFLazy(void)
case BX_LF_INDEX_OSZAP: case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) { switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8: case BX_INSTR_INC8:
of = BX_CPU_THIS_PTR oszap.result_8 == 0x80; of = (BX_CPU_THIS_PTR oszap.result_8 == 0x80);
break; break;
case BX_INSTR_INC16: case BX_INSTR_INC16:
of = BX_CPU_THIS_PTR oszap.result_16 == 0x8000; of = (BX_CPU_THIS_PTR oszap.result_16 == 0x8000);
break; break;
case BX_INSTR_INC32: case BX_INSTR_INC32:
of = BX_CPU_THIS_PTR oszap.result_32 == 0x80000000; of = (BX_CPU_THIS_PTR oszap.result_32 == 0x80000000);
break; break;
#if BX_SUPPORT_X86_64 #if BX_SUPPORT_X86_64
case BX_INSTR_INC64: case BX_INSTR_INC64:
of = BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x8000000000000000); of = (BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x8000000000000000));
break; break;
#endif #endif
case BX_INSTR_DEC8: case BX_INSTR_DEC8:
of = BX_CPU_THIS_PTR oszap.result_8 == 0x7F; of = (BX_CPU_THIS_PTR oszap.result_8 == 0x7F);
break; break;
case BX_INSTR_DEC16: case BX_INSTR_DEC16:
of = BX_CPU_THIS_PTR oszap.result_16 == 0x7FFF; of = (BX_CPU_THIS_PTR oszap.result_16 == 0x7FFF);
break; break;
case BX_INSTR_DEC32: case BX_INSTR_DEC32:
of = BX_CPU_THIS_PTR oszap.result_32 == 0x7FFFFFFF; of = (BX_CPU_THIS_PTR oszap.result_32 == 0x7FFFFFFF);
break; break;
#if BX_SUPPORT_X86_64 #if BX_SUPPORT_X86_64
case BX_INSTR_DEC64: case BX_INSTR_DEC64:
of = BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x7FFFFFFFFFFFFFFF); of = (BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x7FFFFFFFFFFFFFFF));
break; break;
#endif #endif
default: default:
of = 0; // Keep compiler happy. of = 0; // Keep compiler happy.
BX_PANIC(("get_OF: OSZAP: unknown instr")); BX_PANIC(("get_OF: OSZAP: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff; BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11; BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
@ -922,7 +951,7 @@ bx_bool BX_CPU_C::get_OFLazy(void)
default: default:
BX_PANIC(("get_OF: unknown case")); BX_PANIC(("get_OF: unknown case"));
return(0); return(0);
} }
} }
bx_bool BX_CPU_C::get_PFLazy(void) bx_bool BX_CPU_C::get_PFLazy(void)
@ -951,6 +980,7 @@ bx_bool BX_CPU_C::get_PFLazy(void)
case BX_INSTR_NEG16: case BX_INSTR_NEG16:
case BX_INSTR_SAR16: case BX_INSTR_SAR16:
case BX_INSTR_SHR16: case BX_INSTR_SHR16:
case BX_INSTR_SHRD16:
case BX_INSTR_SHL16: case BX_INSTR_SHL16:
case BX_INSTR_BITSCAN16: case BX_INSTR_BITSCAN16:
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_16]; pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_16];
@ -963,6 +993,7 @@ bx_bool BX_CPU_C::get_PFLazy(void)
case BX_INSTR_NEG32: case BX_INSTR_NEG32:
case BX_INSTR_SAR32: case BX_INSTR_SAR32:
case BX_INSTR_SHR32: case BX_INSTR_SHR32:
case BX_INSTR_SHRD32:
case BX_INSTR_SHL32: case BX_INSTR_SHL32:
case BX_INSTR_BITSCAN32: case BX_INSTR_BITSCAN32:
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_32]; pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_32];
@ -976,6 +1007,7 @@ bx_bool BX_CPU_C::get_PFLazy(void)
case BX_INSTR_NEG64: case BX_INSTR_NEG64:
case BX_INSTR_SAR64: case BX_INSTR_SAR64:
case BX_INSTR_SHR64: case BX_INSTR_SHR64:
case BX_INSTR_SHRD64:
case BX_INSTR_SHL64: case BX_INSTR_SHL64:
case BX_INSTR_BITSCAN64: case BX_INSTR_BITSCAN64:
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_64]; pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_64];
@ -1002,7 +1034,7 @@ bx_bool BX_CPU_C::get_PFLazy(void)
default: default:
pf = 0; // Keep compiler quiet. pf = 0; // Keep compiler quiet.
BX_PANIC(("get_PF: OSZAPC: unknown instr")); BX_PANIC(("get_PF: OSZAPC: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f; BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here
@ -1031,7 +1063,7 @@ bx_bool BX_CPU_C::get_PFLazy(void)
default: default:
pf = 0; // Keep compiler quiet. pf = 0; // Keep compiler quiet.
BX_PANIC(("get_PF: OSZAP: unknown instr")); BX_PANIC(("get_PF: OSZAP: unknown instr"));
} }
BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f; BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2); BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here
@ -1040,5 +1072,5 @@ bx_bool BX_CPU_C::get_PFLazy(void)
default: default:
BX_PANIC(("get_PF: unknown case")); BX_PANIC(("get_PF: unknown case"));
return(0); return(0);
} }
} }

7
bochs/cpu/lazy_flags.h
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: lazy_flags.h,v 1.22 2005-07-25 04:18:20 sshwarts Exp $ // $Id: lazy_flags.h,v 1.23 2005-10-13 20:21:35 sshwarts Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2001 MandrakeSoft S.A. // Copyright (C) 2001 MandrakeSoft S.A.
@ -109,6 +109,11 @@
#define BX_INSTR_IMUL32 55 #define BX_INSTR_IMUL32 55
#define BX_INSTR_IMUL64 56 #define BX_INSTR_IMUL64 56
// BX_INSTR_SHRD8 not exists, leave number for alignment
#define BX_INSTR_SHRD16 58
#define BX_INSTR_SHRD32 59
#define BX_INSTR_SHRD64 60
#define BX_INSTR_COMPARE8 BX_INSTR_SUB8 #define BX_INSTR_COMPARE8 BX_INSTR_SUB8
#define BX_INSTR_COMPARE16 BX_INSTR_SUB16 #define BX_INSTR_COMPARE16 BX_INSTR_SUB16
#define BX_INSTR_COMPARE32 BX_INSTR_SUB32 #define BX_INSTR_COMPARE32 BX_INSTR_SUB32

14
bochs/cpu/shift16.cc
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: shift16.cc,v 1.27 2005-10-13 19:28:10 sshwarts Exp $ // $Id: shift16.cc,v 1.28 2005-10-13 20:21:35 sshwarts Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2001 MandrakeSoft S.A. // Copyright (C) 2001 MandrakeSoft S.A.
@ -130,17 +130,9 @@ void BX_CPU_C::SHRD_EwGw(bxInstruction_c *i)
} }
/* set eflags: /* set eflags:
* SHRD count affects the following flags: S,Z,P,C,O * SHRD count affects the following flags: O,S,Z,A,P,C
*/ */
SET_FLAGS_OSZAPC_16(op1_16, count, result_16, BX_INSTR_SHRD16);
set_CF((op1_16 >> (count - 1)) & 0x01);
set_ZF(result_16 == 0);
set_SF(result_16 >> 15);
set_AF(0);
/* for shift of 1, OF set if sign change occurred. */
if (count == 1)
set_OF(((op1_16 ^ result_16) & 0x8000) > 0);
set_PF_base((Bit8u) result_16);
} }
void BX_CPU_C::ROL_Ew(bxInstruction_c *i) void BX_CPU_C::ROL_Ew(bxInstruction_c *i)

14
bochs/cpu/shift32.cc
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: shift32.cc,v 1.28 2005-10-13 19:28:10 sshwarts Exp $ // $Id: shift32.cc,v 1.29 2005-10-13 20:21:35 sshwarts Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2001 MandrakeSoft S.A. // Copyright (C) 2001 MandrakeSoft S.A.
@ -105,17 +105,9 @@ void BX_CPU_C::SHRD_EdGd(bxInstruction_c *i)
} }
/* set eflags: /* set eflags:
* SHRD count affects the following flags: S,Z,P,C,O * SHRD count affects the following flags: O,S,Z,A,P,C
*/ */
SET_FLAGS_OSZAPC_32(op1_32, count, result_32, BX_INSTR_SHRD32);
set_CF((op1_32 >> (count - 1)) & 0x01);
set_ZF(result_32 == 0);
set_SF(result_32 >> 31);
set_AF(0);
/* for shift of 1, OF set if sign change occurred. */
if (count == 1)
set_OF(((op1_32 ^ result_32) & 0x80000000) > 0);
set_PF_base(result_32);
} }
void BX_CPU_C::ROL_Ed(bxInstruction_c *i) void BX_CPU_C::ROL_Ed(bxInstruction_c *i)

14
bochs/cpu/shift64.cc
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: shift64.cc,v 1.17 2005-10-13 19:28:10 sshwarts Exp $ // $Id: shift64.cc,v 1.18 2005-10-13 20:21:35 sshwarts Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2001 MandrakeSoft S.A. // Copyright (C) 2001 MandrakeSoft S.A.
@ -107,17 +107,9 @@ void BX_CPU_C::SHRD_EqGq(bxInstruction_c *i)
} }
/* set eflags: /* set eflags:
* SHRD count affects the following flags: S,Z,P,C,O * SHRD count affects the following flags: O,S,Z,A,P,C
*/ */
SET_FLAGS_OSZAPC_64(op1_64, count, result_64, BX_INSTR_SHRD64);
set_CF((op1_64 >> (count - 1)) & 0x01);
set_ZF(result_64 == 0);
set_SF(result_64 >> 63);
set_AF(0);
/* for shift of 1, OF set if sign change occurred. */
if (count == 1)
set_OF(((op1_64 ^ result_64) & BX_CONST64(0x8000000000000000)) > 0);
set_PF_base(result_64);
} }
void BX_CPU_C::ROL_Eq(bxInstruction_c *i) void BX_CPU_C::ROL_Eq(bxInstruction_c *i)