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

code optimization for future

Browse Source
This commit is contained in:
Stanislav Shwartsman 2009-10-08 18:07:50 +00:00
parent a5a22cc00d
commit 6d6bf4a65e
3 changed files with 129 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
bochs/cpu/access.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: access.cc,v 1.124 2009-03-13 18:48:08 sshwarts Exp $
// $Id: access.cc,v 1.125 2009-10-08 18:07:50 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -333,6 +333,81 @@ BX_CPU_C::system_read_qword(bx_address laddr)
return data;
}
void BX_CPP_AttrRegparmN(2)
BX_CPU_C::system_write_byte(bx_address laddr, Bit8u data)
{
unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 0);
Bit32u lpf = LPFOf(laddr);
bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
if (tlbEntry->lpf == lpf) {
// See if the TLB entry privilege level allows us write access
// from this CPL.
if (! (tlbEntry->accessBits & 0x2)) {
bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
Bit32u pageOffset = PAGE_OFFSET(laddr);
BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 1, BX_WRITE);
BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
tlbEntry->ppf | pageOffset, 1, 0, BX_WRITE, (Bit8u*) &data);
Bit8u *hostAddr = (Bit8u*) (hostPageAddr | pageOffset);
pageWriteStampTable.decWriteStamp(tlbEntry->ppf);
*hostAddr = data;
return;
}
}
access_write_linear(laddr, 1, 0, (void *) &data);
}
void BX_CPP_AttrRegparmN(2)
BX_CPU_C::system_write_word(bx_address laddr, Bit16u data)
{
unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 1);
Bit32u lpf = LPFOf(laddr);
bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
if (tlbEntry->lpf == lpf) {
// See if the TLB entry privilege level allows us write access
// from this CPL.
if (! (tlbEntry->accessBits & 0x2)) {
bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
Bit32u pageOffset = PAGE_OFFSET(laddr);
BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 2, BX_WRITE);
BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
tlbEntry->ppf | pageOffset, 2, 0, BX_WRITE, (Bit8u*) &data);
Bit16u *hostAddr = (Bit16u*) (hostPageAddr | pageOffset);
pageWriteStampTable.decWriteStamp(tlbEntry->ppf);
WriteHostWordToLittleEndian(hostAddr, data);
return;
}
}
access_write_linear(laddr, 2, 0, (void *) &data);
}
void BX_CPP_AttrRegparmN(2)
BX_CPU_C::system_write_dword(bx_address laddr, Bit32u data)
{
unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 3);
Bit32u lpf = LPFOf(laddr);
bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
if (tlbEntry->lpf == lpf) {
// See if the TLB entry privilege level allows us write access
// from this CPL.
if (! (tlbEntry->accessBits & 0x2)) {
bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
Bit32u pageOffset = PAGE_OFFSET(laddr);
BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 4, BX_WRITE);
BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
tlbEntry->ppf | pageOffset, 4, 0, BX_WRITE, (Bit8u*) &data);
Bit32u *hostAddr = (Bit32u*) (hostPageAddr | pageOffset);
pageWriteStampTable.decWriteStamp(tlbEntry->ppf);
WriteHostDWordToLittleEndian(hostAddr, data);
return;
}
}
access_write_linear(laddr, 4, 0, (void *) &data);
}
Bit8u* BX_CPP_AttrRegparmN(2)
BX_CPU_C::v2h_read_byte(bx_address laddr, bx_bool user)
{

6
bochs/cpu/cpu.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: cpu.h,v 1.611 2009-10-02 16:09:08 sshwarts Exp $
// $Id: cpu.h,v 1.612 2009-10-08 18:07:50 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -3008,6 +3008,10 @@ public: // for now...
BX_SMF Bit32u system_read_dword(bx_address laddr) BX_CPP_AttrRegparmN(1);
BX_SMF Bit64u system_read_qword(bx_address laddr) BX_CPP_AttrRegparmN(1);
BX_SMF void system_write_byte(bx_address laddr, Bit8u data) BX_CPP_AttrRegparmN(2);
BX_SMF void system_write_word(bx_address laddr, Bit16u data) BX_CPP_AttrRegparmN(2);
BX_SMF void system_write_dword(bx_address laddr, Bit32u data) BX_CPP_AttrRegparmN(2);
BX_SMF Bit8u* v2h_read_byte(bx_address laddr, bx_bool user) BX_CPP_AttrRegparmN(2);
BX_SMF Bit8u* v2h_write_byte(bx_address laddr, bx_bool user) BX_CPP_AttrRegparmN(2);

95
bochs/cpu/tasking.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: tasking.cc,v 1.75 2009-07-27 05:52:28 sshwarts Exp $
// $Id: tasking.cc,v 1.76 2009-10-08 18:07:50 sshwarts Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
@ -120,7 +120,7 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
Bit32u temp32, newCR3;
Bit16u raw_cs_selector, raw_ss_selector, raw_ds_selector, raw_es_selector,
raw_fs_selector, raw_gs_selector, raw_ldt_selector;
Bit16u temp16, trap_word;
Bit16u trap_word;
bx_selector_t cs_selector, ss_selector, ds_selector, es_selector,
fs_selector, gs_selector, ldt_selector;
bx_descriptor_t cs_descriptor, ss_descriptor, ldt_descriptor;
@ -246,24 +246,25 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
dtranslate_linear(Bit32u(obase32 + 41), 0, BX_WRITE);
}
temp16 = IP; access_write_linear(Bit32u(obase32 + 14), 2, 0, &temp16);
temp16 = oldEFLAGS; access_write_linear(Bit32u(obase32 + 16), 2, 0, &temp16);
temp16 = AX; access_write_linear(Bit32u(obase32 + 18), 2, 0, &temp16);
temp16 = CX; access_write_linear(Bit32u(obase32 + 20), 2, 0, &temp16);
temp16 = DX; access_write_linear(Bit32u(obase32 + 22), 2, 0, &temp16);
temp16 = BX; access_write_linear(Bit32u(obase32 + 24), 2, 0, &temp16);
temp16 = SP; access_write_linear(Bit32u(obase32 + 26), 2, 0, &temp16);
temp16 = BP; access_write_linear(Bit32u(obase32 + 28), 2, 0, &temp16);
temp16 = SI; access_write_linear(Bit32u(obase32 + 30), 2, 0, &temp16);
temp16 = DI; access_write_linear(Bit32u(obase32 + 32), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value;
access_write_linear(Bit32u(obase32 + 34), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value;
access_write_linear(Bit32u(obase32 + 36), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value;
access_write_linear(Bit32u(obase32 + 38), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value;
access_write_linear(Bit32u(obase32 + 40), 2, 0, &temp16);
system_write_word(Bit32u(obase32 + 14), IP);
system_write_word(Bit32u(obase32 + 16), oldEFLAGS);
system_write_word(Bit32u(obase32 + 18), AX);
system_write_word(Bit32u(obase32 + 20), CX);
system_write_word(Bit32u(obase32 + 22), DX);
system_write_word(Bit32u(obase32 + 24), BX);
system_write_word(Bit32u(obase32 + 26), SP);
system_write_word(Bit32u(obase32 + 28), BP);
system_write_word(Bit32u(obase32 + 30), SI);
system_write_word(Bit32u(obase32 + 32), DI);
system_write_word(Bit32u(obase32 + 34),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value);
system_write_word(Bit32u(obase32 + 36),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value);
system_write_word(Bit32u(obase32 + 38),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value);
system_write_word(Bit32u(obase32 + 40),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value);
}
else {
// check that we won't page fault while writing
@ -272,36 +273,36 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
dtranslate_linear(Bit32u(obase32 + 0x5d), 0, BX_WRITE);
}
temp32 = EIP; access_write_linear(Bit32u(obase32 + 0x20), 4, 0, &temp32);
temp32 = oldEFLAGS; access_write_linear(Bit32u(obase32 + 0x24), 4, 0, &temp32);
temp32 = EAX; access_write_linear(Bit32u(obase32 + 0x28), 4, 0, &temp32);
temp32 = ECX; access_write_linear(Bit32u(obase32 + 0x2c), 4, 0, &temp32);
temp32 = EDX; access_write_linear(Bit32u(obase32 + 0x30), 4, 0, &temp32);
temp32 = EBX; access_write_linear(Bit32u(obase32 + 0x34), 4, 0, &temp32);
temp32 = ESP; access_write_linear(Bit32u(obase32 + 0x38), 4, 0, &temp32);
temp32 = EBP; access_write_linear(Bit32u(obase32 + 0x3c), 4, 0, &temp32);
temp32 = ESI; access_write_linear(Bit32u(obase32 + 0x40), 4, 0, &temp32);
temp32 = EDI; access_write_linear(Bit32u(obase32 + 0x44), 4, 0, &temp32);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value;
access_write_linear(Bit32u(obase32 + 0x48), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value;
access_write_linear(Bit32u(obase32 + 0x4c), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value;
access_write_linear(Bit32u(obase32 + 0x50), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value;
access_write_linear(Bit32u(obase32 + 0x54), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value;
access_write_linear(Bit32u(obase32 + 0x58), 2, 0, &temp16);
temp16 = BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value;
access_write_linear(Bit32u(obase32 + 0x5c), 2, 0, &temp16);
system_write_dword(Bit32u(obase32 + 0x20), EIP);
system_write_dword(Bit32u(obase32 + 0x24), oldEFLAGS);
system_write_dword(Bit32u(obase32 + 0x28), EAX);
system_write_dword(Bit32u(obase32 + 0x2c), ECX);
system_write_dword(Bit32u(obase32 + 0x30), EDX);
system_write_dword(Bit32u(obase32 + 0x34), EBX);
system_write_dword(Bit32u(obase32 + 0x38), ESP);
system_write_dword(Bit32u(obase32 + 0x3c), EBP);
system_write_dword(Bit32u(obase32 + 0x40), ESI);
system_write_dword(Bit32u(obase32 + 0x44), EDI);
system_write_word(Bit32u(obase32 + 0x48),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES].selector.value);
system_write_word(Bit32u(obase32 + 0x4c),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value);
system_write_word(Bit32u(obase32 + 0x50),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value);
system_write_word(Bit32u(obase32 + 0x54),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS].selector.value);
system_write_word(Bit32u(obase32 + 0x58),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS].selector.value);
system_write_word(Bit32u(obase32 + 0x5c),
BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS].selector.value);
}
// effect on link field of new task
if (source == BX_TASK_FROM_CALL || source == BX_TASK_FROM_INT)
{
// set to selector of old task's TSS
temp16 = BX_CPU_THIS_PTR tr.selector.value;
access_write_linear(nbase32, 2, 0, &temp16);
system_write_word(nbase32, BX_CPU_THIS_PTR tr.selector.value);
}
// STEP 4: The new-task state is loaded from the TSS
@ -315,7 +316,7 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
// - upper word of eflags is zero'd
// - FS, GS are zero'd
// - upper word of eIP is zero'd
temp16 = system_read_word(Bit32u(nbase32 + 18));
Bit16u temp16 = system_read_word(Bit32u(nbase32 + 18));
newEAX = 0xffff0000 | temp16;
temp16 = system_read_word(Bit32u(nbase32 + 20));
newECX = 0xffff0000 | temp16;
@ -378,7 +379,7 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
{
// set the new task's busy bit
Bit32u laddr = (Bit32u)(BX_CPU_THIS_PTR gdtr.base) + (tss_selector->index<<3) + 4;
access_read_linear(laddr, 4, 0, BX_READ, &dword2);
access_read_linear(laddr, 4, 0, BX_RW, &dword2);
dword2 |= 0x200;
access_write_linear(laddr, 4, 0, &dword2);
}
@ -390,7 +391,7 @@ void BX_CPU_C::task_switch(bxInstruction_c *i, bx_selector_t *tss_selector,
if (source == BX_TASK_FROM_JUMP || source == BX_TASK_FROM_IRET) {
// Bit is cleared
Bit32u laddr = (Bit32u) BX_CPU_THIS_PTR gdtr.base + (BX_CPU_THIS_PTR tr.selector.index<<3) + 4;
access_read_linear(laddr, 4, 0, BX_READ, &temp32);
access_read_linear(laddr, 4, 0, BX_RW, &temp32);
temp32 &= ~0x200;
access_write_linear(laddr, 4, 0, &temp32);
}