From 88899cf61792aaa1b5a55bb7537c072db55a1475 Mon Sep 17 00:00:00 2001
From: Stanislav Shwartsman <sshwarts@users.sourceforge.net>
Date: Tue, 4 Dec 2007 19:27:23 +0000
Subject: [PATCH] Changes for lazy flags handling -> 1st stap in transition to
 new lazy flags handling by Darek Mihocka (www.emulators.com)

---
 bochs/cpu/arith16.cc    |   14 +-
 bochs/cpu/arith32.cc    |   14 +-
 bochs/cpu/arith64.cc    |   10 +-
 bochs/cpu/arith8.cc     |   24 +-
 bochs/cpu/cpu.cc        |   13 +-
 bochs/cpu/cpu.h         |  104 ++--
 bochs/cpu/lazy_flags.cc | 1210 +++++++++++++++++----------------------
 bochs/cpu/lazy_flags.h  |   14 +-
 8 files changed, 625 insertions(+), 778 deletions(-)

diff --git a/bochs/cpu/arith16.cc b/bochs/cpu/arith16.cc
index 8cd2e490f..f0028d2e8 100644
--- a/bochs/cpu/arith16.cc
+++ b/bochs/cpu/arith16.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: arith16.cc,v 1.58 2007-12-01 16:45:15 sshwarts Exp $
+// $Id: arith16.cc,v 1.59 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -35,13 +35,13 @@
 void BX_CPU_C::INC_RX(bxInstruction_c *i)
 {
   Bit16u rx = ++BX_READ_16BIT_REG(i->opcodeReg());
-  SET_FLAGS_OSZAP_RESULT_16(rx, BX_INSTR_INC16);
+  SET_FLAGS_OSZAPC_INC_16(rx);
 }
 
 void BX_CPU_C::DEC_RX(bxInstruction_c *i)
 {
   Bit16u rx = --BX_READ_16BIT_REG(i->opcodeReg());
-  SET_FLAGS_OSZAP_RESULT_16(rx, BX_INSTR_DEC16);
+  SET_FLAGS_OSZAPC_DEC_16(rx);
 }
 
 void BX_CPU_C::ADD_EwGwM(bxInstruction_c *i)
@@ -561,7 +561,7 @@ void BX_CPU_C::INC_EwM(bxInstruction_c *i)
   op1_16++;
   write_RMW_virtual_word(op1_16);
 
-  SET_FLAGS_OSZAP_RESULT_16(op1_16, BX_INSTR_INC16);
+  SET_FLAGS_OSZAPC_INC_16(op1_16);
 }
 
 void BX_CPU_C::INC_EwR(bxInstruction_c *i)
@@ -570,7 +570,7 @@ void BX_CPU_C::INC_EwR(bxInstruction_c *i)
   op1_16++;
   BX_WRITE_16BIT_REG(i->rm(), op1_16);
 
-  SET_FLAGS_OSZAP_RESULT_16(op1_16, BX_INSTR_INC16);
+  SET_FLAGS_OSZAPC_INC_16(op1_16);
 }
 
 void BX_CPU_C::DEC_EwM(bxInstruction_c *i)
@@ -581,7 +581,7 @@ void BX_CPU_C::DEC_EwM(bxInstruction_c *i)
   op1_16--;
   write_RMW_virtual_word(op1_16);
 
-  SET_FLAGS_OSZAP_RESULT_16(op1_16, BX_INSTR_DEC16);
+  SET_FLAGS_OSZAPC_DEC_16(op1_16);
 }
 
 void BX_CPU_C::DEC_EwR(bxInstruction_c *i)
@@ -590,7 +590,7 @@ void BX_CPU_C::DEC_EwR(bxInstruction_c *i)
   op1_16--;
   BX_WRITE_16BIT_REG(i->rm(), op1_16);
 
-  SET_FLAGS_OSZAP_RESULT_16(op1_16, BX_INSTR_DEC16);
+  SET_FLAGS_OSZAPC_DEC_16(op1_16);
 }
 
 void BX_CPU_C::CMPXCHG_EwGwM(bxInstruction_c *i)
diff --git a/bochs/cpu/arith32.cc b/bochs/cpu/arith32.cc
index e992478ed..39f82080c 100644
--- a/bochs/cpu/arith32.cc
+++ b/bochs/cpu/arith32.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: arith32.cc,v 1.65 2007-12-03 20:48:02 sshwarts Exp $
+// $Id: arith32.cc,v 1.66 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -42,14 +42,14 @@
 void BX_CPU_C::INC_ERX(bxInstruction_c *i)
 {
   Bit32u erx = ++BX_READ_32BIT_REG(i->opcodeReg());
-  SET_FLAGS_OSZAP_RESULT_32(erx, BX_INSTR_INC32);
+  SET_FLAGS_OSZAPC_INC_32(erx);
   BX_CLEAR_64BIT_HIGH(i->opcodeReg());
 }
 
 void BX_CPU_C::DEC_ERX(bxInstruction_c *i)
 {
   Bit32u erx = --BX_READ_32BIT_REG(i->opcodeReg());
-  SET_FLAGS_OSZAP_RESULT_32(erx, BX_INSTR_DEC32);
+  SET_FLAGS_OSZAPC_DEC_32(erx);
   BX_CLEAR_64BIT_HIGH(i->opcodeReg());
 }
 
@@ -615,7 +615,7 @@ void BX_CPU_C::INC_EdM(bxInstruction_c *i)
   op1_32++;
   write_RMW_virtual_dword(op1_32);
 
-  SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_INC32);
+  SET_FLAGS_OSZAPC_INC_32(op1_32);
 }
 
 void BX_CPU_C::INC_EdR(bxInstruction_c *i)
@@ -624,7 +624,7 @@ void BX_CPU_C::INC_EdR(bxInstruction_c *i)
   op1_32++;
   BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
 
-  SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_INC32);
+  SET_FLAGS_OSZAPC_INC_32(op1_32);
 }
 
 void BX_CPU_C::DEC_EdM(bxInstruction_c *i)
@@ -635,7 +635,7 @@ void BX_CPU_C::DEC_EdM(bxInstruction_c *i)
   op1_32--;
   write_RMW_virtual_dword(op1_32);
 
-  SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_DEC32);
+  SET_FLAGS_OSZAPC_DEC_32(op1_32);
 }
 
 void BX_CPU_C::DEC_EdR(bxInstruction_c *i)
@@ -644,7 +644,7 @@ void BX_CPU_C::DEC_EdR(bxInstruction_c *i)
   op1_32--;
   BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
 
-  SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_DEC32);
+  SET_FLAGS_OSZAPC_DEC_32(op1_32);
 }
 
 void BX_CPU_C::CMPXCHG_EdGdM(bxInstruction_c *i)
diff --git a/bochs/cpu/arith64.cc b/bochs/cpu/arith64.cc
index 5048a2979..4ee1c10f9 100644
--- a/bochs/cpu/arith64.cc
+++ b/bochs/cpu/arith64.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: arith64.cc,v 1.41 2007-12-03 20:48:02 sshwarts Exp $
+// $Id: arith64.cc,v 1.42 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -597,7 +597,7 @@ void BX_CPU_C::INC_EqM(bxInstruction_c *i)
   op1_64++;
   write_RMW_virtual_qword(op1_64);
 
-  SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_INC64);
+  SET_FLAGS_OSZAPC_INC_64(op1_64);
 }
 
 void BX_CPU_C::INC_EqR(bxInstruction_c *i)
@@ -606,7 +606,7 @@ void BX_CPU_C::INC_EqR(bxInstruction_c *i)
   op1_64++;
   BX_WRITE_64BIT_REG(i->rm(), op1_64);
 
-  SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_INC64);
+  SET_FLAGS_OSZAPC_INC_64(op1_64);
 }
 
 void BX_CPU_C::DEC_EqM(bxInstruction_c *i)
@@ -618,7 +618,7 @@ void BX_CPU_C::DEC_EqM(bxInstruction_c *i)
   op1_64--;
   write_RMW_virtual_qword(op1_64);
 
-  SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_DEC64);
+  SET_FLAGS_OSZAPC_DEC_64(op1_64);
 }
 
 void BX_CPU_C::DEC_EqR(bxInstruction_c *i)
@@ -627,7 +627,7 @@ void BX_CPU_C::DEC_EqR(bxInstruction_c *i)
   op1_64--;
   BX_WRITE_64BIT_REG(i->rm(), op1_64);
 
-  SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_DEC64);
+  SET_FLAGS_OSZAPC_DEC_64(op1_64);
 }
 
 void BX_CPU_C::CMPXCHG_EqGqM(bxInstruction_c *i)
diff --git a/bochs/cpu/arith8.cc b/bochs/cpu/arith8.cc
index 896ba362d..f9b994a03 100644
--- a/bochs/cpu/arith8.cc
+++ b/bochs/cpu/arith8.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: arith8.cc,v 1.49 2007-12-01 16:45:16 sshwarts Exp $
+// $Id: arith8.cc,v 1.50 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -525,22 +525,22 @@ void BX_CPU_C::NEG_EbR(bxInstruction_c *i)
 
 void BX_CPU_C::INC_EbM(bxInstruction_c *i)
 {
-  Bit8u op1;
+  Bit8u op1_8;
 
-  read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
-  op1++;
-  write_RMW_virtual_byte(op1);
+  read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
+  op1_8++;
+  write_RMW_virtual_byte(op1_8);
 
-  SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
+  SET_FLAGS_OSZAPC_INC_8(op1_8);
 }
 
 void BX_CPU_C::INC_EbR(bxInstruction_c *i)
 {
-  Bit8u op1 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
-  op1++;
-  BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1);
+  Bit8u op1_8 = BX_READ_8BIT_REGx(i->rm(), i->extend8bitL());
+  op1_8++;
+  BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1_8);
 
-  SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
+  SET_FLAGS_OSZAPC_INC_8(op1_8);
 }
 
 void BX_CPU_C::DEC_EbM(bxInstruction_c *i)
