2001-10-03 17:10:38 +04:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
2007-01-12 19:09:39 +03:00
|
|
|
// $Id: init.cc,v 1.126 2007-01-12 16:09:39 sshwarts Exp $
|
2001-10-03 17:10:38 +04:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
2001-04-10 06:20:02 +04:00
|
|
|
// Copyright (C) 2001 MandrakeSoft S.A.
|
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
|
|
|
|
|
|
|
|
|
2001-05-24 22:46:34 +04:00
|
|
|
#define NEED_CPU_REG_SHORTCUTS 1
|
2001-04-10 05:04:59 +04:00
|
|
|
#include "bochs.h"
|
2006-03-07 01:03:16 +03:00
|
|
|
#include "cpu.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
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_X86_64==0
|
|
|
|
// Make life easier merging cpu64 & cpu code.
|
|
|
|
#define RIP EIP
|
|
|
|
#endif
|
|
|
|
|
2006-03-07 01:03:16 +03:00
|
|
|
|
2005-11-27 00:36:51 +03:00
|
|
|
BX_CPU_C::BX_CPU_C(unsigned id): bx_cpuid(id)
|
2001-06-12 17:07:43 +04:00
|
|
|
#if BX_SUPPORT_APIC
|
2003-02-13 18:51:22 +03:00
|
|
|
,local_apic (this)
|
2001-05-23 12:16:07 +04:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
{
|
2001-05-23 12:16:07 +04:00
|
|
|
// in case of SMF, you cannot reference any member data
|
|
|
|
// in the constructor because the only access to it is via
|
|
|
|
// global variables which aren't initialized quite yet.
|
2001-06-27 23:16:01 +04:00
|
|
|
put("CPU");
|
2001-06-16 08:27:22 +04:00
|
|
|
settype (CPU0LOG);
|
2001-05-23 12:16:07 +04:00
|
|
|
}
|
2001-04-10 05:04:59 +04:00
|
|
|
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
#if BX_WITH_WX
|
- 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
|
|
|
|
2006-03-07 23:32:07 +03:00
|
|
|
#define IF_SEG_REG_GET(x) \
|
|
|
|
if (!strcmp(param->get_name(), #x)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
return BX_CPU(cpu)->sregs[BX_SEG_REG_##x].selector.value; \
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
#define IF_SEG_REG_SET(reg, val) \
|
|
|
|
if (!strcmp(param->get_name(), #reg)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
BX_CPU(cpu)->load_seg_reg(&BX_CPU(cpu)->sregs[BX_SEG_REG_##reg],val); \
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
#define IF_LAZY_EFLAG_GET(flag) \
|
|
|
|
if (!strcmp(param->get_name(), #flag)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
return BX_CPU(cpu)->get_##flag(); \
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
#define IF_LAZY_EFLAG_SET(flag, val) \
|
|
|
|
if (!strcmp(param->get_name(), #flag)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
BX_CPU(cpu)->set_##flag(val); \
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
#define IF_EFLAG_GET(flag) \
|
|
|
|
if (!strcmp(param->get_name(), #flag)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
return BX_CPU(cpu)->get_##flag(); \
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
#define IF_EFLAG_SET(flag, val) \
|
|
|
|
if (!strcmp(param->get_name(), #flag)) { \
|
2006-03-09 23:16:17 +03:00
|
|
|
BX_CPU(cpu)->set_##flag(val); \
|
2006-03-07 23:32:07 +03: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
|
|
|
|
|
|
|
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
// implement get/set handler for parameters that need unusual set/get
|
2006-03-07 23:32:07 +03:00
|
|
|
static Bit64s cpu_param_handler(bx_param_c *param, int set, Bit64s val)
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
{
|
2006-04-16 14:12:32 +04:00
|
|
|
#if BX_SUPPORT_SMP
|
2006-03-09 23:16:17 +03:00
|
|
|
int cpu = atoi(param->get_parent()->get_name());
|
2006-04-16 14:12:32 +04:00
|
|
|
#endif
|
- 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 (set) {
|
2006-03-07 23:32:07 +03:00
|
|
|
if (!strcmp(param->get_name(), "LDTR")) {
|
2006-03-09 23:16:17 +03:00
|
|
|
BX_CPU(cpu)->panic("setting LDTR not implemented");
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
}
|
2006-03-07 23:32:07 +03:00
|
|
|
if (!strcmp(param->get_name(), "TR")) {
|
2006-03-09 23:16:17 +03:00
|
|
|
BX_CPU(cpu)->panic("setting LDTR not implemented");
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
IF_SEG_REG_SET(CS, val);
|
|
|
|
IF_SEG_REG_SET(DS, val);
|
|
|
|
IF_SEG_REG_SET(SS, val);
|
|
|
|
IF_SEG_REG_SET(ES, val);
|
|
|
|
IF_SEG_REG_SET(FS, val);
|
|
|
|
IF_SEG_REG_SET(GS, val);
|
|
|
|
IF_LAZY_EFLAG_SET(OF, val);
|
|
|
|
IF_LAZY_EFLAG_SET(SF, val);
|
|
|
|
IF_LAZY_EFLAG_SET(ZF, val);
|
|
|
|
IF_LAZY_EFLAG_SET(AF, val);
|
|
|
|
IF_LAZY_EFLAG_SET(PF, val);
|
|
|
|
IF_LAZY_EFLAG_SET(CF, val);
|
|
|
|
IF_EFLAG_SET(ID, val);
|
|
|
|
IF_EFLAG_SET(VIP, val);
|
|
|
|
IF_EFLAG_SET(VIF, val);
|
|
|
|
IF_EFLAG_SET(AC, val);
|
|
|
|
IF_EFLAG_SET(VM, val);
|
|
|
|
IF_EFLAG_SET(RF, val);
|
|
|
|
IF_EFLAG_SET(NT, val);
|
|
|
|
IF_EFLAG_SET(IOPL, val);
|
|
|
|
IF_EFLAG_SET(DF, val);
|
|
|
|
IF_EFLAG_SET(IF, val);
|
|
|
|
IF_EFLAG_SET(TF, val);
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
} else {
|
2006-03-07 23:32:07 +03:00
|
|
|
if (!strcmp(param->get_name(), "LDTR")) {
|
2006-03-09 23:16:17 +03:00
|
|
|
return BX_CPU(cpu)->ldtr.selector.value;
|
2006-03-07 23:32:07 +03:00
|
|
|
}
|
|
|
|
if (!strcmp(param->get_name(), "TR")) {
|
2006-03-09 23:16:17 +03:00
|
|
|
return BX_CPU(cpu)->tr.selector.value;
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
}
|
2006-03-07 23:32:07 +03:00
|
|
|
IF_SEG_REG_GET (CS);
|
|
|
|
IF_SEG_REG_GET (DS);
|
|
|
|
IF_SEG_REG_GET (SS);
|
|
|
|
IF_SEG_REG_GET (ES);
|
|
|
|
IF_SEG_REG_GET (FS);
|
|
|
|
IF_SEG_REG_GET (GS);
|
|
|
|
IF_LAZY_EFLAG_GET(OF);
|
|
|
|
IF_LAZY_EFLAG_GET(SF);
|
|
|
|
IF_LAZY_EFLAG_GET(ZF);
|
|
|
|
IF_LAZY_EFLAG_GET(AF);
|
|
|
|
IF_LAZY_EFLAG_GET(PF);
|
|
|
|
IF_LAZY_EFLAG_GET(CF);
|
|
|
|
IF_EFLAG_GET(ID);
|
|
|
|
IF_EFLAG_GET(VIP);
|
|
|
|
IF_EFLAG_GET(VIF);
|
|
|
|
IF_EFLAG_GET(AC);
|
|
|
|
IF_EFLAG_GET(VM);
|
|
|
|
IF_EFLAG_GET(RF);
|
|
|
|
IF_EFLAG_GET(NT);
|
|
|
|
IF_EFLAG_GET(IOPL);
|
|
|
|
IF_EFLAG_GET(DF);
|
|
|
|
IF_EFLAG_GET(IF);
|
|
|
|
IF_EFLAG_GET(TF);
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
2006-03-07 23:32:07 +03:00
|
|
|
#undef IF_SEG_REG_GET
|
|
|
|
#undef IF_SEG_REG_SET
|
- 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
|
|
|
|
- apply a patch I've been working on
- modified files: config.h.in cpu/init.cc debug/dbg_main.cc gui/control.cc
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h iodev/keyboard.cc
----------------------------------------------------------------------
Patch name: patch.wx-show-cpu2
Author: Bryce Denney
Date: Fri Sep 6 12:13:28 EDT 2002
Description:
Second try at implementing the "Debug:Show Cpu" and "Debug:Show
Keyboard" dialog with values that change as the simulation proceeds.
(Nobody gets to see the first try.) This is the first step toward
making something resembling a wxWindows debugger.
First, variables which are going to be visible in the CI must be
registered as parameters. For some variables, it might be acceptable
to change them from Bit32u into bx_param_num_c and access them only
with set/get methods, but for most variables it would be a horrible
pain and wreck performance.
To deal with this, I introduced the concept of a shadow parameter. A
normal parameter has its value stored inside the struct, but a shadow
parameter has only a pointer to the value. Shadow params allow you to
treat any variable as if it was a parameter, without having to change
its type and access it using get/set methods. Of course, a shadow
param's value is controlled by someone else, so it can change at any
time.
To demonstrate and test the registration of shadow parameters, I
added code in cpu/init.cc to register a few CPU registers and
code in iodev/keyboard.cc to register a few keyboard state values.
Now these parameters are visible in the Debug:Show CPU and
Debug:Show Keyboard dialog boxes.
The Debug:Show* dialog boxes are created by the ParamDialog class,
which already understands how to display each type of parameter,
including the new shadow parameters (because they are just a subclass
of a normal parameter class). I have added a ParamDialog::Refresh()
method, which rereads the value from every parameter that it is
displaying and changes the displayed value. At the moment, in the
Debug:Show CPU dialog, changing the values has no effect. However
this is trivial to add when it's time (just call CommitChanges!). It
wouldn't really make sense to change the values unless you have paused
the simulation, for example when single stepping with the debugger.
The Refresh() method must be called periodically or else the dialog
will show the initial values forever. At the moment, Refresh() is
called when the simulator sends an async event called
BX_ASYNC_EVT_REFRESH, created by a call to SIM->refresh_ci ().
Details:
- implement shadow parameter class for Bit32s, called bx_shadow_num_c.
implement shadow parameter class for Boolean, called bx_shadow_bool_c.
more to follow (I need one for every type!)
- now the simulator thread can request that the config interface refresh
its display. For now, the refresh event causes the CI to check every
parameter it is watching and change the display value. Later, it may
be worth the trouble to keep track of which parameters have actually
changed. Code in the simulator thread calls SIM->refresh_ci(), which
creates an async event called BX_ASYNC_EVT_REFRESH and sends it to
the config interface. When it arrives in the wxWindows gui thread,
it calls RefreshDialogs(), which calls the Refresh() method on any
dialogs that might need it.
- in the debugger, SIM->refresh_ci() is called before every prompt
is printed. Otherwise, the refresh would wait until the next
SIM->periodic(), which might be thousands of cycles. This way,
when you're single stepping, the dialogs update with every step.
- To improve performance, the CI has a flag (MyFrame::WantRefresh())
which tells whether it has any need for refresh events. If no
dialogs are showing that need refresh events, then no event is sent
between threads.
- add a few defaults to the param classes that affect the settings of
newly created parameters. When declaring a lot of params with
similar settings it's more compact to set the default for new params
rather than to change each one separately. default_text_format is
the printf format string for displaying numbers. default_base is
the default base for displaying numbers (0, 16, 2, etc.)
- I added to ParamDialog to make it able to display modeless dialog
boxes such as "Debug:Show CPU". The new Refresh() method queries
all the parameters for their current value and changes the value in
the wxWindows control. The ParamDialog class still needs a little
work; for example, if it's modal it should have Cancel/Ok buttons,
but if it's going to be modeless it should maybe have Apply (commit
any changes) and Close.
2002-09-06 20:43:26 +04:00
|
|
|
#endif
|
|
|
|
|
2005-11-27 00:36:51 +03:00
|
|
|
void BX_CPU_C::initialize(BX_MEM_C *addrspace)
|
2001-05-23 12:16:07 +04:00
|
|
|
{
|
|
|
|
// BX_CPU_C constructor
|
|
|
|
BX_CPU_THIS_PTR set_INTR (0);
|
2006-01-11 21:22:12 +03:00
|
|
|
|
2001-06-12 17:07:43 +04:00
|
|
|
#if BX_SUPPORT_APIC
|
2006-01-11 21:22:12 +03:00
|
|
|
BX_CPU_THIS_PTR local_apic.set_id(BX_CPU_ID);
|
|
|
|
BX_CPU_THIS_PTR local_apic.init();
|
2001-05-23 12:16:07 +04:00
|
|
|
#endif
|
2006-01-11 21:22:12 +03:00
|
|
|
|
2001-05-23 12:16:07 +04:00
|
|
|
// in SMP mode, the prefix of the CPU will be changed to [CPUn] in
|
|
|
|
// bx_local_apic_c::set_id as soon as the apic ID is assigned.
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2005-03-22 21:19:55 +03:00
|
|
|
// <TAG-INIT-CPU-START>
|
2001-04-10 05:04:59 +04:00
|
|
|
// for decoding instructions: access to seg reg's via index number
|
|
|
|
sreg_mod00_rm16[0] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod00_rm16[1] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod00_rm16[2] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod00_rm16[3] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod00_rm16[4] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod00_rm16[5] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod00_rm16[6] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod00_rm16[7] = BX_SEG_REG_DS;
|
|
|
|
|
2004-12-11 23:51:13 +03:00
|
|
|
sreg_mod01or10_rm16[0] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm16[1] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm16[2] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod01or10_rm16[3] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod01or10_rm16[4] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm16[5] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm16[6] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod01or10_rm16[7] = BX_SEG_REG_DS;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2004-12-11 23:51:13 +03:00
|
|
|
// the default segment to use for a one-byte modrm with
|
|
|
|
// mod==01b or mod==10b and rm == i
|
|
|
|
sreg_mod01or10_rm32[0] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[1] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[2] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[3] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[4] = BX_SEG_REG_NULL;
|
2001-04-10 05:04:59 +04:00
|
|
|
// this entry should never be accessed
|
|
|
|
// (escape to 2-byte)
|
2004-12-11 23:51:13 +03:00
|
|
|
sreg_mod01or10_rm32[5] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod01or10_rm32[6] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[7] = BX_SEG_REG_DS;
|
2002-09-14 04:51:46 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
2004-12-11 23:51:13 +03:00
|
|
|
sreg_mod01or10_rm32[8] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[9] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[10] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[11] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[12] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[13] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[14] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod01or10_rm32[15] = BX_SEG_REG_DS;
|
2002-09-14 04:51:46 +04:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2004-12-11 23:51:13 +03:00
|
|
|
// the default segment to use for a two-byte modrm with
|
|
|
|
// mod==00b and base == i
|
2001-04-10 05:04:59 +04:00
|
|
|
sreg_mod0_base32[0] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[1] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[2] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[3] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[4] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod0_base32[5] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[6] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[7] = BX_SEG_REG_DS;
|
2002-09-14 04:51:46 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
sreg_mod0_base32[8] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[9] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[10] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[11] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[12] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[13] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[14] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod0_base32[15] = BX_SEG_REG_DS;
|
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
// the default segment to use for a two-byte modrm with
|
2004-12-11 23:51:13 +03:00
|
|
|
// mod==01b or mod==10b and base == i
|
2001-04-10 05:04:59 +04:00
|
|
|
sreg_mod1or2_base32[0] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[1] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[2] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[3] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[4] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod1or2_base32[5] = BX_SEG_REG_SS;
|
|
|
|
sreg_mod1or2_base32[6] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[7] = BX_SEG_REG_DS;
|
2002-09-14 04:51:46 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
sreg_mod1or2_base32[8] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[9] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[10] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[11] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[12] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[13] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[14] = BX_SEG_REG_DS;
|
|
|
|
sreg_mod1or2_base32[15] = BX_SEG_REG_DS;
|
|
|
|
#endif
|
2005-03-22 21:19:55 +03:00
|
|
|
// <TAG-INIT-CPU-END>
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2001-05-23 12:16:07 +04:00
|
|
|
mem = addrspace;
|
2006-03-07 23:32:07 +03:00
|
|
|
sprintf(name, "CPU %d", BX_CPU_ID);
|
2001-05-23 12:16:07 +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
|
|
|
#if BX_WITH_WX
|
2006-06-06 22:36:50 +04:00
|
|
|
if (SIM->get_param(BXPN_WX_CPU_STATE) != NULL) {
|
2002-10-01 02:18:53 +04:00
|
|
|
// Register some of the CPUs variables as shadow parameters so that
|
|
|
|
// they can be visible in the config interface.
|
|
|
|
// (Experimental, obviously not a complete list)
|
|
|
|
bx_param_num_c *param;
|
2006-09-07 22:50:51 +04:00
|
|
|
char cpu_name[10], cpu_title[10], cpu_pname[16];
|
2002-10-01 02:18:53 +04:00
|
|
|
const char *fmt16 = "%04X";
|
|
|
|
const char *fmt32 = "%08X";
|
2006-03-07 23:32:07 +03:00
|
|
|
Bit32u oldbase = bx_param_num_c::set_default_base(16);
|
|
|
|
const char *oldfmt = bx_param_num_c::set_default_format(fmt32);
|
2006-03-09 23:16:17 +03:00
|
|
|
sprintf(cpu_name, "%d", BX_CPU_ID);
|
|
|
|
sprintf(cpu_title, "CPU %d", BX_CPU_ID);
|
2006-09-07 22:50:51 +04:00
|
|
|
sprintf(cpu_pname, "%s.%d", BXPN_WX_CPU_STATE, BX_CPU_ID);
|
|
|
|
if (SIM->get_param(cpu_pname) == NULL) {
|
|
|
|
bx_list_c *list = new bx_list_c(SIM->get_param(BXPN_WX_CPU_STATE),
|
|
|
|
cpu_name, cpu_title, 60);
|
2006-05-30 02:33: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
|
|
|
#define DEFPARAM_NORMAL(name,field) \
|
2006-05-27 19:54:49 +04:00
|
|
|
new bx_shadow_num_c(list, #name, &(field))
|
2006-03-07 23:32:07 +03:00
|
|
|
|
|
|
|
DEFPARAM_NORMAL(EAX, EAX);
|
|
|
|
DEFPARAM_NORMAL(EBX, EBX);
|
|
|
|
DEFPARAM_NORMAL(ECX, ECX);
|
|
|
|
DEFPARAM_NORMAL(EDX, EDX);
|
|
|
|
DEFPARAM_NORMAL(ESP, ESP);
|
|
|
|
DEFPARAM_NORMAL(EBP, EBP);
|
|
|
|
DEFPARAM_NORMAL(ESI, ESI);
|
|
|
|
DEFPARAM_NORMAL(EDI, EDI);
|
|
|
|
DEFPARAM_NORMAL(EIP, EIP);
|
|
|
|
DEFPARAM_NORMAL(DR0, dr0);
|
|
|
|
DEFPARAM_NORMAL(DR1, dr1);
|
|
|
|
DEFPARAM_NORMAL(DR2, dr2);
|
|
|
|
DEFPARAM_NORMAL(DR3, dr3);
|
|
|
|
DEFPARAM_NORMAL(DR6, dr6);
|
|
|
|
DEFPARAM_NORMAL(DR7, dr7);
|
|
|
|
DEFPARAM_NORMAL(CR0, cr0.val32);
|
|
|
|
DEFPARAM_NORMAL(CR1, cr1);
|
|
|
|
DEFPARAM_NORMAL(CR2, cr2);
|
|
|
|
DEFPARAM_NORMAL(CR3, cr3);
|
- add infrastructure for sending commands from the wxWindows interface to the
Bochs debugger. The Bochs debugger calls SIM->debug_get_next_command() which
does not return until a debugger command is found. The siminterface sends an
synchronous event to the wxWindows thread with a blank to be filled in with a
debugger command. wxWindows fills in the blank and sends the synchronous
event back, and the Bochs debugger interprets it as if it was typed on
the command line. For the long term I haven't decided whether to stick with
sending text strings vs. some other method.
- so far the wxWindows debugger consists of one big dialog box that shows
all the standard registers, and a working Continue, Stop, and Step button.
- modify ParamDialog so that it is more useful as a base class, by moving
some things to protected members&fields, separating out functionality
that is most likely to be replaced into virtual functions, and making it
generally more flexible. The new CpuRegistersDialog is based on
ParamDialog.
- in wxdialog.cc, continue the convention of using wxID_HELP, wxID_OK,
wxID_CANCEL, etc. for the id's of buttons, instead of wxHELP, wxOK, etc.
which are intended to be ORred together in a bit field.
- cpu/init.cc: put ifdefs around DEFPARAMs for flags in configurations
where they don't exist. Add an eflags shadow parameter that represents all
of the bits of eflags at once. There are also boolean shadow params for
each bit.
- modified files: cpu/init.cc debug/dbg_main.cc debug/debug.h
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h
2002-09-13 23:39:38 +04:00
|
|
|
#if BX_CPU_LEVEL >= 4
|
2006-03-07 23:32:07 +03:00
|
|
|
DEFPARAM_NORMAL(CR4, cr4.registerValue);
|
- add infrastructure for sending commands from the wxWindows interface to the
Bochs debugger. The Bochs debugger calls SIM->debug_get_next_command() which
does not return until a debugger command is found. The siminterface sends an
synchronous event to the wxWindows thread with a blank to be filled in with a
debugger command. wxWindows fills in the blank and sends the synchronous
event back, and the Bochs debugger interprets it as if it was typed on
the command line. For the long term I haven't decided whether to stick with
sending text strings vs. some other method.
- so far the wxWindows debugger consists of one big dialog box that shows
all the standard registers, and a working Continue, Stop, and Step button.
- modify ParamDialog so that it is more useful as a base class, by moving
some things to protected members&fields, separating out functionality
that is most likely to be replaced into virtual functions, and making it
generally more flexible. The new CpuRegistersDialog is based on
ParamDialog.
- in wxdialog.cc, continue the convention of using wxID_HELP, wxID_OK,
wxID_CANCEL, etc. for the id's of buttons, instead of wxHELP, wxOK, etc.
which are intended to be ORred together in a bit field.
- cpu/init.cc: put ifdefs around DEFPARAMs for flags in configurations
where they don't exist. Add an eflags shadow parameter that represents all
of the bits of eflags at once. There are also boolean shadow params for
each bit.
- modified files: cpu/init.cc debug/dbg_main.cc debug/debug.h
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h
2002-09-13 23:39:38 +04:00
|
|
|
#endif
|
- 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
|
|
|
|
2006-09-07 22:50:51 +04:00
|
|
|
// segment registers require a handler function because they have
|
|
|
|
// special get/set requirements.
|
- 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
|
|
|
#define DEFPARAM_SEG_REG(x) \
|
2006-03-07 23:32:07 +03:00
|
|
|
param = new bx_param_num_c(list, \
|
|
|
|
#x, #x, "", 0, 0xffff, 0); \
|
|
|
|
param->set_handler(cpu_param_handler); \
|
|
|
|
param->set_format(fmt16);
|
- 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
|
|
|
#define DEFPARAM_GLOBAL_SEG_REG(name,field) \
|
2006-03-07 23:32:07 +03:00
|
|
|
param = new bx_shadow_num_c(list, \
|
2006-05-27 19:54:49 +04:00
|
|
|
#name"_base", \
|
2006-03-07 23:32:07 +03:00
|
|
|
& BX_CPU_THIS_PTR field.base); \
|
|
|
|
param = new bx_shadow_num_c(list, \
|
2006-05-27 19:54:49 +04:00
|
|
|
#name"_limit", \
|
2006-03-07 23:32:07 +03:00
|
|
|
& BX_CPU_THIS_PTR field.limit);
|
2002-10-01 02:18:53 +04:00
|
|
|
|
2006-09-07 22:50:51 +04:00
|
|
|
DEFPARAM_SEG_REG(CS);
|
|
|
|
DEFPARAM_SEG_REG(DS);
|
|
|
|
DEFPARAM_SEG_REG(SS);
|
|
|
|
DEFPARAM_SEG_REG(ES);
|
|
|
|
DEFPARAM_SEG_REG(FS);
|
|
|
|
DEFPARAM_SEG_REG(GS);
|
|
|
|
DEFPARAM_SEG_REG(LDTR);
|
|
|
|
DEFPARAM_SEG_REG(TR);
|
|
|
|
DEFPARAM_GLOBAL_SEG_REG(GDTR, gdtr);
|
|
|
|
DEFPARAM_GLOBAL_SEG_REG(IDTR, idtr);
|
2006-05-01 22:24:47 +04:00
|
|
|
#undef DEFPARAM_NORMAL
|
2006-04-22 22:14:55 +04:00
|
|
|
#undef DEFPARAM_SEG_REG
|
|
|
|
#undef DEFPARAM_GLOBAL_SEG_REG
|
- 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
|
|
|
|
2006-09-07 22:50:51 +04:00
|
|
|
param = new bx_shadow_num_c(list, "EFLAGS",
|
|
|
|
&BX_CPU_THIS_PTR eflags.val32);
|
- add infrastructure for sending commands from the wxWindows interface to the
Bochs debugger. The Bochs debugger calls SIM->debug_get_next_command() which
does not return until a debugger command is found. The siminterface sends an
synchronous event to the wxWindows thread with a blank to be filled in with a
debugger command. wxWindows fills in the blank and sends the synchronous
event back, and the Bochs debugger interprets it as if it was typed on
the command line. For the long term I haven't decided whether to stick with
sending text strings vs. some other method.
- so far the wxWindows debugger consists of one big dialog box that shows
all the standard registers, and a working Continue, Stop, and Step button.
- modify ParamDialog so that it is more useful as a base class, by moving
some things to protected members&fields, separating out functionality
that is most likely to be replaced into virtual functions, and making it
generally more flexible. The new CpuRegistersDialog is based on
ParamDialog.
- in wxdialog.cc, continue the convention of using wxID_HELP, wxID_OK,
wxID_CANCEL, etc. for the id's of buttons, instead of wxHELP, wxOK, etc.
which are intended to be ORred together in a bit field.
- cpu/init.cc: put ifdefs around DEFPARAMs for flags in configurations
where they don't exist. Add an eflags shadow parameter that represents all
of the bits of eflags at once. There are also boolean shadow params for
each bit.
- modified files: cpu/init.cc debug/dbg_main.cc debug/debug.h
gui/siminterface.cc gui/siminterface.h gui/wxdialog.cc gui/wxdialog.h
gui/wxmain.cc gui/wxmain.h
2002-09-13 23:39:38 +04:00
|
|
|
|
2006-09-07 22:50:51 +04:00
|
|
|
// flags implemented in lazy_flags.cc must be done with a handler
|
|
|
|
// that calls their get function, to force them to be computed.
|
- 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
|
|
|
#define DEFPARAM_EFLAG(name) \
|
2006-03-07 23:32:07 +03:00
|
|
|
param = new bx_param_bool_c(list, \
|
|
|
|
#name, #name, "", get_##name()); \
|
|
|
|
param->set_handler(cpu_param_handler);
|
- 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
|
|
|
#define DEFPARAM_LAZY_EFLAG(name) \
|
2006-03-07 23:32:07 +03:00
|
|
|
param = new bx_param_bool_c(list, \
|
|
|
|
#name, #name, "", get_##name()); \
|
|
|
|
param->set_handler(cpu_param_handler);
|
- 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_LEVEL >= 4
|
2006-09-07 22:50:51 +04:00
|
|
|
DEFPARAM_EFLAG(ID);
|
|
|
|
DEFPARAM_EFLAG(VIP);
|
|
|
|
DEFPARAM_EFLAG(VIF);
|
|
|
|
DEFPARAM_EFLAG(AC);
|
- 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
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-09-07 22:50:51 +04:00
|
|
|
DEFPARAM_EFLAG(VM);
|
|
|
|
DEFPARAM_EFLAG(RF);
|
- 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
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2006-09-07 22:50:51 +04:00
|
|
|
DEFPARAM_EFLAG(NT);
|
|
|
|
// IOPL is a special case because it is 2 bits wide.
|
|
|
|
param = new bx_shadow_num_c(
|
|
|
|
list,
|
|
|
|
"IOPL",
|
|
|
|
&eflags.val32, 10,
|
|
|
|
12, 13);
|
|
|
|
param->set_range(0, 3);
|
|
|
|
param->set_format("%d");
|
- 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
|
|
|
#endif
|
2006-09-07 22:50:51 +04:00
|
|
|
DEFPARAM_LAZY_EFLAG(OF);
|
|
|
|
DEFPARAM_EFLAG(DF);
|
|
|
|
DEFPARAM_EFLAG(IF);
|
|
|
|
DEFPARAM_EFLAG(TF);
|
|
|
|
DEFPARAM_LAZY_EFLAG(SF);
|
|
|
|
DEFPARAM_LAZY_EFLAG(ZF);
|
|
|
|
DEFPARAM_LAZY_EFLAG(AF);
|
|
|
|
DEFPARAM_LAZY_EFLAG(PF);
|
|
|
|
DEFPARAM_LAZY_EFLAG(CF);
|
2002-10-01 02:18:53 +04:00
|
|
|
|
2006-09-07 22:50:51 +04:00
|
|
|
// restore defaults
|
|
|
|
bx_param_num_c::set_default_base(oldbase);
|
|
|
|
bx_param_num_c::set_default_format(oldfmt);
|
|
|
|
}
|
2002-10-01 02:18:53 +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
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_SAVE_RESTORE
|
2006-05-28 21:07:57 +04:00
|
|
|
void BX_CPU_C::register_state(void)
|
2006-05-27 19:54:49 +04:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
char cpu_name[10], cpu_title[10], name[10];
|
|
|
|
|
|
|
|
sprintf(cpu_name, "%d", BX_CPU_ID);
|
|
|
|
sprintf(cpu_title, "CPU %d", BX_CPU_ID);
|
2006-05-30 02:33:38 +04:00
|
|
|
bx_list_c *list = new bx_list_c(SIM->get_param("save_restore.cpu"),
|
|
|
|
cpu_name, cpu_title, 60);
|
|
|
|
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_PARAM_SPECIAL32(list, cpu_version, param_save_handler, param_restore_handler);
|
|
|
|
BXRS_PARAM_SPECIAL32(list, cpuid_std, param_save_handler, param_restore_handler);
|
|
|
|
BXRS_PARAM_SPECIAL32(list, cpuid_ext, param_save_handler, param_restore_handler);
|
2006-05-30 21:01:27 +04:00
|
|
|
BXRS_DEC_PARAM_SIMPLE(list, cpu_mode);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, inhibit_mask);
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RAX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RBX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RCX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RDX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RSP);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RBP);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RSI);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RDI);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R8);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R9);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R10);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R11);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R12);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R13);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R14);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, R15);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, RIP);
|
2006-05-27 19:54:49 +04:00
|
|
|
#else
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EAX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EBX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, ECX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EDX);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, ESP);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EBP);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, ESI);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EDI);
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, EIP);
|
|
|
|
#endif
|
2006-06-02 00:05:15 +04:00
|
|
|
BXRS_PARAM_SPECIAL32(list, EFLAGS,
|
|
|
|
param_save_handler, param_restore_handler);
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR0, dr0);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR1, dr1);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR2, dr2);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR3, dr3);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR6, dr6);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, DR7, dr7);
|
|
|
|
#endif
|
2007-01-12 19:09:39 +03:00
|
|
|
BXRS_HEX_PARAM_FIELD(list, CR0, cr0.val32);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(list, CR2, cr2);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, CR3, cr3);
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_CPU_LEVEL >= 4
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(list, CR4, cr4.registerValue);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
|
|
|
|
2006-05-28 23:18:29 +04:00
|
|
|
for(i=0; i<6; i++) {
|
|
|
|
bx_segment_reg_t *segment = &BX_CPU_THIS_PTR sregs[i];
|
2006-05-30 02:33:38 +04:00
|
|
|
bx_list_c *sreg = new bx_list_c(list, strseg(segment), 9);
|
2006-05-28 23:18:29 +04:00
|
|
|
BXRS_PARAM_SPECIAL16(sreg, selector,
|
|
|
|
param_save_handler, param_restore_handler);
|
|
|
|
BXRS_HEX_PARAM_FIELD(sreg, base, segment->cache.u.segment.base);
|
|
|
|
BXRS_HEX_PARAM_FIELD(sreg, limit, segment->cache.u.segment.limit);
|
|
|
|
BXRS_HEX_PARAM_FIELD(sreg, limit_scaled, segment->cache.u.segment.limit_scaled);
|
|
|
|
BXRS_PARAM_SPECIAL8 (sreg, ar_byte,
|
|
|
|
param_save_handler, param_restore_handler);
|
|
|
|
BXRS_PARAM_BOOL(sreg, granularity, segment->cache.u.segment.g);
|
|
|
|
BXRS_PARAM_BOOL(sreg, d_b, segment->cache.u.segment.d_b);
|
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
BXRS_PARAM_BOOL(sreg, l, segment->cache.u.segment.l);
|
|
|
|
#endif
|
|
|
|
BXRS_PARAM_BOOL(sreg, avl, segment->cache.u.segment.avl);
|
|
|
|
}
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_CPU_LEVEL >= 2
|
2006-05-28 23:18:29 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(list, GDTR_BASE, BX_CPU_THIS_PTR gdtr.base);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, GDTR_LIMIT, BX_CPU_THIS_PTR gdtr.limit);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, IDTR_BASE, BX_CPU_THIS_PTR idtr.base);
|
|
|
|
BXRS_HEX_PARAM_FIELD(list, IDTR_LIMIT, BX_CPU_THIS_PTR idtr.limit);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
|
|
|
|
2006-08-26 11:35:27 +04:00
|
|
|
bx_list_c *LDTR = new bx_list_c (list, "LDTR", 7);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_PARAM_SPECIAL16(LDTR, selector, param_save_handler, param_restore_handler);
|
2006-08-31 22:18:17 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(LDTR, base, ldtr.cache.u.system.base);
|
|
|
|
BXRS_HEX_PARAM_FIELD(LDTR, limit, ldtr.cache.u.system.limit);
|
|
|
|
BXRS_HEX_PARAM_FIELD(LDTR, limit_scaled, ldtr.cache.u.system.limit);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_PARAM_SPECIAL8 (LDTR, ar_byte, param_save_handler, param_restore_handler);
|
2006-08-31 22:18:17 +04:00
|
|
|
BXRS_PARAM_BOOL(LDTR, granularity, ldtr.cache.u.system.g);
|
|
|
|
BXRS_PARAM_BOOL(LDTR, avl, ldtr.cache.u.system.avl);
|
2006-05-28 21:07:57 +04:00
|
|
|
|
|
|
|
bx_list_c *TR = new bx_list_c (list, "TR", 7);
|
|
|
|
BXRS_PARAM_SPECIAL16(TR, selector, param_save_handler, param_restore_handler);
|
2006-08-31 22:18:17 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(TR, base, tr.cache.u.system.base);
|
|
|
|
BXRS_HEX_PARAM_FIELD(TR, limit, tr.cache.u.system.limit);
|
|
|
|
BXRS_HEX_PARAM_FIELD(TR, limit_scaled, tr.cache.u.system.limit_scaled);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_PARAM_SPECIAL8 (TR, ar_byte, param_save_handler, param_restore_handler);
|
2006-08-31 22:18:17 +04:00
|
|
|
BXRS_PARAM_BOOL(TR, granularity, tr.cache.u.system.g);
|
|
|
|
BXRS_PARAM_BOOL(TR, avl, tr.cache.u.system.avl);
|
2006-05-28 21:07:57 +04:00
|
|
|
|
|
|
|
BXRS_HEX_PARAM_SIMPLE(list, smbase);
|
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_CPU_LEVEL >= 5
|
|
|
|
bx_list_c *MSR = new bx_list_c(list, "msr", 12);
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_APIC
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, apicbase, msr.apicbase);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
|
|
|
#if BX_SUPPORT_X86_64
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_PARAM_SPECIAL32(MSR, EFER, param_save_handler, param_restore_handler);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, star, msr.star);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, lstar, msr.lstar);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, cstar, msr.cstar);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, fmask, msr.fmask);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, kernelgsbase, msr.kernelgsbase);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, tsc_aux, msr.tsc_aux);
|
|
|
|
#endif
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, tsc_last_reset, msr.tsc_last_reset);
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_SEP
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, sysenter_cs_msr, msr.sysenter_cs_msr);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, sysenter_esp_msr, msr.sysenter_esp_msr);
|
|
|
|
BXRS_HEX_PARAM_FIELD(MSR, sysenter_eip_msr, msr.sysenter_eip_msr);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_FPU || BX_SUPPORT_MMX
|
2006-05-28 21:07:57 +04:00
|
|
|
bx_list_c *fpu = new bx_list_c(list, "FPU", 17);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, cwd, the_i387.cwd);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, swd, the_i387.swd);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, twd, the_i387.twd);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, foo, the_i387.foo);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, fcs, the_i387.fcs);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, fip, the_i387.fip);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, fds, the_i387.fds);
|
|
|
|
BXRS_HEX_PARAM_FIELD(fpu, fdp, the_i387.fdp);
|
2006-05-27 19:54:49 +04:00
|
|
|
for (i=0; i<8; i++) {
|
|
|
|
sprintf(name, "st%d", i);
|
2006-05-30 02:33:38 +04:00
|
|
|
bx_list_c *STx = new bx_list_c(fpu, name, 8);
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_HEX_PARAM_FIELD(STx, exp, the_i387.st_space[i].exp);
|
|
|
|
BXRS_HEX_PARAM_FIELD(STx, fraction, the_i387.st_space[i].fraction);
|
2006-05-27 19:54:49 +04:00
|
|
|
}
|
2006-05-28 21:07:57 +04:00
|
|
|
BXRS_DEC_PARAM_FIELD(fpu, tos, the_i387.tos);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_SSE
|
2006-05-28 21:07:57 +04:00
|
|
|
bx_list_c *sse = new bx_list_c(list, "SSE", 2*BX_XMM_REGISTERS+1);
|
|
|
|
BXRS_HEX_PARAM_FIELD(sse, mxcsr, mxcsr.mxcsr);
|
2006-05-27 19:54:49 +04:00
|
|
|
for (i=0; i<BX_XMM_REGISTERS; i++) {
|
|
|
|
sprintf(name, "xmm%02d_hi", i);
|
2006-05-30 02:33:38 +04:00
|
|
|
new bx_shadow_num_c(sse, name, &BX_CPU_THIS_PTR xmm[i].xmm64u(1), BASE_HEX);
|
2006-05-27 19:54:49 +04:00
|
|
|
sprintf(name, "xmm%02d_lo", i);
|
2006-05-30 02:33:38 +04:00
|
|
|
new bx_shadow_num_c(sse, name, &BX_CPU_THIS_PTR xmm[i].xmm64u(0), BASE_HEX);
|
2006-05-27 19:54:49 +04:00
|
|
|
}
|
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_APIC
|
2006-06-02 00:05:15 +04:00
|
|
|
local_apic.register_state(list);
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
|
|
|
BXRS_PARAM_BOOL(list, EXT, EXT);
|
|
|
|
BXRS_PARAM_BOOL(list, async_event, async_event);
|
|
|
|
BXRS_PARAM_BOOL(list, INTR, INTR);
|
|
|
|
BXRS_PARAM_BOOL(list, smi_pending, smi_pending);
|
|
|
|
BXRS_PARAM_BOOL(list, nmi_pending, nmi_pending);
|
|
|
|
BXRS_PARAM_BOOL(list, in_smm, in_smm);
|
|
|
|
BXRS_PARAM_BOOL(list, nmi_disable, nmi_disable);
|
2006-06-05 21:33:25 +04:00
|
|
|
BXRS_PARAM_BOOL(list, trace, trace);
|
2006-05-27 19:54:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
Bit64s BX_CPU_C::param_save_handler(void *devptr, bx_param_c *param, Bit64s val)
|
|
|
|
{
|
|
|
|
#if !BX_USE_CPU_SMF
|
|
|
|
BX_CPU_C *class_ptr = (BX_CPU_C *) devptr;
|
|
|
|
return class_ptr->param_save(param, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit64s BX_CPU_C::param_save(bx_param_c *param, Bit64s val)
|
|
|
|
{
|
|
|
|
#else
|
|
|
|
UNUSED(devptr);
|
|
|
|
#endif // !BX_USE_CPU_SMF
|
2006-05-30 02:33:38 +04:00
|
|
|
const char *pname, *segname;
|
2006-05-27 19:54:49 +04:00
|
|
|
bx_segment_reg_t *segment = NULL;
|
|
|
|
|
|
|
|
pname = param->get_name();
|
|
|
|
if (!strcmp(pname, "cpu_version")) {
|
|
|
|
val = get_cpu_version_information();
|
|
|
|
} else if (!strcmp(pname, "cpuid_std")) {
|
|
|
|
val = get_std_cpuid_features();
|
|
|
|
} else if (!strcmp(pname, "cpuid_ext")) {
|
|
|
|
val = get_extended_cpuid_features();
|
2006-06-02 00:05:15 +04:00
|
|
|
} else if (!strcmp(pname, "EFLAGS")) {
|
|
|
|
val = BX_CPU_THIS_PTR read_eflags();
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
} else if (!strcmp(pname, "EFER")) {
|
2006-05-28 21:07:57 +04:00
|
|
|
val = BX_CPU_THIS_PTR get_EFER();
|
2006-05-27 19:54:49 +04:00
|
|
|
#endif
|
|
|
|
} else if (!strcmp(pname, "ar_byte") || !strcmp(pname, "selector")) {
|
|
|
|
segname = param->get_parent()->get_name();
|
|
|
|
if (!strcmp(segname, "CS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS];
|
|
|
|
} else if (!strcmp(segname, "DS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
|
|
|
} else if (!strcmp(segname, "SS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS];
|
|
|
|
} else if (!strcmp(segname, "ES")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES];
|
|
|
|
} else if (!strcmp(segname, "FS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS];
|
|
|
|
} else if (!strcmp(segname, "GS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS];
|
|
|
|
} else if (!strcmp(segname, "LDTR")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR ldtr;
|
|
|
|
} else if (!strcmp(segname, "TR")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR tr;
|
|
|
|
}
|
|
|
|
if (segment != NULL) {
|
|
|
|
if (!strcmp(pname, "ar_byte")) {
|
|
|
|
val = ar_byte(&(segment->cache));
|
|
|
|
}
|
|
|
|
else if (!strcmp(pname, "selector")) {
|
|
|
|
val = segment->selector.value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
BX_PANIC(("Unknown param %s in param_save handler !", pname));
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit64s BX_CPU_C::param_restore_handler(void *devptr, bx_param_c *param, Bit64s val)
|
|
|
|
{
|
|
|
|
#if !BX_USE_CPU_SMF
|
|
|
|
BX_CPU_C *class_ptr = (BX_CPU_C *) devptr;
|
|
|
|
return class_ptr->param_restore(param, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit64s BX_CPU_C::param_restore(bx_param_c *param, Bit64s val)
|
|
|
|
{
|
|
|
|
#else
|
|
|
|
UNUSED(devptr);
|
|
|
|
#endif // !BX_USE_CPU_SMF
|
2006-05-30 02:33:38 +04:00
|
|
|
const char *pname, *segname;
|
2006-05-27 19:54:49 +04:00
|
|
|
bx_segment_reg_t *segment = NULL;
|
|
|
|
|
|
|
|
pname = param->get_name();
|
|
|
|
if (!strcmp(pname, "cpu_version")) {
|
|
|
|
if (val != get_cpu_version_information()) {
|
|
|
|
BX_PANIC(("save/restore: CPU version mismatch"));
|
|
|
|
}
|
|
|
|
} else if (!strcmp(pname, "cpuid_std")) {
|
|
|
|
if (val != get_std_cpuid_features()) {
|
|
|
|
BX_PANIC(("save/restore: CPUID mismatch"));
|
|
|
|
}
|
|
|
|
} else if (!strcmp(pname, "cpuid_ext")) {
|
|
|
|
if (val != get_extended_cpuid_features()) {
|
|
|
|
BX_PANIC(("save/restore: CPUID mismatch"));
|
|
|
|
}
|
2006-06-02 00:05:15 +04:00
|
|
|
} else if (!strcmp(pname, "EFLAGS")) {
|
|
|
|
BX_CPU_THIS_PTR setEFlags(val);
|
2006-05-27 19:54:49 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
} else if (!strcmp(pname, "EFER")) {
|
|
|
|
BX_CPU_THIS_PTR msr.sce = (val >> 0) & 1;
|
|
|
|
BX_CPU_THIS_PTR msr.lme = (val >> 8) & 1;
|
|
|
|
BX_CPU_THIS_PTR msr.lma = (val >> 10) & 1;
|
|
|
|
BX_CPU_THIS_PTR msr.nxe = (val >> 11) & 1;
|
|
|
|
BX_CPU_THIS_PTR msr.ffxsr = (val >> 14) & 1;
|
|
|
|
#endif
|
|
|
|
} else if (!strcmp(pname, "ar_byte") || !strcmp(pname, "selector")) {
|
|
|
|
segname = param->get_parent()->get_name();
|
|
|
|
if (!strcmp(segname, "CS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS];
|
|
|
|
} else if (!strcmp(segname, "DS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
|
|
|
} else if (!strcmp(segname, "SS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS];
|
|
|
|
} else if (!strcmp(segname, "ES")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES];
|
|
|
|
} else if (!strcmp(segname, "FS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS];
|
|
|
|
} else if (!strcmp(segname, "GS")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS];
|
|
|
|
} else if (!strcmp(segname, "LDTR")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR ldtr;
|
|
|
|
} else if (!strcmp(segname, "TR")) {
|
|
|
|
segment = &BX_CPU_THIS_PTR tr;
|
|
|
|
}
|
|
|
|
if (segment != NULL) {
|
|
|
|
bx_descriptor_t *d = &(segment->cache);
|
|
|
|
bx_selector_t *selector = &(segment->selector);
|
|
|
|
if (!strcmp(pname, "ar_byte")) {
|
|
|
|
set_ar_byte(d, val);
|
|
|
|
}
|
|
|
|
else if (!strcmp(pname, "selector")) {
|
|
|
|
parse_selector(val, selector);
|
|
|
|
// validate the selector
|
|
|
|
if ((selector->value & 0xfffc) != 0) d->valid = 1;
|
|
|
|
else d->valid = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
BX_PANIC(("Unknown param %s in param_restore handler !", pname));
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2006-05-28 21:07:57 +04:00
|
|
|
void BX_CPU_C::after_restore_state(void)
|
2006-05-27 19:54:49 +04:00
|
|
|
{
|
|
|
|
SetCR0(cr0.val32);
|
|
|
|
CR3_change(cr3);
|
|
|
|
TLB_flush(1);
|
|
|
|
assert_checks();
|
|
|
|
invalidate_prefetch_q();
|
|
|
|
debug(RIP);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-05-28 21:07:57 +04:00
|
|
|
BX_CPU_C::~BX_CPU_C()
|
2001-04-10 05:04:59 +04:00
|
|
|
{
|
2003-02-13 18:04:11 +03:00
|
|
|
BX_INSTR_SHUTDOWN(BX_CPU_ID);
|
2006-05-27 19:54:49 +04:00
|
|
|
BX_DEBUG(("Exit."));
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
|
2004-10-16 14:18:01 +04:00
|
|
|
void BX_CPU_C::reset(unsigned source)
|
2001-04-10 05:04:59 +04:00
|
|
|
{
|
|
|
|
UNUSED(source); // either BX_RESET_HARDWARE or BX_RESET_SOFTWARE
|
|
|
|
|
2004-11-14 22:29:34 +03:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
RAX = 0; // processor passed test :-)
|
|
|
|
RBX = 0;
|
|
|
|
RCX = 0;
|
|
|
|
RDX = get_cpu_version_information();
|
|
|
|
RBP = 0;
|
|
|
|
RSI = 0;
|
|
|
|
RDI = 0;
|
|
|
|
RSP = 0;
|
|
|
|
R8 = 0;
|
|
|
|
R9 = 0;
|
|
|
|
R10 = 0;
|
|
|
|
R11 = 0;
|
|
|
|
R12 = 0;
|
|
|
|
R13 = 0;
|
|
|
|
R14 = 0;
|
|
|
|
R15 = 0;
|
|
|
|
#else
|
2001-04-10 05:04:59 +04:00
|
|
|
// general registers
|
|
|
|
EAX = 0; // processor passed test :-)
|
2004-11-14 22:29:34 +03:00
|
|
|
EBX = 0;
|
|
|
|
ECX = 0;
|
|
|
|
EDX = get_cpu_version_information();
|
|
|
|
EBP = 0;
|
|
|
|
ESI = 0;
|
|
|
|
EDI = 0;
|
|
|
|
ESP = 0;
|
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
// all status flags at known values, use BX_CPU_THIS_PTR eflags structure
|
|
|
|
BX_CPU_THIS_PTR lf_flags_status = 0x000000;
|
|
|
|
|
|
|
|
// status and control flags register set
|
2002-09-22 22:22:24 +04:00
|
|
|
BX_CPU_THIS_PTR setEFlags(0x2); // Bit1 is always set
|
2002-09-12 22:10:46 +04:00
|
|
|
BX_CPU_THIS_PTR clear_IF ();
|
2001-04-10 05:04:59 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2002-09-12 22:10:46 +04:00
|
|
|
BX_CPU_THIS_PTR clear_RF ();
|
|
|
|
BX_CPU_THIS_PTR clear_VM ();
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 4
|
2002-09-12 22:10:46 +04:00
|
|
|
BX_CPU_THIS_PTR clear_AC ();
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
BX_CPU_THIS_PTR inhibit_mask = 0;
|
|
|
|
BX_CPU_THIS_PTR debug_trap = 0;
|
|
|
|
|
|
|
|
/* instruction pointer */
|
|
|
|
#if BX_CPU_LEVEL < 2
|
2004-10-14 00:58:16 +04:00
|
|
|
BX_CPU_THIS_PTR prev_eip = EIP = 0x00000000;
|
2001-04-10 05:04:59 +04:00
|
|
|
#else /* from 286 up */
|
|
|
|
BX_CPU_THIS_PTR prev_eip =
|
2002-09-14 04:51:46 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
RIP = 0x0000FFF0;
|
|
|
|
#else
|
|
|
|
EIP = 0x0000FFF0;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
2002-09-14 04:51:46 +04:00
|
|
|
#endif
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
/* CS (Code Segment) and descriptor cache */
|
|
|
|
/* Note: on a real cpu, CS initially points to upper memory. After
|
|
|
|
* the 1st jump, the descriptor base is zero'd out. Since I'm just
|
|
|
|
* going to jump to my BIOS, I don't need to do this.
|
|
|
|
* For future reference:
|
|
|
|
* processor cs.selector cs.base cs.limit EIP
|
|
|
|
* 8086 FFFF FFFF0 FFFF 0000
|
|
|
|
* 286 F000 FF0000 FFFF FFF0
|
|
|
|
* 386+ F000 FFFF0000 FFFF FFF0
|
|
|
|
*/
|
|
|
|
|
2006-06-12 01:37:22 +04:00
|
|
|
parse_selector(0xf000,
|
|
|
|
&BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector);
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2004-11-15 00:25:42 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.valid = 1;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.p = 1;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.dpl = 0;
|
2005-11-19 22:38:45 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.segment = 1; /* data/code segment */
|
2006-06-12 20:58:27 +04:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.type = BX_CODE_EXEC_READ_ACCESSED;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2004-11-19 12:39:30 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.base = 0xFFFF0000;
|
2006-02-28 22:50:08 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit = 0xFFFF;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.limit_scaled = 0xFFFF;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.g = 0; /* byte granular */
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.d_b = 0; /* 16bit default size */
|
2005-11-08 01:45:25 +03:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.l = 0; /* 16bit default size */
|
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.avl = 0;
|
|
|
|
#endif
|
|
|
|
|
2006-01-16 22:22:28 +03:00
|
|
|
#if BX_SUPPORT_ICACHE
|
2006-03-27 22:02:07 +04:00
|
|
|
BX_CPU_THIS_PTR updateFetchModeMask();
|
2006-01-16 22:22:28 +03:00
|
|
|
#endif
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
/* DS (Data Segment) and descriptor cache */
|
|
|
|
|
2006-06-12 01:37:22 +04:00
|
|
|
parse_selector(0x0000,
|
|
|
|
&BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector);
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2004-11-15 00:25:42 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.valid = 1;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.p = 1;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.dpl = 0;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.segment = 1; /* data/code segment */
|
2006-06-12 20:58:27 +04:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.type = BX_DATA_READ_WRITE_ACCESSED;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.base = 0x00000000;
|
2006-02-28 22:50:08 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit = 0xFFFF;
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.limit_scaled = 0xFFFF;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-02-28 22:50:08 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.avl = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.g = 0; /* byte granular */
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.d_b = 0; /* 16bit default size */
|
2005-11-08 01:45:25 +03:00
|
|
|
#if BX_SUPPORT_X86_64
|
2005-11-19 22:38:45 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].cache.u.segment.l = 0; /* 16bit default size */
|
2005-11-08 01:45:25 +03:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
2006-02-28 22:50:08 +03:00
|
|
|
// use DS segment as template for the others
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS] = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES] = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
2001-04-10 05:04:59 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-02-28 22:50:08 +03:00
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS] = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS] = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS];
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2004-10-16 14:18:01 +04:00
|
|
|
/* GDTR (Global Descriptor Table Register) */
|
2005-11-19 22:38:45 +03:00
|
|
|
BX_CPU_THIS_PTR gdtr.base = 0x00000000;
|
|
|
|
BX_CPU_THIS_PTR gdtr.limit = 0xFFFF;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
/* IDTR (Interrupt Descriptor Table Register) */
|
2005-11-19 22:38:45 +03:00
|
|
|
BX_CPU_THIS_PTR idtr.base = 0x00000000;
|
|
|
|
BX_CPU_THIS_PTR idtr.limit = 0xFFFF; /* always byte granular */
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
/* LDTR (Local Descriptor Table Register) */
|
2004-10-16 14:18:01 +04:00
|
|
|
BX_CPU_THIS_PTR ldtr.selector.value = 0x0000;
|
|
|
|
BX_CPU_THIS_PTR ldtr.selector.index = 0x0000;
|
2004-11-15 00:25:42 +03:00
|
|
|
BX_CPU_THIS_PTR ldtr.selector.ti = 0;
|
|
|
|
BX_CPU_THIS_PTR ldtr.selector.rpl = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2005-11-19 21:27:15 +03:00
|
|
|
BX_CPU_THIS_PTR ldtr.cache.valid = 1; /* valid */
|
|
|
|
BX_CPU_THIS_PTR ldtr.cache.p = 1; /* present */
|
2004-11-15 00:25:42 +03:00
|
|
|
BX_CPU_THIS_PTR ldtr.cache.dpl = 0; /* field not used */
|
|
|
|
BX_CPU_THIS_PTR ldtr.cache.segment = 0; /* system segment */
|
2006-05-21 23:31:23 +04:00
|
|
|
BX_CPU_THIS_PTR ldtr.cache.type = BX_SYS_SEGMENT_LDT;
|
2006-08-31 22:18:17 +04:00
|
|
|
BX_CPU_THIS_PTR ldtr.cache.u.system.base = 0x00000000;
|
|
|
|
BX_CPU_THIS_PTR ldtr.cache.u.system.limit = 0xFFFF;
|
2006-08-25 23:56:03 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-08-31 22:21:16 +04:00
|
|
|
BX_CPU_THIS_PTR ldtr.cache.u.system.limit_scaled = 0xFFFF;
|
|
|
|
BX_CPU_THIS_PTR ldtr.cache.u.system.avl = 0;
|
|
|
|
BX_CPU_THIS_PTR ldtr.cache.u.system.g = 0; /* byte granular */
|
2006-08-25 23:56:03 +04:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2004-11-15 00:25:42 +03:00
|
|
|
/* TR (Task Register) */
|
|
|
|
BX_CPU_THIS_PTR tr.selector.value = 0x0000;
|
|
|
|
BX_CPU_THIS_PTR tr.selector.index = 0x0000; /* undefined */
|
|
|
|
BX_CPU_THIS_PTR tr.selector.ti = 0;
|
|
|
|
BX_CPU_THIS_PTR tr.selector.rpl = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2005-11-19 21:27:15 +03:00
|
|
|
BX_CPU_THIS_PTR tr.cache.valid = 1; /* valid */
|
|
|
|
BX_CPU_THIS_PTR tr.cache.p = 1; /* present */
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR tr.cache.dpl = 0; /* field not used */
|
2005-11-19 21:27:15 +03:00
|
|
|
BX_CPU_THIS_PTR tr.cache.segment = 0; /* system segment */
|
2006-05-21 23:31:23 +04:00
|
|
|
BX_CPU_THIS_PTR tr.cache.type = BX_SYS_SEGMENT_BUSY_286_TSS;
|
2006-08-31 22:18:17 +04:00
|
|
|
BX_CPU_THIS_PTR tr.cache.u.system.base = 0x00000000;
|
|
|
|
BX_CPU_THIS_PTR tr.cache.u.system.limit = 0xFFFF;
|
2006-05-22 00:41:48 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-08-31 22:18:17 +04:00
|
|
|
BX_CPU_THIS_PTR tr.cache.u.system.limit_scaled = 0xFFFF;
|
|
|
|
BX_CPU_THIS_PTR tr.cache.u.system.avl = 0;
|
|
|
|
BX_CPU_THIS_PTR tr.cache.u.system.g = 0; /* byte granular */
|
2006-05-22 00:41:48 +04:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// DR0 - DR7 (Debug Registers)
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
BX_CPU_THIS_PTR dr0 = 0; /* undefined */
|
|
|
|
BX_CPU_THIS_PTR dr1 = 0; /* undefined */
|
|
|
|
BX_CPU_THIS_PTR dr2 = 0; /* undefined */
|
|
|
|
BX_CPU_THIS_PTR dr3 = 0; /* undefined */
|
|
|
|
#endif
|
2006-02-28 22:50:08 +03:00
|
|
|
|
|
|
|
BX_CPU_THIS_PTR dr7 = 0x00000400;
|
2001-04-10 05:04:59 +04:00
|
|
|
#if BX_CPU_LEVEL == 3
|
|
|
|
BX_CPU_THIS_PTR dr6 = 0xFFFF1FF0;
|
|
|
|
#elif BX_CPU_LEVEL == 4
|
|
|
|
BX_CPU_THIS_PTR dr6 = 0xFFFF1FF0;
|
|
|
|
#elif BX_CPU_LEVEL == 5
|
|
|
|
BX_CPU_THIS_PTR dr6 = 0xFFFF0FF0;
|
2001-05-23 12:16:07 +04:00
|
|
|
#elif BX_CPU_LEVEL == 6
|
|
|
|
BX_CPU_THIS_PTR dr6 = 0xFFFF0FF0;
|
2001-04-10 05:04:59 +04:00
|
|
|
#else
|
2006-02-28 22:50:08 +03:00
|
|
|
# error "DR6: CPU > 6"
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
2005-03-15 22:00:04 +03:00
|
|
|
BX_CPU_THIS_PTR cpu_mode = BX_MODE_IA32_REAL;
|
|
|
|
|
2006-02-14 22:00:08 +03:00
|
|
|
BX_CPU_THIS_PTR smi_pending = 0;
|
|
|
|
BX_CPU_THIS_PTR nmi_pending = 0;
|
2006-02-14 23:03:14 +03:00
|
|
|
BX_CPU_THIS_PTR in_smm = 0;
|
2006-03-16 23:24:09 +03:00
|
|
|
BX_CPU_THIS_PTR nmi_disable = 0;
|
2006-02-14 22:00:08 +03:00
|
|
|
|
2006-04-05 21:31:35 +04:00
|
|
|
BX_CPU_THIS_PTR smbase = 0x30000;
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
#if BX_CPU_LEVEL >= 2
|
|
|
|
// MSW (Machine Status Word), so called on 286
|
|
|
|
// CR0 (Control Register 0), so called on 386+
|
|
|
|
BX_CPU_THIS_PTR cr0.ts = 0; // no task switch
|
|
|
|
BX_CPU_THIS_PTR cr0.em = 0; // emulate math coprocessor
|
|
|
|
BX_CPU_THIS_PTR cr0.mp = 0; // wait instructions not trapped
|
|
|
|
BX_CPU_THIS_PTR cr0.pe = 0; // real mode
|
|
|
|
BX_CPU_THIS_PTR cr0.val32 = 0;
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
BX_CPU_THIS_PTR cr0.pg = 0; // paging disabled
|
|
|
|
// no change to cr0.val32
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 4
|
2005-02-17 00:27:21 +03:00
|
|
|
BX_CPU_THIS_PTR cr0.cd = 0;
|
|
|
|
BX_CPU_THIS_PTR cr0.nw = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR cr0.am = 0; // disable alignment check
|
|
|
|
BX_CPU_THIS_PTR cr0.wp = 0; // disable write-protect
|
2006-03-04 19:58:10 +03:00
|
|
|
BX_CPU_THIS_PTR cr0.ne = 0; // np exceptions through int 13H, DOS compat
|
2005-02-17 00:27:21 +03:00
|
|
|
BX_CPU_THIS_PTR cr0.val32 |= 0x00000000;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// handle reserved bits
|
|
|
|
#if BX_CPU_LEVEL == 3
|
|
|
|
// reserved bits all set to 1 on 386
|
|
|
|
BX_CPU_THIS_PTR cr0.val32 |= 0x7ffffff0;
|
|
|
|
#elif BX_CPU_LEVEL >= 4
|
|
|
|
// bit 4 is hardwired to 1 on all x86
|
|
|
|
BX_CPU_THIS_PTR cr0.val32 |= 0x00000010;
|
|
|
|
#endif
|
|
|
|
#endif // CPU >= 2
|
|
|
|
|
2006-03-04 19:58:10 +03:00
|
|
|
// CR0 paging might be modified
|
|
|
|
TLB_flush(1);
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-05-28 21:07:57 +04:00
|
|
|
BX_CPU_THIS_PTR cr1 = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR cr2 = 0;
|
|
|
|
BX_CPU_THIS_PTR cr3 = 0;
|
2003-12-31 01:12:45 +03:00
|
|
|
BX_CPU_THIS_PTR cr3_masked = 0;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
#if BX_CPU_LEVEL >= 4
|
2002-09-14 23:21:41 +04:00
|
|
|
BX_CPU_THIS_PTR cr4.setRegister(0);
|
2002-09-14 04:51:46 +04:00
|
|
|
#endif
|
|
|
|
|
2002-03-27 19:04:05 +03:00
|
|
|
/* initialise MSR registers to defaults */
|
|
|
|
#if BX_CPU_LEVEL >= 5
|
2006-03-15 20:57:11 +03:00
|
|
|
#if BX_SUPPORT_APIC
|
2002-03-27 19:04:05 +03:00
|
|
|
/* APIC Address, APIC enabled and BSP is default, we'll fill in the rest later */
|
2006-03-07 01:03:16 +03:00
|
|
|
BX_CPU_THIS_PTR msr.apicbase = BX_LAPIC_BASE_ADDR;
|
2006-03-15 20:57:11 +03:00
|
|
|
BX_CPU_THIS_PTR local_apic.init();
|
2004-02-12 03:56:21 +03:00
|
|
|
BX_CPU_THIS_PTR msr.apicbase |= 0x900;
|
2004-12-14 23:41:55 +03:00
|
|
|
#endif
|
2002-09-14 04:51:46 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
BX_CPU_THIS_PTR msr.lme = BX_CPU_THIS_PTR msr.lma = 0;
|
2006-05-28 21:07:57 +04:00
|
|
|
BX_CPU_THIS_PTR msr.sce = BX_CPU_THIS_PTR msr.nxe = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.ffxsr = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.star = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.lstar = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.cstar = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.fmask = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.kernelgsbase = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.tsc_aux = 0;
|
2002-09-14 04:51:46 +04:00
|
|
|
#endif
|
2006-01-21 15:06:03 +03:00
|
|
|
BX_CPU_THIS_PTR set_TSC(0);
|
2002-03-27 19:04:05 +03:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2006-06-03 16:59:14 +04:00
|
|
|
#if BX_SUPPORT_SEP
|
2006-05-28 21:07:57 +04:00
|
|
|
BX_CPU_THIS_PTR msr.sysenter_cs_msr = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.sysenter_esp_msr = 0;
|
|
|
|
BX_CPU_THIS_PTR msr.sysenter_eip_msr = 0;
|
2006-06-03 16:59:14 +04:00
|
|
|
#endif
|
2006-05-28 21:07:57 +04:00
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR EXT = 0;
|
|
|
|
|
2001-08-10 22:42:24 +04:00
|
|
|
#if BX_USE_TLB
|
2001-04-10 05:04:59 +04:00
|
|
|
TLB_init();
|
2001-08-10 22:42:24 +04:00
|
|
|
#endif // BX_USE_TLB
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2006-03-15 20:57:11 +03:00
|
|
|
// invalidate the prefetch queue
|
2002-09-02 22:44:35 +04:00
|
|
|
BX_CPU_THIS_PTR eipPageBias = 0;
|
|
|
|
BX_CPU_THIS_PTR eipPageWindowSize = 0;
|
|
|
|
BX_CPU_THIS_PTR eipFetchPtr = NULL;
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
#if BX_DEBUGGER
|
2004-01-29 20:49:03 +03:00
|
|
|
#if BX_MAGIC_BREAKPOINT
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR magic_break = 0;
|
|
|
|
#endif
|
|
|
|
BX_CPU_THIS_PTR stop_reason = STOP_NO_REASON;
|
2002-11-19 08:52:52 +03:00
|
|
|
BX_CPU_THIS_PTR trace_reg = 0;
|
2006-01-24 22:03:55 +03:00
|
|
|
BX_CPU_THIS_PTR dbg_cpu_mode = BX_CPU_THIS_PTR cpu_mode;
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
2005-12-12 22:54:48 +03:00
|
|
|
BX_CPU_THIS_PTR trace = 0;
|
|
|
|
|
2004-06-18 18:11:11 +04:00
|
|
|
// Reset the Floating Point Unit
|
2003-04-23 00:21:34 +04:00
|
|
|
#if BX_SUPPORT_FPU
|
2004-11-15 00:25:42 +03:00
|
|
|
BX_CPU_THIS_PTR the_i387.reset(); // unchanged on #INIT
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Reset XMM state
|
|
|
|
#if BX_SUPPORT_SSE >= 1 // unchanged on #INIT
|
|
|
|
for(unsigned index=0; index < BX_XMM_REGISTERS; index++)
|
|
|
|
{
|
|
|
|
BX_CPU_THIS_PTR xmm[index].xmm64u(0) = 0;
|
|
|
|
BX_CPU_THIS_PTR xmm[index].xmm64u(1) = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
BX_CPU_THIS_PTR mxcsr.mxcsr = MXCSR_RESET;
|
2003-04-23 00:21:34 +04:00
|
|
|
#endif
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2006-01-18 21:35:38 +03:00
|
|
|
#if BX_SUPPORT_SMP
|
2001-05-23 12:16:07 +04:00
|
|
|
// notice if I'm the bootstrap processor. If not, do the equivalent of
|
|
|
|
// a HALT instruction.
|
2006-03-15 20:57:11 +03:00
|
|
|
int apic_id = local_apic.get_id();
|
|
|
|
if (BX_BOOTSTRAP_PROCESSOR == apic_id) {
|
2001-05-23 12:16:07 +04:00
|
|
|
// boot normally
|
2002-10-04 21:04:33 +04:00
|
|
|
BX_CPU_THIS_PTR msr.apicbase |= 0x0100; /* set bit 8 BSP */
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_INFO(("CPU[%d] is the bootstrap processor", apic_id));
|
2001-05-23 12:16:07 +04:00
|
|
|
} else {
|
|
|
|
// it's an application processor, halt until IPI is heard.
|
2002-10-04 21:04:33 +04:00
|
|
|
BX_CPU_THIS_PTR msr.apicbase &= ~0x0100; /* clear bit 8 BSP */
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_INFO(("CPU[%d] is an application processor. Halting until IPI.", apic_id));
|
2006-04-10 23:05:21 +04:00
|
|
|
debug_trap |= BX_DEBUG_TRAP_HALT_STATE;
|
2001-05-23 12:16:07 +04:00
|
|
|
async_event = 1;
|
|
|
|
}
|
|
|
|
#endif
|
2002-09-28 04:54:05 +04:00
|
|
|
|
2003-02-13 18:04:11 +03:00
|
|
|
BX_INSTR_RESET(BX_CPU_ID);
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
|
2004-10-16 14:18:01 +04:00
|
|
|
void BX_CPU_C::sanity_checks(void)
|
2001-04-10 05:04:59 +04:00
|
|
|
{
|
|
|
|
Bit8u al, cl, dl, bl, ah, ch, dh, bh;
|
|
|
|
Bit16u ax, cx, dx, bx, sp, bp, si, di;
|
|
|
|
Bit32u eax, ecx, edx, ebx, esp, ebp, esi, edi;
|
|
|
|
|
|
|
|
EAX = 0xFFEEDDCC;
|
|
|
|
ECX = 0xBBAA9988;
|
|
|
|
EDX = 0x77665544;
|
|
|
|
EBX = 0x332211FF;
|
|
|
|
ESP = 0xEEDDCCBB;
|
|
|
|
EBP = 0xAA998877;
|
|
|
|
ESI = 0x66554433;
|
|
|
|
EDI = 0x2211FFEE;
|
|
|
|
|
|
|
|
al = AL;
|
|
|
|
cl = CL;
|
|
|
|
dl = DL;
|
|
|
|
bl = BL;
|
|
|
|
ah = AH;
|
|
|
|
ch = CH;
|
|
|
|
dh = DH;
|
|
|
|
bh = BH;
|
|
|
|
|
|
|
|
if ( al != (EAX & 0xFF) ||
|
|
|
|
cl != (ECX & 0xFF) ||
|
|
|
|
dl != (EDX & 0xFF) ||
|
|
|
|
bl != (EBX & 0xFF) ||
|
|
|
|
ah != ((EAX >> 8) & 0xFF) ||
|
|
|
|
ch != ((ECX >> 8) & 0xFF) ||
|
|
|
|
dh != ((EDX >> 8) & 0xFF) ||
|
2006-02-28 22:50:08 +03:00
|
|
|
bh != ((EBX >> 8) & 0xFF) )
|
|
|
|
{
|
2002-09-14 04:51:46 +04:00
|
|
|
BX_PANIC(("problems using BX_READ_8BIT_REGx()!"));
|
2006-02-28 22:50:08 +03:00
|
|
|
}
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
ax = AX;
|
|
|
|
cx = CX;
|
|
|
|
dx = DX;
|
|
|
|
bx = BX;
|
|
|
|
sp = SP;
|
|
|
|
bp = BP;
|
|
|
|
si = SI;
|
|
|
|
di = DI;
|
|
|
|
|
|
|
|
if ( ax != (EAX & 0xFFFF) ||
|
|
|
|
cx != (ECX & 0xFFFF) ||
|
|
|
|
dx != (EDX & 0xFFFF) ||
|
|
|
|
bx != (EBX & 0xFFFF) ||
|
|
|
|
sp != (ESP & 0xFFFF) ||
|
|
|
|
bp != (EBP & 0xFFFF) ||
|
|
|
|
si != (ESI & 0xFFFF) ||
|
2006-02-28 22:50:08 +03:00
|
|
|
di != (EDI & 0xFFFF) )
|
|
|
|
{
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("problems using BX_READ_16BIT_REG()!"));
|
2006-02-28 22:50:08 +03:00
|
|
|
}
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
eax = EAX;
|
|
|
|
ecx = ECX;
|
|
|
|
edx = EDX;
|
|
|
|
ebx = EBX;
|
|
|
|
esp = ESP;
|
|
|
|
ebp = EBP;
|
|
|
|
esi = ESI;
|
|
|
|
edi = EDI;
|
|
|
|
|
|
|
|
if (sizeof(Bit8u) != 1 || sizeof(Bit8s) != 1)
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("data type Bit8u or Bit8s is not of length 1 byte!"));
|
2001-04-10 05:04:59 +04:00
|
|
|
if (sizeof(Bit16u) != 2 || sizeof(Bit16s) != 2)
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("data type Bit16u or Bit16s is not of length 2 bytes!"));
|
2001-04-10 05:04:59 +04:00
|
|
|
if (sizeof(Bit32u) != 4 || sizeof(Bit32s) != 4)
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("data type Bit32u or Bit32s is not of length 4 bytes!"));
|
2003-08-07 23:22:37 +04:00
|
|
|
if (sizeof(Bit64u) != 8 || sizeof(Bit64s) != 8)
|
|
|
|
BX_PANIC(("data type Bit64u or Bit64u is not of length 8 bytes!"));
|
2001-04-10 05:04:59 +04:00
|
|
|
|
2006-01-26 01:20:00 +03:00
|
|
|
BX_DEBUG(("#(%u)all sanity checks passed!", BX_CPU_ID));
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
|
2006-04-25 18:42:57 +04:00
|
|
|
void BX_CPU_C::assert_checks(void)
|
|
|
|
{
|
|
|
|
// check CPU mode consistency
|
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
if (BX_CPU_THIS_PTR msr.lma) {
|
|
|
|
if (! BX_CPU_THIS_PTR cr0.pe) {
|
|
|
|
BX_PANIC(("assert_checks: EFER.LMA is set when CR0.PE=0 !"));
|
|
|
|
}
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.l) {
|
|
|
|
if (BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64)
|
|
|
|
BX_PANIC(("assert_checks: unconsistent cpu_mode BX_MODE_LONG_64 !"));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_COMPAT)
|
|
|
|
BX_PANIC(("assert_checks: unconsistent cpu_mode BX_MODE_LONG_COMPAT !"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
if (BX_CPU_THIS_PTR cr0.pe) {
|
|
|
|
if (BX_CPU_THIS_PTR get_VM()) {
|
|
|
|
if (BX_CPU_THIS_PTR cpu_mode != BX_MODE_IA32_V8086)
|
|
|
|
BX_PANIC(("assert_checks: unconsistent cpu_mode BX_MODE_IA32_V8086 !"));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (BX_CPU_THIS_PTR cpu_mode != BX_MODE_IA32_PROTECTED)
|
|
|
|
BX_PANIC(("assert_checks: unconsistent cpu_mode BX_MODE_IA32_PROTECTED !"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (BX_CPU_THIS_PTR cpu_mode != BX_MODE_IA32_REAL)
|
|
|
|
BX_PANIC(("assert_checks: unconsistent cpu_mode BX_MODE_IA32_REAL !"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if BX_SUPPORT_X86_64
|
2006-05-20 00:04:33 +04:00
|
|
|
// VM should be OFF in long mode
|
2006-10-04 23:08:40 +04:00
|
|
|
if (long_mode()) {
|
2006-04-25 18:42:57 +04:00
|
|
|
if (BX_CPU_THIS_PTR get_VM()) BX_PANIC(("assert_checks: VM is set in long mode !"));
|
|
|
|
}
|
2006-05-20 00:04:33 +04:00
|
|
|
|
|
|
|
// CS.L and CS.D_B are mutualy exclusive
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.l &&
|
|
|
|
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].cache.u.segment.d_b)
|
|
|
|
{
|
|
|
|
BX_PANIC(("assert_checks: CS.l and CS.d_b set together !"));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-05-21 23:31:23 +04:00
|
|
|
// check LDTR type
|
2006-06-05 20:36:56 +04:00
|
|
|
if (BX_CPU_THIS_PTR ldtr.cache.valid)
|
2006-05-21 23:31:23 +04:00
|
|
|
{
|
2006-06-05 20:36:56 +04:00
|
|
|
if (BX_CPU_THIS_PTR ldtr.cache.type != BX_SYS_SEGMENT_LDT)
|
|
|
|
{
|
|
|
|
BX_PANIC(("assert_checks: LDTR is not LDT type !"));
|
|
|
|
}
|
2006-05-21 23:31:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// check Task Register type
|
2006-06-05 20:36:56 +04:00
|
|
|
if(BX_CPU_THIS_PTR tr.cache.valid)
|
2006-05-21 23:31:23 +04:00
|
|
|
{
|
2006-06-05 20:36:56 +04:00
|
|
|
switch(BX_CPU_THIS_PTR tr.cache.type)
|
|
|
|
{
|
|
|
|
case BX_SYS_SEGMENT_BUSY_286_TSS:
|
|
|
|
case BX_SYS_SEGMENT_AVAIL_286_TSS:
|
2006-05-22 00:41:48 +04:00
|
|
|
#if BX_CPU_LEVEL >= 3
|
2006-08-31 22:18:17 +04:00
|
|
|
if (BX_CPU_THIS_PTR tr.cache.u.system.g != 0)
|
2006-06-05 20:36:56 +04:00
|
|
|
BX_PANIC(("assert_checks: tss286.g != 0 !"));
|
2006-08-31 22:18:17 +04:00
|
|
|
if (BX_CPU_THIS_PTR tr.cache.u.system.avl != 0)
|
2006-06-05 20:36:56 +04:00
|
|
|
BX_PANIC(("assert_checks: tss286.avl != 0 !"));
|
2006-05-22 00:41:48 +04:00
|
|
|
#endif
|
2006-06-05 20:36:56 +04:00
|
|
|
break;
|
|
|
|
case BX_SYS_SEGMENT_BUSY_386_TSS:
|
|
|
|
case BX_SYS_SEGMENT_AVAIL_386_TSS:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BX_PANIC(("assert_checks: TR is not TSS type !"));
|
|
|
|
}
|
2006-05-21 23:31:23 +04:00
|
|
|
}
|
|
|
|
|
2006-05-20 00:04:33 +04:00
|
|
|
// validate CR0 register
|
|
|
|
if (BX_CPU_THIS_PTR cr0.pe != (BX_CPU_THIS_PTR cr0.val32 & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.PE !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.mp != ((BX_CPU_THIS_PTR cr0.val32 >> 1) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.MP !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.em != ((BX_CPU_THIS_PTR cr0.val32 >> 2) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.EM !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.ts != ((BX_CPU_THIS_PTR cr0.val32 >> 3) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.TS !"));
|
|
|
|
#if BX_CPU_LEVEL >= 4
|
|
|
|
if (BX_CPU_THIS_PTR cr0.ne != ((BX_CPU_THIS_PTR cr0.val32 >> 5) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.NE !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.wp != ((BX_CPU_THIS_PTR cr0.val32 >> 16) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.WP !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.am != ((BX_CPU_THIS_PTR cr0.val32 >> 18) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.AM !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.nw != ((BX_CPU_THIS_PTR cr0.val32 >> 29) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.NW !"));
|
|
|
|
if (BX_CPU_THIS_PTR cr0.cd != ((BX_CPU_THIS_PTR cr0.val32 >> 30) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.CD !"));
|
|
|
|
#endif
|
|
|
|
if (BX_CPU_THIS_PTR cr0.pg != ((BX_CPU_THIS_PTR cr0.val32 >> 31) & 1))
|
|
|
|
BX_PANIC(("assert_checks: inconsistent CR0.PG !"));
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR cr0.pg && ! BX_CPU_THIS_PTR cr0.pe)
|
|
|
|
BX_PANIC(("assert_checks: CR0.PG=1 with CR0.PE=0 !"));
|
|
|
|
#if BX_CPU_LEVEL >= 4
|
|
|
|
if (BX_CPU_THIS_PTR cr0.nw && ! BX_CPU_THIS_PTR cr0.cd)
|
|
|
|
BX_PANIC(("assert_checks: CR0.NW=1 with CR0.CD=0 !"));
|
2006-04-25 18:42:57 +04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2004-10-16 14:18:01 +04:00
|
|
|
void BX_CPU_C::set_INTR(bx_bool value)
|
2001-04-10 05:04:59 +04:00
|
|
|
{
|
2001-05-23 12:16:07 +04:00
|
|
|
BX_CPU_THIS_PTR INTR = value;
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_THIS_PTR async_event = 1;
|
|
|
|
}
|