mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
22eb32934a
Bochs/bochs/cpu/debugstuff.cc

1018 lines
42 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
/////////////////////////////////////////////////////////////////////////
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
// $Id: debugstuff.cc,v 1.13 2002-09-11 03:55:22 bdenney 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
void
BX_CPU_C::debug(Bit32u offset)
{
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_INFO(("| EAX=%08x EBX=%08x ECX=%08x EDX=%08x",
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) EAX, (unsigned) EBX, (unsigned) ECX, (unsigned) EDX));
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_INFO(("| ESP=%08x EBP=%08x ESI=%08x EDI=%08x",
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) ESP, (unsigned) EBP, (unsigned) ESI, (unsigned) EDI));
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_INFO(("| IOPL=%1u %s %s %s %s %s %s %s %s",
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
IOPL,
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR get_OF() ? "OV" : "NV",
BX_CPU_THIS_PTR eflags.get_DF() ? "DW" : "UP",
BX_CPU_THIS_PTR eflags.get_IF() ? "EI" : "DI",
BX_CPU_THIS_PTR get_SF() ? "NG" : "PL",
BX_CPU_THIS_PTR get_ZF() ? "ZR" : "NZ",
BX_CPU_THIS_PTR get_AF() ? "AC" : "NA",
BX_CPU_THIS_PTR get_PF() ? "PE" : "PO",
BX_CPU_THIS_PTR get_CF() ? "CY" : "NC"));
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_INFO(("| SEG selector base limit G D"));
BX_INFO(("| SEG sltr(index|ti|rpl) base limit G D"));
BX_INFO(("| DS:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.g,
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 sregs[BX_SEG_REG_DS].cache.u.segment.d_b));
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_INFO(("| ES:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.g,
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 sregs[BX_SEG_REG_ES].cache.u.segment.d_b));
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_INFO(("| FS:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.g,
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 sregs[BX_SEG_REG_FS].cache.u.segment.d_b));
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_INFO(("| GS:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.g,
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 sregs[BX_SEG_REG_GS].cache.u.segment.d_b));
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_INFO(("| SS:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.g,
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 sregs[BX_SEG_REG_SS].cache.u.segment.d_b));
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_INFO(("| CS:%04x( %04x| %01u| %1u) %08x %08x %1u %1u",
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.index,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.ti,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.rpl,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit,
(unsigned) BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.g,
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 sregs[BX_SEG_REG_CS].cache.u.segment.d_b));
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_INFO(("| EIP=%08x (%08x)", (unsigned) BX_CPU_THIS_PTR eip,
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 prev_eip));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#if 0
/* (mch) Hack to display the area round EIP and prev_EIP */
char buf[100];
sprintf(buf, "%04x:%08x ", BX_CPU_THIS_PTR sregs[BX_SREG_CS].selector.value, BX_CPU_THIS_PTR eip);
for (int i = 0; i < 8; i++) {
Bit8u data;
BX_CPU_THIS_PTR read_virtual_byte(BX_SREG_CS, BX_CPU_THIS_PTR eip + i, &data);
sprintf(buf+strlen(buf), "%02x ", data);
}
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
BX_INFO((buf));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
sprintf(buf, "%04x:%08x ", BX_CPU_THIS_PTR sregs[BX_SREG_CS].selector.value, BX_CPU_THIS_PTR prev_eip);
for (int i = 0; i < 8; i++) {
Bit8u data;
BX_CPU_THIS_PTR read_virtual_byte(BX_SREG_CS, BX_CPU_THIS_PTR prev_eip + i, &data);
sprintf(buf+strlen(buf), "%02x ", data);
}
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
BX_INFO((buf));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#endif
#if BX_DISASM
Boolean valid;
Bit32u phy_addr;
Bit8u instr_buf[32];
char char_buf[256];
unsigned isize;
dbg_xlate_linear2phy(BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base + offset,
&phy_addr, &valid);
if (valid) {
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
BX_CPU_THIS_PTR mem->dbg_fetch_mem(phy_addr, 16, instr_buf);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
isize = bx_disassemble.disasm(BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.d_b,
instr_buf, char_buf);
for (unsigned j=0; j<isize; j++)
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_INFO((">> %02x", (unsigned) instr_buf[j]));
BX_INFO((">> : %s", char_buf));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
else {
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_INFO(("(instruction unavailable) page not present"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
#else
UNUSED(offset);
#endif // #if BX_DISASM
}
#if BX_DEBUGGER
Bit32u
BX_CPU_C::dbg_get_reg(unsigned reg)
{
Bit32u return_val32;
switch (reg) {
case BX_DBG_REG_EAX: return(EAX);
case BX_DBG_REG_ECX: return(ECX);
case BX_DBG_REG_EDX: return(EDX);
case BX_DBG_REG_EBX: return(EBX);
case BX_DBG_REG_ESP: return(ESP);
case BX_DBG_REG_EBP: return(EBP);
case BX_DBG_REG_ESI: return(ESI);
case BX_DBG_REG_EDI: return(EDI);
case BX_DBG_REG_EIP: return(EIP);
case BX_DBG_REG_EFLAGS:
return_val32 = dbg_get_eflags();
return(return_val32);
case BX_DBG_REG_CS: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value);
case BX_DBG_REG_SS: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value);
case BX_DBG_REG_DS: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value);
case BX_DBG_REG_ES: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value);
case BX_DBG_REG_FS: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value);
case BX_DBG_REG_GS: return(BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value);
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_reg: request for unknown register"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
Boolean
BX_CPU_C::dbg_set_reg(unsigned reg, Bit32u val)
{
// returns 1=OK, 0=can't change
bx_segment_reg_t *seg;
Bit32u current_sys_bits;
switch (reg) {
case BX_DBG_REG_EAX: EAX = val; return(1);
case BX_DBG_REG_ECX: ECX = val; return(1);
case BX_DBG_REG_EDX: EDX = val; return(1);
case BX_DBG_REG_EBX: EBX = val; return(1);
case BX_DBG_REG_ESP: ESP = val; return(1);
case BX_DBG_REG_EBP: EBP = val; return(1);
case BX_DBG_REG_ESI: ESI = val; return(1);
case BX_DBG_REG_EDI: EDI = val; return(1);
case BX_DBG_REG_EIP: EIP = val; return(1);
case BX_DBG_REG_EFLAGS:
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_INFO(("dbg_set_reg: can not handle eflags yet."));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
if ( val & 0xffff0000 ) {
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_INFO(("dbg_set_reg: can not set upper 16 bits of eflags."));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
// make sure none of the system bits are being changed
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
current_sys_bits = (BX_CPU_THIS_PTR eflags.get_NT () << 14) |
(BX_CPU_THIS_PTR eflags.get_IOPL () << 12) |
(BX_CPU_THIS_PTR eflags.get_TF () << 8);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
if ( current_sys_bits != (val & 0x0000f100) ) {
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_INFO(("dbg_set_reg: can not modify NT, IOPL, or TF."));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
BX_CPU_THIS_PTR set_CF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_PF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_AF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_ZF(val & 0x01); val >>= 1;
BX_CPU_THIS_PTR set_SF(val & 0x01); val >>= 2;
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR eflags.set_IF (val & 0x01); val >>= 1;
BX_CPU_THIS_PTR eflags.set_DF (val & 0x01); val >>= 1;
- 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 set_OF(val & 0x01);
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
if (BX_CPU_THIS_PTR eflags.get_IF ())
- 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 async_event = 1;
return(1);
case BX_DBG_REG_CS:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS];
break;
case BX_DBG_REG_SS:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS];
break;
case BX_DBG_REG_DS:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
break;
case BX_DBG_REG_ES:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES];
break;
case BX_DBG_REG_FS:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS];
break;
case BX_DBG_REG_GS:
seg = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS];
break;
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(("dbg_set_reg: unrecognized register ID (%u)", reg));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
if (BX_CPU_THIS_PTR real_mode()) {
seg->selector.value = val;
seg->cache.valid = 1;
seg->cache.p = 1;
seg->cache.dpl = 0;
seg->cache.segment = 1; // regular segment
if (reg == BX_DBG_REG_CS) {
seg->cache.u.segment.executable = 1; // code segment
}
else {
seg->cache.u.segment.executable = 0; // data segment
}
seg->cache.u.segment.c_ed = 0; // expand up/non-conforming
seg->cache.u.segment.r_w = 1; // writeable
seg->cache.u.segment.a = 1; // accessed
seg->cache.u.segment.base = val << 4;
seg->cache.u.segment.limit = 0xffff;
seg->cache.u.segment.limit_scaled = 0xffff;
seg->cache.u.segment.g = 0; // byte granular
seg->cache.u.segment.d_b = 0; // default 16bit size
seg->cache.u.segment.avl = 0;
return(1); // ok
}
return(0); // can't change when not in real mode
}
unsigned
BX_CPU_C::dbg_query_pending(void)
{
unsigned ret = 0;
if ( BX_HRQ ) { // DMA Hold Request
ret |= BX_DBG_PENDING_DMA;
}
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
if ( BX_CPU_THIS_PTR INTR && BX_CPU_THIS_PTR eflags.get_IF () ) {
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
ret |= BX_DBG_PENDING_IRQ;
}
return(ret);
}
Bit32u
BX_CPU_C::dbg_get_eflags(void)
{
Bit32u val32;
val32 =
(BX_CPU_THIS_PTR get_CF()) |
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
(BX_CPU_THIS_PTR eflags.get_bit1 () << 1) |
- 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 get_PF()) << 2) |
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
(BX_CPU_THIS_PTR eflags.get_bit3 () << 3) |
- 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 get_AF()>0) << 4) |
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
(BX_CPU_THIS_PTR eflags.get_bit5 () << 5) |
- 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 get_ZF()>0) << 6) |
((BX_CPU_THIS_PTR get_SF()>0) << 7) |
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
(BX_CPU_THIS_PTR eflags.get_TF () << 8) |
(BX_CPU_THIS_PTR eflags.get_IF () << 9) |
(BX_CPU_THIS_PTR eflags.get_DF () << 10) |
- 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 get_OF()>0) << 11) |
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
(BX_CPU_THIS_PTR eflags.get_IOPL () << 12) |
(BX_CPU_THIS_PTR eflags.get_NT () << 14) |
(BX_CPU_THIS_PTR eflags.get_bit15 () << 15) |
(BX_CPU_THIS_PTR eflags.get_RF () << 16) |
(BX_CPU_THIS_PTR eflags.get_VM () << 17);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#if BX_CPU_LEVEL >= 4
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
val32 |= (BX_CPU_THIS_PTR eflags.get_AC () << 18);
//val32 |= (BX_CPU_THIS_PTR eflags.get_VIF () << 19);
//val32 |= (BX_CPU_THIS_PTR eflags.get_VIP () << 20);
val32 |= (BX_CPU_THIS_PTR eflags.get_ID () << 21);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#endif
return(val32);
}
Bit32u
BX_CPU_C::dbg_get_descriptor_l(bx_descriptor_t *d)
{
Bit32u val;
if (d->valid == 0) {
return(0);
}
if (d->segment) {
val = ((d->u.segment.base & 0xffff) << 16) |
(d->u.segment.limit & 0xffff);
return(val);
}
else {
switch (d->type) {
case 0: // Reserved (not yet defined)
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_ERROR(( "#get_descriptor_l(): type %d not finished", d->type ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
case 1: // available 16bit TSS
val = ((d->u.tss286.base & 0xffff) << 16) |
(d->u.tss286.limit & 0xffff);
return(val);
case 2: // LDT
val = ((d->u.ldt.base & 0xffff) << 16) |
d->u.ldt.limit;
return(val);
case 9: // available 32bit TSS
val = ((d->u.tss386.base & 0xffff) << 16) |
(d->u.tss386.limit & 0xffff);
return(val);
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_ERROR(( "#get_descriptor_l(): type %d not finished", d->type ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
}
Bit32u
BX_CPU_C::dbg_get_descriptor_h(bx_descriptor_t *d)
{
Bit32u val;
if (d->valid == 0) {
return(0);
}
if (d->segment) {
val = (d->u.segment.base & 0xff000000) |
((d->u.segment.base >> 16) & 0x000000ff) |
(d->u.segment.executable << 11) |
(d->u.segment.c_ed << 10) |
(d->u.segment.r_w << 9) |
(d->u.segment.a << 8) |
(d->segment << 12) |
(d->dpl << 13) |
(d->p << 15) |
(d->u.segment.limit & 0xf0000) |
(d->u.segment.avl << 20) |
(d->u.segment.d_b << 22) |
(d->u.segment.g << 23);
return(val);
}
else {
switch (d->type) {
case 0: // Reserved (not yet defined)
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_ERROR(( "#get_descriptor_h(): type %d not finished", d->type ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
case 1: // available 16bit TSS
val = ((d->u.tss286.base >> 16) & 0xff) |
(d->type << 8) |
(d->dpl << 13) |
(d->p << 15);
return(val);
case 2: // LDT
val = ((d->u.ldt.base >> 16) & 0xff) |
(d->type << 8) |
(d->dpl << 13) |
(d->p << 15) |
(d->u.ldt.base & 0xff000000);
return(val);
case 9: // available 32bit TSS
val = ((d->u.tss386.base >> 16) & 0xff) |
(d->type << 8) |
(d->dpl << 13) |
(d->p << 15) |
(d->u.tss386.limit & 0xf0000) |
(d->u.tss386.avl << 20) |
(d->u.tss386.g << 23) |
(d->u.tss386.base & 0xff000000);
return(val);
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_ERROR(( "#get_descriptor_h(): type %d not finished", d->type ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0);
}
}
}
Boolean
BX_CPU_C::dbg_get_sreg(bx_dbg_sreg_t *sreg, unsigned sreg_no)
{
if (sreg_no > 5)
return(0);
sreg->sel = BX_CPU_THIS_PTR sregs[sreg_no].selector.value;
sreg->des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[sreg_no].cache);
sreg->des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[sreg_no].cache);
sreg->valid = BX_CPU_THIS_PTR sregs[sreg_no].cache.valid;
return(1);
}
Boolean
BX_CPU_C::dbg_get_cpu(bx_dbg_cpu_t *cpu)
{
cpu->eax = EAX;
cpu->ebx = EBX;
cpu->ecx = ECX;
cpu->edx = EDX;
cpu->ebp = EBP;
cpu->esi = ESI;
cpu->edi = EDI;
cpu->esp = ESP;
cpu->eflags = dbg_get_eflags();
cpu->eip = BX_CPU_THIS_PTR eip;
cpu->cs.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value;
cpu->cs.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache);
cpu->cs.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache);
cpu->cs.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.valid;
cpu->ss.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value;
cpu->ss.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache);
cpu->ss.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache);
cpu->ss.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.valid;
cpu->ds.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value;
cpu->ds.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache);
cpu->ds.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache);
cpu->ds.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.valid;
cpu->es.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value;
cpu->es.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache);
cpu->es.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache);
cpu->es.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.valid;
cpu->fs.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value;
cpu->fs.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache);
cpu->fs.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache);
cpu->fs.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.valid;
cpu->gs.sel = BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value;
cpu->gs.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache);
cpu->gs.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache);
cpu->gs.valid = BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.valid;
cpu->ldtr.sel = BX_CPU_THIS_PTR ldtr.selector.value;
cpu->ldtr.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR ldtr.cache);
cpu->ldtr.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR ldtr.cache);
cpu->ldtr.valid = BX_CPU_THIS_PTR ldtr.cache.valid;
cpu->tr.sel = BX_CPU_THIS_PTR tr.selector.value;
cpu->tr.des_l = dbg_get_descriptor_l(&BX_CPU_THIS_PTR tr.cache);
cpu->tr.des_h = dbg_get_descriptor_h(&BX_CPU_THIS_PTR tr.cache);
cpu->tr.valid = BX_CPU_THIS_PTR tr.cache.valid;
cpu->gdtr.base = BX_CPU_THIS_PTR gdtr.base;
cpu->gdtr.limit = BX_CPU_THIS_PTR gdtr.limit;
cpu->idtr.base = BX_CPU_THIS_PTR idtr.base;
cpu->idtr.limit = BX_CPU_THIS_PTR idtr.limit;
cpu->dr0 = BX_CPU_THIS_PTR dr0;
cpu->dr1 = BX_CPU_THIS_PTR dr1;
cpu->dr2 = BX_CPU_THIS_PTR dr2;
cpu->dr3 = BX_CPU_THIS_PTR dr3;
cpu->dr6 = BX_CPU_THIS_PTR dr6;
cpu->dr7 = BX_CPU_THIS_PTR dr7;
cpu->tr3 = 0;
cpu->tr4 = 0;
cpu->tr5 = 0;
cpu->tr6 = 0;
cpu->tr7 = 0;
// cr0:32=pg,cd,nw,am,wp,ne,ts,em,mp,pe
cpu->cr0 = BX_CPU_THIS_PTR cr0.val32;
cpu->cr1 = 0;
cpu->cr2 = BX_CPU_THIS_PTR cr2;
cpu->cr3 = BX_CPU_THIS_PTR cr3;
cpu->cr4 = 0;
cpu->inhibit_mask = BX_CPU_THIS_PTR inhibit_mask;
return(1);
}
Boolean
BX_CPU_C::dbg_set_cpu(bx_dbg_cpu_t *cpu)
{
// returns 1=OK, 0=Error
Bit32u val;
Bit32u type;
// =================================================
// Do checks first, before setting any CPU registers
// =================================================
// CS, SS, DS, ES, FS, GS descriptor checks
if (!cpu->cs.valid) {
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_ERROR(( "Error: CS not valid" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if ( (cpu->cs.des_h & 0x1000) == 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_ERROR(( "Error: CS not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if ( (cpu->cs.des_h & 0x0800) == 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_ERROR(( "Error: CS not executable" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if (!cpu->ss.valid) {
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_ERROR(( "Error: SS not valid" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if ( (cpu->ss.des_h & 0x1000) == 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_ERROR(( "Error: SS not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if (cpu->ds.valid) {
if ( (cpu->ds.des_h & 0x1000) == 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_ERROR(( "Error: DS not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
if (cpu->es.valid) {
if ( (cpu->es.des_h & 0x1000) == 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_ERROR(( "Error: ES not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
if (cpu->fs.valid) {
if ( (cpu->fs.des_h & 0x1000) == 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_ERROR(( "Error: FS not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
if (cpu->gs.valid) {
if ( (cpu->gs.des_h & 0x1000) == 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_ERROR(( "Error: GS not application type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
if (cpu->ldtr.valid) {
if ( cpu->ldtr.des_h & 0x1000 ) {
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_ERROR(( "Error: LDTR not system type" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
if ( ((cpu->ldtr.des_h >> 8) & 0x0f) != 2 ) {
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_ERROR(( "Error: LDTR descriptor type not LDT" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
if (cpu->tr.valid) {
if ( cpu->tr.des_h & 0x1000 ) {
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_ERROR(( "Error: TR not system type"));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
type = (cpu->tr.des_h >> 8) & 0x0f;
if ( (type != 1) && (type != 9) ) {
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_ERROR(( "Error: TR descriptor type not TSS" ));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
return(0); // error
}
}
// =============
// end of checks
// =============
EAX = cpu->eax;
EBX = cpu->ebx;
ECX = cpu->ecx;
EDX = cpu->edx;
EBP = cpu->ebp;
ESI = cpu->esi;
EDI = cpu->edi;
ESP = cpu->esp;
// eflags
val = cpu->eflags;
BX_CPU_THIS_PTR set_CF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_PF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_AF(val & 0x01); val >>= 2;
BX_CPU_THIS_PTR set_ZF(val & 0x01); val >>= 1;
BX_CPU_THIS_PTR set_SF(val & 0x01); val >>= 1;
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR eflags.set_TF (val & 0x01); val >>= 1;
BX_CPU_THIS_PTR eflags.set_IF (val & 0x01); val >>= 1;
BX_CPU_THIS_PTR eflags.set_DF (val & 0x01); val >>= 1;
- 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 set_OF(val & 0x01); val >>= 1;
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR eflags.set_IOPL (val & 0x03); val >>= 2;
BX_CPU_THIS_PTR eflags.set_NT (val & 0x01); val >>= 2;
BX_CPU_THIS_PTR eflags.set_RF (val & 0x01); val >>= 1;
BX_CPU_THIS_PTR eflags.set_VM (val & 0x01); val >>= 1;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#if BX_CPU_LEVEL >= 4
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR eflags.set_AC (val & 0x01); val >>= 1;
//BX_CPU_THIS_PTR eflags.set_VIF (val & 0x01);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
val >>= 1;
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
//BX_CPU_THIS_PTR eflags.set_VIP (val & 0x01);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
val >>= 1;
- the debugger was broken by recent changes in the cpu flags. To provide a consistent way of accessing these flags that works both inside and outside the BX_CPU class, I added inline accessor methods for each flag: assert_FLAG(), clear_FLAG(), set_FLAG(value), and get_FLAG () that returns its value. I use assert to mean "set the value to one" to avoid confusion, since there's also a set method that takes a value. - the eflags access macros (e.g. GetEFlagsDFLogical, ClearEFlagsTF) are now defined in terms of the inline accessors. In most cases it will result in the same code anyway. The major advantage of the accesors is that they can be used from inside or outside the BX_CPU object, while the macros can only be used from inside. - since almost all eflags were stored in val32 now, I went ahead and removed the if_, rf, and vm fields. Now the val32 bit is the "official" value for these flags, and they have accessors just like everything else. - init.cc: move the registration of registers until after they have been initialized so that the initial value of each parameter is correct. Modified files: debug/dbg_main.cc cpu/cpu.h cpu/debugstuff.cc cpu/flag_ctrl.cc cpu/flag_ctrl_pro.cc cpu/init.cc
2002-09-11 07:55:22 +04:00
BX_CPU_THIS_PTR eflags.set_ID (val & 0x01);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#endif
BX_CPU_THIS_PTR eip = cpu->eip;
// CS:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value = cpu->cs.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.index = cpu->cs.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.ti = (cpu->cs.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.rpl = cpu->cs.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.valid = cpu->cs.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.p = (cpu->cs.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.dpl = (cpu->cs.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.segment = (cpu->cs.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.type = (cpu->cs.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.executable = (cpu->cs.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.c_ed = (cpu->cs.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.r_w = (cpu->cs.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.a = (cpu->cs.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base = (cpu->cs.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base |= (cpu->cs.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base |= (cpu->cs.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit = (cpu->cs.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit |= (cpu->cs.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.g = (cpu->cs.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.d_b = (cpu->cs.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.avl = (cpu->cs.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit;
- back out my poorly written patch.virtual-address-checks-overflow
2001-10-03 00:01:29 +04:00
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
// SS:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value = cpu->ss.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.index = cpu->ss.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.ti = (cpu->ss.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.rpl = cpu->ss.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.valid = cpu->ss.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.p = (cpu->ss.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.dpl = (cpu->ss.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.segment = (cpu->ss.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.type = (cpu->ss.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.executable = (cpu->ss.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.c_ed = (cpu->ss.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.r_w = (cpu->ss.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.a = (cpu->ss.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.base = (cpu->ss.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.base |= (cpu->ss.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.base |= (cpu->ss.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit = (cpu->ss.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit |= (cpu->ss.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.g = (cpu->ss.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b = (cpu->ss.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.avl = (cpu->ss.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit;
- back out my poorly written patch.virtual-address-checks-overflow
2001-10-03 00:01:29 +04:00
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
// DS:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value = cpu->ds.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.index = cpu->ds.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.ti = (cpu->ds.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.rpl = cpu->ds.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.valid = cpu->ds.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.p = (cpu->ds.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.dpl = (cpu->ds.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.segment = (cpu->ds.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.type = (cpu->ds.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.executable = (cpu->ds.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.c_ed = (cpu->ds.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.r_w = (cpu->ds.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.a = (cpu->ds.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.base = (cpu->ds.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.base |= (cpu->ds.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.base |= (cpu->ds.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit = (cpu->ds.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit |= (cpu->ds.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.g = (cpu->ds.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.d_b = (cpu->ds.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.avl = (cpu->ds.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit;
- back out my poorly written patch.virtual-address-checks-overflow
2001-10-03 00:01:29 +04:00
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
// ES:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value = cpu->es.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.index = cpu->es.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.ti = (cpu->es.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.rpl = cpu->es.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.valid = cpu->es.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.p = (cpu->es.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.dpl = (cpu->es.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.segment = (cpu->es.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.type = (cpu->es.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.executable = (cpu->es.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.c_ed = (cpu->es.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.r_w = (cpu->es.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.a = (cpu->es.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.base = (cpu->es.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.base |= (cpu->es.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.base |= (cpu->es.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit = (cpu->es.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit |= (cpu->es.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.g = (cpu->es.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.d_b = (cpu->es.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.avl = (cpu->es.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].cache.u.segment.limit;
- back out my poorly written patch.virtual-address-checks-overflow
2001-10-03 00:01:29 +04:00
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
// FS:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value = cpu->fs.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.index = cpu->fs.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.ti = (cpu->fs.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.rpl = cpu->fs.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.valid = cpu->fs.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.p = (cpu->fs.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.dpl = (cpu->fs.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.segment = (cpu->fs.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.type = (cpu->fs.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.executable = (cpu->fs.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.c_ed = (cpu->fs.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.r_w = (cpu->fs.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.a = (cpu->fs.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.base = (cpu->fs.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.base |= (cpu->fs.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.base |= (cpu->fs.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit = (cpu->fs.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit |= (cpu->fs.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.g = (cpu->fs.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.d_b = (cpu->fs.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.avl = (cpu->fs.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].cache.u.segment.limit;
- back out my poorly written patch.virtual-address-checks-overflow
2001-10-03 00:01:29 +04:00
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
// GS:
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value = cpu->gs.sel;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.index = cpu->gs.sel >> 3;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.ti = (cpu->gs.sel >> 2) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.rpl = cpu->gs.sel & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.valid = cpu->gs.valid;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.p = (cpu->gs.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.dpl = (cpu->gs.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.segment = (cpu->gs.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.type = (cpu->gs.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.executable = (cpu->gs.des_h >> 11) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.c_ed = (cpu->gs.des_h >> 10) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.r_w = (cpu->gs.des_h >> 9) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.a = (cpu->gs.des_h >> 8) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.base = (cpu->gs.des_l >> 16);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.base |= (cpu->gs.des_h & 0xff) << 16;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.base |= (cpu->gs.des_h & 0xff000000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit = (cpu->gs.des_l & 0xffff);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit |= (cpu->gs.des_h & 0x000f0000);
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.g = (cpu->gs.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.d_b = (cpu->gs.des_h >> 22) & 0x01;
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.avl = (cpu->gs.des_h >> 20) & 0x01;
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.g)
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit_scaled =
(BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit << 12) | 0x0fff;
else
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit_scaled =
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].cache.u.segment.limit;
// LDTR:
BX_CPU_THIS_PTR ldtr.selector.value = cpu->ldtr.sel;
BX_CPU_THIS_PTR ldtr.selector.index = cpu->ldtr.sel >> 3;
BX_CPU_THIS_PTR ldtr.selector.ti = (cpu->ldtr.sel >> 2) & 0x01;
BX_CPU_THIS_PTR ldtr.selector.rpl = cpu->ldtr.sel & 0x03;
BX_CPU_THIS_PTR ldtr.cache.valid = cpu->ldtr.valid;
BX_CPU_THIS_PTR ldtr.cache.p = (cpu->ldtr.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR ldtr.cache.dpl = (cpu->ldtr.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR ldtr.cache.segment = (cpu->ldtr.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR ldtr.cache.type = (cpu->ldtr.des_h >> 8) & 0x0f;
BX_CPU_THIS_PTR ldtr.cache.u.ldt.base = (cpu->ldtr.des_l >> 16);
BX_CPU_THIS_PTR ldtr.cache.u.ldt.base |= (cpu->ldtr.des_h & 0xff) << 16;
BX_CPU_THIS_PTR ldtr.cache.u.ldt.base |= (cpu->ldtr.des_h & 0xff000000);
BX_CPU_THIS_PTR ldtr.cache.u.ldt.limit = (cpu->ldtr.des_l & 0xffff);
// TR
type = (cpu->tr.des_h >> 8) & 0x0f;
- committed patches/patch.no-busy-in-tr-cache. I'm leaving the patch lying around for a while in case it needs to be reverted.
2001-10-10 01:15:14 +04:00
type &= ~2; // never allow busy bit in tr.cache.type
- 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 tr.selector.value = cpu->tr.sel;
BX_CPU_THIS_PTR tr.selector.index = cpu->tr.sel >> 3;
BX_CPU_THIS_PTR tr.selector.ti = (cpu->tr.sel >> 2) & 0x01;
BX_CPU_THIS_PTR tr.selector.rpl = cpu->tr.sel & 0x03;
BX_CPU_THIS_PTR tr.cache.valid = cpu->tr.valid;
BX_CPU_THIS_PTR tr.cache.p = (cpu->tr.des_h >> 15) & 0x01;
BX_CPU_THIS_PTR tr.cache.dpl = (cpu->tr.des_h >> 13) & 0x03;
BX_CPU_THIS_PTR tr.cache.segment = (cpu->tr.des_h >> 12) & 0x01;
BX_CPU_THIS_PTR tr.cache.type = type;
if (type == 1) { // 286 TSS
BX_CPU_THIS_PTR tr.cache.u.tss286.base = (cpu->tr.des_l >> 16);
BX_CPU_THIS_PTR tr.cache.u.tss286.base |= (cpu->tr.des_h & 0xff) << 16;
BX_CPU_THIS_PTR tr.cache.u.tss286.limit = (cpu->tr.des_l & 0xffff);
}
else { // type == 9, 386 TSS
BX_CPU_THIS_PTR tr.cache.u.tss386.base = (cpu->tr.des_l >> 16);
BX_CPU_THIS_PTR tr.cache.u.tss386.base |= (cpu->tr.des_h & 0xff) << 16;
BX_CPU_THIS_PTR tr.cache.u.tss386.base |= (cpu->tr.des_h & 0xff000000);
BX_CPU_THIS_PTR tr.cache.u.tss386.limit = (cpu->tr.des_l & 0xffff);
BX_CPU_THIS_PTR tr.cache.u.tss386.limit |= (cpu->tr.des_h & 0x000f0000);
BX_CPU_THIS_PTR tr.cache.u.tss386.g = (cpu->tr.des_h >> 23) & 0x01;
BX_CPU_THIS_PTR tr.cache.u.tss386.avl = (cpu->tr.des_h >> 20) & 0x01;
}
// gdtr
BX_CPU_THIS_PTR gdtr.base = cpu->gdtr.base;
BX_CPU_THIS_PTR gdtr.limit = cpu->gdtr.limit;
// idtr
BX_CPU_THIS_PTR idtr.base = cpu->idtr.base;
BX_CPU_THIS_PTR idtr.limit = cpu->idtr.limit;
BX_CPU_THIS_PTR dr0 = cpu->dr0;
BX_CPU_THIS_PTR dr1 = cpu->dr1;
BX_CPU_THIS_PTR dr2 = cpu->dr2;
BX_CPU_THIS_PTR dr3 = cpu->dr3;
BX_CPU_THIS_PTR dr6 = cpu->dr6;
BX_CPU_THIS_PTR dr7 = cpu->dr7;
// BX_CPU_THIS_PTR tr3 = cpu->tr3;
// BX_CPU_THIS_PTR tr4 = cpu->tr4;
// BX_CPU_THIS_PTR tr5 = cpu->tr5;
// BX_CPU_THIS_PTR tr6 = cpu->tr6;
// BX_CPU_THIS_PTR tr7 = cpu->tr7;
// cr0, cr1, cr2, cr3, cr4
SetCR0(cpu->cr0);
BX_CPU_THIS_PTR cr1 = cpu->cr1;
BX_CPU_THIS_PTR cr2 = cpu->cr2;
BX_CPU_THIS_PTR cr3 = cpu->cr3;
#if BX_CPU_LEVEL >= 5
BX_CPU_THIS_PTR cr4 = cpu->cr4;
#endif
BX_CPU_THIS_PTR inhibit_mask = cpu->inhibit_mask;
//
// flush cached items, prefetch, paging, etc
//
BX_CPU_THIS_PTR CR3_change(cpu->cr3);
BX_CPU_THIS_PTR invalidate_prefetch_q();
BX_CPU_THIS_PTR async_event = 1;
return(1);
}
#if BX_SIM_ID == 0
# define BX_DBG_NULL_CALLBACK bx_dbg_null_callback0
#else
# define BX_DBG_NULL_CALLBACK bx_dbg_null_callback1
#endif
void
BX_DBG_NULL_CALLBACK(unsigned val)
{
// bochs uses the pc_system variables, so this function is
// a stub for notification by the debugger, that a change
// occurred.
UNUSED(val);
}
void
#if BX_SIM_ID == 0
bx_dbg_init_cpu_mem_env0(bx_dbg_callback_t *callback, int argc, char *argv[])
#else
bx_dbg_init_cpu_mem_env1(bx_dbg_callback_t *callback, int argc, char *argv[])
#endif
{
UNUSED(argc);
UNUSED(argv);
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
#if 0
#warning hardcoding BX_CPU_THIS_PTR mem[0] and cpu[0]
callback->setphymem = BX_MEM(0)->dbg_set_mem;
callback->getphymem = BX_MEM(0)->dbg_fetch_mem;
callback->xlate_linear2phy = BX_CPU(0)->dbg_xlate_linear2phy;
callback->set_reg = BX_CPU(0)->dbg_set_reg;
callback->get_reg = BX_CPU(0)->dbg_get_reg;
callback->get_sreg = BX_CPU(0)->dbg_get_sreg;
callback->get_cpu = BX_CPU(0)->dbg_get_cpu;
callback->set_cpu = BX_CPU(0)->dbg_set_cpu;
callback->dirty_page_tbl_size = sizeof(BX_MEM(0)->dbg_dirty_pages);
callback->dirty_page_tbl = BX_MEM(0)->dbg_dirty_pages;
callback->atexit = BX_CPU(0)->atexit;
callback->query_pending = BX_CPU(0)->dbg_query_pending;
callback->execute = BX_CPU(0)->cpu_loop;
callback->take_irq = BX_CPU(0)->dbg_take_irq;
callback->take_dma = BX_CPU(0)->dbg_take_dma;
callback->reset_cpu = BX_CPU(0)->reset;
callback->init_mem = BX_MEM(0)->init_memory;
callback->load_ROM = BX_MEM(0)->load_ROM;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
callback->set_A20 = NULL;
callback->set_NMI = BX_DBG_NULL_CALLBACK;
callback->set_RESET = BX_DBG_NULL_CALLBACK;
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
callback->set_INTR = BX_CPU(0)->set_INTR;
callback->force_interrupt = BX_CPU(0)->dbg_force_interrupt;
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
#if BX_INSTRUMENTATION
callback->instr_start = bx_instr_start;
callback->instr_stop = bx_instr_stop;
callback->instr_reset = bx_instr_reset;
callback->instr_print = bx_instr_print;
#endif
#if BX_USE_LOADER
callback->loader = bx_dbg_loader;
#endif
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
callback->crc32 = BX_MEM(0)->dbg_crc32;
#endif
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
#endif // #if BX_DEBUGGER
void
BX_CPU_C::atexit(void)
{
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
if (protected_mode()) BX_INFO(("protected mode"));
else if (v8086_mode()) BX_INFO(("v8086 mode"));
else BX_INFO(("real mode"));
BX_INFO(("CS.d_b = %u bit",
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
BX_CPU_THIS_PTR sregs[BX_SREG_CS].cache.u.segment.d_b ? 32 : 16));
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_INFO(("SS.d_b = %u bit",
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
BX_CPU_THIS_PTR sregs[BX_SREG_SS].cache.u.segment.d_b ? 32 : 16));
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
- merged BRANCH-smp-bochs into main branch. For details see comments in BRANCH-smp-bochs revisions. - The general task was to make multiple CPU's which communicate through their APICs. So instead of BX_CPU and BX_MEM, we now have BX_CPU(x) and BX_MEM(y). For an SMP simulation you have several processors in a shared memory space, so there might be processors BX_CPU(0..3) but only one memory space BX_MEM(0). For cosimulation, you could have BX_CPU(0) with BX_MEM(0), then BX_CPU(1) with BX_MEM(1). WARNING: Cosimulation is almost certainly broken by the SMP changes. - to simulate multiple CPUs, you have to give each CPU time to execute in turn. This is currently implemented using debugger guards. The cpu loop steps one CPU for a few instructions, then steps the next CPU for a few instructions, etc. - there is some limited support in the debugger for two CPUs, for example printing information from each CPU when single stepping.
2001-05-23 12:16:07 +04:00
debug(BX_CPU_THIS_PTR prev_eip);
- entered original Bochs snapshot bochs-2000_0325a.tar.gz from ftp.bochs.com
2001-04-10 05:04:59 +04:00
}
Reference in New Issue Copy Permalink