wfeldt / libx86emu Goto Github PK

Test.obj  
000000B0 00 0A 00 00 55 8B EC 51 C7 45 FC 00 00 00 00 8B 
000000C0 45 FC 50 E8 09 00 00 00 83 C4 04 33 C0 8B E5 5D 
000000D0 C3 55 8B EC B8 01 00 00 00 5D C3 00 07 00 00 00 

0:  55                      push   ebp
1:  8b ec                   mov    ebp,esp
3:  51                      push   ecx
4:  c7 45 fc 00 00 00 00    mov    DWORD PTR [ebp-0x4],0x0
b:  8b 45 fc                mov    eax,DWORD PTR [ebp-0x4]
e:  50                      push   eax
f:  e8 09 00 00 00          call   0x1d
14: 83 c4 04                add    esp,0x4
17: 33 c0                   xor    eax,eax
19: 8b e5                   mov    esp,ebp
1b: 5d                      pop    ebp
1c: c3                      ret
1d: 55                      push   ebp
1e: 8b ec                   mov    ebp,esp
20: b8 01 00 00 00          mov    eax,0x1
25: 5d                      pop    ebp
26: c3                      ret

./x86emu-demo -l 0 -s 0xB4 Test.obj

eax 00000000, ebx 00000000, ecx 00000000, edx 00000000
esi 00000000, edi 00000000, ebp 00000000, esp 00000000
cs 0000, ss 0000, ds 0000, es 0000, fs 0000, gs 0000
eip 000000b4, eflags 00000002
x [000000b4] = 55
w [0000fffe] = 0000
0 0000:00b4 55                       push bp

eax 00000000, ebx 00000000, ecx 00000000, edx 00000000
esi 00000000, edi 00000000, ebp 00000000, esp 0000fffe
cs 0000, ss 0000, ds 0000, es 0000, fs 0000, gs 0000
eip 000000b5, eflags 00000002
x [000000b5] = 8b
x [000000b6] = ec
1 0000:00b5 8bec                     mov bp,sp

eax 00000000, ebx 00000000, ecx 00000000, edx 00000000
esi 00000000, edi 00000000, ebp 0000fffe, esp 0000fffe
cs 0000, ss 0000, ds 0000, es 0000, fs 0000, gs 0000
eip 000000b7, eflags 00000002
x [000000b7] = 51
w [0000fffc] = 0000
2 0000:00b7 51                       push cx

eax 00000000, ebx 00000000, ecx 00000000, edx 00000000
esi 00000000, edi 00000000, ebp 0000fffe, esp 0000fffc
cs 0000, ss 0000, ds 0000, es 0000, fs 0000, gs 0000
eip 000000b8, eflags 00000002
x [000000b8] = c7
x [000000b9] = 45
x [000000ba] = fc
x [000000bb] = 0000
w [0000fffc] = 0000
3 0000:00b8 c745fc0000               mov [di-04],0000

eax 00000000, ebx 00000000, ecx 00000000, edx 00000000
esi 00000000, edi 00000000, ebp 0000fffe, esp 0000fffc
cs 0000, ss 0000, ds 0000, es 0000, fs 0000, gs 0000
eip 000000bd, eflags 00000002
x [000000bd] = 00
x [000000be] = 00
r [00000000] = 4c
w [00000000] = 4c
4 0000:00bd 0000                     add [bx+si],al
* no proper code

I have compiled libx86emu in a chrooted environment (my host was x86_64 and the chrooted environment was i686). The 0032_rol16.init test has failed. The logs are here: 0032_rol16.tar.gz.
Does this mean that libx86emu shouldn't be used on i686?

x86emu-demo.c does not work correctly with my test data under Linux unless it uses the 2015 version of x86emu.h.
Everything else seems to work correctly under both Linux and Windows including the regression tests under Linux.
I forced x86test.c and x86emu-demo.c to use "../include/x86emu.h" and only the demo quit working. I found this error when I was trying to augment x86emu_t with additional features.

There are four lines of code in x86emu.h that make the difference. The general regression tests will not pass without these four lines and my own regression test of x86emu-demo.c will not pass with these fours lines.

