mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
605b88ec2f
Bochs/bochs/cpu/lazy_flags.cc

1039 lines
32 KiB
C++
Raw Normal View History

- add RCS Id to header of every file. This makes it easier to know what's going on when someone sends in a modified file.
2001-10-03 17:10:38 +04:00
/////////////////////////////////////////////////////////////////////////
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
// $Id: lazy_flags.cc,v 1.11 2002-10-04 17:04:33 kevinlawton Exp $
- add RCS Id to header of every file. This makes it easier to know what's going on when someone sends in a modified file.
2001-10-03 17:10:38 +04:00
/////////////////////////////////////////////////////////////////////////
//
- update copyright dates to 2001 for all mandrake headers - for bochs files with other header, replaced with current mandrake header
2001-04-10 06:20:02 +04:00
// Copyright (C) 2001 MandrakeSoft S.A.
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
//
// MandrakeSoft S.A.
// 43, rue d'Aboukir
// 75002 Paris - France
// http://www.linux-mandrake.com/
// http://www.mandrakesoft.com/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- parts of the SMP merge apparantly broke the debugger and this revision tries to fix it. The shortcuts to register names such as AX and DL are #defines in cpu/cpu.h, and they are defined in terms of BX_CPU_THIS_PTR. When BX_USE_CPU_SMF=1, this works fine. (This is what bochs used for a long time, and nobody used the SMF=0 mode at all.) To make SMP bochs work, I had to get SMF=0 mode working for the CPU so that there could be an array of cpus. When SMF=0 for the CPU, BX_CPU_THIS_PTR is defined to be "this->" which only works within methods of BX_CPU_C. Code outside of BX_CPU_C must reference BX_CPU(num) instead. - to try to enforce the correct use of AL/AX/DL/etc. shortcuts, they are now only #defined when "NEED_CPU_REG_SHORTCUTS" is #defined. This is only done in the cpu/*.cc code.
2001-05-24 22:46:34 +04:00
#define NEED_CPU_REG_SHORTCUTS 1
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#include "bochs.h"
merge in BRANCH-io-cleanup. To see the commit logs for this use either cvsweb or cvs update -r BRANCH-io-cleanup and then 'cvs log' the various files. In general this provides a generic interface for logging. logfunctions:: is a class that is inherited by some classes, and also . allocated as a standalone global called 'genlog'. All logging uses . one of the ::info(), ::error(), ::ldebug(), ::panic() methods of this . class through 'BX_INFO(), BX_ERROR(), BX_DEBUG(), BX_PANIC()' macros . respectively. . . An example usage: . BX_INFO(("Hello, World!\n")); iofunctions:: is a class that is allocated once by default, and assigned as the iofunction of each logfunctions instance. It is this class that maintains the file descriptor and other output related code, at this point using vfprintf(). At some future point, someone may choose to write a gui 'console' for bochs to which messages would be redirected simply by assigning a different iofunction class to the various logfunctions objects. More cleanup is coming, but this works for now. If you want to see alot of debugging output, in main.cc, change onoff[LOGLEV_DEBUG]=0 to =1. Comments, bugs, flames, to me: todd@fries.net
2001-05-15 18:49:57 +04:00
#define LOG_THIS BX_CPU_THIS_PTR
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_CFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned cf;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
switch ( BX_CPU_THIS_PTR lf_flags_status & 0x00000f ) {
case BX_LF_INDEX_OSZAPC:
switch (BX_CPU_THIS_PTR oszapc.instr) {
case BX_INSTR_ADD8:
case BX_INSTR_XADD8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.result_8 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op1_8);
break;
case BX_INSTR_ADD16:
case BX_INSTR_XADD16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.result_16 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op1_16);
break;
case BX_INSTR_ADD32:
case BX_INSTR_XADD32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.result_32 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op1_32);
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_XADD64:
cf = (BX_CPU_THIS_PTR oszapc.result_64 <
BX_CPU_THIS_PTR oszapc.op1_64);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_ADC8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.result_8 <
BX_CPU_THIS_PTR oszapc.op1_8) ||
(BX_CPU_THIS_PTR oszapc.prev_CF &&
BX_CPU_THIS_PTR oszapc.result_8 ==
BX_CPU_THIS_PTR oszapc.op1_8);
break;
case BX_INSTR_ADC16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.result_16 <
BX_CPU_THIS_PTR oszapc.op1_16) ||
(BX_CPU_THIS_PTR oszapc.prev_CF &&
BX_CPU_THIS_PTR oszapc.result_16 ==
BX_CPU_THIS_PTR oszapc.op1_16);
break;
case BX_INSTR_ADC32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.result_32 <
BX_CPU_THIS_PTR oszapc.op1_32) ||
(BX_CPU_THIS_PTR oszapc.prev_CF &&
BX_CPU_THIS_PTR oszapc.result_32 ==
BX_CPU_THIS_PTR oszapc.op1_32);
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADC64:
cf =
(BX_CPU_THIS_PTR oszapc.result_64 <
BX_CPU_THIS_PTR oszapc.op1_64) ||
(BX_CPU_THIS_PTR oszapc.prev_CF &&
BX_CPU_THIS_PTR oszapc.result_64 ==
BX_CPU_THIS_PTR oszapc.op1_64);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_SUB8:
case BX_INSTR_CMP8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.op1_8 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op2_8);
break;
case BX_INSTR_SUB16:
case BX_INSTR_CMP16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.op1_16 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op2_16);
break;
case BX_INSTR_SUB32:
case BX_INSTR_CMP32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = (BX_CPU_THIS_PTR oszapc.op1_32 <
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.op2_32);
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_SUB64:
case BX_INSTR_CMP64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
cf = (BX_CPU_THIS_PTR oszapc.op1_64 <
BX_CPU_THIS_PTR oszapc.op2_64);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_SBB8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_8 <
BX_CPU_THIS_PTR oszapc.result_8) ||
((BX_CPU_THIS_PTR oszapc.op2_8==0xff) &&
BX_CPU_THIS_PTR oszapc.prev_CF);
break;
case BX_INSTR_SBB16:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_16 <
BX_CPU_THIS_PTR oszapc.result_16) ||
((BX_CPU_THIS_PTR oszapc.op2_16==0xffff) &&
BX_CPU_THIS_PTR oszapc.prev_CF);
break;
case BX_INSTR_SBB32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_32 <
BX_CPU_THIS_PTR oszapc.result_32) ||
((BX_CPU_THIS_PTR oszapc.op2_32==0xffffffff) &&
BX_CPU_THIS_PTR oszapc.prev_CF);
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_SBB64:
cf =
(BX_CPU_THIS_PTR oszapc.op1_64 <
BX_CPU_THIS_PTR oszapc.result_64) ||
((BX_CPU_THIS_PTR oszapc.op2_64==BX_CONST64(0xffffffffffffffff)) &&
BX_CPU_THIS_PTR oszapc.prev_CF);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_NEG8:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
cf = BX_CPU_THIS_PTR oszapc.op1_8 != 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG16:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
cf = BX_CPU_THIS_PTR oszapc.op1_16 != 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
cf = BX_CPU_THIS_PTR oszapc.op1_32 != 0;
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_NEG64:
cf = BX_CPU_THIS_PTR oszapc.op1_64 != 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_OR8:
case BX_INSTR_OR16:
case BX_INSTR_OR32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_AND8:
case BX_INSTR_AND16:
case BX_INSTR_AND32:
case BX_INSTR_TEST8:
case BX_INSTR_TEST16:
case BX_INSTR_TEST32:
case BX_INSTR_XOR8:
case BX_INSTR_XOR16:
case BX_INSTR_XOR32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHR8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_8 >>
(BX_CPU_THIS_PTR oszapc.op2_8 - 1)) & 0x01;
break;
case BX_INSTR_SHR16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_16 >>
(BX_CPU_THIS_PTR oszapc.op2_16 - 1)) & 0x01;
break;
case BX_INSTR_SHR32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_32 >>
(BX_CPU_THIS_PTR oszapc.op2_32 - 1)) & 0x01;
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_SHR64:
cf =
(BX_CPU_THIS_PTR oszapc.op1_64 >>
(BX_CPU_THIS_PTR oszapc.op2_64 - 1)) & 0x01;
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_SHL8:
if (BX_CPU_THIS_PTR oszapc.op2_8 <= 8) {
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_8 >>
(8 - BX_CPU_THIS_PTR oszapc.op2_8)) & 0x01;
}
else {
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
break;
case BX_INSTR_SHL16:
if (BX_CPU_THIS_PTR oszapc.op2_16 <= 16) {
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_16 >>
(16 - BX_CPU_THIS_PTR oszapc.op2_16)) & 0x01;
}
else {
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
break;
case BX_INSTR_SHL32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(BX_CPU_THIS_PTR oszapc.op1_32 >>
(32 - BX_CPU_THIS_PTR oszapc.op2_32)) & 0x01;
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_SHL64:
cf =
(BX_CPU_THIS_PTR oszapc.op1_64 >>
(32 - BX_CPU_THIS_PTR oszapc.op2_64)) & 0x01;
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
cf = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_CF: OSZAPC: unknown instr %u",
merge in BRANCH-io-cleanup. To see the commit logs for this use either cvsweb or cvs update -r BRANCH-io-cleanup and then 'cvs log' the various files. In general this provides a generic interface for logging. logfunctions:: is a class that is inherited by some classes, and also . allocated as a standalone global called 'genlog'. All logging uses . one of the ::info(), ::error(), ::ldebug(), ::panic() methods of this . class through 'BX_INFO(), BX_ERROR(), BX_DEBUG(), BX_PANIC()' macros . respectively. . . An example usage: . BX_INFO(("Hello, World!\n")); iofunctions:: is a class that is allocated once by default, and assigned as the iofunction of each logfunctions instance. It is this class that maintains the file descriptor and other output related code, at this point using vfprintf(). At some future point, someone may choose to write a gui 'console' for bochs to which messages would be redirected simply by assigning a different iofunction class to the various logfunctions objects. More cleanup is coming, but this works for now. If you want to see alot of debugging output, in main.cc, change onoff[LOGLEV_DEBUG]=0 to =1. Comments, bugs, flames, to me: todd@fries.net
2001-05-15 18:49:57 +04:00
(unsigned) BX_CPU_THIS_PTR oszapc.instr));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xfffff0;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<0);
BX_CPU_THIS_PTR eflags.val32 |= (!!cf)<<0;
return(cf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_CF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_AFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned af;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
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:
case BX_INSTR_ADC8:
case BX_INSTR_SUB8:
case BX_INSTR_SBB8:
case BX_INSTR_CMP8:
case BX_INSTR_XADD8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
((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:
case BX_INSTR_ADC16:
case BX_INSTR_SUB16:
case BX_INSTR_SBB16:
case BX_INSTR_CMP16:
case BX_INSTR_XADD16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
((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:
case BX_INSTR_ADC32:
case BX_INSTR_SUB32:
case BX_INSTR_SBB32:
case BX_INSTR_CMP32:
case BX_INSTR_XADD32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af =
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
((BX_CPU_THIS_PTR oszapc.op1_32 ^
BX_CPU_THIS_PTR oszapc.op2_32) ^
BX_CPU_THIS_PTR oszapc.result_32) & 0x10;
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_ADC64:
case BX_INSTR_SUB64:
case BX_INSTR_SBB64:
case BX_INSTR_CMP64:
case BX_INSTR_XADD64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af =
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
((BX_CPU_THIS_PTR oszapc.op1_64 ^
BX_CPU_THIS_PTR oszapc.op2_64) ^
BX_CPU_THIS_PTR oszapc.result_64) & 0x10;
break;
#endif
case BX_INSTR_NEG8:
af = (BX_CPU_THIS_PTR oszapc.op1_8 & 0x0f) > 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG16:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
af = (BX_CPU_THIS_PTR oszapc.op1_16 & 0x0f) > 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
af = (BX_CPU_THIS_PTR oszapc.op1_32 & 0x0f) > 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_NEG64:
af = (BX_CPU_THIS_PTR oszapc.op1_64 & 0x0f) > 0;
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_OR8:
case BX_INSTR_OR16:
case BX_INSTR_OR32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
case BX_INSTR_SHR64:
case BX_INSTR_SHL64:
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_AND8:
case BX_INSTR_AND16:
case BX_INSTR_AND32:
case BX_INSTR_TEST8:
case BX_INSTR_TEST16:
case BX_INSTR_TEST32:
case BX_INSTR_XOR8:
case BX_INSTR_XOR16:
case BX_INSTR_XOR32:
case BX_INSTR_SHR8:
case BX_INSTR_SHR16:
case BX_INSTR_SHR32:
case BX_INSTR_SHL8:
case BX_INSTR_SHL16:
case BX_INSTR_SHL32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af = 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
/* undefined */
break;
default:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_AF: OSZAPC: unknown instr %u",
merge in BRANCH-io-cleanup. To see the commit logs for this use either cvsweb or cvs update -r BRANCH-io-cleanup and then 'cvs log' the various files. In general this provides a generic interface for logging. logfunctions:: is a class that is inherited by some classes, and also . allocated as a standalone global called 'genlog'. All logging uses . one of the ::info(), ::error(), ::ldebug(), ::panic() methods of this . class through 'BX_INFO(), BX_ERROR(), BX_DEBUG(), BX_PANIC()' macros . respectively. . . An example usage: . BX_INFO(("Hello, World!\n")); iofunctions:: is a class that is allocated once by default, and assigned as the iofunction of each logfunctions instance. It is this class that maintains the file descriptor and other output related code, at this point using vfprintf(). At some future point, someone may choose to write a gui 'console' for bochs to which messages would be redirected simply by assigning a different iofunction class to the various logfunctions objects. More cleanup is coming, but this works for now. If you want to see alot of debugging output, in main.cc, change onoff[LOGLEV_DEBUG]=0 to =1. Comments, bugs, flames, to me: todd@fries.net
2001-05-15 18:49:57 +04:00
(unsigned) BX_CPU_THIS_PTR oszapc.instr));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
return(af);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
af = (BX_CPU_THIS_PTR oszap.result_8 & 0x0f) == 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC16:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
af = (BX_CPU_THIS_PTR oszap.result_16 & 0x0f) == 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC32:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_32 & 0x0f) == 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_INC64:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_64 & 0x0f) == 0;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_DEC8:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_8 & 0x0f) == 0x0f;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_DEC16:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_16 & 0x0f) == 0x0f;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_DEC32:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_32 & 0x0f) == 0x0f;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_DEC64:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
af = (BX_CPU_THIS_PTR oszap.result_64 & 0x0f) == 0x0f;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
af = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_AF: OSZAP: unknown instr %u",
merge in BRANCH-io-cleanup. To see the commit logs for this use either cvsweb or cvs update -r BRANCH-io-cleanup and then 'cvs log' the various files. In general this provides a generic interface for logging. logfunctions:: is a class that is inherited by some classes, and also . allocated as a standalone global called 'genlog'. All logging uses . one of the ::info(), ::error(), ::ldebug(), ::panic() methods of this . class through 'BX_INFO(), BX_ERROR(), BX_DEBUG(), BX_PANIC()' macros . respectively. . . An example usage: . BX_INFO(("Hello, World!\n")); iofunctions:: is a class that is allocated once by default, and assigned as the iofunction of each logfunctions instance. It is this class that maintains the file descriptor and other output related code, at this point using vfprintf(). At some future point, someone may choose to write a gui 'console' for bochs to which messages would be redirected simply by assigning a different iofunction class to the various logfunctions objects. More cleanup is coming, but this works for now. If you want to see alot of debugging output, in main.cc, change onoff[LOGLEV_DEBUG]=0 to =1. Comments, bugs, flames, to me: todd@fries.net
2001-05-15 18:49:57 +04:00
(unsigned) BX_CPU_THIS_PTR oszap.instr));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xfff0ff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<4);
BX_CPU_THIS_PTR eflags.val32 |= (!!af)<<4;
return(af);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_AF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_ZFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned zf;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
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_ADD8:
case BX_INSTR_ADC8:
case BX_INSTR_SUB8:
case BX_INSTR_SBB8:
case BX_INSTR_CMP8:
case BX_INSTR_NEG8:
case BX_INSTR_XADD8:
case BX_INSTR_OR8:
case BX_INSTR_AND8:
case BX_INSTR_TEST8:
case BX_INSTR_XOR8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
case BX_INSTR_SHR8:
case BX_INSTR_SHL8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszapc.result_8 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD16:
case BX_INSTR_ADC16:
case BX_INSTR_SUB16:
case BX_INSTR_SBB16:
case BX_INSTR_CMP16:
case BX_INSTR_NEG16:
case BX_INSTR_XADD16:
case BX_INSTR_OR16:
case BX_INSTR_AND16:
case BX_INSTR_TEST16:
case BX_INSTR_XOR16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
case BX_INSTR_SHR16:
case BX_INSTR_SHL16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszapc.result_16 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD32:
case BX_INSTR_ADC32:
case BX_INSTR_SUB32:
case BX_INSTR_SBB32:
case BX_INSTR_CMP32:
case BX_INSTR_NEG32:
case BX_INSTR_XADD32:
case BX_INSTR_OR32:
case BX_INSTR_AND32:
case BX_INSTR_TEST32:
case BX_INSTR_XOR32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
case BX_INSTR_SHR32:
case BX_INSTR_SHL32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszapc.result_32 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_ADC64:
case BX_INSTR_SUB64:
case BX_INSTR_SBB64:
case BX_INSTR_CMP64:
case BX_INSTR_NEG64:
case BX_INSTR_XADD64:
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
case BX_INSTR_SHR64:
case BX_INSTR_SHL64:
zf = (BX_CPU_THIS_PTR oszapc.result_64 == 0);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = 0;
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_ZF: OSZAPC: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
Changed eflags accessors for get_?F() to use (val32 & (1<<N)) instead of (1 & (val32>>N)), and added a getB_?F() accessor for special cases which need a strict binary value (exactly 0 or 1). Most code only needed a value for logical comparison. I modified the special cases which do need a binary number for shifting and comparison between flags, to use the special getB_?F() accessor. Cleaned up memory.cc functions a little, now that all accesses are within a single page. Fixed a (not very likely encountered) bug in fetchdecode.cc (and fetchdecode64.cc) where a 2-byte opcode starting with a prefix starts at the last offset on a page. There were no checks on the segment overrides for a boundary condition. I added them. The eflags enhancements added just a tiny bit of performance.
2002-09-22 22:22:24 +04:00
BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
return(zf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8:
case BX_INSTR_DEC8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszap.result_8 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC16:
case BX_INSTR_DEC16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszap.result_16 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC32:
case BX_INSTR_DEC32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
zf = (BX_CPU_THIS_PTR oszap.result_32 == 0);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_INC64:
case BX_INSTR_DEC64:
zf = (BX_CPU_THIS_PTR oszap.result_64 == 0);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
zf = 0;
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_ZF: OSZAP: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xff0fff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<6);
Changed eflags accessors for get_?F() to use (val32 & (1<<N)) instead of (1 & (val32>>N)), and added a getB_?F() accessor for special cases which need a strict binary value (exactly 0 or 1). Most code only needed a value for logical comparison. I modified the special cases which do need a binary number for shifting and comparison between flags, to use the special getB_?F() accessor. Cleaned up memory.cc functions a little, now that all accesses are within a single page. Fixed a (not very likely encountered) bug in fetchdecode.cc (and fetchdecode64.cc) where a 2-byte opcode starting with a prefix starts at the last offset on a page. There were no checks on the segment overrides for a boundary condition. I added them. The eflags enhancements added just a tiny bit of performance.
2002-09-22 22:22:24 +04:00
BX_CPU_THIS_PTR eflags.val32 |= zf<<6; // zf always exactly 0 or 1.
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
return(zf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_ZF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_SFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned sf;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
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_ADD8:
case BX_INSTR_ADC8:
case BX_INSTR_SUB8:
case BX_INSTR_SBB8:
case BX_INSTR_CMP8:
case BX_INSTR_NEG8:
case BX_INSTR_XADD8:
case BX_INSTR_OR8:
case BX_INSTR_AND8:
case BX_INSTR_TEST8:
case BX_INSTR_XOR8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
case BX_INSTR_SHR8:
case BX_INSTR_SHL8:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
sf = (BX_CPU_THIS_PTR oszapc.result_8 >= 0x80);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD16:
case BX_INSTR_ADC16:
case BX_INSTR_SUB16:
case BX_INSTR_SBB16:
case BX_INSTR_CMP16:
case BX_INSTR_NEG16:
case BX_INSTR_XADD16:
case BX_INSTR_OR16:
case BX_INSTR_AND16:
case BX_INSTR_TEST16:
case BX_INSTR_XOR16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
case BX_INSTR_SHR16:
case BX_INSTR_SHL16:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
sf = (BX_CPU_THIS_PTR oszapc.result_16 >= 0x8000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD32:
case BX_INSTR_ADC32:
case BX_INSTR_SUB32:
case BX_INSTR_SBB32:
case BX_INSTR_CMP32:
case BX_INSTR_NEG32:
case BX_INSTR_XADD32:
case BX_INSTR_OR32:
case BX_INSTR_AND32:
case BX_INSTR_TEST32:
case BX_INSTR_XOR32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
case BX_INSTR_SHR32:
case BX_INSTR_SHL32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
sf = (BX_CPU_THIS_PTR oszapc.result_32 >= 0x80000000);
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_ADC64:
case BX_INSTR_SUB64:
case BX_INSTR_SBB64:
case BX_INSTR_CMP64:
case BX_INSTR_NEG64:
case BX_INSTR_XADD64:
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
case BX_INSTR_SHR64:
case BX_INSTR_SHL64:
sf = (BX_CPU_THIS_PTR oszapc.result_64 >= BX_CONST64(0x8000000000000000));
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
sf = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_SF: OSZAPC: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
return(sf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8:
case BX_INSTR_DEC8:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
sf = (BX_CPU_THIS_PTR oszap.result_8 >= 0x80);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC16:
case BX_INSTR_DEC16:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
sf = (BX_CPU_THIS_PTR oszap.result_16 >= 0x8000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC32:
case BX_INSTR_DEC32:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
sf = (BX_CPU_THIS_PTR oszap.result_32 >= 0x80000000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_INC64:
case BX_INSTR_DEC64:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
sf = (BX_CPU_THIS_PTR oszap.result_64 >= BX_CONST64(0x8000000000000000));
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
sf = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_SF: OSZAP: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xf0ffff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<7);
BX_CPU_THIS_PTR eflags.val32 |= (!!sf)<<7;
return(sf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_SF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_OFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
Bit8u op1_b7, op2_b7, result_b7;
Bit16u op1_b15, op2_b15, result_b15;
Bit32u op1_b31, op2_b31, result_b31;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
Bit64u op1_b63, op2_b63, result_b63;
#endif
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned of;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
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:
case BX_INSTR_ADC8:
case BX_INSTR_XADD8:
op1_b7 = BX_CPU_THIS_PTR oszapc.op1_8 & 0x80;
op2_b7 = BX_CPU_THIS_PTR oszapc.op2_8 & 0x80;
result_b7 = BX_CPU_THIS_PTR oszapc.result_8 & 0x80;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b7 == op2_b7) && (result_b7 ^ op2_b7);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD16:
case BX_INSTR_ADC16:
case BX_INSTR_XADD16:
op1_b15 = BX_CPU_THIS_PTR oszapc.op1_16 & 0x8000;
op2_b15 = BX_CPU_THIS_PTR oszapc.op2_16 & 0x8000;
result_b15 = BX_CPU_THIS_PTR oszapc.result_16 & 0x8000;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b15 == op2_b15) && (result_b15 ^ op2_b15);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD32:
case BX_INSTR_ADC32:
case BX_INSTR_XADD32:
op1_b31 = BX_CPU_THIS_PTR oszapc.op1_32 & 0x80000000;
op2_b31 = BX_CPU_THIS_PTR oszapc.op2_32 & 0x80000000;
result_b31 = BX_CPU_THIS_PTR oszapc.result_32 & 0x80000000;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b31 == op2_b31) && (result_b31 ^ op2_b31);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_ADC64:
case BX_INSTR_XADD64:
op1_b63 = BX_CPU_THIS_PTR oszapc.op1_64 & BX_CONST64(0x8000000000000000);
op2_b63 = BX_CPU_THIS_PTR oszapc.op2_64 & BX_CONST64(0x8000000000000000);
result_b63 = BX_CPU_THIS_PTR oszapc.result_64 & BX_CONST64(0x8000000000000000);
of = (op1_b63 == op2_b63) && (result_b63 ^ op2_b63);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_SUB8:
case BX_INSTR_SBB8:
case BX_INSTR_CMP8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
op1_b7 = BX_CPU_THIS_PTR oszapc.op1_8 & 0x80;
op2_b7 = BX_CPU_THIS_PTR oszapc.op2_8 & 0x80;
result_b7 = BX_CPU_THIS_PTR oszapc.result_8 & 0x80;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b7 ^ op2_b7) && (op1_b7 ^ result_b7);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SUB16:
case BX_INSTR_SBB16:
case BX_INSTR_CMP16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
op1_b15 = BX_CPU_THIS_PTR oszapc.op1_16 & 0x8000;
op2_b15 = BX_CPU_THIS_PTR oszapc.op2_16 & 0x8000;
result_b15 = BX_CPU_THIS_PTR oszapc.result_16 & 0x8000;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b15 ^ op2_b15) && (op1_b15 ^ result_b15);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SUB32:
case BX_INSTR_SBB32:
case BX_INSTR_CMP32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
op1_b31 = BX_CPU_THIS_PTR oszapc.op1_32 & 0x80000000;
op2_b31 = BX_CPU_THIS_PTR oszapc.op2_32 & 0x80000000;
result_b31 = BX_CPU_THIS_PTR oszapc.result_32 & 0x80000000;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (op1_b31 ^ op2_b31) && (op1_b31 ^ result_b31);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_SUB64:
case BX_INSTR_SBB64:
case BX_INSTR_CMP64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
op1_b63 = BX_CPU_THIS_PTR oszapc.op1_64 & BX_CONST64(0x8000000000000000);
op2_b63 = BX_CPU_THIS_PTR oszapc.op2_64 & BX_CONST64(0x8000000000000000);
result_b63 = BX_CPU_THIS_PTR oszapc.result_64 & BX_CONST64(0x8000000000000000);
of = (op1_b63 ^ op2_b63) && (op1_b63 ^ result_b63);
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_NEG8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_8 == 0x80);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_16 == 0x8000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_NEG32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_32 == 0x80000000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_NEG64:
of = (BX_CPU_THIS_PTR oszapc.op1_64 == BX_CONST64(0x8000000000000000));
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_OR8:
case BX_INSTR_OR16:
case BX_INSTR_OR32:
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_AND8:
case BX_INSTR_AND16:
case BX_INSTR_AND32:
case BX_INSTR_TEST8:
case BX_INSTR_TEST16:
case BX_INSTR_TEST32:
case BX_INSTR_XOR8:
case BX_INSTR_XOR16:
case BX_INSTR_XOR32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = 0;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHR8:
if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_8 >= 0x80);
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHR16:
if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_16 >= 0x8000);
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHR32:
if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = (BX_CPU_THIS_PTR oszapc.op1_32 >= 0x80000000);
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#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));
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
else
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_SHL8:
if (BX_CPU_THIS_PTR oszapc.op2_8 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = ((BX_CPU_THIS_PTR oszapc.op1_8 ^
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.result_8) & 0x80) > 0;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHL16:
if (BX_CPU_THIS_PTR oszapc.op2_16 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = ((BX_CPU_THIS_PTR oszapc.op1_16 ^
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.result_16) & 0x8000) > 0;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_SHL32:
if (BX_CPU_THIS_PTR oszapc.op2_32 == 1)
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = ((BX_CPU_THIS_PTR oszapc.op1_32 ^
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
BX_CPU_THIS_PTR oszapc.result_32) & 0x80000000) > 0;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
else
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#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;
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
else
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
of = (BX_CPU_THIS_PTR eflags.val32 >> 11) & 1; // Old val
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
of = 0; // Keep compiler happy.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_OF: OSZAPC: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
return(of);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_8 == 0x80;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC16:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_16 == 0x8000;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC32:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_32 == 0x80000000;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_INC64:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x8000000000000000);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_INSTR_DEC8:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_8 == 0x7F;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_DEC16:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_16 == 0x7FFF;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_DEC32:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_32 == 0x7FFFFFFF;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
break;
#if BX_SUPPORT_X86_64
case BX_INSTR_DEC64:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = BX_CPU_THIS_PTR oszap.result_64 == BX_CONST64(0x7FFFFFFFFFFFFFFF);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
of = 0; // Keep compiler happy.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_OF: OSZAP: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0x0fffff;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<11);
BX_CPU_THIS_PTR eflags.val32 |= (!!of)<<11;
return(of);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_OF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
Split out JZ/JNZ instructions from JCC because they were called so frequently. Coded asm() statements for INC/DEC_ERX() instructions. Cleaned up the iCache a litle including a bug fix. The generation ID was decrementing the whole field including some high meta bits. That could roll over after 1 Billion cycles. I know only decrement if the field is valid, to save the write. I implemented inline functions which can serve the value of the arithmetic flags if they are cached, and redirect to the lazy_flags.cc routines if not. Most of this was just prep work for adding more asm() statements for native eflags processing when on x86.
2002-09-22 05:52:21 +04:00
BX_CPU_C::get_PFLazy(void)
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
{
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
unsigned pf;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
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_ADD8:
case BX_INSTR_ADC8:
case BX_INSTR_SUB8:
case BX_INSTR_SBB8:
case BX_INSTR_CMP8:
case BX_INSTR_NEG8:
case BX_INSTR_XADD8:
case BX_INSTR_OR8:
case BX_INSTR_AND8:
case BX_INSTR_TEST8:
case BX_INSTR_XOR8:
case BX_INSTR_CMPS8:
case BX_INSTR_SCAS8:
case BX_INSTR_SHR8:
case BX_INSTR_SHL8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[BX_CPU_THIS_PTR oszapc.result_8];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD16:
case BX_INSTR_ADC16:
case BX_INSTR_SUB16:
case BX_INSTR_SBB16:
case BX_INSTR_CMP16:
case BX_INSTR_NEG16:
case BX_INSTR_XADD16:
case BX_INSTR_OR16:
case BX_INSTR_AND16:
case BX_INSTR_TEST16:
case BX_INSTR_XOR16:
case BX_INSTR_CMPS16:
case BX_INSTR_SCAS16:
case BX_INSTR_SHR16:
case BX_INSTR_SHL16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_16];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_ADD32:
case BX_INSTR_ADC32:
case BX_INSTR_SUB32:
case BX_INSTR_SBB32:
case BX_INSTR_CMP32:
case BX_INSTR_NEG32:
case BX_INSTR_XADD32:
case BX_INSTR_OR32:
case BX_INSTR_AND32:
case BX_INSTR_TEST32:
case BX_INSTR_XOR32:
case BX_INSTR_CMPS32:
case BX_INSTR_SCAS32:
case BX_INSTR_SHR32:
case BX_INSTR_SHL32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_32];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#if BX_SUPPORT_X86_64
case BX_INSTR_ADD64:
case BX_INSTR_ADC64:
case BX_INSTR_SUB64:
case BX_INSTR_SBB64:
case BX_INSTR_CMP64:
case BX_INSTR_NEG64:
case BX_INSTR_XADD64:
case BX_INSTR_OR64:
case BX_INSTR_AND64:
case BX_INSTR_TEST64:
case BX_INSTR_XOR64:
case BX_INSTR_CMPS64:
case BX_INSTR_SCAS64:
case BX_INSTR_SHR64:
case BX_INSTR_SHL64:
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszapc.result_64];
break;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
Replaced tabs in cpu/*.{cc,h} files with spaces.
2002-10-04 21:04:33 +04:00
pf = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_PF: OSZAPC: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
BX_CPU_THIS_PTR eflags.val32 |= (!!pf)<<2;
return(pf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
case BX_LF_INDEX_OSZAP:
switch (BX_CPU_THIS_PTR oszap.instr) {
case BX_INSTR_INC8:
case BX_INSTR_DEC8:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[BX_CPU_THIS_PTR oszap.result_8];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC16:
case BX_INSTR_DEC16:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszap.result_16];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
case BX_INSTR_INC32:
case BX_INSTR_DEC32:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = bx_parity_lookup[(Bit8u) BX_CPU_THIS_PTR oszap.result_32];
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
break;
(cpu64) Merged lazy_flags.cc.
2002-09-15 04:18:41 +04:00
#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
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
pf = 0; // Keep compiler quiet.
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_PF: OSZAP: unknown instr"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
BX_CPU_THIS_PTR lf_flags_status &= 0xffff0f;
I rehashed the way the EFLAGS register was stored internally. All the EFLAGS bits used to be cached in separate fields. I left a few of them in separate fields for now - might remove them at some point also. When the arithmetic fields are known (ie they're not in lazy mode), they are all cached in a 32-bit EFLAGS image, just like the x86 EFLAGS register expects. All other eflags are store in the 32-bit register also, with a few also mirrored in separate fields for now. The reason I did this, was so that on x86 hosts, asm() statements can be #ifdef'd in to do the calculation and get the native eflags results very cheaply. Just to test that it works, I coded ADD_EdId() and ADD_EwIw() with some conditionally compiled asm()s for accelerated eflags processing and it works. -Kevin
2002-09-08 08:08:14 +04:00
BX_CPU_THIS_PTR eflags.val32 &= ~(1<<2);
BX_CPU_THIS_PTR eflags.val32 |= (!!pf)<<2;
return(pf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
default:
strip '\n' from BX_{INFO,DEBUG,ERROR,PANIC} don't need it, moved the output of it into the general io functions. saves space, as well as removes the confusing output if a '\n' is left off
2001-05-30 22:56:02 +04:00
BX_PANIC(("get_PF: unknown case"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Reference in New Issue Copy Permalink