@@ -551,7 +551,7 @@ void BX_CPU_C::DEC_EbM(bxInstruction_c *i)
   op1_8--;
   write_RMW_virtual_byte(op1_8);
 
-  SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
+  SET_FLAGS_OSZAPC_DEC_8(op1_8);
 }
 
 void BX_CPU_C::DEC_EbR(bxInstruction_c *i)
@@ -560,7 +560,7 @@ void BX_CPU_C::DEC_EbR(bxInstruction_c *i)
   op1_8--;
   BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op1_8);
 
-  SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
+  SET_FLAGS_OSZAPC_DEC_8(op1_8);
 }
 
 void BX_CPU_C::CMPXCHG_EbGbM(bxInstruction_c *i)
diff --git a/bochs/cpu/cpu.cc b/bochs/cpu/cpu.cc
index a9edd6493..342d9a8db 100644
--- a/bochs/cpu/cpu.cc
+++ b/bochs/cpu/cpu.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: cpu.cc,v 1.185 2007-12-03 21:43:14 sshwarts Exp $
+// $Id: cpu.cc,v 1.186 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -60,16 +60,16 @@ void flushICaches(void)
 #define InstrumentICACHE 0
 
 #if InstrumentICACHE
-static unsigned iCacheLookups=0;
-static unsigned iCacheMisses=0;
+static Bit32u iCacheLookups=0;
+static Bit32u iCacheMisses=0;
 
-#define InstrICache_StatsMask 0xffffff
+#define InstrICache_StatsMask 0xfffffff
 
 #define InstrICache_Stats() {\
   if ((iCacheLookups & InstrICache_StatsMask) == 0) { \
     BX_INFO(("ICACHE lookups: %u, misses: %u, hit rate = %6.2f%% ", \
-          iCacheLookups, \
-          iCacheMisses,  \
+          (unsigned) iCacheLookups, \
+          (unsigned) iCacheMisses,  \
           (iCacheLookups-iCacheMisses) * 100.0 / iCacheLookups)); \
     iCacheLookups = iCacheMisses = 0; \
   } \
@@ -86,7 +86,6 @@ static unsigned iCacheMisses=0;
 // Make code more tidy with a few macros.
 #if BX_SUPPORT_X86_64==0
 #define RIP EIP
-#define RSP ESP
 #define RCX ECX
 #endif
 
diff --git a/bochs/cpu/cpu.h b/bochs/cpu/cpu.h
index f934a58b2..9668df5c6 100644
--- a/bochs/cpu/cpu.h
+++ b/bochs/cpu/cpu.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: cpu.h,v 1.380 2007-12-03 20:49:24 sshwarts Exp $
+// $Id: cpu.h,v 1.381 2007-12-04 19:27:22 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -1093,11 +1093,9 @@ public: // for now...
   bx_eip_reg_t eip_reg;
 
   // status and control flags register set
-  Bit32u lf_flags_status;
   bx_flags_reg_t eflags;
-
+  Bit32u lf_flags_status;
   bx_lf_flags_entry oszapc;
-  bx_lf_flags_entry oszap;
 
   // so that we can back up when handling faults, exceptions, etc.
   // we need to store the value of the instruction pointer, before
@@ -1282,13 +1280,6 @@ public: // for now...
 
   BX_SMF void setEFlags(Bit32u val) BX_CPP_AttrRegparmN(1);
 
-#define lfMaskCF 0x0000000f
-#define lfMaskPF 0x000000f0
-#define lfMaskAF 0x00000f00
-#define lfMaskZF 0x0000f000
-#define lfMaskSF 0x000f0000
-#define lfMaskOF 0x00f00000
-
 #define ArithmeticalFlag(flag, lfMask, eflagsBitShift) \
   BX_SMF bx_bool get_##flag##Lazy(void); \
   BX_SMF bx_bool getB_##flag(void) { \
@@ -1299,30 +1290,35 @@ public: // for now...
   } \
   BX_SMF bx_bool get_##flag(void) { \
     if ( (BX_CPU_THIS_PTR lf_flags_status & (lfMask)) == 0) \
-      return BX_CPU_THIS_PTR eflags.val32 & (1<<eflagsBitShift); \
+      return BX_CPU_THIS_PTR eflags.val32 & (lfMask); \
     else \
       return get_##flag##Lazy(); \
   } \
   BX_SMF void set_##flag(bx_bool val) { \
     BX_CPU_THIS_PTR lf_flags_status &= ~(lfMask); \
-    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<eflagsBitShift); \
+    BX_CPU_THIS_PTR eflags.val32 &= ~(lfMask); \
     BX_CPU_THIS_PTR eflags.val32 |= ((val)<<eflagsBitShift); \
   } \
   BX_SMF void clear_##flag(void) { \
     BX_CPU_THIS_PTR lf_flags_status &= ~(lfMask); \
-    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<eflagsBitShift); \
+    BX_CPU_THIS_PTR eflags.val32 &= ~(lfMask); \
   } \
   BX_SMF void assert_##flag(void) { \
     BX_CPU_THIS_PTR lf_flags_status &= ~(lfMask); \
-    BX_CPU_THIS_PTR eflags.val32 |= (1<<eflagsBitShift); \
+    BX_CPU_THIS_PTR eflags.val32 |= (lfMask); \
+  } \
+  BX_SMF void force_##flag(void) { \
+    if ( (BX_CPU_THIS_PTR lf_flags_status & (lfMask)) != 0) { \
+      set_##flag(!!get_##flag##Lazy()); \
+    } \
   }
 
-  ArithmeticalFlag(OF, lfMaskOF, 11);
-  ArithmeticalFlag(SF, lfMaskSF,  7);
-  ArithmeticalFlag(ZF, lfMaskZF,  6);
-  ArithmeticalFlag(AF, lfMaskAF,  4);
-  ArithmeticalFlag(PF, lfMaskPF,  2);
-  ArithmeticalFlag(CF, lfMaskCF,  0);
+  ArithmeticalFlag(OF, EFlagsOFMask, 11);
+  ArithmeticalFlag(SF, EFlagsSFMask,  7);
+  ArithmeticalFlag(ZF, EFlagsZFMask,  6);
+  ArithmeticalFlag(AF, EFlagsAFMask,  4);
+  ArithmeticalFlag(PF, EFlagsPFMask,  2);
+  ArithmeticalFlag(CF, EFlagsCFMask,  0);
 
   BX_SMF BX_CPP_INLINE void set_PF_base(Bit8u val);
 
@@ -3532,7 +3528,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   BX_CPU_THIS_PTR oszapc.op2##size = lf_op2; \
   BX_CPU_THIS_PTR oszapc.result##size = lf_result; \
   BX_CPU_THIS_PTR oszapc.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = BX_LF_MASK_OSZAPC; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
 
 #define SET_FLAGS_OSZAPC_8(op1, op2, result, ins) \
@@ -3551,7 +3547,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   BX_CPU_THIS_PTR oszapc.op1##size = lf_op1; \
   BX_CPU_THIS_PTR oszapc.result##size = lf_result; \
   BX_CPU_THIS_PTR oszapc.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = BX_LF_MASK_OSZAPC; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
 
 #define SET_FLAGS_OSZAPC_S1_8(op1, result, ins) \
@@ -3570,7 +3566,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   BX_CPU_THIS_PTR oszapc.op2##size = lf_op2; \
   BX_CPU_THIS_PTR oszapc.result##size = lf_result; \
   BX_CPU_THIS_PTR oszapc.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = BX_LF_MASK_OSZAPC; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
 
 #define SET_FLAGS_OSZAPC_S2_8(op2, result, ins) \
@@ -3589,7 +3585,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   BX_CPU_THIS_PTR oszapc.op1##size = lf_op1; \
   BX_CPU_THIS_PTR oszapc.op2##size = lf_op2; \
   BX_CPU_THIS_PTR oszapc.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = BX_LF_MASK_OSZAPC; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
 
 #define SET_FLAGS_OSZAPC_S1S2_8(op1, op2, ins) \
@@ -3607,7 +3603,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
 #define SET_FLAGS_OSZAPC_RESULT_SIZE(size, lf_result, ins) { \
   BX_CPU_THIS_PTR oszapc.result##size = lf_result; \
   BX_CPU_THIS_PTR oszapc.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = BX_LF_MASK_OSZAPC; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
 
 #define SET_FLAGS_OSZAPC_RESULT_8(result, ins) \
@@ -3625,31 +3621,12 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
 // OSZAP
 // *******************
 
-/* op1, op2, result */
-#define SET_FLAGS_OSZAP_SIZE(size, lf_op1, lf_op2, lf_result, ins) { \
-  BX_CPU_THIS_PTR oszap.op1##size = lf_op1; \
-  BX_CPU_THIS_PTR oszap.op2##size = lf_op2; \
-  BX_CPU_THIS_PTR oszap.result##size = lf_result; \
-  BX_CPU_THIS_PTR oszap.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = (BX_CPU_THIS_PTR lf_flags_status & 0x00000f) | BX_LF_MASK_OSZAP; \
-}
-
-#define SET_FLAGS_OSZAP_8(op1, op2, result, ins) \
-  SET_FLAGS_OSZAP_SIZE(_8, op1, op2, result, ins)
-#define SET_FLAGS_OSZAP_16(op1, op2, result, ins) \
-  SET_FLAGS_OSZAP_SIZE(_16, op1, op2, result, ins)
-#define SET_FLAGS_OSZAP_32(op1, op2, result, ins) \
-  SET_FLAGS_OSZAP_SIZE(_32, op1, op2, result, ins)
-#if BX_SUPPORT_X86_64
-#define SET_FLAGS_OSZAP_64(op1, op2, result, ins) \
-  SET_FLAGS_OSZAP_SIZE(_64, op1, op2, result, ins)
-#endif
-
 /* result only */
 #define SET_FLAGS_OSZAP_RESULT_SIZE(size, lf_result, ins) { \
