Greetings, SimpleScalar LLC is pleased to make available to (brave) testers an experimental release of SimpleScalar/x86. This experimental release supports user-level emulation of RedHat Linux/x86 version 7.0 applications. We are looking for existing SimpleScalar users that are interested in getting early access to this infrastructure in exchange for assisting us in testing the functional simulation components. In its current state SimpleScalar/x86 is able to execute a wide variety of benchmarks, so testers may begin constructing x86 microarchitecture models (using current SimpleScalar modeling infrastructure) in parallel with testing and development of the first SimpleScalar/x86 release. Interested users, please send e-mail to info@simplescalar.com, and please indicate what benchmarks/programs you can test on the experimental release. Note, you will need source to the program in order to build a statically linked version, and we have tested all the usual suspects, e.g., SPEC, Softfloat, and MediaBench. Also note that this test release is only available free-of-charge to non-commercial academic users and current SimpleScalar commercial licensees. The test release includes all simulator sources, and the current simulator build has only been tested on RedHat Linux/x86 version 7 platforms. The test release README file is attached. Best Regards, Todd Austin, for SimpleScalar LLC -- README.x86 -- Greetings, this version of SimpleScalar contains experimental x86 ISA emulation and microcode support. This short document is intended to get you started on using these sources. Questions, comments, bugfixes, and suggestions should be directed to info@simplescalar.com. To build the distribution: -------------------------- make config-x86 make The simulator binaries have only been tested on RedHat Linux/x86 version 7, but don't panic if you are on another platform. SimpleScalar codes can be made quite portable, see host.h for porting details. To build you own binaries for execution on the simulators: ---------------------------------------------------------- SimpleScalar/x86 simulators can only run ELF format x86 binaries compiled to use RedHat Linux/x86 version 7 system calls. SimpleScalar/x86 requires statically linked x86 ELF binaries; to build SimpleScalar/x86 binaries on RedHat Linux, use the following command: gcc -static -o [flags] To run the simulators: ---------------------- Currently, only two simulators will build, sim-safe and sim-uop. sim-safe executes x86 instructions, sim-uop performs microcode decomposition and then executes the generated microcode stream. Currently the only options supported are debug (-d) and verbose operation (-v). These options, when turned on, will emit lots of information regarding the static and dynamic disposition of your program. Abandon all sanity ye who enter HERE: ------------------------------------- This is preliminary distribution of the SimpleScalar/x86 code, as such there are a few caveats that you should be aware of... Here's what works: - x86 integer and x87 floating point instruction set emulation * all 8, 16, and 32-bit instruction modes are implemented * only user-level instruction emulation has been implemented * MMX, SSE, SSE2, and x86-64 have not yet been implemented * the instruction emulator has been extensively tested against a real x86 hardware reference (using the FuzzBuster random tester) - x86 microcode specification, decomposition, and execution * the test release includes a flexible microcode specification interface, used to describe the decomposition of x86 instructions into internal processor microcode, x86 decoders are generated automagically from this specification * x86 microcode is fully functional with its own synthesized emulator, permitting detailed modeling of dynamically scheduled and microcoded microarchitectures that include timing dependent execution semantics and aggressive control and data speculation * the FuzzBuster random instruction tester is available to test microarchitecture-specific microcode implementations against the reference x86 ISA semantics supported by SimpleScalar LLC * a simple x86 microcode baseline implementation is included in this release, it provides vanilla translations of instructions to two-operand fixed-latency microcode operations, here's an example of a translated instruction stream: pop EBP => agend TMP0.d,ESP,ZERO.d,0,0x00000000 ldd EBP,(TMP0.d) addd ESP,ESP,0x00000004 retn => agend TMP0.d,ESP,ZERO.d,0,0x00000000 ldpcd PC,(TMP0.d) addd ESP,ESP,0x00000004 fld REAL4 PTR [0x08060c58] => agend TMP0.d,ZERO.d,ZERO.d,0,0x08060c58 flds ST7,(TMP0.d),stk-- fadd REAL4 PTR [0x08060c5c] => agend TMP0.d,ZERO.d,ZERO.d,0,0x08060c5c flds FTMP0.e,(TMP0.d) adde ST0,ST0,FTMP0.e fstp REAL4 PTR [0x08060c74] => agend TMP0.d,ZERO.d,ZERO.d,0,0x08060c74 fsts ST0,(TMP0.d),stk++ mov EAX,DWORD PTR 0x10[EBP] => agend TMP0.d,EBP,ZERO.d,0,0x00000010 ldd EAX,(TMP0.d) test EDI,EDI => andd ZERO.d,EDI,EDI push EBP => agend TMP0.d,ESP,ZERO.d,0,0xfffffffc std EBP,(TMP0.d) addd ESP,ESP,0xfffffffc cmp BYTE PTR [EBX],0x00 => agend TMP0.d,EBX,ZERO.d,0,0x00000000 ldb TMP1.b,(TMP0.d) subb ZERO.b,TMP1.b,0x00 jns 0x0804d9d0 => jns 0x0804d9d0 mov EDX,DWORD PTR 0x8[EBP] => agend TMP0.d,EBP,ZERO.d,0,0x00000008 ldd EDX,(TMP0.d) inc ECX => incd ECX,ECX dec DWORD PTR 0xfffffff0[EBP] => agend TMP0.d,EBP,ZERO.d,0,0xfffffff0 ldd TMP1.d,(TMP0.d) decd TMP1.d,TMP1.d std TMP1.d,(TMP0.d) add AL,0xe0 => addb AL,AL,0xffffffe0 movzx EAX,WORD PTR [0x08060ca8] => agend TMP0.d,ZERO.d,ZERO.d,0,0x08060ca8 ldw TMP1.w,(TMP0.d) movzxwd EAX,TMP1.w mov AX,WORD PTR 0x8[EBP] => agend TMP0.d,EBP,ZERO.d,0,0x00000008 ldw AX,(TMP0.d) and DX,0xf0c0 => andw DX,DX,0xfffff0c0 mov CH,CL => addb CH,CL,ZERO.b movsb BYTE PTR DS:[ESI],BYTE PTR ES:[EDI] => agend TMP0.d,ESI,ZERO.d,0,0x00000000 ldb TMP1.b,(TMP0.d) agend TMP0.d,EDI,ZERO.d,0,0x00000000 stb TMP1.b,(TMP0.d) addfd ESI,ESI,0x01 addfd EDI,EDI,0x01 repnz scasb BYTE PTR ES:[EDI] => agend TMP0.d,EDI,ZERO.d,0,0x00000000 ldb TMP1.b,(TMP0.d) subb ZERO.b,AL,TMP1.b addfd EDI,EDI,0x01 cld => movfw ZERO.w,0x0400 rep movsv DWORD PTR DS:[ESI],DWORD PTR ES:[EDI] => agend TMP0.d,ESI,ZERO.d,0,0x00000000 ldd TMP1.d,(TMP0.d) agend TMP0.d,EDI,ZERO.d,0,0x00000000 std TMP1.d,(TMP0.d) addfd ESI,ESI,0x04 addfd EDI,EDI,0x04 - RedHat Linux/x86 version 7 system call emulation * all simulated I/O is implemented at the system call interface by the system call I/O module, currently basic file and tty I/O system calls are supported Here's what doesn't work yet: - ELF symbol table support (the DLite debugger will not recognize program symbols, and sim-profile won't do function profiling) - regression tests are not built yet - DLite debugger has not been ported to x86 yet - EIO trace files are not working yet - cross-endian execution support is not yet tested - documentation (other than this doc) needs to be completed - syscall.c only supports MIN_SYSCALL_MODE, that is the minimal system call support mode - performance modeling is not yet supported for x86, this release is primarily intended for testing functional simulation, although the emulation support is sufficiently stable that users can begin building their own performance models at this time, if they so choose SimpleScalar/x86 License: ------------------------- SimpleScalar/x86 sources are (C) 2001 SimpleScalar LLC. This release may be used free of charge by academic institutions for academic non-commercial research or instructional purposes only. Commercial use of any kind (e.g., any use of SimpleScalar in a commercial setting) requires that a commercial use license be purchased from SimpleScalar LLC. Contact info@simplescalar.com for more details.