mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Support access to SMRAM in memory object

Browse Source 
Cleanup in CPU code
This commit is contained in:
Stanislav Shwartsman 2006-03-26 18:58:01 +00:00
parent 6cbdf98b38
commit 5c3fba4399
24 changed files with 394 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
bochs/cpu/arith16.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: arith16.cc,v 1.42 2006-03-06 22:02:51 sshwarts Exp $
// $Id: arith16.cc,v 1.43 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -69,7 +69,7 @@ void BX_CPU_C::ADD_EwGw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
sum_16 = op1_16 + op2_16;
Write_RMW_virtual_word(sum_16);
write_RMW_virtual_word(sum_16);
}
SET_FLAGS_OSZAPC_16(op1_16, op2_16, sum_16, BX_INSTR_ADD16);
@ -144,7 +144,7 @@ void BX_CPU_C::ADC_EwGw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
sum_16 = op1_16 + op2_16 + temp_CF;
Write_RMW_virtual_word(sum_16);
write_RMW_virtual_word(sum_16);
}
SET_FLAGS_OSZAPC_16(op1_16, op2_16, sum_16, BX_INSTR_ADD_ADC16(temp_CF));
@ -201,7 +201,7 @@ void BX_CPU_C::SBB_EwGw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
diff_16 = op1_16 - (op2_16 + temp_CF);
Write_RMW_virtual_word(diff_16);
write_RMW_virtual_word(diff_16);
}
SET_FLAGS_OSZAPC_16(op1_16, op2_16, diff_16, BX_INSTR_SUB_SBB16(temp_CF));
@ -257,7 +257,7 @@ void BX_CPU_C::SBB_EwIw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
diff_16 = op1_16 - (op2_16 + temp_CF);
Write_RMW_virtual_word(diff_16);
write_RMW_virtual_word(diff_16);
}
SET_FLAGS_OSZAPC_16(op1_16, op2_16, diff_16, BX_INSTR_SUB_SBB16(temp_CF));
@ -289,7 +289,7 @@ void BX_CPU_C::SUB_EwGw(bxInstruction_c *i)
#else
diff_16 = op1_16 - op2_16;
#endif
Write_RMW_virtual_word(diff_16);
write_RMW_virtual_word(diff_16);
}
#if !defined(BX_HostAsm_Sub16)
@ -449,7 +449,7 @@ void BX_CPU_C::XADD_EwGw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
sum_16 = op1_16 + op2_16;
Write_RMW_virtual_word(sum_16);
write_RMW_virtual_word(sum_16);
/* and write destination into source */
BX_WRITE_16BIT_REG(i->nnn(), op1_16);
}
@ -478,7 +478,7 @@ void BX_CPU_C::ADD_EEwIw(bxInstruction_c *i)
SET_FLAGS_OSZAPC_16(op1_16, op2_16, sum_16, BX_INSTR_ADD16);
#endif
Write_RMW_virtual_word(sum_16);
write_RMW_virtual_word(sum_16);
}
void BX_CPU_C::ADD_EGwIw(bxInstruction_c *i)
@ -516,7 +516,7 @@ void BX_CPU_C::ADC_EwIw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
sum_16 = op1_16 + op2_16 + temp_CF;
Write_RMW_virtual_word(sum_16);
write_RMW_virtual_word(sum_16);
}
SET_FLAGS_OSZAPC_16(op1_16, op2_16, sum_16, BX_INSTR_ADD_ADC16(temp_CF));
@ -548,7 +548,7 @@ void BX_CPU_C::SUB_EwIw(bxInstruction_c *i)
#else
diff_16 = op1_16 - op2_16;
#endif
Write_RMW_virtual_word(diff_16);
write_RMW_virtual_word(diff_16);
}
#if !defined(BX_HostAsm_Sub16)
@ -591,7 +591,7 @@ void BX_CPU_C::NEG_Ew(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
diff_16 = -op1_16;
Write_RMW_virtual_word(diff_16);
write_RMW_virtual_word(diff_16);
}
SET_FLAGS_OSZAPC_RESULT_16(diff_16, BX_INSTR_NEG16);
@ -609,7 +609,7 @@ void BX_CPU_C::INC_Ew(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
op1_16++;
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
SET_FLAGS_OSZAP_RESULT_16(op1_16, BX_INSTR_INC16);
@ -639,7 +639,7 @@ void BX_CPU_C::DEC_Ew(bxInstruction_c *i)
#else
op1_16--;
#endif
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
#if !defined(BX_HostAsm_Dec16)
@ -671,7 +671,7 @@ void BX_CPU_C::CMPXCHG_EwGw(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), op2_16);
}
else {
Write_RMW_virtual_word(op2_16);
write_RMW_virtual_word(op2_16);
}
}
else {

30
bochs/cpu/arith32.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: arith32.cc,v 1.47 2006-03-06 22:02:51 sshwarts Exp $
// $Id: arith32.cc,v 1.48 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -85,7 +85,7 @@ void BX_CPU_C::ADD_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
sum_32 = op1_32 + op2_32;
Write_RMW_virtual_dword(sum_32);
write_RMW_virtual_dword(sum_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, sum_32, BX_INSTR_ADD32);
@ -161,7 +161,7 @@ void BX_CPU_C::ADC_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
sum_32 = op1_32 + op2_32 + temp_CF;
Write_RMW_virtual_dword(sum_32);
write_RMW_virtual_dword(sum_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, sum_32, BX_INSTR_ADD_ADC32(temp_CF));
@ -220,7 +220,7 @@ void BX_CPU_C::SBB_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
diff_32 = op1_32 - (op2_32 + temp_CF);
Write_RMW_virtual_dword(diff_32);
write_RMW_virtual_dword(diff_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, diff_32, BX_INSTR_SUB_SBB32(temp_CF));
@ -279,7 +279,7 @@ void BX_CPU_C::SBB_EdId(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
diff_32 = op1_32 - (op2_32 + temp_CF);
Write_RMW_virtual_dword(diff_32);
write_RMW_virtual_dword(diff_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, diff_32, BX_INSTR_SUB_SBB32(temp_CF));
@ -299,7 +299,7 @@ void BX_CPU_C::SUB_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
diff_32 = op1_32 - op2_32;
Write_RMW_virtual_dword(diff_32);
write_RMW_virtual_dword(diff_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, diff_32, BX_INSTR_SUB32);
@ -477,7 +477,7 @@ void BX_CPU_C::XADD_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
sum_32 = op1_32 + op2_32;
Write_RMW_virtual_dword(sum_32);
write_RMW_virtual_dword(sum_32);
/* and write destination into source */
BX_WRITE_32BIT_REGZ(i->nnn(), op1_32);
}
@ -506,7 +506,7 @@ void BX_CPU_C::ADD_EEdId(bxInstruction_c *i)
SET_FLAGS_OSZAPC_32(op1_32, op2_32, sum_32, BX_INSTR_ADD32);
#endif
Write_RMW_virtual_dword(sum_32);
write_RMW_virtual_dword(sum_32);
}
void BX_CPU_C::ADD_EGdId(bxInstruction_c *i)
@ -544,7 +544,7 @@ void BX_CPU_C::ADC_EdId(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
sum_32 = op1_32 + op2_32 + temp_CF;
Write_RMW_virtual_dword(sum_32);
write_RMW_virtual_dword(sum_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, sum_32, BX_INSTR_ADD_ADC32(temp_CF));
@ -564,7 +564,7 @@ void BX_CPU_C::SUB_EdId(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
diff_32 = op1_32 - op2_32;
Write_RMW_virtual_dword(diff_32);
write_RMW_virtual_dword(diff_32);
}
SET_FLAGS_OSZAPC_32(op1_32, op2_32, diff_32, BX_INSTR_SUB32);
@ -606,7 +606,7 @@ void BX_CPU_C::NEG_Ed(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
diff_32 = -op1_32;
Write_RMW_virtual_dword(diff_32);
write_RMW_virtual_dword(diff_32);
}
SET_FLAGS_OSZAPC_RESULT_32(diff_32, BX_INSTR_NEG32);
@ -624,7 +624,7 @@ void BX_CPU_C::INC_Ed(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
op1_32++;
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_INC32);
@ -642,7 +642,7 @@ void BX_CPU_C::DEC_Ed(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
op1_32--;
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
SET_FLAGS_OSZAP_RESULT_32(op1_32, BX_INSTR_DEC32);
@ -672,7 +672,7 @@ void BX_CPU_C::CMPXCHG_EdGd(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), op2_32);
}
else {
Write_RMW_virtual_dword(op2_32);
write_RMW_virtual_dword(op2_32);
}
}
else {
@ -705,7 +705,7 @@ void BX_CPU_C::CMPXCHG8B(bxInstruction_c *i)
// ZF = 1
set_ZF(1);
// dest <-- src
Write_RMW_virtual_dword(ECX);
write_RMW_virtual_dword(ECX);
write_virtual_dword(i->seg(), RMAddr(i), &EBX);
}
else {

30
bochs/cpu/arith64.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: arith64.cc,v 1.28 2006-03-06 22:02:51 sshwarts Exp $
// $Id: arith64.cc,v 1.29 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -51,7 +51,7 @@ void BX_CPU_C::ADD_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
sum_64 = op1_64 + op2_64;
Write_RMW_virtual_qword(sum_64);
write_RMW_virtual_qword(sum_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, sum_64, BX_INSTR_ADD64);
@ -115,7 +115,7 @@ void BX_CPU_C::ADC_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
sum_64 = op1_64 + op2_64 + temp_CF;
Write_RMW_virtual_qword(sum_64);
write_RMW_virtual_qword(sum_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, sum_64, BX_INSTR_ADD_ADC64(temp_CF));
@ -183,7 +183,7 @@ void BX_CPU_C::SBB_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
diff_64 = op1_64 - (op2_64 + temp_CF);
Write_RMW_virtual_qword(diff_64);
write_RMW_virtual_qword(diff_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, diff_64, BX_INSTR_SUB_SBB64(temp_CF));
@ -251,7 +251,7 @@ void BX_CPU_C::SBB_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
diff_64 = op1_64 - (op2_64 + temp_CF);
Write_RMW_virtual_qword(diff_64);
write_RMW_virtual_qword(diff_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, diff_64, BX_INSTR_SUB_SBB64(temp_CF));
@ -274,7 +274,7 @@ void BX_CPU_C::SUB_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
diff_64 = op1_64 - op2_64;
Write_RMW_virtual_qword(diff_64);
write_RMW_virtual_qword(diff_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, diff_64, BX_INSTR_SUB64);
@ -422,7 +422,7 @@ void BX_CPU_C::XADD_EqGq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), sum_64);
}
else {
Write_RMW_virtual_qword(sum_64);
write_RMW_virtual_qword(sum_64);
/* and write destination into source */
BX_WRITE_64BIT_REG(i->nnn(), op1_64);
}
@ -447,7 +447,7 @@ void BX_CPU_C::ADD_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
sum_64 = op1_64 + op2_64;
Write_RMW_virtual_qword(sum_64);
write_RMW_virtual_qword(sum_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, sum_64, BX_INSTR_ADD64);
@ -472,7 +472,7 @@ void BX_CPU_C::ADC_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
sum_64 = op1_64 + op2_64 + temp_CF;
Write_RMW_virtual_qword(sum_64);
write_RMW_virtual_qword(sum_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, sum_64, BX_INSTR_ADD_ADC64(temp_CF));
@ -495,7 +495,7 @@ void BX_CPU_C::SUB_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
diff_64 = op1_64 - op2_64;
Write_RMW_virtual_qword(diff_64);
write_RMW_virtual_qword(diff_64);
}
SET_FLAGS_OSZAPC_64(op1_64, op2_64, diff_64, BX_INSTR_SUB64);
@ -537,7 +537,7 @@ void BX_CPU_C::NEG_Eq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
diff_64 = -op1_64;
Write_RMW_virtual_qword(diff_64);
write_RMW_virtual_qword(diff_64);
}
SET_FLAGS_OSZAPC_RESULT_64(diff_64, BX_INSTR_NEG64);
@ -557,7 +557,7 @@ void BX_CPU_C::INC_Eq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
op1_64++;
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_INC64);
@ -577,7 +577,7 @@ void BX_CPU_C::DEC_Eq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
op1_64--;
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
SET_FLAGS_OSZAP_RESULT_64(op1_64, BX_INSTR_DEC64);
@ -608,7 +608,7 @@ void BX_CPU_C::CMPXCHG_EqGq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), op2_64);
}
else {
Write_RMW_virtual_qword(op2_64);
write_RMW_virtual_qword(op2_64);
}
}
else {
@ -641,7 +641,7 @@ void BX_CPU_C::CMPXCHG16B(bxInstruction_c *i)
// ZF = 1
set_ZF(1);
// dest <-- src
Write_RMW_virtual_qword(RCX);
write_RMW_virtual_qword(RCX);
write_virtual_qword(i->seg(), RMAddr(i), &RBX);
}
else {

28
bochs/cpu/arith8.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: arith8.cc,v 1.38 2006-03-06 22:02:51 sshwarts Exp $
// $Id: arith8.cc,v 1.39 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -45,7 +45,7 @@ void BX_CPU_C::ADD_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
sum = op1 + op2;
Write_RMW_virtual_byte(sum);
write_RMW_virtual_byte(sum);
}
SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
@ -98,7 +98,7 @@ void BX_CPU_C::ADC_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
sum = op1 + op2 + temp_CF;
Write_RMW_virtual_byte(sum);
write_RMW_virtual_byte(sum);
}
SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
@ -153,7 +153,7 @@ void BX_CPU_C::SBB_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
diff_8 = op1_8 - (op2_8 + temp_CF);
Write_RMW_virtual_byte(diff_8);
write_RMW_virtual_byte(diff_8);
}
SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
@ -208,7 +208,7 @@ void BX_CPU_C::SBB_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
diff_8 = op1_8 - (op2_8 + temp_CF);
Write_RMW_virtual_byte(diff_8);
write_RMW_virtual_byte(diff_8);
}
SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB_SBB8(temp_CF));
@ -228,7 +228,7 @@ void BX_CPU_C::SUB_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
diff_8 = op1_8 - op2_8;
Write_RMW_virtual_byte(diff_8);
write_RMW_virtual_byte(diff_8);
}
SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
@ -353,7 +353,7 @@ void BX_CPU_C::XADD_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
sum = op1 + op2;
Write_RMW_virtual_byte(sum);
write_RMW_virtual_byte(sum);
/* and write destination into source */
BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);
}
@ -379,7 +379,7 @@ void BX_CPU_C::ADD_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
sum = op1 + op2;
Write_RMW_virtual_byte(sum);
write_RMW_virtual_byte(sum);
}
SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD8);
@ -400,7 +400,7 @@ void BX_CPU_C::ADC_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
sum = op1 + op2 + temp_CF;
Write_RMW_virtual_byte(sum);
write_RMW_virtual_byte(sum);
}
SET_FLAGS_OSZAPC_8(op1, op2, sum, BX_INSTR_ADD_ADC8(temp_CF));
@ -420,7 +420,7 @@ void BX_CPU_C::SUB_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
diff_8 = op1_8 - op2_8;
Write_RMW_virtual_byte(diff_8);
write_RMW_virtual_byte(diff_8);
}
SET_FLAGS_OSZAPC_8(op1_8, op2_8, diff_8, BX_INSTR_SUB8);
@ -461,7 +461,7 @@ void BX_CPU_C::NEG_Eb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
diff_8 = -op1_8;
Write_RMW_virtual_byte(diff_8);
write_RMW_virtual_byte(diff_8);
}
SET_FLAGS_OSZAPC_RESULT_8(diff_8, BX_INSTR_NEG8);
@ -479,7 +479,7 @@ void BX_CPU_C::INC_Eb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
op1++;
Write_RMW_virtual_byte(op1);
write_RMW_virtual_byte(op1);
}
SET_FLAGS_OSZAP_RESULT_8(op1, BX_INSTR_INC8);
@ -497,7 +497,7 @@ void BX_CPU_C::DEC_Eb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
op1_8--;
Write_RMW_virtual_byte(op1_8);
write_RMW_virtual_byte(op1_8);
}
SET_FLAGS_OSZAP_RESULT_8(op1_8, BX_INSTR_DEC8);
@ -527,7 +527,7 @@ void BX_CPU_C::CMPXCHG_EbGb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), op2_8);
}
else {
Write_RMW_virtual_byte(op2_8);
write_RMW_virtual_byte(op2_8);
}
}
else {

38
bochs/cpu/bit.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: bit.cc,v 1.26 2006-03-06 22:02:51 sshwarts Exp $
// $Id: bit.cc,v 1.27 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -918,7 +918,7 @@ void BX_CPU_C::BTS_EwGw(bxInstruction_c *i)
bit_i = (op1_16 >> index) & 0x01;
op1_16 |= (((Bit16u) 1) << index);
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
set_CF(bit_i);
}
@ -953,7 +953,7 @@ void BX_CPU_C::BTS_EdGd(bxInstruction_c *i)
bit_i = (op1_32 >> index) & 0x01;
op1_32 |= (((Bit32u) 1) << index);
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
set_CF(bit_i);
}
@ -990,7 +990,7 @@ void BX_CPU_C::BTS_EqGq(bxInstruction_c *i)
bit_i = (op1_64 >> index) & 0x01;
op1_64 |= (((Bit64u) 1) << index);
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
set_CF(bit_i);
}
@ -1027,7 +1027,7 @@ void BX_CPU_C::BTR_EwGw(bxInstruction_c *i)
op1_16 &= ~(((Bit16u) 1) << index);
/* now write back to destination */
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
set_CF(temp_cf);
}
@ -1063,7 +1063,7 @@ void BX_CPU_C::BTR_EdGd(bxInstruction_c *i)
op1_32 &= ~(((Bit32u) 1) << index);
/* now write back to destination */
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
set_CF(temp_cf);
}
@ -1100,7 +1100,7 @@ void BX_CPU_C::BTR_EqGq(bxInstruction_c *i)
op1_64 &= ~(((Bit64u) 1) << index);
/* now write back to destination */
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
set_CF(temp_cf);
}
@ -1135,7 +1135,7 @@ void BX_CPU_C::BTC_EwGw(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), op1_16);
}
else {
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
set_CF(temp_CF);
@ -1170,7 +1170,7 @@ void BX_CPU_C::BTC_EdGd(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
}
else {
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
}
@ -1205,7 +1205,7 @@ void BX_CPU_C::BTC_EqGq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), op1_64);
}
else {
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
}
#endif
@ -1289,7 +1289,7 @@ void BX_CPU_C::BTS_EwIb(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), op1_16);
}
else {
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
set_CF(temp_CF);
@ -1318,7 +1318,7 @@ void BX_CPU_C::BTS_EdIb(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
}
else {
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
set_CF(temp_CF);
@ -1348,7 +1348,7 @@ void BX_CPU_C::BTS_EqIb(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), op1_64);
}
else {
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
set_CF(temp_CF);
@ -1379,7 +1379,7 @@ void BX_CPU_C::BTC_EwIb(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), op1_16);
}
else {
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
}
@ -1407,7 +1407,7 @@ void BX_CPU_C::BTC_EdIb(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
}
else {
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
}
@ -1436,7 +1436,7 @@ void BX_CPU_C::BTC_EqIb(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), op1_64);
}
else {
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
}
#endif
@ -1464,7 +1464,7 @@ void BX_CPU_C::BTR_EwIb(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), op1_16);
}
else {
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
set_CF(temp_CF);
@ -1493,7 +1493,7 @@ void BX_CPU_C::BTR_EdIb(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), op1_32);
}
else {
Write_RMW_virtual_dword(op1_32);
write_RMW_virtual_dword(op1_32);
}
set_CF(temp_CF);
@ -1523,7 +1523,7 @@ void BX_CPU_C::BTR_EqIb(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), op1_64);
}
else {
Write_RMW_virtual_qword(op1_64);
write_RMW_virtual_qword(op1_64);
}
set_CF(temp_CF);