-  BX_CPU_THIS_PTR oszap.result##size = lf_result; \
-  BX_CPU_THIS_PTR oszap.instr = ins; \
-  BX_CPU_THIS_PTR lf_flags_status = (BX_CPU_THIS_PTR lf_flags_status & 0x00000f) | BX_LF_MASK_OSZAP; \
+  force_CF(); \
+  BX_CPU_THIS_PTR oszapc.result##size = lf_result; \
+  BX_CPU_THIS_PTR oszapc.instr = ins; \
+  BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPMask; \
 }
 
 #define SET_FLAGS_OSZAP_RESULT_8(result, ins) \
@@ -3663,6 +3640,7 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   SET_FLAGS_OSZAP_RESULT_SIZE(_64, result, ins)
 #endif
 
+// transition to new lazy flags code
 #define SET_FLAGS_OSZAPC_LOGIC_8(result_8) \
    SET_FLAGS_OSZAPC_RESULT_8((result_8), BX_INSTR_LOGIC8)
 #define SET_FLAGS_OSZAPC_LOGIC_16(result_16) \
@@ -3696,6 +3674,28 @@ BX_CPP_INLINE void BX_CPU_C::set_PF_base(Bit8u val)
   SET_FLAGS_OSZAPC_64((op1_64), (op2_64), (diff_64), BX_INSTR_SUB64)
 #endif
 
+#define SET_FLAGS_OSZAPC_INC_8(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_8, (result), BX_INSTR_INC8)
+#define SET_FLAGS_OSZAPC_INC_16(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_16, (result), BX_INSTR_INC16)
+#define SET_FLAGS_OSZAPC_INC_32(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_32, (result), BX_INSTR_INC32)
+#if BX_SUPPORT_X86_64
+#define SET_FLAGS_OSZAPC_INC_64(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_64, (result), BX_INSTR_INC64)
+#endif
+
+#define SET_FLAGS_OSZAPC_DEC_8(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_8, (result), BX_INSTR_DEC8)
+#define SET_FLAGS_OSZAPC_DEC_16(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_16, (result), BX_INSTR_DEC16)
+#define SET_FLAGS_OSZAPC_DEC_32(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_32, (result), BX_INSTR_DEC32)
+#if BX_SUPPORT_X86_64
+#define SET_FLAGS_OSZAPC_DEC_64(result) \
+  SET_FLAGS_OSZAP_RESULT_SIZE(_64, (result), BX_INSTR_DEC64)
+#endif
+
 IMPLEMENT_EFLAG_ACCESSOR   (ID,  21)
 IMPLEMENT_EFLAG_ACCESSOR   (VIP, 20)
 IMPLEMENT_EFLAG_ACCESSOR   (VIF, 19)
@@ -3782,12 +3782,6 @@ IMPLEMENT_EFLAG_ACCESSOR   (TF,   8)
   BX_CPU_THIS_PTR lf_flags_status = 0;                   \
 }
 
-#define SET_FLAGS_OxxxxC(new_of, new_cf) {                              \
-    BX_CPU_THIS_PTR eflags.val32 &= ~((1<<11) | (1<<0));                \
-    BX_CPU_THIS_PTR eflags.val32 |= ((!!new_of)<<11) | ((!!new_cf)<<0); \
-    BX_CPU_THIS_PTR lf_flags_status &= 0x0ffff0;                        \
-}
-
 #define ASSERT_FLAGS_OxxxxC() {                                         \
   BX_CPU_THIS_PTR eflags.val32 |= (EFlagsOFMask | EFlagsCFMask);        \
   BX_CPU_THIS_PTR lf_flags_status &= ~(EFlagsOFMask | EFlagsCFMask);    \