These lines of x86emu.h make x86emu-demo.c flunk regression
(420) struct i386_see_regs sse; // 2020-07-19
(522) x86emu_cpuid_handler_t cpuid; // 2020-07-19
(525) x86emu_wrmsr_handler_t wrmsr; // 2020-07-19
(526) x86emu_wrmsr_handler_t rdmsr; // 2020-07-19

The test data only fails on x86emu-demo.c with the current version of x86emu.h when linked to the shared library. It works correctly as a single executable under Linux, Windows and linked to the library as a DLL under Windows.

This problem was very difficult to detect because of #include <x86emu.h> referenced a copy of the file that was not in any of the source directories.

I'm looking for a emulator that can run on Win10 and then I found this. But this is only for linux. I plan to learn from this code to make a windows version but I found some opcode like 0x64,0x65 are marked as illegal , who can tell me why is that???

Hello,

I have developed a python binding for this code; would this be something that I should create a PR for, or should I create a separate repository?

Also, is licensing on this project is OSI approved?

Thanks!

It only took a few very minor changes to adapt the code to compile under Visual Studio 2017.
I am pretty sure that this is a comprehensive list all all of the changes it was derived from a diff.

(1) API_SYM was removed everywhere
(2) decode.c-------------void decode_hex(x86emu_t *emu, char **p, u64 ofs)
(3) api.c -----------------emu->x86.R_EAX = (uint32_t) emu->x86.msr[u];
(4) mem.c---------------six low level port io functions were swapped

#if (_MSC_VER >= 1900)  // (Visual Studio 2015 version 14.0)
  #include <intrin.h>
#endif 
return inb(addr); // becomes __inbyte(addr);
return inw(addr); // becomes __inword(addr);
return inl(addr); // becomes __indword(addr);
outb(val, addr);  // becomes __outbyte(val, addr);
outw(val, addr);  // becomes __outword(val, addr);
outl(val, addr);  // becomes __outdword(val, addr);

(5) x86emu-demo.c-----if(!(f = fopen(file, "rb"))) return 0;
(6) I found a good getopt.h that works under Windows. It has a compatible license.
https://github.com/skandhurkat/Getopt-for-Visual-Studio/blob/master/getopt.h

To make things very simple I compiled the demo code together with the library files into a single executable. The adapted code also compiles under Linux as a shared library.

Microsoft Visual Studio 2017 Community Edition is freeware.
Thanks for adding the --32 option to the demo program.
All of these changes have been applied to the most recent commit.

With additional changes it now compiles as c++ in Visual Studio 2017 and gcc.

With a zero dividend the instruction "idiv %ebx" , with %ebx > 0 asserts a #DE instead of returning zero quotient and remainder.

Hello, what architectures does libx86emu support?

Hey I don't know how to email you I wanted to ask you..

I may end up using your library for cpu emulation because it's very simple short and not too hard to understand others are way to complicated I need to add to this library floating-point instructions emulation to make it complete x86 emu emulator for my needs.

Now I just ask how do I step code line by line?.. I tried quickfix but EIP never changes?? how come.

I use this at the moment and EIP never changes and loop just crashes Segmentation fault error.

    //Set the emulator to start at this instruction. [EIP register]
    emu->x86.R_EIP = 0x00457D60; //start of function 0x457D60

    //Set the CPU emulator flags
    unsigned flags;
    flags = X86EMU_RUN_LOOP | X86EMU_RUN_NO_CODE;

        unsigned instructions_run_max = 1;
    if(instuctions_run_max) {
        emu->max_instr = instuctions_run_max; //max instructions to run
        flags |= X86EMU_RUN_MAX_INSTR;
    }

    //Run the CPU Emulator!
    while(emu->x86.R_EIP != 0x00458BD0) //where CPU emulator must stop address
    {
        x86emu_run(emu, flags);
        //I debug here line by line to see where CPU emulator needs more implmentation of new instructions.. I will try to put in floating-point operations myself using this.
    }

Have any way to step instructions line by line? not always running x86_emu_run(...);

I look at it more in depth it looks like X86EMU_RUN_LOOP only detect JMP for EIP? if(op1 == 0xeb) and else if(op1 == 0xe9) should detect every line?? i dont understand sorry.
But I really like your library

According to the openSUSE spec, this is a 3-clause BSD licensed program. However, no LICENSE or COPYING file spells out the exact terms. Please correct this, as the BSD licenses require full notice and attribution.