4
bochs/cpu/cpu.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: cpu.cc,v 1.139 2006-03-16 20:24:09 sshwarts Exp $
// $Id: cpu.cc,v 1.140 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -771,7 +771,7 @@ void BX_CPU_C::prefetch(void)
BX_CPU_THIS_PTR eipPageWindowSize = 4096;
BX_CPU_THIS_PTR pAddrA20Page = pAddr & 0xfffff000;
BX_CPU_THIS_PTR eipFetchPtr =
BX_CPU_THIS_PTR mem->getHostMemAddr(BX_CPU_THIS, BX_CPU_THIS_PTR pAddrA20Page, BX_READ);
BX_CPU_THIS_PTR mem->getHostMemAddrCode(BX_CPU_THIS, BX_CPU_THIS_PTR pAddrA20Page);
// Sanity checks
if (! BX_CPU_THIS_PTR eipFetchPtr) {

8
bochs/cpu/cpu.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: cpu.h,v 1.271 2006-03-22 20:47:11 sshwarts Exp $
// $Id: cpu.h,v 1.272 2006-03-26 18:58:00 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -2680,11 +2680,6 @@ public: // for now...
BX_SMF void write_RMW_virtual_dword(Bit32u val32) BX_CPP_AttrRegparmN(1);
BX_SMF void write_RMW_virtual_qword(Bit64u val64) BX_CPP_AttrRegparmN(1);
#define Write_RMW_virtual_byte(val8) write_RMW_virtual_byte(val8)
#define Write_RMW_virtual_word(val16) write_RMW_virtual_word(val16)
#define Write_RMW_virtual_dword(val32) write_RMW_virtual_dword(val32)
#define Write_RMW_virtual_qword(val64) write_RMW_virtual_qword(val64)
#if BX_SupportGuest2HostTLB
BX_SMF Bit8u* v2h_read_byte(bx_address laddr, unsigned pl) BX_CPP_AttrRegparmN(2);
BX_SMF Bit16u* v2h_read_word(bx_address laddr, unsigned pl) BX_CPP_AttrRegparmN(2);
@ -2746,6 +2741,7 @@ public: // for now...
BX_SMF void exception(unsigned vector, Bit16u error_code, bx_bool is_INT)
BX_CPP_AttrNoReturn();
#endif
BX_SMF bx_bool smram_write(bx_phy_address a20addr);
BX_SMF int int_number(bx_segment_reg_t *seg);
BX_SMF void CR3_change(bx_address value) BX_CPP_AttrRegparmN(1);
BX_SMF void pagingCR0Changed(Bit32u oldCR0, Bit32u newCR0) BX_CPP_AttrRegparmN(2);

4
bochs/cpu/data_xfer16.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: data_xfer16.cc,v 1.37 2006-03-06 22:02:52 sshwarts Exp $
// $Id: data_xfer16.cc,v 1.38 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -223,7 +223,7 @@ void BX_CPU_C::XCHG_EwGw(bxInstruction_c *i)
else {
/* pointer, segment address pair */
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
Write_RMW_virtual_word(op2_16);
write_RMW_virtual_word(op2_16);
}
BX_WRITE_16BIT_REG(i->nnn(), op1_16);

4
bochs/cpu/data_xfer32.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: data_xfer32.cc,v 1.36 2006-03-06 22:02:52 sshwarts Exp $
// $Id: data_xfer32.cc,v 1.37 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -189,7 +189,7 @@ void BX_CPU_C::XCHG_EdGd(bxInstruction_c *i)
else {
/* pointer, segment address pair */
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
Write_RMW_virtual_dword(op2_32);
write_RMW_virtual_dword(op2_32);
}
BX_WRITE_32BIT_REGZ(i->nnn(), op1_32);

4
bochs/cpu/data_xfer64.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: data_xfer64.cc,v 1.23 2006-03-06 22:02:53 sshwarts Exp $
// $Id: data_xfer64.cc,v 1.24 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -248,7 +248,7 @@ void BX_CPU_C::XCHG_EqGq(bxInstruction_c *i)
else {
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
Write_RMW_virtual_qword(op2_64);
write_RMW_virtual_qword(op2_64);
}
BX_WRITE_64BIT_REG(i->nnn(), op1_64);

4
bochs/cpu/data_xfer8.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: data_xfer8.cc,v 1.23 2006-03-06 22:02:53 sshwarts Exp $
// $Id: data_xfer8.cc,v 1.24 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -124,7 +124,7 @@ void BX_CPU_C::XCHG_EbGb(bxInstruction_c *i)
else {
/* pointer, segment address pair */
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
Write_RMW_virtual_byte(op2);
write_RMW_virtual_byte(op2);
}
BX_WRITE_8BIT_REGx(i->nnn(), i->extend8bitL(), op1);

16
bochs/cpu/logical16.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: logical16.cc,v 1.24 2006-03-06 22:03:00 sshwarts Exp $
// $Id: logical16.cc,v 1.25 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -58,7 +58,7 @@ void BX_CPU_C::XOR_EwGw(bxInstruction_c *i)
#else
result_16 = op1_16 ^ op2_16;
#endif
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
#if !defined(BX_HostAsm_Xor16)
@ -113,7 +113,7 @@ void BX_CPU_C::XOR_EwIw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
result_16 = op1_16 ^ op2_16;
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
@ -133,7 +133,7 @@ void BX_CPU_C::OR_EwIw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
result_16 = op1_16 | op2_16;
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
@ -151,7 +151,7 @@ void BX_CPU_C::NOT_Ew(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
result_16 = ~op1_16;
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
}
@ -169,7 +169,7 @@ void BX_CPU_C::OR_EwGw(bxInstruction_c *i)
else {
read_RMW_virtual_word(i->seg(), RMAddr(i), &op1_16);
result_16 = op1_16 | op2_16;
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
SET_FLAGS_OSZAPC_RESULT_16(result_16, BX_INSTR_LOGIC16);
@ -242,7 +242,7 @@ void BX_CPU_C::AND_EwGw(bxInstruction_c *i)
result_16 = op1_16 & op2_16;
#endif
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
#if !defined(BX_HostAsm_And16)
@ -324,7 +324,7 @@ void BX_CPU_C::AND_EwIw(bxInstruction_c *i)
result_16 = op1_16 & op2_16;
#endif
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
#if !defined(BX_HostAsm_And16)

16
bochs/cpu/logical32.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: logical32.cc,v 1.25 2006-03-06 22:03:00 sshwarts Exp $
// $Id: logical32.cc,v 1.26 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -45,7 +45,7 @@ void BX_CPU_C::XOR_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
result_32 = op1_32 ^ op2_32;
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_RESULT_32(result_32, BX_INSTR_LOGIC32);
@ -104,7 +104,7 @@ void BX_CPU_C::XOR_EdId(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
result_32 = op1_32 ^ op2_32;
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_RESULT_32(result_32, BX_INSTR_LOGIC32);
@ -124,7 +124,7 @@ void BX_CPU_C::OR_EdId(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
result_32 = op1_32 | op2_32;
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_RESULT_32(result_32, BX_INSTR_LOGIC32);
@ -142,7 +142,7 @@ void BX_CPU_C::NOT_Ed(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
result_32 = ~op1_32;
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
}
@ -160,7 +160,7 @@ void BX_CPU_C::OR_EdGd(bxInstruction_c *i)
else {
read_RMW_virtual_dword(i->seg(), RMAddr(i), &op1_32);
result_32 = op1_32 | op2_32;
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_RESULT_32(result_32, BX_INSTR_LOGIC32);
@ -238,7 +238,7 @@ void BX_CPU_C::AND_EdGd(bxInstruction_c *i)
result_32 = op1_32 & op2_32;
#endif
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
#if !defined(BX_HostAsm_And32)
@ -324,7 +324,7 @@ void BX_CPU_C::AND_EdId(bxInstruction_c *i)
result_32 = op1_32 & op2_32;
#endif
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
#if !defined(BX_HostAsm_And32)

16
bochs/cpu/logical64.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: logical64.cc,v 1.15 2006-03-06 22:03:00 sshwarts Exp $
// $Id: logical64.cc,v 1.16 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -49,7 +49,7 @@ void BX_CPU_C::XOR_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 ^ op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);
@ -110,7 +110,7 @@ void BX_CPU_C::XOR_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 ^ op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);
@ -132,7 +132,7 @@ void BX_CPU_C::OR_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 | op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);
@ -152,7 +152,7 @@ void BX_CPU_C::NOT_Eq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = ~op1_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
}
@ -172,7 +172,7 @@ void BX_CPU_C::OR_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 | op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);
@ -231,7 +231,7 @@ void BX_CPU_C::AND_EqGq(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 & op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);
@ -290,7 +290,7 @@ void BX_CPU_C::AND_EqId(bxInstruction_c *i)
/* pointer, segment address pair */
read_RMW_virtual_qword(i->seg(), RMAddr(i), &op1_64);
result_64 = op1_64 & op2_64;
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_RESULT_64(result_64, BX_INSTR_LOGIC64);

16
bochs/cpu/logical8.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: logical8.cc,v 1.27 2006-03-06 22:03:00 sshwarts Exp $
// $Id: logical8.cc,v 1.28 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -45,7 +45,7 @@ void BX_CPU_C::XOR_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
result = op1 ^ op2;
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
SET_FLAGS_OSZAPC_RESULT_8(result, BX_INSTR_LOGIC8);
@ -97,7 +97,7 @@ void BX_CPU_C::XOR_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
result = op1 ^ op2;
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
SET_FLAGS_OSZAPC_RESULT_8(result, BX_INSTR_LOGIC8);
@ -117,7 +117,7 @@ void BX_CPU_C::OR_EbIb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
result = op1 | op2;
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
SET_FLAGS_OSZAPC_RESULT_8(result, BX_INSTR_LOGIC8);
@ -135,7 +135,7 @@ void BX_CPU_C::NOT_Eb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1_8);
result_8 = ~op1_8;
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
}
@ -153,7 +153,7 @@ void BX_CPU_C::OR_EbGb(bxInstruction_c *i)
else {
read_RMW_virtual_byte(i->seg(), RMAddr(i), &op1);
result = op1 | op2;
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
SET_FLAGS_OSZAPC_RESULT_8(result, BX_INSTR_LOGIC8);
@ -233,7 +233,7 @@ void BX_CPU_C::AND_EbGb(bxInstruction_c *i)
result = op1 & op2;
#endif
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
#if !defined(BX_HostAsm_And8)
@ -315,7 +315,7 @@ void BX_CPU_C::AND_EbIb(bxInstruction_c *i)
result = op1 & op2;
#endif
Write_RMW_virtual_byte(result);
write_RMW_virtual_byte(result);
}
#if !defined(BX_HostAsm_And8)

