mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
25582ed29d
Bochs/bochs/cpu/resolve64.cc

457 lines
12 KiB
C++
Raw Normal View History

Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
/////////////////////////////////////////////////////////////////////////
remove redundant CPU LEVEL checks for x86-64
2003-12-30 00:47:36 +03:00
// $Id: resolve64.cc,v 1.7 2003-12-29 21:47:36 sshwarts Exp $
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2001 MandrakeSoft S.A.
//
// 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
#define NEED_CPU_REG_SHORTCUTS 1
#include "bochs.h"
#define LOG_THIS BX_CPU_THIS_PTR
- apply patch.ifdef-disabled-options. Comments from that patch are below: For a whole lot of configure options, I put #if...#endif around code that is specific to the option, even in files which are normally only compiled when the option is on. This allows me to create a MS Visual C++ 6.0 workspace that supports many of these options. The workspace will basically compile every file all the time, but the code for disabled options will be commented out by the #if...#endif. This may one day lead to simplification of the Makefiles and configure scripts, but for the moment I'm leaving Makefiles and configure scripts alone. Affected options: BX_SUPPORT_APIC (cpu/apic.cc) BX_SUPPORT_X86_64 (cpu/*64.cc) BX_DEBUGGER (debug/*) BX_DISASM (disasm/*) BX_WITH_nameofgui (gui/*) BX_SUPPORT_CDROM (iodev/cdrom.cc) BX_NE2K_SUPPORT (iodev/eth*.cc, iodev/ne2k.cc) BX_SUPPORT_APIC (iodev/ioapic.cc) BX_IODEBUG_SUPPORT (iodev/iodebug.cc) BX_PCI_SUPPORT (iodev/pci*.cc) BX_SUPPORT_SB16 (iodev/sb*.cc) Modified Files: cpu/apic.cc cpu/arith64.cc cpu/ctrl_xfer64.cc cpu/data_xfer64.cc cpu/fetchdecode64.cc cpu/logical64.cc cpu/mult64.cc cpu/resolve64.cc cpu/shift64.cc cpu/stack64.cc debug/Makefile.in debug/crc.cc debug/dbg_main.cc debug/lexer.l debug/linux.cc debug/parser.c debug/parser.y disasm/dis_decode.cc disasm/dis_groups.cc gui/amigaos.cc gui/beos.cc gui/carbon.cc gui/macintosh.cc gui/rfb.cc gui/sdl.cc gui/term.cc gui/win32.cc gui/wx.cc gui/wxdialog.cc gui/wxmain.cc gui/x.cc iodev/cdrom.cc iodev/eth.cc iodev/eth_arpback.cc iodev/eth_fbsd.cc iodev/eth_linux.cc iodev/eth_null.cc iodev/eth_packetmaker.cc iodev/eth_tap.cc iodev/eth_tuntap.cc iodev/eth_win32.cc iodev/ioapic.cc iodev/iodebug.cc iodev/ne2k.cc iodev/pci.cc iodev/pci2isa.cc iodev/sb16.cc iodev/soundlnx.cc iodev/soundwin.cc
2002-11-19 08:47:45 +03:00
#if BX_SUPPORT_X86_64
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm0(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm1(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm2(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm3(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm5(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
// eip hasn't been bumped yet when this is called. must choose the saved value.
Converted all the remaining available separate fields in bxInstruction_c to bitfields. bxInstruction_c is now 24 bytes, including 4 for the memory addr resolution function pointer, and 4 for the execution function pointer (16 + 4 + 4). Coded more accessors, to abstract access from most code.
2002-09-18 12:00:43 +04:00
RMAddr(i) = BX_CPU_THIS_PTR prev_eip + i->ilen() + (Bit32s)i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm6(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm7(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm8(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm9(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm10(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm11(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm12(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm13(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm14(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Rm15(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm0(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm1(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm2(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm3(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm5(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBP + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm6(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm7(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm8(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm9(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm10(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm11(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm12(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm13(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm14(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Rm15(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base0(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base1(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base2(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base3(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base4(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSP;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base5(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4) {
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base6(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base7(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base8(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base9(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base10(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base11(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base12(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base13(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base14(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod0Base15(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15;
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base0(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RAX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base1(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RCX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base2(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base3(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBX + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base4(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSP + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base5(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RBP + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base6(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RSI + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base7(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = RDI + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base8(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R8 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base9(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R9 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base10(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R10 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base11(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R11 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base12(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R12 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base13(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R13 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base14(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R14 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- add __attribute__((regparm(X))) performance trick with gcc on x86 on some cpu instructions (patch from Conn Clark) - performance improvement is 1% on win95 boot
2003-03-17 03:41:01 +03:00
void BX_CPP_AttrRegparmN(1)
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
BX_CPU_C::Resolve64Mod1or2Base15(bxInstruction_c *i)
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
{
Updated accessing of modrm/sib addressing information to use accessors. This lets me work on compressing the size of fetch-decode structure (now called bxInstruction_c). I've reduced it down to about 76 bytes. We should be able to do much better soon. I needed the abstraction of the accessors, so I have a lot of freedom to re-arrange things without making massive future changes. Lost a few percent of performance in these mods, but my main focus was to get the abstraction.
2002-09-18 02:50:53 +04:00
if (i->sibIndex() != 4)
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
else
Moved more separate fields in the bxInstruction_c into bitfields with accessors. Had to touch a number of files to update the access using the new accessors. Moved rm_addr to the CPU structure, to slim down bxInstruction_c and to prevent future instruction caching from getting sprayed with writes to individual rm_addr fields. There only needs to be one. Though need to deal with instructions which have static non-modrm addresses, but which are using rm_addr since that will change. bxInstruction_c is down to about 40 bytes now. Trying to get down to 24 bytes.
2002-09-18 09:36:48 +04:00
RMAddr(i) = R15 + (Bit32s) i->displ32u();
Moved 64-bit only files from cpu64 to cpu and modified the Makefiles accordingly. These files cause no conflicts at all, since they are not used in 32-bit compiles.
2002-09-13 19:53:22 +04:00
}
- apply patch.ifdef-disabled-options. Comments from that patch are below: For a whole lot of configure options, I put #if...#endif around code that is specific to the option, even in files which are normally only compiled when the option is on. This allows me to create a MS Visual C++ 6.0 workspace that supports many of these options. The workspace will basically compile every file all the time, but the code for disabled options will be commented out by the #if...#endif. This may one day lead to simplification of the Makefiles and configure scripts, but for the moment I'm leaving Makefiles and configure scripts alone. Affected options: BX_SUPPORT_APIC (cpu/apic.cc) BX_SUPPORT_X86_64 (cpu/*64.cc) BX_DEBUGGER (debug/*) BX_DISASM (disasm/*) BX_WITH_nameofgui (gui/*) BX_SUPPORT_CDROM (iodev/cdrom.cc) BX_NE2K_SUPPORT (iodev/eth*.cc, iodev/ne2k.cc) BX_SUPPORT_APIC (iodev/ioapic.cc) BX_IODEBUG_SUPPORT (iodev/iodebug.cc) BX_PCI_SUPPORT (iodev/pci*.cc) BX_SUPPORT_SB16 (iodev/sb*.cc) Modified Files: cpu/apic.cc cpu/arith64.cc cpu/ctrl_xfer64.cc cpu/data_xfer64.cc cpu/fetchdecode64.cc cpu/logical64.cc cpu/mult64.cc cpu/resolve64.cc cpu/shift64.cc cpu/stack64.cc debug/Makefile.in debug/crc.cc debug/dbg_main.cc debug/lexer.l debug/linux.cc debug/parser.c debug/parser.y disasm/dis_decode.cc disasm/dis_groups.cc gui/amigaos.cc gui/beos.cc gui/carbon.cc gui/macintosh.cc gui/rfb.cc gui/sdl.cc gui/term.cc gui/win32.cc gui/wx.cc gui/wxdialog.cc gui/wxmain.cc gui/x.cc iodev/cdrom.cc iodev/eth.cc iodev/eth_arpback.cc iodev/eth_fbsd.cc iodev/eth_linux.cc iodev/eth_null.cc iodev/eth_packetmaker.cc iodev/eth_tap.cc iodev/eth_tuntap.cc iodev/eth_win32.cc iodev/ioapic.cc iodev/iodebug.cc iodev/ne2k.cc iodev/pci.cc iodev/pci2isa.cc iodev/sb16.cc iodev/soundlnx.cc iodev/soundwin.cc
2002-11-19 08:47:45 +03:00
#endif /* if BX_SUPPORT_X86_64 */
Reference in New Issue Copy Permalink