2001-10-03 17:10:38 +04:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
2002-10-25 15:44:41 +04:00
|
|
|
// $Id: stack_pro.cc,v 1.10 2002-10-25 11:44:35 bdenney 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"
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
BX_CPU_C::push_16(Bit16u value16)
|
|
|
|
{
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
BailBigRSP("push_16");
|
2001-04-10 05:04:59 +04:00
|
|
|
Bit32u temp_ESP;
|
|
|
|
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
|
|
|
if (protected_mode()) {
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b)
|
|
|
|
temp_ESP = ESP;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
temp_ESP = SP;
|
|
|
|
if (!can_push(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache, temp_ESP, 2)) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("push_16(): can't push on stack"));
|
2001-04-10 05:04:59 +04:00
|
|
|
exception(BX_SS_EXCEPTION, 0, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* access within limits */
|
|
|
|
write_virtual_word(BX_SEG_REG_SS, temp_ESP - 2, &value16);
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b)
|
|
|
|
ESP -= 2;
|
|
|
|
else
|
|
|
|
SP -= 2;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{ /* real mode */
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b) {
|
|
|
|
if (ESP == 1)
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("CPU shutting down due to lack of stack space, ESP==1"));
|
2001-04-10 05:04:59 +04:00
|
|
|
ESP -= 2;
|
|
|
|
temp_ESP = ESP;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (SP == 1)
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("CPU shutting down due to lack of stack space, SP==1"));
|
2001-04-10 05:04:59 +04:00
|
|
|
SP -= 2;
|
|
|
|
temp_ESP = SP;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_virtual_word(BX_SEG_REG_SS, temp_ESP, &value16);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
/* push 32 bit operand size */
|
|
|
|
void
|
|
|
|
BX_CPU_C::push_32(Bit32u value32)
|
|
|
|
{
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
BailBigRSP("push_32");
|
2001-04-10 05:04:59 +04:00
|
|
|
/* must use StackAddrSize, and either ESP or SP accordingly */
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b) { /* StackAddrSize = 32 */
|
|
|
|
/* 32bit stack size: pushes use SS:ESP */
|
|
|
|
if (protected_mode()) {
|
|
|
|
if (!can_push(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache, ESP, 4)) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("push_32(): push outside stack limits"));
|
2001-04-10 05:04:59 +04:00
|
|
|
/* #SS(0) */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else { /* real mode */
|
|
|
|
if ((ESP>=1) && (ESP<=3)) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("push_32: ESP=%08x", (unsigned) ESP));
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
write_virtual_dword(BX_SEG_REG_SS, ESP-4, &value32);
|
|
|
|
ESP -= 4;
|
|
|
|
/* will return after error anyway */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else { /* 16bit stack size: pushes use SS:SP */
|
|
|
|
if (protected_mode()) {
|
|
|
|
if (!can_push(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache, SP, 4)) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("push_32(): push outside stack limits"));
|
2001-04-10 05:04:59 +04:00
|
|
|
/* #SS(0) */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else { /* real mode */
|
|
|
|
if ((SP>=1) && (SP<=3)) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("push_32: SP=%08x", (unsigned) SP));
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
write_virtual_dword(BX_SEG_REG_SS, (Bit16u) (SP-4), &value32);
|
|
|
|
SP -= 4;
|
|
|
|
/* will return after error anyway */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2002-09-15 05:00:20 +04:00
|
|
|
|
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
void
|
|
|
|
BX_CPU_C::push_64(Bit64u value64)
|
|
|
|
{
|
|
|
|
/* 64bit stack size: pushes use SS:RSP, assume protected mode */
|
|
|
|
if (!can_push(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache, RSP, 8)) {
|
|
|
|
BX_PANIC(("push_64(): push outside stack limits"));
|
|
|
|
/* #SS(0) */
|
|
|
|
}
|
|
|
|
|
|
|
|
write_virtual_qword(BX_SEG_REG_SS, RSP-8, &value64);
|
|
|
|
RSP -= 8;
|
|
|
|
/* will return after error anyway */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif // #if BX_SUPPORT_X86_64
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif /* BX_CPU_LEVEL >= 3 */
|
|
|
|
|
|
|
|
void
|
|
|
|
BX_CPU_C::pop_16(Bit16u *value16_ptr)
|
|
|
|
{
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
BailBigRSP("pop_16");
|
2001-04-10 05:04:59 +04:00
|
|
|
Bit32u temp_ESP;
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b)
|
|
|
|
temp_ESP = ESP;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
temp_ESP = SP;
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
|
|
|
if (protected_mode()) {
|
|
|
|
if ( !can_pop(2) ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_INFO(("pop_16(): can't pop from stack"));
|
2001-04-10 05:04:59 +04:00
|
|
|
exception(BX_SS_EXCEPTION, 0, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* access within limits */
|
|
|
|
read_virtual_word(BX_SEG_REG_SS, temp_ESP, value16_ptr);
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b)
|
|
|
|
ESP += 2;
|
|
|
|
else
|
|
|
|
SP += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 3
|
|
|
|
void
|
|
|
|
BX_CPU_C::pop_32(Bit32u *value32_ptr)
|
|
|
|
{
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
BailBigRSP("pop_32");
|
2001-04-10 05:04:59 +04:00
|
|
|
Bit32u temp_ESP;
|
|
|
|
|
|
|
|
/* 32 bit stack mode: use SS:ESP */
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b)
|
|
|
|
temp_ESP = ESP;
|
|
|
|
else
|
|
|
|
temp_ESP = SP;
|
|
|
|
|
|
|
|
/* 16 bit stack mode: use SS:SP */
|
|
|
|
if (protected_mode()) {
|
|
|
|
if ( !can_pop(4) ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("pop_32(): can't pop from stack"));
|
2001-04-10 05:04:59 +04:00
|
|
|
exception(BX_SS_EXCEPTION, 0, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* access within limits */
|
|
|
|
read_virtual_dword(BX_SEG_REG_SS, temp_ESP, value32_ptr);
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b==1)
|
|
|
|
ESP += 4;
|
|
|
|
else
|
|
|
|
SP += 4;
|
|
|
|
}
|
2002-09-15 05:00:20 +04:00
|
|
|
|
|
|
|
#if BX_SUPPORT_X86_64
|
|
|
|
void
|
|
|
|
BX_CPU_C::pop_64(Bit64u *value64_ptr)
|
|
|
|
{
|
|
|
|
if ( !can_pop(8) ) {
|
|
|
|
BX_PANIC(("pop_64(): can't pop from stack"));
|
|
|
|
exception(BX_SS_EXCEPTION, 0, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* access within limits */
|
|
|
|
|
|
|
|
read_virtual_qword(BX_SEG_REG_SS, RSP, value64_ptr);
|
|
|
|
|
|
|
|
RSP += 8;
|
|
|
|
}
|
|
|
|
#endif // #if BX_SUPPORT_X86_64
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2002-10-25 15:44:41 +04:00
|
|
|
bx_bool
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_C::can_push(bx_descriptor_t *descriptor, Bit32u esp, Bit32u bytes)
|
|
|
|
{
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
2002-09-24 12:29:06 +04:00
|
|
|
if (BX_CPU_THIS_PTR cpu_mode == BX_MODE_LONG_64) {
|
|
|
|
return(1);
|
|
|
|
}
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
#endif
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
if ( real_mode() ) { /* code not needed ??? */
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): called in real mode"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0); /* never gets here */
|
|
|
|
}
|
|
|
|
|
|
|
|
// small stack compares against 16-bit SP
|
|
|
|
if (!descriptor->u.segment.d_b)
|
|
|
|
esp &= 0x0000ffff;
|
|
|
|
|
|
|
|
|
|
|
|
if (descriptor->valid==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): SS invalidated."));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (descriptor->p==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): not present"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (descriptor->u.segment.c_ed) { /* expand down segment */
|
|
|
|
Bit32u expand_down_limit;
|
|
|
|
|
|
|
|
if (descriptor->u.segment.d_b)
|
|
|
|
expand_down_limit = 0xffffffff;
|
|
|
|
else
|
|
|
|
expand_down_limit = 0x0000ffff;
|
|
|
|
|
|
|
|
if (esp==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): esp=0, wraparound?"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (esp < bytes) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): expand-down: esp < N"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ( (esp - bytes) <= descriptor->u.segment.limit_scaled ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): expand-down: esp-N < limit"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ( esp > expand_down_limit ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): esp > expand-down-limit"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
else { /* normal (expand-up) segment */
|
|
|
|
if (descriptor->u.segment.limit_scaled==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): found limit of 0"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look at case where esp==0. Possibly, it's an intentional wraparound
|
|
|
|
// If so, limit must be the maximum for the given stack size
|
|
|
|
if (esp==0) {
|
|
|
|
if (descriptor->u.segment.d_b && (descriptor->u.segment.limit_scaled==0xffffffff))
|
|
|
|
return(1);
|
|
|
|
if ((descriptor->u.segment.d_b==0) && (descriptor->u.segment.limit_scaled>=0xffff))
|
|
|
|
return(1);
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_push(): esp=0, normal, wraparound? limit=%08x",
|
merge in BRANCH-io-cleanup.
To see the commit logs for this use either cvsweb or
cvs update -r BRANCH-io-cleanup and then 'cvs log' the various files.
In general this provides a generic interface for logging.
logfunctions:: is a class that is inherited by some classes, and also
. allocated as a standalone global called 'genlog'. All logging uses
. one of the ::info(), ::error(), ::ldebug(), ::panic() methods of this
. class through 'BX_INFO(), BX_ERROR(), BX_DEBUG(), BX_PANIC()' macros
. respectively.
.
. An example usage:
. BX_INFO(("Hello, World!\n"));
iofunctions:: is a class that is allocated once by default, and assigned
as the iofunction of each logfunctions instance. It is this class that
maintains the file descriptor and other output related code, at this
point using vfprintf(). At some future point, someone may choose to
write a gui 'console' for bochs to which messages would be redirected
simply by assigning a different iofunction class to the various logfunctions
objects.
More cleanup is coming, but this works for now. If you want to see alot
of debugging output, in main.cc, change onoff[LOGLEV_DEBUG]=0 to =1.
Comments, bugs, flames, to me: todd@fries.net
2001-05-15 18:49:57 +04:00
|
|
|
descriptor->u.segment.limit_scaled));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (esp < bytes) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_INFO(("can_push(): expand-up: esp < N"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ((esp-1) > descriptor->u.segment.limit_scaled) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_INFO(("can_push(): expand-up: SP > limit"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
/* all checks pass */
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if BX_CPU_LEVEL >= 2
|
2002-10-25 15:44:41 +04:00
|
|
|
bx_bool
|
2001-04-10 05:04:59 +04:00
|
|
|
BX_CPU_C::can_pop(Bit32u bytes)
|
|
|
|
{
|
|
|
|
Bit32u temp_ESP, expand_down_limit;
|
|
|
|
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
#if BX_SUPPORT_X86_64
|
2002-09-24 12:29:06 +04:00
|
|
|
if (BX_CPU_THIS_PTR cpu_mode == BX_MODE_LONG_64) {
|
|
|
|
return(1);
|
|
|
|
}
|
I integrated my hacks to get Linux/x86-64 booting. To keep
these from interfering from a normal compile here's what I did.
In config.h.in (which will generate config.h after a configure),
I added a #define called KPL64Hacks:
#define KPL64Hacks
*After* running configure, you must set this by hand. It will
default to off, so you won't get my hacks in a normal compile.
This will go away soon. There is also a macro just after that
called BailBigRSP(). You don't need to enabled that, but you
can. In many of the instructions which seemed like they could
be hit by the fetchdecode64() process, but which also touched
EIP/ESP, I inserted a macro. Usually this macro expands to nothing.
If you like, you can enabled it, and it will panic if it finds
the upper bits of RIP/RSP set. This helped me find bugs.
Also, I cleaned up the emulation in ctrl_xfer{8,16,32}.cc.
There were some really old legacy code snippets which directly
accessed operands on the stack with access_linear. Lots of
ugly code instead of just pop_32() etc. Cleaning those up,
minimized the number of instructions which directly manipulate
the stack pointer, which should help in refining 64-bit support.
2002-09-24 04:44:56 +04:00
|
|
|
#endif
|
|
|
|
|
2001-04-10 05:04:59 +04:00
|
|
|
/* ??? */
|
2001-05-30 22:56:02 +04:00
|
|
|
if (real_mode()) BX_PANIC(("can_pop(): called in real mode?"));
|
2001-04-10 05:04:59 +04:00
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.d_b) { /* Big bit set: use ESP */
|
|
|
|
temp_ESP = ESP;
|
|
|
|
expand_down_limit = 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
else { /* Big bit clear: use SP */
|
|
|
|
temp_ESP = SP;
|
|
|
|
expand_down_limit = 0xFFFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.valid==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): SS invalidated."));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0); /* never gets here */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.p==0) { /* ??? */
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): SS.p = 0"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.c_ed) { /* expand down segment */
|
|
|
|
if ( temp_ESP == expand_down_limit ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): found SP=ffff"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ( ((expand_down_limit - temp_ESP) + 1) >= bytes )
|
|
|
|
return(1);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
else { /* normal (expand-up) segment */
|
|
|
|
if (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit_scaled==0) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): SS.limit = 0"));
|
2001-04-10 05:04:59 +04:00
|
|
|
}
|
|
|
|
if ( temp_ESP == expand_down_limit ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): found SP=ffff"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ( temp_ESP > BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit_scaled ) {
|
2001-05-30 22:56:02 +04:00
|
|
|
BX_PANIC(("can_pop(): eSP > SS.limit"));
|
2001-04-10 05:04:59 +04:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if ( ((BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.u.segment.limit_scaled - temp_ESP) + 1) >= bytes )
|
|
|
|
return(1);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|