4
bochs/cpu/protect_ctrl.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: protect_ctrl.cc,v 1.45 2006-03-06 22:03:01 sshwarts Exp $
// $Id: protect_ctrl.cc,v 1.46 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -65,7 +65,7 @@ void BX_CPU_C::ARPL_EwGw(bxInstruction_c *i)
}
}
else {
Write_RMW_virtual_word(op1_16);
write_RMW_virtual_word(op1_16);
}
set_ZF(1);
}

20
bochs/cpu/shift16.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: shift16.cc,v 1.31 2006-03-06 22:03:02 sshwarts Exp $
// $Id: shift16.cc,v 1.32 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -75,7 +75,7 @@ void BX_CPU_C::SHLD_EwGw(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -127,7 +127,7 @@ void BX_CPU_C::SHRD_EwGw(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -174,7 +174,7 @@ void BX_CPU_C::ROL_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -225,7 +225,7 @@ void BX_CPU_C::ROR_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -279,7 +279,7 @@ void BX_CPU_C::RCL_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -325,7 +325,7 @@ void BX_CPU_C::RCR_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
/* set eflags:
@ -368,7 +368,7 @@ void BX_CPU_C::SHL_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
SET_FLAGS_OSZAPC_16(op1_16, count, result_16, BX_INSTR_SHL16);
@ -413,7 +413,7 @@ void BX_CPU_C::SHR_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
}
@ -464,7 +464,7 @@ void BX_CPU_C::SAR_Ew(bxInstruction_c *i)
BX_WRITE_16BIT_REG(i->rm(), result_16);
}
else {
Write_RMW_virtual_word(result_16);
write_RMW_virtual_word(result_16);
}
SET_FLAGS_OSZAPC_16(op1_16, count, result_16, BX_INSTR_SAR16);

20
bochs/cpu/shift32.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: shift32.cc,v 1.30 2006-03-06 22:03:02 sshwarts Exp $
// $Id: shift32.cc,v 1.31 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -63,7 +63,7 @@ void BX_CPU_C::SHLD_EdGd(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -102,7 +102,7 @@ void BX_CPU_C::SHRD_EdGd(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -141,7 +141,7 @@ void BX_CPU_C::ROL_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -183,7 +183,7 @@ void BX_CPU_C::ROR_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -232,7 +232,7 @@ void BX_CPU_C::RCL_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -280,7 +280,7 @@ void BX_CPU_C::RCR_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
/* set eflags:
@ -321,7 +321,7 @@ void BX_CPU_C::SHL_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_32(op1_32, count, result_32, BX_INSTR_SHL32);
@ -364,7 +364,7 @@ void BX_CPU_C::SHR_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
}
@ -404,7 +404,7 @@ void BX_CPU_C::SAR_Ed(bxInstruction_c *i)
BX_WRITE_32BIT_REGZ(i->rm(), result_32);
}
else {
Write_RMW_virtual_dword(result_32);
write_RMW_virtual_dword(result_32);
}
SET_FLAGS_OSZAPC_32(op1_32, count, result_32, BX_INSTR_SAR32);

20
bochs/cpu/shift64.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: shift64.cc,v 1.19 2006-03-06 22:03:02 sshwarts Exp $
// $Id: shift64.cc,v 1.20 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -65,7 +65,7 @@ void BX_CPU_C::SHLD_EqGq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -104,7 +104,7 @@ void BX_CPU_C::SHRD_EqGq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -143,7 +143,7 @@ void BX_CPU_C::ROL_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -185,7 +185,7 @@ void BX_CPU_C::ROR_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -234,7 +234,7 @@ void BX_CPU_C::RCL_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -282,7 +282,7 @@ void BX_CPU_C::RCR_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
/* set eflags:
@ -323,7 +323,7 @@ void BX_CPU_C::SHL_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_64(op1_64, count, result_64, BX_INSTR_SHL64);
@ -359,7 +359,7 @@ void BX_CPU_C::SHR_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_64(op1_64, count, result_64, BX_INSTR_SHR64);
@ -401,7 +401,7 @@ void BX_CPU_C::SAR_Eq(bxInstruction_c *i)
BX_WRITE_64BIT_REG(i->rm(), result_64);
}
else {
Write_RMW_virtual_qword(result_64);
write_RMW_virtual_qword(result_64);
}
SET_FLAGS_OSZAPC_64(op1_64, count, result_64, BX_INSTR_SAR64);

16
bochs/cpu/shift8.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: shift8.cc,v 1.23 2006-03-06 22:03:02 sshwarts Exp $
// $Id: shift8.cc,v 1.24 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -69,7 +69,7 @@ void BX_CPU_C::ROL_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
/* set eflags:
@ -120,7 +120,7 @@ void BX_CPU_C::ROR_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
/* set eflags:
@ -171,7 +171,7 @@ void BX_CPU_C::RCL_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
/* set eflags:
@ -216,7 +216,7 @@ void BX_CPU_C::RCR_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
/* set eflags:
@ -259,7 +259,7 @@ void BX_CPU_C::SHL_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
SET_FLAGS_OSZAPC_8(op1_8, count, result_8, BX_INSTR_SHL8);
@ -298,7 +298,7 @@ void BX_CPU_C::SHR_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
SET_FLAGS_OSZAPC_8(op1_8, count, result_8, BX_INSTR_SHR8);
@ -351,7 +351,7 @@ void BX_CPU_C::SAR_Eb(bxInstruction_c *i)
BX_WRITE_8BIT_REGx(i->rm(), i->extend8bitL(), result_8);
}
else {
Write_RMW_virtual_byte(result_8);
write_RMW_virtual_byte(result_8);
}
SET_FLAGS_OSZAPC_8(op1_8, count, result_8, BX_INSTR_SAR8);

7
bochs/cpu/smm.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: smm.cc,v 1.6 2006-03-16 20:24:09 sshwarts Exp $
// $Id: smm.cc,v 1.7 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006 Stanislav Shwartsman
@ -145,4 +145,9 @@ void BX_CPU_C::enter_system_management_mode(void)
#endif
}
bx_bool BX_CPU_C::smram_write(bx_phy_address a20addr)
{
return 1; // for now
}
#endif /* BX_CPU_LEVEL >= 3 */