diff --git a/bochs/cpu/lazy_flags.cc b/bochs/cpu/lazy_flags.cc
index e7ff4c9c0..e817b0b3d 100644
--- a/bochs/cpu/lazy_flags.cc
+++ b/bochs/cpu/lazy_flags.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: lazy_flags.cc,v 1.38 2007-11-29 21:52:16 sshwarts Exp $
+// $Id: lazy_flags.cc,v 1.39 2007-12-04 19:27:23 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -61,8 +61,6 @@ bx_bool BX_CPU_C::get_CFLazy(void)
 {
   unsigned cf;
 
-  BX_ASSERT((BX_CPU_THIS_PTR lf_flags_status & 0x00000f) == BX_LF_INDEX_OSZAPC);
-
   switch (BX_CPU_THIS_PTR oszapc.instr) {
     case BX_INSTR_ADD8:
       cf = (BX_CPU_THIS_PTR oszapc.result_8 <
@@ -282,7 +280,7 @@ bx_bool BX_CPU_C::get_CFLazy(void)
   }
  
 #if UPDATE_EFLAGS_LAZY
-  BX_CPU_THIS_PTR lf_flags_status &= 0xfffff0;
+  BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsCFMask;
   BX_CPU_THIS_PTR eflags.val32 &= ~(1<<0);
   BX_CPU_THIS_PTR eflags.val32 |= (!!cf)<<0;
 #endif
@@ -293,386 +291,300 @@ bx_bool BX_CPU_C::get_AFLazy(void)
 {
   unsigned af;
 
-  switch ((BX_CPU_THIS_PTR lf_flags_status>>8) & 0x00000f) {
-    case BX_LF_INDEX_OSZAPC:
-      switch (BX_CPU_THIS_PTR oszapc.instr) {
-        case BX_INSTR_ADD8:
-          // restore op1 and fall through into AF calculation
-          BX_CPU_THIS_PTR oszapc.op2_8 =
+  switch (BX_CPU_THIS_PTR oszapc.instr) {
+    case BX_INSTR_ADD8:
+      // restore op1 and fall through into AF calculation
+      BX_CPU_THIS_PTR oszapc.op2_8 =
              BX_CPU_THIS_PTR oszapc.result_8 - BX_CPU_THIS_PTR oszapc.op1_8;
-        case BX_INSTR_ADC8:
-        case BX_INSTR_SUB8:
-        case BX_INSTR_SBB8:
-          af =
-            ((BX_CPU_THIS_PTR oszapc.op1_8 ^
-              BX_CPU_THIS_PTR oszapc.op2_8) ^
+    case BX_INSTR_ADC8:
+    case BX_INSTR_SUB8:
+    case BX_INSTR_SBB8:
+      af = ((BX_CPU_THIS_PTR oszapc.op1_8 ^
+             BX_CPU_THIS_PTR oszapc.op2_8) ^
              BX_CPU_THIS_PTR oszapc.result_8) & 0x10;
-          break;
-        case BX_INSTR_ADD16:
-          // restore op1 and fall through into AF calculation
-          BX_CPU_THIS_PTR oszapc.op2_16 =
+      break;
+    case BX_INSTR_ADD16:
+      // restore op1 and fall through into AF calculation
+      BX_CPU_THIS_PTR oszapc.op2_16 =
              BX_CPU_THIS_PTR oszapc.result_16 - BX_CPU_THIS_PTR oszapc.op1_16;
-        case BX_INSTR_ADC16:
-        case BX_INSTR_SUB16:
-        case BX_INSTR_SBB16:
-          af =
-            ((BX_CPU_THIS_PTR oszapc.op1_16 ^
-              BX_CPU_THIS_PTR oszapc.op2_16) ^
+    case BX_INSTR_ADC16:
+    case BX_INSTR_SUB16:
+    case BX_INSTR_SBB16:
+      af = ((BX_CPU_THIS_PTR oszapc.op1_16 ^
+             BX_CPU_THIS_PTR oszapc.op2_16) ^
              BX_CPU_THIS_PTR oszapc.result_16) & 0x10;
-          break;
-        case BX_INSTR_ADD32:
-          // restore op1 and fall through into AF calculation
-          BX_CPU_THIS_PTR oszapc.op2_32 =
+      break;
+    case BX_INSTR_ADD32:
+      // restore op1 and fall through into AF calculation
+      BX_CPU_THIS_PTR oszapc.op2_32 =
              BX_CPU_THIS_PTR oszapc.result_32 - BX_CPU_THIS_PTR oszapc.op1_32;
-        case BX_INSTR_ADC32:
-        case BX_INSTR_SUB32:
-        case BX_INSTR_SBB32:
-          af =
-            ((BX_CPU_THIS_PTR oszapc.op1_32 ^
-              BX_CPU_THIS_PTR oszapc.op2_32) ^
+    case BX_INSTR_ADC32:
+    case BX_INSTR_SUB32:
+    case BX_INSTR_SBB32:
+      af = ((BX_CPU_THIS_PTR oszapc.op1_32 ^
+             BX_CPU_THIS_PTR oszapc.op2_32) ^
              BX_CPU_THIS_PTR oszapc.result_32) & 0x10;
-          break;
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_ADD64:
-          // restore op1 and fall through into AF calculation
-          BX_CPU_THIS_PTR oszapc.op2_64 =
+    case BX_INSTR_ADD64:
+      // restore op1 and fall through into AF calculation
+      BX_CPU_THIS_PTR oszapc.op2_64 =
              BX_CPU_THIS_PTR oszapc.result_64 - BX_CPU_THIS_PTR oszapc.op1_64;
-        case BX_INSTR_ADC64:
-        case BX_INSTR_SUB64:
-        case BX_INSTR_SBB64:
-          af =
-            ((BX_CPU_THIS_PTR oszapc.op1_64 ^
-              BX_CPU_THIS_PTR oszapc.op2_64) ^
+    case BX_INSTR_ADC64:
+    case BX_INSTR_SUB64:
+    case BX_INSTR_SBB64:
+      af = ((BX_CPU_THIS_PTR oszapc.op1_64 ^
+             BX_CPU_THIS_PTR oszapc.op2_64) ^
              BX_CPU_THIS_PTR oszapc.result_64) & 0x10;
-          break;
+      break;
 #endif
-        case BX_INSTR_NEG8:
-          af = (BX_CPU_THIS_PTR oszapc.result_8 & 0x0f) != 0;
-          break;
-        case BX_INSTR_NEG16:
-          af = (BX_CPU_THIS_PTR oszapc.result_16 & 0x0f) != 0;
-          break;
-        case BX_INSTR_NEG32:
-          af = (BX_CPU_THIS_PTR oszapc.result_32 & 0x0f) != 0;
-          break;
+    case BX_INSTR_NEG8:
+      af = (BX_CPU_THIS_PTR oszapc.result_8 & 0x0f) != 0;
+      break;
+    case BX_INSTR_NEG16:
+      af = (BX_CPU_THIS_PTR oszapc.result_16 & 0x0f) != 0;
+      break;
+    case BX_INSTR_NEG32:
+      af = (BX_CPU_THIS_PTR oszapc.result_32 & 0x0f) != 0;
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_NEG64:
-          af = (BX_CPU_THIS_PTR oszapc.result_64 & 0x0f) != 0;
-          break;
+    case BX_INSTR_NEG64:
+      af = (BX_CPU_THIS_PTR oszapc.result_64 & 0x0f) != 0;
+      break;
 #endif
-        case BX_INSTR_LOGIC8:
-        case BX_INSTR_LOGIC16:
-        case BX_INSTR_LOGIC32:
+    case BX_INSTR_INC8:
+      af = (BX_CPU_THIS_PTR oszapc.result_8 & 0x0f) == 0;
+      break;
+    case BX_INSTR_INC16:
+      af = (BX_CPU_THIS_PTR oszapc.result_16 & 0x0f) == 0;
+      break;
+    case BX_INSTR_INC32:
+      af = (BX_CPU_THIS_PTR oszapc.result_32 & 0x0f) == 0;
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_LOGIC64:
-        case BX_INSTR_SAR64:
-        case BX_INSTR_SHR64:
-        case BX_INSTR_SHRD64:
-        case BX_INSTR_SHL64:
-        case BX_INSTR_IMUL64:
-        case BX_INSTR_MUL64:
+    case BX_INSTR_INC64:
+      af = (BX_CPU_THIS_PTR oszapc.result_64 & 0x0f) == 0;
+      break;
 #endif
-        case BX_INSTR_SAR8:
-        case BX_INSTR_SAR16:
-        case BX_INSTR_SAR32:
-        case BX_INSTR_SHR8:
-        case BX_INSTR_SHR16:
-        case BX_INSTR_SHR32:
-        case BX_INSTR_SHRD16:
-        case BX_INSTR_SHRD32:
-        case BX_INSTR_SHL8:
-        case BX_INSTR_SHL16:
-        case BX_INSTR_SHL32:
-        case BX_INSTR_IMUL8:
-        case BX_INSTR_IMUL16:
-        case BX_INSTR_IMUL32:
-        case BX_INSTR_MUL8:
-        case BX_INSTR_MUL16:
-        case BX_INSTR_MUL32:
-          af = 0;
-          break;
-        default:
-          af = 0; // Keep compiler quiet.
-          BX_PANIC(("get_AF: OSZAPC: unknown instr %u",
-            (unsigned) BX_CPU_THIS_PTR oszapc.instr));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
-#endif
-      return(af);
-
-    case BX_LF_INDEX_OSZAP:
-      switch (BX_CPU_THIS_PTR oszap.instr) {
-        case BX_INSTR_INC8:
-          af = (BX_CPU_THIS_PTR oszap.result_8 & 0x0f) == 0;
-          break;
-        case BX_INSTR_INC16:
-          af = (BX_CPU_THIS_PTR oszap.result_16 & 0x0f) == 0;
-          break;
-        case BX_INSTR_INC32:
-          af = (BX_CPU_THIS_PTR oszap.result_32 & 0x0f) == 0;
-          break;
+    case BX_INSTR_DEC8:
+      af = (BX_CPU_THIS_PTR oszapc.result_8 & 0x0f) == 0x0f;
+      break;
+    case BX_INSTR_DEC16:
+      af = (BX_CPU_THIS_PTR oszapc.result_16 & 0x0f) == 0x0f;
+      break;
+    case BX_INSTR_DEC32:
+      af = (BX_CPU_THIS_PTR oszapc.result_32 & 0x0f) == 0x0f;
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_INC64:
-          af = (BX_CPU_THIS_PTR oszap.result_64 & 0x0f) == 0;
-          break;
+    case BX_INSTR_DEC64:
+      af = (BX_CPU_THIS_PTR oszapc.result_64 & 0x0f) == 0x0f;
+      break;
 #endif
-        case BX_INSTR_DEC8:
-          af = (BX_CPU_THIS_PTR oszap.result_8 & 0x0f) == 0x0f;
-          break;
-        case BX_INSTR_DEC16:
-          af = (BX_CPU_THIS_PTR oszap.result_16 & 0x0f) == 0x0f;
-          break;
-        case BX_INSTR_DEC32:
-          af = (BX_CPU_THIS_PTR oszap.result_32 & 0x0f) == 0x0f;
-          break;
+    case BX_INSTR_LOGIC8:
+    case BX_INSTR_LOGIC16:
+    case BX_INSTR_LOGIC32:
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_DEC64:
-          af = (BX_CPU_THIS_PTR oszap.result_64 & 0x0f) == 0x0f;
-          break;
+    case BX_INSTR_LOGIC64:
+    case BX_INSTR_SAR64:
+    case BX_INSTR_SHR64:
+    case BX_INSTR_SHRD64:
+    case BX_INSTR_SHL64:
+    case BX_INSTR_IMUL64:
+    case BX_INSTR_MUL64:
 #endif
-        default:
-          af = 0; // Keep compiler quiet.
-          BX_PANIC(("get_AF: OSZAP: unknown instr %u",
-            (unsigned) BX_CPU_THIS_PTR oszap.instr));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
-#endif
-      return(af);
-
+    case BX_INSTR_SAR8:
+    case BX_INSTR_SAR16:
+    case BX_INSTR_SAR32:
+    case BX_INSTR_SHR8:
+    case BX_INSTR_SHR16:
+    case BX_INSTR_SHR32:
+    case BX_INSTR_SHRD16:
+    case BX_INSTR_SHRD32:
+    case BX_INSTR_SHL8:
+    case BX_INSTR_SHL16:
+    case BX_INSTR_SHL32:
+    case BX_INSTR_IMUL8:
+    case BX_INSTR_IMUL16:
+    case BX_INSTR_IMUL32:
+    case BX_INSTR_MUL8:
+    case BX_INSTR_MUL16:
+    case BX_INSTR_MUL32:
+      af = 0;
+      break;
     default:
-      BX_PANIC(("get_AF: unknown case"));
-      return(0);
-  }
+      af = 0; // Keep compiler quiet.
+      BX_PANIC(("get_AF: OSZAPC: unknown instr %u", (unsigned) BX_CPU_THIS_PTR oszapc.instr));
+    }
+#if UPDATE_EFLAGS_LAZY
+    BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsAFMask;
+    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
+    BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
+#endif
+    return(af);
 }
 
 bx_bool BX_CPU_C::get_ZFLazy(void)
 {
   unsigned zf;
 
-  switch ((BX_CPU_THIS_PTR lf_flags_status>>12) & 0x00000f) {
-    case BX_LF_INDEX_OSZAPC:
-      switch (BX_CPU_THIS_PTR oszapc.instr) {
-        case BX_INSTR_LOGIC8:
-        case BX_INSTR_ADD8:
-        case BX_INSTR_ADC8:
-        case BX_INSTR_SUB8:
-        case BX_INSTR_SBB8:
-        case BX_INSTR_NEG8:
-        case BX_INSTR_SAR8:
-        case BX_INSTR_SHR8:
-        case BX_INSTR_SHL8:
-        case BX_INSTR_IMUL8:
-        case BX_INSTR_MUL8:
-          zf = (BX_CPU_THIS_PTR oszapc.result_8 == 0);
-          break;
-        case BX_INSTR_LOGIC16:
-        case BX_INSTR_ADD16:
-        case BX_INSTR_ADC16:
-        case BX_INSTR_SUB16:
-        case BX_INSTR_SBB16:
-        case BX_INSTR_NEG16:
-        case BX_INSTR_SAR16:
-        case BX_INSTR_SHR16:
-        case BX_INSTR_SHRD16:
-        case BX_INSTR_SHL16:
-        case BX_INSTR_IMUL16:
-        case BX_INSTR_MUL16:
-          zf = (BX_CPU_THIS_PTR oszapc.result_16 == 0);
-          break;
-        case BX_INSTR_LOGIC32:
-        case BX_INSTR_ADD32:
-        case BX_INSTR_ADC32:
-        case BX_INSTR_SUB32:
-        case BX_INSTR_SBB32:
-        case BX_INSTR_NEG32:
-        case BX_INSTR_SAR32:
-        case BX_INSTR_SHR32:
-        case BX_INSTR_SHRD32:
-        case BX_INSTR_SHL32:
-        case BX_INSTR_IMUL32:
-        case BX_INSTR_MUL32:
-          zf = (BX_CPU_THIS_PTR oszapc.result_32 == 0);
-          break;
+  switch (BX_CPU_THIS_PTR oszapc.instr) {
+    case BX_INSTR_LOGIC8:
+    case BX_INSTR_ADD8:
+    case BX_INSTR_ADC8:
+    case BX_INSTR_SUB8:
+    case BX_INSTR_SBB8:
+    case BX_INSTR_NEG8:
+    case BX_INSTR_SAR8:
+    case BX_INSTR_SHR8:
+    case BX_INSTR_SHL8:
+    case BX_INSTR_IMUL8:
+    case BX_INSTR_MUL8:
+    case BX_INSTR_INC8:
+    case BX_INSTR_DEC8:
+      zf = (BX_CPU_THIS_PTR oszapc.result_8 == 0);
+      break;
+    case BX_INSTR_LOGIC16:
+    case BX_INSTR_ADD16:
+    case BX_INSTR_ADC16:
+    case BX_INSTR_SUB16:
+    case BX_INSTR_SBB16:
+    case BX_INSTR_NEG16:
+    case BX_INSTR_SAR16:
+    case BX_INSTR_SHR16:
+    case BX_INSTR_SHRD16:
+    case BX_INSTR_SHL16:
+    case BX_INSTR_IMUL16:
+    case BX_INSTR_MUL16:
+    case BX_INSTR_INC16:
+    case BX_INSTR_DEC16:
+      zf = (BX_CPU_THIS_PTR oszapc.result_16 == 0);
+      break;
+    case BX_INSTR_LOGIC32:
+    case BX_INSTR_ADD32:
+    case BX_INSTR_ADC32:
+    case BX_INSTR_SUB32:
+    case BX_INSTR_SBB32:
+    case BX_INSTR_NEG32:
+    case BX_INSTR_SAR32:
+    case BX_INSTR_SHR32:
+    case BX_INSTR_SHRD32:
+    case BX_INSTR_SHL32:
+    case BX_INSTR_IMUL32:
+    case BX_INSTR_MUL32:
+    case BX_INSTR_INC32:
+    case BX_INSTR_DEC32:
+      zf = (BX_CPU_THIS_PTR oszapc.result_32 == 0);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_LOGIC64:
-        case BX_INSTR_ADD64:
-        case BX_INSTR_ADC64:
-        case BX_INSTR_SUB64:
-        case BX_INSTR_SBB64:
-        case BX_INSTR_NEG64:
-        case BX_INSTR_SAR64:
-        case BX_INSTR_SHR64:
-        case BX_INSTR_SHRD64:
-        case BX_INSTR_SHL64:
-        case BX_INSTR_IMUL64:
-        case BX_INSTR_MUL64:
-          zf = (BX_CPU_THIS_PTR oszapc.result_64 == 0);
-          break;
+    case BX_INSTR_LOGIC64:
+    case BX_INSTR_ADD64:
+    case BX_INSTR_ADC64:
+    case BX_INSTR_SUB64:
+    case BX_INSTR_SBB64:
+    case BX_INSTR_NEG64:
+    case BX_INSTR_SAR64:
+    case BX_INSTR_SHR64:
+    case BX_INSTR_SHRD64:
+    case BX_INSTR_SHL64:
+    case BX_INSTR_IMUL64:
+    case BX_INSTR_MUL64:
+    case BX_INSTR_INC64:
+    case BX_INSTR_DEC64:
+      zf = (BX_CPU_THIS_PTR oszapc.result_64 == 0);
+      break;
 #endif
-        default:
-          zf = 0;
-          BX_PANIC(("get_ZF: OSZAPC: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
-      BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
-#endif
-      return(zf);
-
-    case BX_LF_INDEX_OSZAP:
-      switch (BX_CPU_THIS_PTR oszap.instr) {
-        case BX_INSTR_INC8:
-        case BX_INSTR_DEC8:
-          zf = (BX_CPU_THIS_PTR oszap.result_8 == 0);
-          break;
-        case BX_INSTR_INC16:
-        case BX_INSTR_DEC16:
-          zf = (BX_CPU_THIS_PTR oszap.result_16 == 0);
-          break;
-        case BX_INSTR_INC32:
-        case BX_INSTR_DEC32:
-          zf = (BX_CPU_THIS_PTR oszap.result_32 == 0);
-          break;
-#if BX_SUPPORT_X86_64
-        case BX_INSTR_INC64:
-        case BX_INSTR_DEC64:
-          zf = (BX_CPU_THIS_PTR oszap.result_64 == 0);
-          break;
-#endif
-        default:
-          zf = 0;
-          BX_PANIC(("get_ZF: OSZAP: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
-      BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
-#endif
-      return(zf);
-
     default:
-      BX_PANIC(("get_ZF: unknown case"));
-      return(0);
-  }
+      zf = 0;
+      BX_PANIC(("get_ZF: OSZAPC: unknown instr"));
+    }
+#if UPDATE_EFLAGS_LAZY
+    BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsZFMask;
+    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
+    BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
+#endif
+    return(zf);
 }
 
 bx_bool BX_CPU_C::get_SFLazy(void)
 {
   unsigned sf;
 
-  switch ((BX_CPU_THIS_PTR lf_flags_status>>16) & 0x00000f) {
-    case BX_LF_INDEX_OSZAPC:
-      switch (BX_CPU_THIS_PTR oszapc.instr) {
-        case BX_INSTR_LOGIC8:
-        case BX_INSTR_ADD8:
-        case BX_INSTR_ADC8:
-        case BX_INSTR_SUB8:
-        case BX_INSTR_SBB8:
-        case BX_INSTR_NEG8:
-        case BX_INSTR_SAR8:
-        case BX_INSTR_SHR8:
-        case BX_INSTR_SHL8:
-        case BX_INSTR_IMUL8:
-        case BX_INSTR_MUL8:
-          sf = (BX_CPU_THIS_PTR oszapc.result_8 >= 0x80);
-          break;
-        case BX_INSTR_LOGIC16:
-        case BX_INSTR_ADD16:
-        case BX_INSTR_ADC16:
-        case BX_INSTR_SUB16:
-        case BX_INSTR_SBB16:
-        case BX_INSTR_NEG16:
-        case BX_INSTR_SAR16:
-        case BX_INSTR_SHR16:
-        case BX_INSTR_SHRD16:
-        case BX_INSTR_SHL16:
-        case BX_INSTR_IMUL16:
-        case BX_INSTR_MUL16:
-          sf = (BX_CPU_THIS_PTR oszapc.result_16 >= 0x8000);
-          break;
-        case BX_INSTR_LOGIC32:
-        case BX_INSTR_ADD32:
-        case BX_INSTR_ADC32:
-        case BX_INSTR_SUB32:
-        case BX_INSTR_SBB32:
-        case BX_INSTR_NEG32:
-        case BX_INSTR_SAR32:
-        case BX_INSTR_SHR32:
-        case BX_INSTR_SHRD32:
-        case BX_INSTR_SHL32:
-        case BX_INSTR_IMUL32:
-        case BX_INSTR_MUL32:
-          sf = (BX_CPU_THIS_PTR oszapc.result_32 >= 0x80000000);
-          break;
+  switch (BX_CPU_THIS_PTR oszapc.instr) {
+    case BX_INSTR_LOGIC8:
+    case BX_INSTR_ADD8:
+    case BX_INSTR_ADC8:
+    case BX_INSTR_SUB8:
+    case BX_INSTR_SBB8:
+    case BX_INSTR_NEG8:
+    case BX_INSTR_SAR8:
+    case BX_INSTR_SHR8:
+    case BX_INSTR_SHL8:
+    case BX_INSTR_IMUL8:
+    case BX_INSTR_MUL8:
+    case BX_INSTR_INC8:
+    case BX_INSTR_DEC8:
+      sf = (BX_CPU_THIS_PTR oszapc.result_8 >= 0x80);
+      break;
+    case BX_INSTR_LOGIC16:
+    case BX_INSTR_ADD16:
+    case BX_INSTR_ADC16:
+    case BX_INSTR_SUB16:
+    case BX_INSTR_SBB16:
+    case BX_INSTR_NEG16:
+    case BX_INSTR_SAR16:
+    case BX_INSTR_SHR16:
+    case BX_INSTR_SHRD16:
+    case BX_INSTR_SHL16:
+    case BX_INSTR_IMUL16:
+    case BX_INSTR_MUL16:
+    case BX_INSTR_INC16:
+    case BX_INSTR_DEC16:
+      sf = (BX_CPU_THIS_PTR oszapc.result_16 >= 0x8000);
+      break;
+    case BX_INSTR_LOGIC32:
+    case BX_INSTR_ADD32:
+    case BX_INSTR_ADC32:
+    case BX_INSTR_SUB32:
+    case BX_INSTR_SBB32:
+    case BX_INSTR_NEG32:
+    case BX_INSTR_SAR32:
+    case BX_INSTR_SHR32:
+    case BX_INSTR_SHRD32:
+    case BX_INSTR_SHL32:
+    case BX_INSTR_IMUL32:
+    case BX_INSTR_MUL32:
+    case BX_INSTR_INC32:
+    case BX_INSTR_DEC32:
+      sf = (BX_CPU_THIS_PTR oszapc.result_32 >= 0x80000000);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_LOGIC64:
-        case BX_INSTR_ADD64:
-        case BX_INSTR_ADC64:
-        case BX_INSTR_SUB64:
-        case BX_INSTR_SBB64:
-        case BX_INSTR_NEG64:
-        case BX_INSTR_SAR64:
-        case BX_INSTR_SHR64:
-        case BX_INSTR_SHRD64:
-        case BX_INSTR_SHL64:
-        case BX_INSTR_IMUL64:
-        case BX_INSTR_MUL64:
-          sf = (BX_CPU_THIS_PTR oszapc.result_64 >= BX_CONST64(0x8000000000000000));
-          break;
+    case BX_INSTR_LOGIC64:
+    case BX_INSTR_ADD64:
+    case BX_INSTR_ADC64:
+    case BX_INSTR_SUB64:
+    case BX_INSTR_SBB64:
+    case BX_INSTR_NEG64:
+    case BX_INSTR_SAR64:
+    case BX_INSTR_SHR64:
+    case BX_INSTR_SHRD64:
+    case BX_INSTR_SHL64:
+    case BX_INSTR_IMUL64:
+    case BX_INSTR_MUL64:
+    case BX_INSTR_INC64:
+    case BX_INSTR_DEC64:
+      sf = (BX_CPU_THIS_PTR oszapc.result_64 >= BX_CONST64(0x8000000000000000));
+      break;
 #endif
-        default:
-          sf = 0; // Keep compiler quiet.
-          BX_PANIC(("get_SF: OSZAPC: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
-#endif
-      return(sf);
-
-    case BX_LF_INDEX_OSZAP:
-      switch (BX_CPU_THIS_PTR oszap.instr) {
-        case BX_INSTR_INC8:
-        case BX_INSTR_DEC8:
-          sf = (BX_CPU_THIS_PTR oszap.result_8 >= 0x80);
-          break;
-        case BX_INSTR_INC16:
-        case BX_INSTR_DEC16:
-          sf = (BX_CPU_THIS_PTR oszap.result_16 >= 0x8000);
-          break;
-        case BX_INSTR_INC32:
-        case BX_INSTR_DEC32:
-          sf = (BX_CPU_THIS_PTR oszap.result_32 >= 0x80000000);
-          break;
-#if BX_SUPPORT_X86_64
-        case BX_INSTR_INC64:
-        case BX_INSTR_DEC64:
-          sf = (BX_CPU_THIS_PTR oszap.result_64 >= BX_CONST64(0x8000000000000000));
-          break;
-#endif
-        default:
-          sf = 0; // Keep compiler quiet.
-          BX_PANIC(("get_SF: OSZAP: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
-#endif
-      return(sf);
-
     default:
-      BX_PANIC(("get_SF: unknown case"));
-      return(0);
-  }
+      sf = 0; // Keep compiler quiet.
+      BX_PANIC(("get_SF: OSZAPC: unknown instr"));
+    }
+#if UPDATE_EFLAGS_LAZY
+    BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsSFMask;
+    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
+    BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
+#endif
+    return(sf);
 }
 
 #define GET_ADD_OVERFLOW(op1, op2, result, mask) \
@@ -685,378 +597,318 @@ bx_bool BX_CPU_C::get_OFLazy(void)
 {
   unsigned of;
 
-  switch ((BX_CPU_THIS_PTR lf_flags_status>>20) & 0x00000f) {
-    case BX_LF_INDEX_OSZAPC:
-      switch (BX_CPU_THIS_PTR oszapc.instr) {
-        case BX_INSTR_ADD8:
-          // restore op1 and fall through into OF calculation
-          BX_CPU_THIS_PTR oszapc.op2_8 =
+  switch (BX_CPU_THIS_PTR oszapc.instr) {
+    case BX_INSTR_ADD8:
+      // restore op1 and fall through into OF calculation
+      BX_CPU_THIS_PTR oszapc.op2_8 =
              BX_CPU_THIS_PTR oszapc.result_8 - BX_CPU_THIS_PTR oszapc.op1_8;
-        case BX_INSTR_ADC8:
-          of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8, BX_CPU_THIS_PTR oszapc.op2_8,
-                                BX_CPU_THIS_PTR oszapc.result_8, 0x80);
-          break;
-        case BX_INSTR_ADD16:
-          // restore op1 and fall through into OF calculation
-          BX_CPU_THIS_PTR oszapc.op2_16 =
+    case BX_INSTR_ADC8:
+      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8, BX_CPU_THIS_PTR oszapc.op2_8,
+                            BX_CPU_THIS_PTR oszapc.result_8, 0x80);
+      break;
+    case BX_INSTR_ADD16:
+      // restore op1 and fall through into OF calculation
+      BX_CPU_THIS_PTR oszapc.op2_16 =
              BX_CPU_THIS_PTR oszapc.result_16 - BX_CPU_THIS_PTR oszapc.op1_16;
-        case BX_INSTR_ADC16:
-          of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16, BX_CPU_THIS_PTR oszapc.op2_16,
-                                BX_CPU_THIS_PTR oszapc.result_16, 0x8000);
-          break;
-        case BX_INSTR_ADD32:
-          // restore op1 and fall through into OF calculation
-          BX_CPU_THIS_PTR oszapc.op2_32 =
+    case BX_INSTR_ADC16:
+      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16, BX_CPU_THIS_PTR oszapc.op2_16,
+                            BX_CPU_THIS_PTR oszapc.result_16, 0x8000);
+      break;
+    case BX_INSTR_ADD32:
+      // restore op1 and fall through into OF calculation
+      BX_CPU_THIS_PTR oszapc.op2_32 =
              BX_CPU_THIS_PTR oszapc.result_32 - BX_CPU_THIS_PTR oszapc.op1_32;
-        case BX_INSTR_ADC32:
-          of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32, BX_CPU_THIS_PTR oszapc.op2_32,
-                                BX_CPU_THIS_PTR oszapc.result_32, 0x80000000);
-          break;
+    case BX_INSTR_ADC32:
+      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32, BX_CPU_THIS_PTR oszapc.op2_32,
+                            BX_CPU_THIS_PTR oszapc.result_32, 0x80000000);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_ADD64:
-          // restore op1 and fall through into OF calculation
-          BX_CPU_THIS_PTR oszapc.op2_64 =
+    case BX_INSTR_ADD64:
+      // restore op1 and fall through into OF calculation
+      BX_CPU_THIS_PTR oszapc.op2_64 =
              BX_CPU_THIS_PTR oszapc.result_64 - BX_CPU_THIS_PTR oszapc.op1_64;
-        case BX_INSTR_ADC64:
-          of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64, BX_CPU_THIS_PTR oszapc.op2_64,
-                                BX_CPU_THIS_PTR oszapc.result_64, BX_CONST64(0x8000000000000000));
-          break;
+    case BX_INSTR_ADC64:
+      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64, BX_CPU_THIS_PTR oszapc.op2_64,
+                            BX_CPU_THIS_PTR oszapc.result_64, BX_CONST64(0x8000000000000000));
+      break;
 #endif
-        case BX_INSTR_SUB8:
-        case BX_INSTR_SBB8:
-          of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8, BX_CPU_THIS_PTR oszapc.op2_8,
-                                BX_CPU_THIS_PTR oszapc.result_8, 0x80);
-          break;
-        case BX_INSTR_SUB16:
-        case BX_INSTR_SBB16:
-          of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16, BX_CPU_THIS_PTR oszapc.op2_16,
-                                BX_CPU_THIS_PTR oszapc.result_16, 0x8000);
-          break;
-        case BX_INSTR_SUB32:
-        case BX_INSTR_SBB32:
-          of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32, BX_CPU_THIS_PTR oszapc.op2_32,
-                                BX_CPU_THIS_PTR oszapc.result_32, 0x80000000);
-          break;
+    case BX_INSTR_SUB8:
+    case BX_INSTR_SBB8:
+      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8, BX_CPU_THIS_PTR oszapc.op2_8,
+                            BX_CPU_THIS_PTR oszapc.result_8, 0x80);
+      break;
+    case BX_INSTR_SUB16:
+    case BX_INSTR_SBB16:
+      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16, BX_CPU_THIS_PTR oszapc.op2_16,
+                            BX_CPU_THIS_PTR oszapc.result_16, 0x8000);
+      break;
+    case BX_INSTR_SUB32:
+    case BX_INSTR_SBB32:
+      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32, BX_CPU_THIS_PTR oszapc.op2_32,
+                            BX_CPU_THIS_PTR oszapc.result_32, 0x80000000);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_SUB64:
-        case BX_INSTR_SBB64:
-          of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64, BX_CPU_THIS_PTR oszapc.op2_64,
-                                BX_CPU_THIS_PTR oszapc.result_64, BX_CONST64(0x8000000000000000));
-          break;
+    case BX_INSTR_SUB64:
+    case BX_INSTR_SBB64:
+      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64, BX_CPU_THIS_PTR oszapc.op2_64,
+                            BX_CPU_THIS_PTR oszapc.result_64, BX_CONST64(0x8000000000000000));
+      break;
 #endif
-        case BX_INSTR_NEG8:
-          of = (BX_CPU_THIS_PTR oszapc.result_8 == 0x80);
-          break;
-        case BX_INSTR_NEG16:
-          of = (BX_CPU_THIS_PTR oszapc.result_16 == 0x8000);
-          break;
-        case BX_INSTR_NEG32:
-          of = (BX_CPU_THIS_PTR oszapc.result_32 == 0x80000000);
-          break;
+    case BX_INSTR_LOGIC8:
+    case BX_INSTR_LOGIC16:
+    case BX_INSTR_LOGIC32:
+    case BX_INSTR_SAR8:
+    case BX_INSTR_SAR16:
+    case BX_INSTR_SAR32:
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_NEG64:
-          of = (BX_CPU_THIS_PTR oszapc.result_64 == BX_CONST64(0x8000000000000000));
-          break;
+    case BX_INSTR_LOGIC64:
+    case BX_INSTR_SAR64:
 #endif
-        case BX_INSTR_LOGIC8:
-        case BX_INSTR_LOGIC16:
-        case BX_INSTR_LOGIC32:
-        case BX_INSTR_SAR8:
-        case BX_INSTR_SAR16:
-        case BX_INSTR_SAR32:
+      of = 0;
+      break;
+    case BX_INSTR_SHR8:
+      if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
+        of = (BX_CPU_THIS_PTR oszapc.op1_8 >= 0x80);
+      else
+        of = 0; /* undocumented, but hardware really does it */
+      break;
+    case BX_INSTR_SHR16:
+      if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
+        of = (BX_CPU_THIS_PTR oszapc.op1_16 >= 0x8000);
+      else
+        of = 0; /* undocumented, but hardware really does it */
+      break;
+    case BX_INSTR_SHR32:
+      if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
+        of = (BX_CPU_THIS_PTR oszapc.op1_32 >= 0x80000000);
+      else
+        of = 0; /* undocumented, but hardware really does it */
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_LOGIC64:
-        case BX_INSTR_SAR64:
+    case BX_INSTR_SHR64:
+      if (BX_CPU_THIS_PTR oszapc.op2_64 == 1)
+        of = (BX_CPU_THIS_PTR oszapc.op1_64 >= BX_CONST64(0x8000000000000000));
+      else
+        of = 0; /* undocumented, but hardware really does it */
+      break;
 #endif
-          of = 0;
-          break;
-        case BX_INSTR_SHR8:
-          if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
-            of = (BX_CPU_THIS_PTR oszapc.op1_8 >= 0x80);
-          else
-            of = 0; /* undocumented, but hardware really does it */
-          break;
-        case BX_INSTR_SHR16:
-          if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
-            of = (BX_CPU_THIS_PTR oszapc.op1_16 >= 0x8000);
-          else
-            of = 0; /* undocumented, but hardware really does it */
-          break;
-        case BX_INSTR_SHR32:
-          if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
-            of = (BX_CPU_THIS_PTR oszapc.op1_32 >= 0x80000000);
-          else
-            of = 0; /* undocumented, but hardware really does it */
-          break;
+    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_SHR64:
-          if (BX_CPU_THIS_PTR oszapc.op2_64 == 1)
-            of = (BX_CPU_THIS_PTR oszapc.op1_64 >= BX_CONST64(0x8000000000000000));
-          else
-            of = 0; /* undocumented, but hardware really does it */
-          break;
+    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
-        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
-        case BX_INSTR_SHL8:
-          if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
-            of = ((BX_CPU_THIS_PTR oszapc.op1_8 ^
-                BX_CPU_THIS_PTR oszapc.result_8) & 0x80) > 0;
-          else
-            of = (((BX_CPU_THIS_PTR oszapc.op1_8 <<
+    case BX_INSTR_SHL8:
+      if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
+        of = ((BX_CPU_THIS_PTR oszapc.op1_8 ^
+               BX_CPU_THIS_PTR oszapc.result_8) & 0x80) > 0;
+      else
+        of = (((BX_CPU_THIS_PTR oszapc.op1_8 <<
                    (BX_CPU_THIS_PTR oszapc.op2_8 - 1)) ^
                       BX_CPU_THIS_PTR oszapc.result_8) & 0x80) > 0;
-          break;
-        case BX_INSTR_SHL16:
-          if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
-            of = ((BX_CPU_THIS_PTR oszapc.op1_16 ^
-                BX_CPU_THIS_PTR oszapc.result_16) & 0x8000) > 0;
-          else
-            of = (((BX_CPU_THIS_PTR oszapc.op1_16 <<
+      break;
+    case BX_INSTR_SHL16:
+      if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
+        of = ((BX_CPU_THIS_PTR oszapc.op1_16 ^
+               BX_CPU_THIS_PTR oszapc.result_16) & 0x8000) > 0;
+      else
+        of = (((BX_CPU_THIS_PTR oszapc.op1_16 <<
                    (BX_CPU_THIS_PTR oszapc.op2_16 - 1)) ^
                       BX_CPU_THIS_PTR oszapc.result_16) & 0x8000) > 0;
-          break;
-        case BX_INSTR_SHL32:
-          if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
-            of = ((BX_CPU_THIS_PTR oszapc.op1_32 ^
-                BX_CPU_THIS_PTR oszapc.result_32) & 0x80000000) > 0;
-          else
-            of = (((BX_CPU_THIS_PTR oszapc.op1_32 <<
+      break;
+    case BX_INSTR_SHL32:
+      if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
+        of = ((BX_CPU_THIS_PTR oszapc.op1_32 ^
+               BX_CPU_THIS_PTR oszapc.result_32) & 0x80000000) > 0;
+      else
+        of = (((BX_CPU_THIS_PTR oszapc.op1_32 <<
                    (BX_CPU_THIS_PTR oszapc.op2_32 - 1)) ^
                       BX_CPU_THIS_PTR oszapc.result_32) & 0x80000000) > 0;
-          break;
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_SHL64:
-          if (BX_CPU_THIS_PTR oszapc.op2_64 == 1)
-            of = ((BX_CPU_THIS_PTR oszapc.op1_64 ^
-                BX_CPU_THIS_PTR oszapc.result_64) & BX_CONST64(0x8000000000000000)) > 0;
-          else
-            of = (((BX_CPU_THIS_PTR oszapc.op1_64 <<
+    case BX_INSTR_SHL64:
+      if (BX_CPU_THIS_PTR oszapc.op2_64 == 1)
+        of = ((BX_CPU_THIS_PTR oszapc.op1_64 ^
+               BX_CPU_THIS_PTR oszapc.result_64) & BX_CONST64(0x8000000000000000)) > 0;
+      else
+        of = (((BX_CPU_THIS_PTR oszapc.op1_64 <<
                    (BX_CPU_THIS_PTR oszapc.op2_64 - 1)) ^
                       BX_CPU_THIS_PTR oszapc.result_64) & BX_CONST64(0x8000000000000000)) > 0;
-          break;
+      break;
 #endif
-        case BX_INSTR_IMUL8:
-          of = ! ((BX_CPU_THIS_PTR oszapc.result_8 < 0x80 &&
-                   BX_CPU_THIS_PTR oszapc.op2_8 == 0) ||
-                ((BX_CPU_THIS_PTR oszapc.result_8 & 0x80) && 
-                  BX_CPU_THIS_PTR oszapc.op2_8 == 0xff));
-          break;
-        case BX_INSTR_IMUL16:
-          of = ! ((BX_CPU_THIS_PTR oszapc.result_16 < 0x8000 &&
-                   BX_CPU_THIS_PTR oszapc.op2_16 == 0) ||
-                ((BX_CPU_THIS_PTR oszapc.result_16 & 0x8000) && 
-                  BX_CPU_THIS_PTR oszapc.op2_16 == 0xffff));
-          break;
-        case BX_INSTR_IMUL32:
-          of = ! ((BX_CPU_THIS_PTR oszapc.result_32 < 0x80000000 &&
-                   BX_CPU_THIS_PTR oszapc.op2_32 == 0) ||
-                ((BX_CPU_THIS_PTR oszapc.result_32 & 0x80000000) && 
-                  BX_CPU_THIS_PTR oszapc.op2_32 == 0xffffffff));
-          break;
+    case BX_INSTR_IMUL8:
+      of = ! ((BX_CPU_THIS_PTR oszapc.result_8 < 0x80 &&
+               BX_CPU_THIS_PTR oszapc.op2_8 == 0) ||
+             ((BX_CPU_THIS_PTR oszapc.result_8 & 0x80) && 
+               BX_CPU_THIS_PTR oszapc.op2_8 == 0xff));
+      break;
+    case BX_INSTR_IMUL16:
+      of = ! ((BX_CPU_THIS_PTR oszapc.result_16 < 0x8000 &&
+               BX_CPU_THIS_PTR oszapc.op2_16 == 0) ||
+             ((BX_CPU_THIS_PTR oszapc.result_16 & 0x8000) && 
+               BX_CPU_THIS_PTR oszapc.op2_16 == 0xffff));
+      break;
+    case BX_INSTR_IMUL32:
+      of = ! ((BX_CPU_THIS_PTR oszapc.result_32 < 0x80000000 &&
+               BX_CPU_THIS_PTR oszapc.op2_32 == 0) ||
+             ((BX_CPU_THIS_PTR oszapc.result_32 & 0x80000000) && 
+               BX_CPU_THIS_PTR oszapc.op2_32 == 0xffffffff));
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_IMUL64:
-          of = ! ((BX_CPU_THIS_PTR oszapc.result_64 < BX_CONST64(0x8000000000000000) &&
-                   BX_CPU_THIS_PTR oszapc.op2_64 == 0) ||
-                ((BX_CPU_THIS_PTR oszapc.result_64 & BX_CONST64(0x8000000000000000)) && 
-                  BX_CPU_THIS_PTR oszapc.op2_64 == BX_CONST64(0xffffffffffffffff)));
-          break;
+    case BX_INSTR_IMUL64:
+      of = ! ((BX_CPU_THIS_PTR oszapc.result_64 < BX_CONST64(0x8000000000000000) &&
+               BX_CPU_THIS_PTR oszapc.op2_64 == 0) ||
+             ((BX_CPU_THIS_PTR oszapc.result_64 & BX_CONST64(0x8000000000000000)) && 
+               BX_CPU_THIS_PTR oszapc.op2_64 == BX_CONST64(0xffffffffffffffff)));
+      break;
 #endif
-        case BX_INSTR_MUL8:
-          of = (BX_CPU_THIS_PTR oszapc.op2_8 != 0);
-          break;
-        case BX_INSTR_MUL16:
-          of = (BX_CPU_THIS_PTR oszapc.op2_16 != 0);
-          break;
-        case BX_INSTR_MUL32:
-          of = (BX_CPU_THIS_PTR oszapc.op2_32 != 0);
-          break;
+    case BX_INSTR_MUL8:
+      of = (BX_CPU_THIS_PTR oszapc.op2_8 != 0);
+      break;
+    case BX_INSTR_MUL16:
+      of = (BX_CPU_THIS_PTR oszapc.op2_16 != 0);
+      break;
+    case BX_INSTR_MUL32:
+      of = (BX_CPU_THIS_PTR oszapc.op2_32 != 0);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_MUL64:
-          of = (BX_CPU_THIS_PTR oszapc.op2_64 != 0);
-          break;
+    case BX_INSTR_MUL64:
+      of = (BX_CPU_THIS_PTR oszapc.op2_64 != 0);
+      break;
 #endif
-        default:
-          of = 0; // Keep compiler happy.
-          BX_PANIC(("get_OF: OSZAPC: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
-#endif
-      return(of);
-
-    case BX_LF_INDEX_OSZAP:
-      switch (BX_CPU_THIS_PTR oszap.instr) {
-        case BX_INSTR_INC8:
-          of = (BX_CPU_THIS_PTR oszap.result_8 == 0x80);
-          break;
-        case BX_INSTR_INC16:
-          of = (BX_CPU_THIS_PTR oszap.result_16 == 0x8000);
-          break;
-        case BX_INSTR_INC32:
-          of = (BX_CPU_THIS_PTR oszap.result_32 == 0x80000000);
-          break;
+    case BX_INSTR_NEG8:
+    case BX_INSTR_INC8:
+      of = (BX_CPU_THIS_PTR oszapc.result_8 == 0x80);
+      break;
+    case BX_INSTR_NEG16:
+    case BX_INSTR_INC16:
+      of = (BX_CPU_THIS_PTR oszapc.result_16 == 0x8000);
+      break;
+    case BX_INSTR_NEG32:
+    case BX_INSTR_INC32:
+      of = (BX_CPU_THIS_PTR oszapc.result_32 == 0x80000000);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_INC64:
-          of = (BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x8000000000000000));
-          break;
+    case BX_INSTR_NEG64:
+    case BX_INSTR_INC64:
+      of = (BX_CPU_THIS_PTR oszapc.result_64 == BX_CONST64(0x8000000000000000));
+      break;
 #endif
-        case BX_INSTR_DEC8:
-          of = (BX_CPU_THIS_PTR oszap.result_8 == 0x7F);
-          break;
-        case BX_INSTR_DEC16:
-          of = (BX_CPU_THIS_PTR oszap.result_16 == 0x7FFF);
-          break;
-        case BX_INSTR_DEC32:
-          of = (BX_CPU_THIS_PTR oszap.result_32 == 0x7FFFFFFF);
-          break;
+    case BX_INSTR_DEC8:
+      of = (BX_CPU_THIS_PTR oszapc.result_8 == 0x7F);
+      break;
+    case BX_INSTR_DEC16:
+      of = (BX_CPU_THIS_PTR oszapc.result_16 == 0x7FFF);
+      break;
+    case BX_INSTR_DEC32:
+      of = (BX_CPU_THIS_PTR oszapc.result_32 == 0x7FFFFFFF);
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_DEC64:
-          of = (BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x7FFFFFFFFFFFFFFF));
-          break;
+    case BX_INSTR_DEC64:
+      of = (BX_CPU_THIS_PTR oszapc.result_64 == BX_CONST64(0x7FFFFFFFFFFFFFFF));
+      break;
 #endif
-        default:
-          of = 0; // Keep compiler happy.
-          BX_PANIC(("get_OF: OSZAP: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
-      BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
-#endif
-      return(of);
-
     default:
-      BX_PANIC(("get_OF: unknown case"));
-      return(0);
-  }
+      of = 0; // Keep compiler happy.
+      BX_PANIC(("get_OF: OSZAPC: unknown instr"));
+    }
+#if UPDATE_EFLAGS_LAZY
+    BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsOFMask;
+    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
+    BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
+#endif
+    return(of);
 }
 
 bx_bool BX_CPU_C::get_PFLazy(void)
 {
   unsigned pf;
 
-  switch ((BX_CPU_THIS_PTR lf_flags_status>>4) & 0x00000f) {
-    case BX_LF_INDEX_OSZAPC:
-      switch (BX_CPU_THIS_PTR oszapc.instr) {
-        case BX_INSTR_LOGIC8:
-        case BX_INSTR_ADD8:
-        case BX_INSTR_ADC8:
-        case BX_INSTR_SUB8:
-        case BX_INSTR_SBB8:
-        case BX_INSTR_NEG8:
-        case BX_INSTR_SAR8:
-        case BX_INSTR_SHR8:
-        case BX_INSTR_SHL8:
-        case BX_INSTR_IMUL8:
-        case BX_INSTR_MUL8:
-          pf = bx_parity_lookup[BX_CPU_THIS_PTR oszapc.result_8];
-          break;
-        case BX_INSTR_LOGIC16:
-        case BX_INSTR_ADD16:
-        case BX_INSTR_ADC16:
-        case BX_INSTR_SUB16:
-        case BX_INSTR_SBB16:
-        case BX_INSTR_NEG16:
-        case BX_INSTR_SAR16:
-        case BX_INSTR_SHR16:
-        case BX_INSTR_SHRD16:
-        case BX_INSTR_SHL16:
-        case BX_INSTR_IMUL16:
-        case BX_INSTR_MUL16:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_16];
-          break;
-        case BX_INSTR_LOGIC32:
-        case BX_INSTR_ADD32:
-        case BX_INSTR_ADC32:
-        case BX_INSTR_SUB32:
-        case BX_INSTR_SBB32:
-        case BX_INSTR_NEG32:
-        case BX_INSTR_SAR32:
-        case BX_INSTR_SHR32:
-        case BX_INSTR_SHRD32:
-        case BX_INSTR_SHL32:
-        case BX_INSTR_IMUL32:
-        case BX_INSTR_MUL32:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_32];
-          break;
+  switch (BX_CPU_THIS_PTR oszapc.instr) {
+    case BX_INSTR_LOGIC8:
+    case BX_INSTR_ADD8:
+    case BX_INSTR_ADC8:
+    case BX_INSTR_SUB8:
+    case BX_INSTR_SBB8:
+    case BX_INSTR_NEG8:
+    case BX_INSTR_SAR8:
+    case BX_INSTR_SHR8:
+    case BX_INSTR_SHL8:
+    case BX_INSTR_IMUL8:
+    case BX_INSTR_MUL8:
+    case BX_INSTR_INC8:
+    case BX_INSTR_DEC8:
+      pf = bx_parity_lookup[BX_CPU_THIS_PTR oszapc.result_8];
+      break;
+    case BX_INSTR_LOGIC16:
+    case BX_INSTR_ADD16:
+    case BX_INSTR_ADC16:
+    case BX_INSTR_SUB16:
+    case BX_INSTR_SBB16:
+    case BX_INSTR_NEG16:
+    case BX_INSTR_SAR16:
+    case BX_INSTR_SHR16:
+    case BX_INSTR_SHRD16:
+    case BX_INSTR_SHL16:
+    case BX_INSTR_IMUL16:
+    case BX_INSTR_MUL16:
+    case BX_INSTR_INC16:
+    case BX_INSTR_DEC16:
+      pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_16];
+      break;
+    case BX_INSTR_LOGIC32:
+    case BX_INSTR_ADD32:
+    case BX_INSTR_ADC32:
+    case BX_INSTR_SUB32:
+    case BX_INSTR_SBB32:
+    case BX_INSTR_NEG32:
+    case BX_INSTR_SAR32:
+    case BX_INSTR_SHR32:
+    case BX_INSTR_SHRD32:
+    case BX_INSTR_SHL32:
+    case BX_INSTR_IMUL32:
+    case BX_INSTR_MUL32:
+    case BX_INSTR_INC32:
+    case BX_INSTR_DEC32:
+      pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_32];
+      break;
 #if BX_SUPPORT_X86_64
-        case BX_INSTR_LOGIC64:
-        case BX_INSTR_ADD64:
-        case BX_INSTR_ADC64:
-        case BX_INSTR_SUB64:
-        case BX_INSTR_SBB64:
-        case BX_INSTR_NEG64:
-        case BX_INSTR_SAR64:
-        case BX_INSTR_SHR64:
-        case BX_INSTR_SHRD64:
-        case BX_INSTR_SHL64:
-        case BX_INSTR_IMUL64:
-        case BX_INSTR_MUL64:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_64];
-          break;
+    case BX_INSTR_LOGIC64:
+    case BX_INSTR_ADD64:
+    case BX_INSTR_ADC64:
+    case BX_INSTR_SUB64:
+    case BX_INSTR_SBB64:
+    case BX_INSTR_NEG64:
+    case BX_INSTR_SAR64:
+    case BX_INSTR_SHR64:
+    case BX_INSTR_SHRD64:
+    case BX_INSTR_SHL64:
+    case BX_INSTR_IMUL64:
+    case BX_INSTR_MUL64:
+    case BX_INSTR_INC64:
+    case BX_INSTR_DEC64:
+      pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_64];
+      break;
 #endif
-        default:
-          pf = 0; // Keep compiler quiet.
-          BX_PANIC(("get_PF: OSZAPC: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
-      BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here
-#endif
-      return(pf);
-
-    case BX_LF_INDEX_OSZAP:
-      switch (BX_CPU_THIS_PTR oszap.instr) {
-        case BX_INSTR_INC8:
-        case BX_INSTR_DEC8:
-          pf = bx_parity_lookup[BX_CPU_THIS_PTR oszap.result_8];
-          break;
-        case BX_INSTR_INC16:
-        case BX_INSTR_DEC16:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszap.result_16];
-          break;
-        case BX_INSTR_INC32:
-        case BX_INSTR_DEC32:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszap.result_32];
-          break;
-#if BX_SUPPORT_X86_64
-        case BX_INSTR_INC64:
-        case BX_INSTR_DEC64:
-          pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszap.result_64];
-          break;
-#endif
-        default:
-          pf = 0; // Keep compiler quiet.
-          BX_PANIC(("get_PF: OSZAP: unknown instr"));
-      }
-#if UPDATE_EFLAGS_LAZY
-      BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
-      BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
-      BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here
-#endif
-      return(pf);
-
     default:
-      BX_PANIC(("get_PF: unknown case"));
-      return(0);
-  }
+      pf = 0; // Keep compiler quiet.
+      BX_PANIC(("get_PF: OSZAPC: unknown instr"));
+    }
+#if UPDATE_EFLAGS_LAZY
+    BX_CPU_THIS_PTR lf_flags_status &= ~EFlagsPFMask;
+    BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
+    BX_CPU_THIS_PTR eflags.val32 |= (pf)<<2; // pf is always 0 or 1 here
+#endif
+    return(pf);
 }
diff --git a/bochs/cpu/lazy_flags.h b/bochs/cpu/lazy_flags.h
index 427822e0f..e25bd6292 100644
--- a/bochs/cpu/lazy_flags.h
+++ b/bochs/cpu/lazy_flags.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: lazy_flags.h,v 1.25 2007-11-29 21:52:16 sshwarts Exp $
+// $Id: lazy_flags.h,v 1.26 2007-12-04 19:27:23 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -109,11 +109,13 @@
 #define BX_INSTR_IMUL32         55
 #define BX_INSTR_IMUL64         56
 
-#define BX_LF_INDEX_OSZAPC  1
-#define BX_LF_INDEX_OSZAP   2
-
-#define BX_LF_MASK_OSZAPC 0x111111
-#define BX_LF_MASK_OSZAP  0x222220
+#if BX_SUPPORT_X86_64
+  #define BX_LF_SIGN_BIT  63
+  #define BX_LF_SIGN_MASK BX_CONST64(0x8000000000000000)
+#else
+  #define BX_LF_SIGN_BIT  31
+  #define BX_LF_SIGN_MASK 0x80000000
+#endif
 
 typedef struct {
   Bit8u op1_8;