115
bochs/memory/memory.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: memory.cc,v 1.50 2006-03-06 22:03:16 sshwarts Exp $
// $Id: memory.cc,v 1.51 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -32,6 +32,17 @@
#if BX_PROVIDE_CPU_MEMORY
//
// Memory map inside the 1st megabyte:
//
// 0x00000 - 0x7ffff DOS area (512K)
// 0x80000 - 0x9ffff Optional fixed memory hole (128K)
// 0xa0000 - 0xbffff Standard PCI/ISA Video Mem / SMMRAM (128K)
// 0xc0000 - 0xdffff Expansion Card BIOS and Buffer Area (128K)
// 0xe0000 - 0xeffff Lower BIOS Area (64K)
// 0xf0000 - 0xfffff Upper BIOS Area (64K)
//
void BX_CPP_AttrRegparmN(3)
BX_MEM_C::writePhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
{
@ -41,7 +52,6 @@ BX_MEM_C::writePhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data
// Note: accesses should always be contained within a single page now
if (cpu != NULL) {
#if BX_SUPPORT_IODEBUG
bx_iodebug_c::mem_write(cpu, a20addr, len, data);
#endif
@ -62,11 +72,17 @@ BX_MEM_C::writePhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data
#if BX_SUPPORT_APIC
bx_generic_apic_c *local_apic = &cpu->local_apic;
if (local_apic->is_selected (a20addr, len)) {
if (local_apic->is_selected(a20addr, len)) {
local_apic->write(a20addr, (Bit32u *)data, len);
return;
}
#endif
if ((a20addr & 0xfffe0000) == 0x000a0000) {
// SMMRAM memory space
if (BX_MEM_THIS smram_enabled > 1 || cpu->smm_mode())
goto mem_write;
}
}
struct memory_handler_struct *memory_handler = memory_handlers[a20addr >> 20];
@ -80,14 +96,18 @@ BX_MEM_C::writePhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data
memory_handler = memory_handler->next;
}
mem_write:
#if BX_SUPPORT_ICACHE
if (a20addr < BX_MEM_THIS len)
pageWriteStampTable.decWriteStamp(a20addr);
#endif
if ( (a20addr + len) <= BX_MEM_THIS len ) {
// all memory access feets in single 4K page
if (a20addr <= BX_MEM_THIS len) {
// all of data is within limits of physical memory
if ( (a20addr & 0xfff80000) != 0x00080000 ) {
if ((a20addr & 0xfff80000) != 0x00080000 || (a20addr <= 0x0009ffff))
{
if (len == 8) {
WriteHostQWordToLittleEndian(&vector[a20addr], *(Bit64u*)data);
BX_DBG_DIRTY_PAGE(a20addr >> 12);
@ -118,8 +138,9 @@ BX_MEM_C::writePhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data
#endif
write_one:
if ( (a20addr & 0xfff80000) != 0x00080000 ) {
// addr *not* in range 00080000 .. 000FFFFF
if ((a20addr & 0xfff80000) != 0x00080000 || (a20addr <= 0x0009ffff))
{
// addr *not* in range 000A0000 .. 000FFFFF
vector[a20addr] = *data_ptr;
BX_DBG_DIRTY_PAGE(a20addr >> 12);
inc_one:
@ -134,14 +155,18 @@ inc_one:
goto write_one;
}
// addr in range 00080000 .. 000FFFFF
// addr must be in range 000A0000 .. 000FFFFF
if (a20addr <= 0x0009ffff) {
// regular memory 80000 .. 9FFFF
vector[a20addr] = *data_ptr;
BX_DBG_DIRTY_PAGE(a20addr >> 12);
// SMMRAM
if (a20addr <= 0x000bffff) {
// devices are not allowed to access SMMRAM under VGA memory
if (cpu && cpu->smram_write(a20addr)) {
vector[a20addr] = *data_ptr;
BX_DBG_DIRTY_PAGE(a20addr >> 12);
}
goto inc_one;
}
// adapter ROM C0000 .. DFFFF
// ROM BIOS memory E0000 .. FFFFF
#if BX_SUPPORT_PCI == 0
@ -164,34 +189,14 @@ inc_one:
default:
BX_PANIC(("writePhysicalPage: default case"));
goto inc_one;
}
}
}
#endif
goto inc_one;
}
else {
// some or all of data is outside limits of physical memory
#ifdef BX_LITTLE_ENDIAN
data_ptr = (Bit8u *) data;
#else // BX_BIG_ENDIAN
data_ptr = (Bit8u *) data + (len - 1);
#endif
for (unsigned i = 0; i < len; i++) {
if (a20addr < BX_MEM_THIS len) {
vector[a20addr] = *data_ptr;
BX_DBG_DIRTY_PAGE(a20addr >> 12);
}
// otherwise ignore byte, since it overruns memory
addr++;
a20addr = (addr);
#ifdef BX_LITTLE_ENDIAN
data_ptr++;
#else // BX_BIG_ENDIAN
data_ptr--;
#endif
}
// access outside limits of physical memory, ignore
BX_DEBUG(("Write outside the limits of physical memory (ignore)"));
}
}
@ -204,7 +209,6 @@ BX_MEM_C::readPhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
// Note: accesses should always be contained within a single page now
if (cpu != NULL) {
#if BX_SUPPORT_IODEBUG
bx_iodebug_c::mem_read(cpu, a20addr, len, data);
#endif
@ -230,6 +234,12 @@ BX_MEM_C::readPhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
return;
}
#endif
if ((a20addr & 0xfffe0000) == 0x000a0000) {
// SMMRAM memory space
if (BX_MEM_THIS smram_enabled > 1 || cpu->smm_mode())
goto mem_read;
}
}
struct memory_handler_struct *memory_handler = memory_handlers[a20addr >> 20];
@ -243,9 +253,12 @@ BX_MEM_C::readPhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
memory_handler = memory_handler->next;
}
if ( (a20addr + len) <= BX_MEM_THIS len ) {
mem_read:
if (a20addr <= BX_MEM_THIS len) {
// all of data is within limits of physical memory
if ( (a20addr & 0xfff80000) != 0x00080000 ) {
if ((a20addr & 0xfff80000) != 0x00080000 || (a20addr <= 0x0009ffff))
{
if (len == 8) {
ReadHostQWordFromLittleEndian(&vector[a20addr], * (Bit64u*) data);
return;
@ -262,10 +275,9 @@ BX_MEM_C::readPhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
* (Bit8u *) data = * ((Bit8u *) (&vector[a20addr]));
return;
}
// len == 3 case can just fall thru to special cases handling
// len == other case can just fall thru to special cases handling
}
#ifdef BX_LITTLE_ENDIAN
data_ptr = (Bit8u *) data;
#else // BX_BIG_ENDIAN
@ -273,7 +285,8 @@ BX_MEM_C::readPhysicalPage(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data)
#endif
read_one:
if ( (a20addr & 0xfff80000) != 0x00080000 ) {
if ((a20addr & 0xfff80000) != 0x00080000 || (a20addr <= 0x0009ffff))
{
// addr *not* in range 00080000 .. 000FFFFF
*data_ptr = vector[a20addr];
inc_one:
@ -288,7 +301,15 @@ inc_one:
goto read_one;
}
// addr in range 00080000 .. 000FFFFF
// addr must be in range 000A0000 .. 000FFFFF
// SMMRAM
if (a20addr <= 0x000bffff) {
// devices are not allowed to access SMMRAM under VGA memory
if (cpu) *data_ptr = vector[a20addr];
goto inc_one;
}
#if BX_SUPPORT_PCI
if (pci_enabled && ((a20addr & 0xfffc0000) == 0x000c0000))
{
@ -314,10 +335,10 @@ inc_one:
else
#endif // #if BX_SUPPORT_PCI
{
if ( (a20addr & 0xfffc0000) != 0x000c0000 ) {
if ((a20addr & 0xfffc0000) != 0x000c0000) {
*data_ptr = vector[a20addr];
}
else if ( (a20addr & 0xfffe0000) == 0x000e0000 )
else if ((a20addr & 0xfffe0000) == 0x000e0000)
{
*data_ptr = rom[a20addr & BIOS_MASK];
}
@ -329,7 +350,7 @@ inc_one:
}
}
else
{ // some or all of data is outside limits of physical memory
{ // access outside limits of physical memory
#ifdef BX_LITTLE_ENDIAN
data_ptr = (Bit8u *) data;
@ -338,9 +359,7 @@ inc_one:
#endif
for (unsigned i = 0; i < len; i++) {
if (a20addr < BX_MEM_THIS len)
*data_ptr = vector[a20addr];
else if (a20addr >= (Bit32u)~BIOS_MASK)
if (a20addr >= (Bit32u)~BIOS_MASK)
*data_ptr = rom[a20addr & BIOS_MASK];
else
*data_ptr = 0xff;

13
bochs/memory/memory.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: memory.h,v 1.32 2006-03-06 19:23:13 sshwarts Exp $
// $Id: memory.h,v 1.33 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -60,11 +60,15 @@ struct memory_handler_struct {
memory_handler_t write_handler;
};
#define SMRAM_CODE 1
#define SMRAM_DATA 2
class BOCHSAPI BX_MEM_C : public logfunctions {
private:
struct memory_handler_struct **memory_handlers;
bx_bool rom_present[65];
bx_bool pci_enabled;
unsigned smram_enabled;
public:
Bit8u *actual_vector;
@ -80,10 +84,12 @@ public:
}
#endif
BX_MEM_C(void);
~BX_MEM_C(void);
BX_MEM_C();
~BX_MEM_C();
BX_MEM_SMF void alloc_vector_aligned (size_t bytes, size_t alignment) BX_CPP_AttrRegparmN(2);
BX_MEM_SMF void init_memory(int memsize);
BX_MEM_SMF void enable_smram(bx_bool code_only);
BX_MEM_SMF void disable_smram(void);
BX_MEM_SMF void readPhysicalPage(BX_CPU_C *cpu, Bit32u addr,
unsigned len, void *data) BX_CPP_AttrRegparmN(3);
BX_MEM_SMF void writePhysicalPage(BX_CPU_C *cpu, Bit32u addr,
@ -95,6 +101,7 @@ public:
BX_MEM_SMF bx_bool dbg_set_mem(Bit32u addr, unsigned len, Bit8u *buf);
BX_MEM_SMF bx_bool dbg_crc32(Bit32u addr1, Bit32u addr2, Bit32u *crc);
BX_MEM_SMF Bit8u* getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op) BX_CPP_AttrRegparmN(3);
BX_MEM_SMF Bit8u* getHostMemAddrCode(BX_CPU_C *cpu, Bit32u a20Addr) BX_CPP_AttrRegparmN(2);;
BX_MEM_SMF bx_bool registerMemoryHandlers(void *param, memory_handler_t read_handler,
memory_handler_t write_handler, Bit32u begin_addr, Bit32u end_addr);
BX_MEM_SMF bx_bool unregisterMemoryHandlers(memory_handler_t read_handler, memory_handler_t write_handler,

184
bochs/memory/misc_mem.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: misc_mem.cc,v 1.81 2006-03-06 22:03:16 sshwarts Exp $
// $Id: misc_mem.cc,v 1.82 2006-03-26 18:58:01 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -38,7 +38,7 @@ Bit32u BX_MEM_C::get_memory_in_k(void)
return(BX_MEM_THIS megabytes * 1024);
}
BX_MEM_C::BX_MEM_C(void)
BX_MEM_C::BX_MEM_C()
{
char mem[6];
snprintf(mem, 6, "MEM0");
@ -76,9 +76,9 @@ BX_MEM_C::alloc_vector_aligned (size_t bytes, size_t alignment)
actual_vector, vector));
}
BX_MEM_C::~BX_MEM_C(void)
BX_MEM_C::~BX_MEM_C()
{
if (this-> vector != NULL) {
if (BX_MEM_THIS vector != NULL) {
delete [] actual_vector;
actual_vector = NULL;
vector = NULL;
@ -94,10 +94,9 @@ void BX_MEM_C::init_memory(int memsize)
{
int idx;
BX_DEBUG(("Init $Id: misc_mem.cc,v 1.81 2006-03-06 22:03:16 sshwarts Exp $"));
BX_DEBUG(("Init $Id: misc_mem.cc,v 1.82 2006-03-26 18:58:01 sshwarts Exp $"));
// you can pass 0 if memory has been allocated already through
// the constructor, or the desired size of memory if it hasn't
// BX_INFO(("%.2fMB", (float)(BX_MEM_THIS megabytes) ));
if (BX_MEM_THIS vector == NULL) {
// memory not already allocated, do now...
@ -124,6 +123,8 @@ void BX_MEM_C::init_memory(int memsize)
}
#endif
// accept only memory size which is multiply of 1M
BX_ASSERT((len & 0xfffff) == 0);
}
#if BX_SUPPORT_APIC
@ -433,14 +434,19 @@ bx_bool BX_MEM_C::dbg_fetch_mem(Bit32u addr, unsigned len, Bit8u *buf)
bx_bool ret = 1;
for (; len>0; len--) {
if ( (addr & 0xfffe0000) == 0x000a0000 )
*buf = DEV_vga_mem_read(addr);
// Reading standard PCI/ISA Video Mem / SMMRAM
if ((addr & 0xfffe0000) == 0x000a0000) {
if (BX_MEM_THIS smram_enabled)
*buf = vector[addr];
else
*buf = DEV_vga_mem_read(addr);
}
#if BX_SUPPORT_PCI
else if (pci_enabled && ((addr & 0xfffc0000) == 0x000c0000))
{
switch (DEV_pci_rd_memtype (addr)) {
case 0x0: // Read from ROM
if ( (addr & 0xfffe0000) == 0x000e0000 )
if ((addr & 0xfffe0000) == 0x000e0000)
{
*buf = rom[addr & BIOS_MASK];
}
@ -459,10 +465,10 @@ bx_bool BX_MEM_C::dbg_fetch_mem(Bit32u addr, unsigned len, Bit8u *buf)
#endif // #if BX_SUPPORT_PCI
else if (addr < BX_MEM_THIS len)
{
if ( (addr & 0xfffc0000) != 0x000c0000 ) {
if ((addr & 0xfffc0000) != 0x000c0000) {
*buf = vector[addr];
}
else if ( (addr & 0xfffe0000) == 0x000e0000 )
else if ((addr & 0xfffe0000) == 0x000e0000)
{
*buf = rom[addr & BIOS_MASK];
}
@ -490,12 +496,17 @@ bx_bool BX_MEM_C::dbg_fetch_mem(Bit32u addr, unsigned len, Bit8u *buf)
#if BX_DEBUGGER || BX_GDBSTUB
bx_bool BX_MEM_C::dbg_set_mem(Bit32u addr, unsigned len, Bit8u *buf)
{
if ( (addr + len) > this->len ) {
if ((addr + len) > BX_MEM_THIS len) {
return(0); // error, beyond limits of memory
}
for (; len>0; len--) {
if ( (addr & 0xfffe0000) == 0x000a0000 )
DEV_vga_mem_write(addr, *buf);
// Write to standard PCI/ISA Video Mem / SMMRAM
if ((a20Addr & 0xfffe0000) == 0x000a0000) {
if (BX_MEM_THIS smram_enabled)
vector[addr] = *buf;
else
DEV_vga_mem_write(addr, *buf);
}
#if BX_SUPPORT_PCI
else if (pci_enabled && ((addr & 0xfffc0000) == 0x000c0000))
{
@ -510,7 +521,7 @@ bx_bool BX_MEM_C::dbg_set_mem(Bit32u addr, unsigned len, Bit8u *buf)
}
}
#endif // #if BX_SUPPORT_PCI
else if ( (addr & 0xfffc0000) != 0x000c0000 && (addr < ~BIOS_MASK) )
else if ((addr & 0xfffc0000) != 0x000c0000 && (addr < ~BIOS_MASK))
{
vector[addr] = *buf;
}
@ -527,7 +538,7 @@ bx_bool BX_MEM_C::dbg_crc32(Bit32u addr1, Bit32u addr2, Bit32u *crc)
if (addr1 > addr2)
return(0);
if (addr2 >= this->len)
if (addr2 >= BX_MEM_THIS len)
return(0); // error, specified address past last phy mem addr
unsigned len = 1 + addr2 - addr1;
@ -548,9 +559,21 @@ bx_bool BX_MEM_C::dbg_crc32(Bit32u addr1, Bit32u addr2, Bit32u *crc)
// directly within the page that encompasses the address requested.
//
Bit8u * BX_CPP_AttrRegparmN(3)
BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
//
// Memory map inside the 1st megabyte:
//
// 0x00000 - 0x7ffff DOS area (512K)
// 0x80000 - 0x9ffff Optional fixed memory hole (128K)
// 0xa0000 - 0xbffff Standard PCI/ISA Video Mem / SMMRAM (128K)
// 0xc0000 - 0xdffff Expansion Card BIOS and Buffer Area (128K)
// 0xe0000 - 0xeffff Lower BIOS Area (64K)
// 0xf0000 - 0xfffff Upper BIOS Area (64K)
//
Bit8u * BX_CPP_AttrRegparmN(2)
BX_MEM_C::getHostMemAddrCode(BX_CPU_C *cpu, Bit32u a20Addr)
{
BX_ASSERT(cpu != 0); // getHostMemAddrCode could be used only inside the CPU
#if BX_SUPPORT_APIC
bx_generic_apic_c *local_apic = &cpu->local_apic;
@ -558,6 +581,89 @@ BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
return(NULL); // Vetoed! APIC address space
#endif
// reading from SMMRAM memory space
if ((a20Addr & 0xfffe0000) == 0x000a0000) {
if (BX_MEM_THIS smram_enabled || cpu->smm_mode())
return (Bit8u *) & vector[a20Addr];
}
struct memory_handler_struct *memory_handler = memory_handlers[a20Addr >> 20];
while (memory_handler) {
if (memory_handler->begin <= a20Addr &&
memory_handler->end >= a20Addr) {
return(NULL); // Vetoed! memory handler for i/o apic, vram, mmio and PCI PnP
}
memory_handler = memory_handler->next;
}
if ((a20Addr & 0xfffe0000) == 0x000a0000)
return(NULL); // Vetoed! Mem mapped IO (VGA)
#if BX_SUPPORT_PCI
else if (pci_enabled && ((a20Addr & 0xfffc0000) == 0x000c0000))
{
switch (DEV_pci_rd_memtype (a20Addr)) {
case 0x0: // Read from ROM
if ((a20Addr & 0xfffe0000) == 0x000e0000)
{
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
return (Bit8u *) & rom[(a20Addr & EXROM_MASK) + BIOSROMSZ];
}
break;
case 0x1: // Read from ShadowRAM
return (Bit8u *) & vector[a20Addr];
default:
BX_PANIC(("getHostMemAddr(): default case"));
return(NULL);
}
}
#endif
else if(a20Addr < BX_MEM_THIS len)
{
if ((a20Addr & 0xfffc0000) != 0x000c0000) {
return (Bit8u *) & vector[a20Addr];
}
else if ((a20Addr & 0xfffe0000) == 0x000e0000)
{
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
return (Bit8u *) & rom[(a20Addr & EXROM_MASK) + BIOSROMSZ];
}
}
else if (a20Addr >= (Bit32u)~BIOS_MASK)
{
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
// Error, requested addr is out of bounds.
return (Bit8u *) & bogus[a20Addr & 0x0fff];
}
}
Bit8u * BX_CPP_AttrRegparmN(3)
BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
{
BX_ASSERT(cpu != 0); // getHostMemAddr could be used only inside the CPU
#if BX_SUPPORT_APIC
bx_generic_apic_c *local_apic = &cpu->local_apic;
if (local_apic->get_base() == (a20Addr & ~0xfff))
return(NULL); // Vetoed! APIC address space
#endif
if (op == BX_READ) {
// reading from SMMRAM memory space
if ((a20Addr & 0xfffe0000) == 0x000a0000) {
if (BX_MEM_THIS smram_enabled > 1 || cpu->smm_mode())
return (Bit8u *) & vector[a20Addr];
}
}
struct memory_handler_struct *memory_handler = memory_handlers[a20Addr >> 20];
while (memory_handler) {
if (memory_handler->begin <= a20Addr &&
@ -568,38 +674,38 @@ BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
}
if (op == BX_READ) {
if ( (a20Addr & 0xfffe0000) == 0x000a0000 )
if ((a20Addr & 0xfffe0000) == 0x000a0000)
return(NULL); // Vetoed! Mem mapped IO (VGA)
#if BX_SUPPORT_PCI
else if (pci_enabled && ((a20Addr & 0xfffc0000) == 0x000c0000))
{
switch (DEV_pci_rd_memtype (a20Addr)) {
case 0x0: // Read from ROM
if ( (a20Addr & 0xfffe0000) == 0x000e0000 )
if ((a20Addr & 0xfffe0000) == 0x000e0000)
{
return( (Bit8u *) & rom[a20Addr & BIOS_MASK]);
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
return( (Bit8u *) & rom[(a20Addr & EXROM_MASK) + BIOSROMSZ]);
return (Bit8u *) & rom[(a20Addr & EXROM_MASK) + BIOSROMSZ];
}
break;
case 0x1: // Read from ShadowRAM
return( (Bit8u *) & vector[a20Addr]);
return (Bit8u *) & vector[a20Addr];
default:
BX_PANIC(("getHostMemAddr(): default case"));
return(0);
return(NULL);
}
}
#endif
else if (a20Addr < BX_MEM_THIS len)
else if(a20Addr < BX_MEM_THIS len)
{
if ( (a20Addr & 0xfffc0000) != 0x000c0000 ) {
return( (Bit8u *) & vector[a20Addr]);
if ((a20Addr & 0xfffc0000) != 0x000c0000) {
return (Bit8u *) & vector[a20Addr];
}
else if ( (a20Addr & 0xfffe0000) == 0x000e0000 )
else if ((a20Addr & 0xfffe0000) == 0x000e0000)
{
return( (Bit8u *) & rom[a20Addr & BIOS_MASK]);
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
@ -608,20 +714,20 @@ BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
}
else if (a20Addr >= (Bit32u)~BIOS_MASK)
{
return( (Bit8u *) & rom[a20Addr & BIOS_MASK]);
return (Bit8u *) & rom[a20Addr & BIOS_MASK];
}
else
{
// Error, requested addr is out of bounds.
return( (Bit8u *) & bogus[a20Addr & 0x0fff]);
return (Bit8u *) & bogus[a20Addr & 0x0fff];
}
}
else
{ // op == {BX_WRITE, BX_RW}
Bit8u *retAddr;
if ( a20Addr >= BX_MEM_THIS len )
if (a20Addr >= BX_MEM_THIS len)
return(NULL); // Error, requested addr is out of bounds.
else if ( (a20Addr & 0xfffe0000) == 0x000a0000 )
else if ((a20Addr & 0xfffe0000) == 0x000a0000)
return(NULL); // Vetoed! Mem mapped IO (VGA)
else if (a20Addr >= (Bit32u)~BIOS_MASK)
return(NULL); // Vetoed! ROMs
@ -655,7 +761,7 @@ BX_MEM_C::getHostMemAddr(BX_CPU_C *cpu, Bit32u a20Addr, unsigned op)
pageWriteStampTable.decWriteStamp(a20Addr);
#endif
return(retAddr);
return retAddr;
}
}
@ -715,3 +821,13 @@ BX_MEM_C::unregisterMemoryHandlers(memory_handler_t read_handler, memory_handler
}
return ret;
}
BX_MEM_SMF void BX_MEM_C::enable_smram(bx_bool code_only)
{
BX_MEM_THIS smram_enabled = code_only ? 1 : 2;
}
BX_MEM_SMF void BX_MEM_C::disable_smram(void)
{
BX_MEM_THIS smram_enabled = 0;
}