mirror of
https://github.com/yuzu-emu/unicorn.git
synced 2025-06-29 16:22:50 +00:00
renames the register constants so unicorn and capstone can compile together
This commit is contained in:
mothran
parent
3e5ebc58a0
commit
a167f7c456
|
|
@ -173,11 +173,11 @@ def hook_intr(uc, intno, user_data):
|
||||||
if intno != 0x80:
|
if intno != 0x80:
|
||||||
return
|
return
|
||||||
|
|
||||||
eax = uc.reg_read(X86_REG_EAX)
|
eax = uc.reg_read(UC_X86_REG_EAX)
|
||||||
ebx = uc.reg_read(X86_REG_EBX)
|
ebx = uc.reg_read(UC_X86_REG_EBX)
|
||||||
ecx = uc.reg_read(X86_REG_ECX)
|
ecx = uc.reg_read(UC_X86_REG_ECX)
|
||||||
edx = uc.reg_read(X86_REG_EDX)
|
edx = uc.reg_read(UC_X86_REG_EDX)
|
||||||
eip = uc.reg_read(X86_REG_EIP)
|
eip = uc.reg_read(UC_X86_REG_EIP)
|
||||||
|
|
||||||
# print(">>> INTERRUPT %d" % eax)
|
# print(">>> INTERRUPT %d" % eax)
|
||||||
|
|
||||||
|
|
@ -217,7 +217,7 @@ def hook_intr(uc, intno, user_data):
|
||||||
filename = uc.mem_read(filename_addr, FILENAME_MAX_LEN)
|
filename = uc.mem_read(filename_addr, FILENAME_MAX_LEN)
|
||||||
|
|
||||||
dummy_fd = id_gen.next()
|
dummy_fd = id_gen.next()
|
||||||
uc.reg_write(X86_REG_EAX, dummy_fd)
|
uc.reg_write(UC_X86_REG_EAX, dummy_fd)
|
||||||
|
|
||||||
msg = "open file (filename=%s flags=%d mode=%d) with fd(%d)" % (bytearray_to_string(filename), flags, mode, dummy_fd)
|
msg = "open file (filename=%s flags=%d mode=%d) with fd(%d)" % (bytearray_to_string(filename), flags, mode, dummy_fd)
|
||||||
|
|
||||||
|
|
@ -234,8 +234,8 @@ def hook_intr(uc, intno, user_data):
|
||||||
print(">>> SYS_DUP2 oldfd=%d newfd=%d" % (ebx, ecx))
|
print(">>> SYS_DUP2 oldfd=%d newfd=%d" % (ebx, ecx))
|
||||||
elif eax == 102: # sys_socketcall
|
elif eax == 102: # sys_socketcall
|
||||||
# ref: http://www.skyfree.org/linux/kernel_network/socket.html
|
# ref: http://www.skyfree.org/linux/kernel_network/socket.html
|
||||||
call = uc.reg_read(X86_REG_EBX)
|
call = uc.reg_read(UC_X86_REG_EBX)
|
||||||
args = uc.reg_read(X86_REG_ECX)
|
args = uc.reg_read(UC_X86_REG_ECX)
|
||||||
|
|
||||||
buf = uc.mem_read(args, SOCKETCALL_MAX_ARGS*SIZE_REG)
|
buf = uc.mem_read(args, SOCKETCALL_MAX_ARGS*SIZE_REG)
|
||||||
args = struct.unpack("<" + "I"*SOCKETCALL_MAX_ARGS, buf)
|
args = struct.unpack("<" + "I"*SOCKETCALL_MAX_ARGS, buf)
|
||||||
|
|
@ -249,7 +249,7 @@ def hook_intr(uc, intno, user_data):
|
||||||
protocol = args[2]
|
protocol = args[2]
|
||||||
|
|
||||||
dummy_fd = id_gen.next()
|
dummy_fd = id_gen.next()
|
||||||
uc.reg_write(X86_REG_EAX, dummy_fd)
|
uc.reg_write(UC_X86_REG_EAX, dummy_fd)
|
||||||
|
|
||||||
if family == 2: # AF_INET
|
if family == 2: # AF_INET
|
||||||
|
|
||||||
|
|
@ -353,7 +353,7 @@ def test_i386(code):
|
||||||
mu.mem_write(ADDRESS, code)
|
mu.mem_write(ADDRESS, code)
|
||||||
|
|
||||||
# initialize stack
|
# initialize stack
|
||||||
mu.reg_write(X86_REG_ESP, ADDRESS + 0x200000)
|
mu.reg_write(UC_X86_REG_ESP, ADDRESS + 0x200000)
|
||||||
|
|
||||||
# tracing all instructions with customized callback
|
# tracing all instructions with customized callback
|
||||||
# mu.hook_add(UC_HOOK_CODE, hook_code)
|
# mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||||
|
|
|
||||||
|
|
@ -26,7 +26,7 @@ def hook_block(uc, address, size, user_data):
|
||||||
# callback for tracing instructions
|
# callback for tracing instructions
|
||||||
def hook_code(uc, address, size, user_data):
|
def hook_code(uc, address, size, user_data):
|
||||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||||
#eip = uc.reg_read(X86_REG_EIP)
|
#eip = uc.reg_read(UC_X86_REG_EIP)
|
||||||
#print(">>> EIP = 0x%x" %(eip))
|
#print(">>> EIP = 0x%x" %(eip))
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -56,7 +56,7 @@ def hook_mem_access(uc, access, address, size, value, user_data):
|
||||||
|
|
||||||
# callback for IN instruction
|
# callback for IN instruction
|
||||||
def hook_in(uc, port, size, user_data):
|
def hook_in(uc, port, size, user_data):
|
||||||
eip = uc.reg_read(X86_REG_EIP)
|
eip = uc.reg_read(UC_X86_REG_EIP)
|
||||||
print("--- reading from port 0x%x, size: %u, address: 0x%x" %(port, size, eip))
|
print("--- reading from port 0x%x, size: %u, address: 0x%x" %(port, size, eip))
|
||||||
if size == 1:
|
if size == 1:
|
||||||
# read 1 byte to AL
|
# read 1 byte to AL
|
||||||
|
|
@ -73,20 +73,20 @@ def hook_in(uc, port, size, user_data):
|
||||||
|
|
||||||
# callback for OUT instruction
|
# callback for OUT instruction
|
||||||
def hook_out(uc, port, size, value, user_data):
|
def hook_out(uc, port, size, value, user_data):
|
||||||
eip = uc.reg_read(X86_REG_EIP)
|
eip = uc.reg_read(UC_X86_REG_EIP)
|
||||||
print("--- writing to port 0x%x, size: %u, value: 0x%x, address: 0x%x" %(port, size, value, eip))
|
print("--- writing to port 0x%x, size: %u, value: 0x%x, address: 0x%x" %(port, size, value, eip))
|
||||||
|
|
||||||
# confirm that value is indeed the value of AL/AX/EAX
|
# confirm that value is indeed the value of AL/AX/EAX
|
||||||
v = 0
|
v = 0
|
||||||
if size == 1:
|
if size == 1:
|
||||||
# read 1 byte in AL
|
# read 1 byte in AL
|
||||||
v = uc.reg_read(X86_REG_AL)
|
v = uc.reg_read(UC_X86_REG_AL)
|
||||||
if size == 2:
|
if size == 2:
|
||||||
# read 2 bytes in AX
|
# read 2 bytes in AX
|
||||||
v = uc.reg_read(X86_REG_AX)
|
v = uc.reg_read(UC_X86_REG_AX)
|
||||||
if size == 4:
|
if size == 4:
|
||||||
# read 4 bytes in EAX
|
# read 4 bytes in EAX
|
||||||
v = uc.reg_read(X86_REG_EAX)
|
v = uc.reg_read(UC_X86_REG_EAX)
|
||||||
|
|
||||||
print("--- register value = 0x%x" %v)
|
print("--- register value = 0x%x" %v)
|
||||||
|
|
||||||
|
|
@ -105,8 +105,8 @@ def test_i386():
|
||||||
mu.mem_write(ADDRESS, X86_CODE32)
|
mu.mem_write(ADDRESS, X86_CODE32)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_ECX, 0x1234)
|
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||||
mu.reg_write(X86_REG_EDX, 0x7890)
|
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
@ -120,8 +120,8 @@ def test_i386():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
r_ecx = mu.reg_read(X86_REG_ECX)
|
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||||
r_edx = mu.reg_read(X86_REG_EDX)
|
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||||
print(">>> ECX = 0x%x" %r_ecx)
|
print(">>> ECX = 0x%x" %r_ecx)
|
||||||
print(">>> EDX = 0x%x" %r_edx)
|
print(">>> EDX = 0x%x" %r_edx)
|
||||||
|
|
||||||
|
|
@ -149,8 +149,8 @@ def test_i386_loop():
|
||||||
mu.mem_write(ADDRESS, X86_CODE32_LOOP)
|
mu.mem_write(ADDRESS, X86_CODE32_LOOP)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_ECX, 0x1234)
|
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||||
mu.reg_write(X86_REG_EDX, 0x7890)
|
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||||
|
|
||||||
# emulate machine code in infinite time
|
# emulate machine code in infinite time
|
||||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_LOOP), 2 * UC_SECOND_SCALE)
|
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_LOOP), 2 * UC_SECOND_SCALE)
|
||||||
|
|
@ -158,8 +158,8 @@ def test_i386_loop():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
r_ecx = mu.reg_read(X86_REG_ECX)
|
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||||
r_edx = mu.reg_read(X86_REG_EDX)
|
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||||
print(">>> ECX = 0x%x" %r_ecx)
|
print(">>> ECX = 0x%x" %r_ecx)
|
||||||
print(">>> EDX = 0x%x" %r_edx)
|
print(">>> EDX = 0x%x" %r_edx)
|
||||||
|
|
||||||
|
|
@ -180,8 +180,8 @@ def test_i386_invalid_mem_read():
|
||||||
mu.mem_write(ADDRESS, X86_CODE32_MEM_READ)
|
mu.mem_write(ADDRESS, X86_CODE32_MEM_READ)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_ECX, 0x1234)
|
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||||
mu.reg_write(X86_REG_EDX, 0x7890)
|
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
@ -198,8 +198,8 @@ def test_i386_invalid_mem_read():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
r_ecx = mu.reg_read(X86_REG_ECX)
|
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||||
r_edx = mu.reg_read(X86_REG_EDX)
|
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||||
print(">>> ECX = 0x%x" %r_ecx)
|
print(">>> ECX = 0x%x" %r_ecx)
|
||||||
print(">>> EDX = 0x%x" %r_edx)
|
print(">>> EDX = 0x%x" %r_edx)
|
||||||
|
|
||||||
|
|
@ -220,8 +220,8 @@ def test_i386_invalid_mem_write():
|
||||||
mu.mem_write(ADDRESS, X86_CODE32_MEM_WRITE)
|
mu.mem_write(ADDRESS, X86_CODE32_MEM_WRITE)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_ECX, 0x1234)
|
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||||
mu.reg_write(X86_REG_EDX, 0x7890)
|
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
#mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
#mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
@ -241,8 +241,8 @@ def test_i386_invalid_mem_write():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
r_ecx = mu.reg_read(X86_REG_ECX)
|
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||||
r_edx = mu.reg_read(X86_REG_EDX)
|
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||||
print(">>> ECX = 0x%x" %r_ecx)
|
print(">>> ECX = 0x%x" %r_ecx)
|
||||||
print(">>> EDX = 0x%x" %r_edx)
|
print(">>> EDX = 0x%x" %r_edx)
|
||||||
|
|
||||||
|
|
@ -280,8 +280,8 @@ def test_i386_inout():
|
||||||
mu.mem_write(ADDRESS, X86_CODE32_INOUT)
|
mu.mem_write(ADDRESS, X86_CODE32_INOUT)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_EAX, 0x1234)
|
mu.reg_write(UC_X86_REG_EAX, 0x1234)
|
||||||
mu.reg_write(X86_REG_ECX, 0x6789)
|
mu.reg_write(UC_X86_REG_ECX, 0x6789)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
@ -290,8 +290,8 @@ def test_i386_inout():
|
||||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||||
|
|
||||||
# handle IN & OUT instruction
|
# handle IN & OUT instruction
|
||||||
mu.hook_add(UC_HOOK_INSN, hook_in, None, X86_INS_IN)
|
mu.hook_add(UC_HOOK_INSN, hook_in, None, UC_X86_INS_IN)
|
||||||
mu.hook_add(UC_HOOK_INSN, hook_out, None, X86_INS_OUT)
|
mu.hook_add(UC_HOOK_INSN, hook_out, None, UC_X86_INS_OUT)
|
||||||
|
|
||||||
# emulate machine code in infinite time
|
# emulate machine code in infinite time
|
||||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_INOUT))
|
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_INOUT))
|
||||||
|
|
@ -299,8 +299,8 @@ def test_i386_inout():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
r_ecx = mu.reg_read(X86_REG_ECX)
|
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||||
r_eax = mu.reg_read(X86_REG_EAX)
|
r_eax = mu.reg_read(UC_X86_REG_EAX)
|
||||||
print(">>> EAX = 0x%x" %r_eax)
|
print(">>> EAX = 0x%x" %r_eax)
|
||||||
print(">>> ECX = 0x%x" %r_ecx)
|
print(">>> ECX = 0x%x" %r_ecx)
|
||||||
except UcError as e:
|
except UcError as e:
|
||||||
|
|
@ -320,23 +320,23 @@ def test_x86_64():
|
||||||
mu.mem_write(ADDRESS, X86_CODE64)
|
mu.mem_write(ADDRESS, X86_CODE64)
|
||||||
|
|
||||||
# initialize machine registers
|
# initialize machine registers
|
||||||
mu.reg_write(X86_REG_RAX, 0x71f3029efd49d41d)
|
mu.reg_write(UC_X86_REG_RAX, 0x71f3029efd49d41d)
|
||||||
mu.reg_write(X86_REG_RBX, 0xd87b45277f133ddb)
|
mu.reg_write(UC_X86_REG_RBX, 0xd87b45277f133ddb)
|
||||||
mu.reg_write(X86_REG_RCX, 0xab40d1ffd8afc461)
|
mu.reg_write(UC_X86_REG_RCX, 0xab40d1ffd8afc461)
|
||||||
mu.reg_write(X86_REG_RDX, 0x919317b4a733f01)
|
mu.reg_write(UC_X86_REG_RDX, 0x919317b4a733f01)
|
||||||
mu.reg_write(X86_REG_RSI, 0x4c24e753a17ea358)
|
mu.reg_write(UC_X86_REG_RSI, 0x4c24e753a17ea358)
|
||||||
mu.reg_write(X86_REG_RDI, 0xe509a57d2571ce96)
|
mu.reg_write(UC_X86_REG_RDI, 0xe509a57d2571ce96)
|
||||||
mu.reg_write(X86_REG_R8, 0xea5b108cc2b9ab1f)
|
mu.reg_write(UC_X86_REG_R8, 0xea5b108cc2b9ab1f)
|
||||||
mu.reg_write(X86_REG_R9, 0x19ec097c8eb618c1)
|
mu.reg_write(UC_X86_REG_R9, 0x19ec097c8eb618c1)
|
||||||
mu.reg_write(X86_REG_R10, 0xec45774f00c5f682)
|
mu.reg_write(UC_X86_REG_R10, 0xec45774f00c5f682)
|
||||||
mu.reg_write(X86_REG_R11, 0xe17e9dbec8c074aa)
|
mu.reg_write(UC_X86_REG_R11, 0xe17e9dbec8c074aa)
|
||||||
mu.reg_write(X86_REG_R12, 0x80f86a8dc0f6d457)
|
mu.reg_write(UC_X86_REG_R12, 0x80f86a8dc0f6d457)
|
||||||
mu.reg_write(X86_REG_R13, 0x48288ca5671c5492)
|
mu.reg_write(UC_X86_REG_R13, 0x48288ca5671c5492)
|
||||||
mu.reg_write(X86_REG_R14, 0x595f72f6e4017f6e)
|
mu.reg_write(UC_X86_REG_R14, 0x595f72f6e4017f6e)
|
||||||
mu.reg_write(X86_REG_R15, 0x1efd97aea331cccc)
|
mu.reg_write(UC_X86_REG_R15, 0x1efd97aea331cccc)
|
||||||
|
|
||||||
# setup stack
|
# setup stack
|
||||||
mu.reg_write(X86_REG_RSP, ADDRESS + 0x200000)
|
mu.reg_write(UC_X86_REG_RSP, ADDRESS + 0x200000)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
@ -359,20 +359,20 @@ def test_x86_64():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
rax = mu.reg_read(X86_REG_RAX)
|
rax = mu.reg_read(UC_X86_REG_RAX)
|
||||||
rbx = mu.reg_read(X86_REG_RBX)
|
rbx = mu.reg_read(UC_X86_REG_RBX)
|
||||||
rcx = mu.reg_read(X86_REG_RCX)
|
rcx = mu.reg_read(UC_X86_REG_RCX)
|
||||||
rdx = mu.reg_read(X86_REG_RDX)
|
rdx = mu.reg_read(UC_X86_REG_RDX)
|
||||||
rsi = mu.reg_read(X86_REG_RSI)
|
rsi = mu.reg_read(UC_X86_REG_RSI)
|
||||||
rdi = mu.reg_read(X86_REG_RDI)
|
rdi = mu.reg_read(UC_X86_REG_RDI)
|
||||||
r8 = mu.reg_read(X86_REG_R8)
|
r8 = mu.reg_read(UC_X86_REG_R8)
|
||||||
r9 = mu.reg_read(X86_REG_R9)
|
r9 = mu.reg_read(UC_X86_REG_R9)
|
||||||
r10 = mu.reg_read(X86_REG_R10)
|
r10 = mu.reg_read(UC_X86_REG_R10)
|
||||||
r11 = mu.reg_read(X86_REG_R11)
|
r11 = mu.reg_read(UC_X86_REG_R11)
|
||||||
r12 = mu.reg_read(X86_REG_R12)
|
r12 = mu.reg_read(UC_X86_REG_R12)
|
||||||
r13 = mu.reg_read(X86_REG_R13)
|
r13 = mu.reg_read(UC_X86_REG_R13)
|
||||||
r14 = mu.reg_read(X86_REG_R14)
|
r14 = mu.reg_read(UC_X86_REG_R14)
|
||||||
r15 = mu.reg_read(X86_REG_R15)
|
r15 = mu.reg_read(UC_X86_REG_R15)
|
||||||
|
|
||||||
print(">>> RAX = %x" %rax)
|
print(">>> RAX = %x" %rax)
|
||||||
print(">>> RBX = %x" %rbx)
|
print(">>> RBX = %x" %rbx)
|
||||||
|
|
@ -409,17 +409,17 @@ def test_x86_64_syscall():
|
||||||
mu.mem_write(ADDRESS, X86_CODE64_SYSCALL)
|
mu.mem_write(ADDRESS, X86_CODE64_SYSCALL)
|
||||||
|
|
||||||
def hook_syscall(mu, user_data):
|
def hook_syscall(mu, user_data):
|
||||||
rax = mu.reg_read(X86_REG_RAX)
|
rax = mu.reg_read(UC_X86_REG_RAX)
|
||||||
if rax == 0x100:
|
if rax == 0x100:
|
||||||
mu.reg_write(X86_REG_RAX, 0x200)
|
mu.reg_write(UC_X86_REG_RAX, 0x200)
|
||||||
else:
|
else:
|
||||||
print('ERROR: was not expecting rax=%d in syscall' % rax)
|
print('ERROR: was not expecting rax=%d in syscall' % rax)
|
||||||
|
|
||||||
# hook interrupts for syscall
|
# hook interrupts for syscall
|
||||||
mu.hook_add(UC_HOOK_INSN, hook_syscall, None, X86_INS_SYSCALL)
|
mu.hook_add(UC_HOOK_INSN, hook_syscall, None, UC_X86_INS_SYSCALL)
|
||||||
|
|
||||||
# syscall handler is expecting rax=0x100
|
# syscall handler is expecting rax=0x100
|
||||||
mu.reg_write(X86_REG_RAX, 0x100)
|
mu.reg_write(UC_X86_REG_RAX, 0x100)
|
||||||
|
|
||||||
try:
|
try:
|
||||||
# emulate machine code in infinite time
|
# emulate machine code in infinite time
|
||||||
|
|
@ -430,7 +430,7 @@ def test_x86_64_syscall():
|
||||||
# now print out some registers
|
# now print out some registers
|
||||||
print(">>> Emulation done. Below is the CPU context")
|
print(">>> Emulation done. Below is the CPU context")
|
||||||
|
|
||||||
rax = mu.reg_read(X86_REG_RAX)
|
rax = mu.reg_read(UC_X86_REG_RAX)
|
||||||
print(">>> RAX = 0x%x" % rax)
|
print(">>> RAX = 0x%x" % rax)
|
||||||
|
|
||||||
except UcError as e:
|
except UcError as e:
|
||||||
|
|
|
||||||
|
|
@ -40,16 +40,16 @@ def hook_intr(uc, intno, user_data):
|
||||||
uc.emu_stop()
|
uc.emu_stop()
|
||||||
return
|
return
|
||||||
|
|
||||||
eax = uc.reg_read(X86_REG_EAX)
|
eax = uc.reg_read(UC_X86_REG_EAX)
|
||||||
eip = uc.reg_read(X86_REG_EIP)
|
eip = uc.reg_read(UC_X86_REG_EIP)
|
||||||
if eax == 1: # sys_exit
|
if eax == 1: # sys_exit
|
||||||
print(">>> 0x%x: interrupt 0x%x, EAX = 0x%x" %(eip, intno, eax))
|
print(">>> 0x%x: interrupt 0x%x, EAX = 0x%x" %(eip, intno, eax))
|
||||||
uc.emu_stop()
|
uc.emu_stop()
|
||||||
elif eax == 4: # sys_write
|
elif eax == 4: # sys_write
|
||||||
# ECX = buffer address
|
# ECX = buffer address
|
||||||
ecx = uc.reg_read(X86_REG_ECX)
|
ecx = uc.reg_read(UC_X86_REG_ECX)
|
||||||
# EDX = buffer size
|
# EDX = buffer size
|
||||||
edx = uc.reg_read(X86_REG_EDX)
|
edx = uc.reg_read(UC_X86_REG_EDX)
|
||||||
|
|
||||||
try:
|
try:
|
||||||
buf = uc.mem_read(ecx, edx)
|
buf = uc.mem_read(ecx, edx)
|
||||||
|
|
@ -79,7 +79,7 @@ def test_i386(mode, code):
|
||||||
mu.mem_write(ADDRESS, code)
|
mu.mem_write(ADDRESS, code)
|
||||||
|
|
||||||
# initialize stack
|
# initialize stack
|
||||||
mu.reg_write(X86_REG_ESP, ADDRESS + 0x200000)
|
mu.reg_write(UC_X86_REG_ESP, ADDRESS + 0x200000)
|
||||||
|
|
||||||
# tracing all basic blocks with customized callback
|
# tracing all basic blocks with customized callback
|
||||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||||
|
|
|
||||||
|
|
@ -416,11 +416,11 @@ class Uc(object):
|
||||||
cb, ctypes.cast(self._callback_count, ctypes.c_void_p))
|
cb, ctypes.cast(self._callback_count, ctypes.c_void_p))
|
||||||
elif htype == UC_HOOK_INSN:
|
elif htype == UC_HOOK_INSN:
|
||||||
insn = ctypes.c_int(arg1)
|
insn = ctypes.c_int(arg1)
|
||||||
if arg1 == x86_const.X86_INS_IN: # IN instruction
|
if arg1 == x86_const.UC_X86_INS_IN: # IN instruction
|
||||||
cb = ctypes.cast(UC_HOOK_INSN_IN_CB(self._hook_insn_in_cb), UC_HOOK_INSN_IN_CB)
|
cb = ctypes.cast(UC_HOOK_INSN_IN_CB(self._hook_insn_in_cb), UC_HOOK_INSN_IN_CB)
|
||||||
if arg1 == x86_const.X86_INS_OUT: # OUT instruction
|
if arg1 == x86_const.UC_X86_INS_OUT: # OUT instruction
|
||||||
cb = ctypes.cast(UC_HOOK_INSN_OUT_CB(self._hook_insn_out_cb), UC_HOOK_INSN_OUT_CB)
|
cb = ctypes.cast(UC_HOOK_INSN_OUT_CB(self._hook_insn_out_cb), UC_HOOK_INSN_OUT_CB)
|
||||||
if arg1 in (x86_const.X86_INS_SYSCALL, x86_const.X86_INS_SYSENTER): # SYSCALL/SYSENTER instruction
|
if arg1 in (x86_const.UC_X86_INS_SYSCALL, x86_const.UC_X86_INS_SYSENTER): # SYSCALL/SYSENTER instruction
|
||||||
cb = ctypes.cast(UC_HOOK_INSN_SYSCALL_CB(self._hook_insn_syscall_cb), UC_HOOK_INSN_SYSCALL_CB)
|
cb = ctypes.cast(UC_HOOK_INSN_SYSCALL_CB(self._hook_insn_syscall_cb), UC_HOOK_INSN_SYSCALL_CB)
|
||||||
status = _uc.uc_hook_add(self._uch, ctypes.byref(_h2), htype, \
|
status = _uc.uc_hook_add(self._uch, ctypes.byref(_h2), htype, \
|
||||||
cb, ctypes.cast(self._callback_count, ctypes.c_void_p), insn)
|
cb, ctypes.cast(self._callback_count, ctypes.c_void_p), insn)
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -13,131 +13,131 @@ extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
//> ARM registers
|
//> ARM registers
|
||||||
typedef enum arm_reg {
|
typedef enum uc_arm_reg {
|
||||||
ARM_REG_INVALID = 0,
|
UC_ARM_REG_INVALID = 0,
|
||||||
ARM_REG_APSR,
|
UC_ARM_REG_APSR,
|
||||||
ARM_REG_APSR_NZCV,
|
UC_ARM_REG_APSR_NZCV,
|
||||||
ARM_REG_CPSR,
|
UC_ARM_REG_CPSR,
|
||||||
ARM_REG_FPEXC,
|
UC_ARM_REG_FPEXC,
|
||||||
ARM_REG_FPINST,
|
UC_ARM_REG_FPINST,
|
||||||
ARM_REG_FPSCR,
|
UC_ARM_REG_FPSCR,
|
||||||
ARM_REG_FPSCR_NZCV,
|
UC_ARM_REG_FPSCR_NZCV,
|
||||||
ARM_REG_FPSID,
|
UC_ARM_REG_FPSID,
|
||||||
ARM_REG_ITSTATE,
|
UC_ARM_REG_ITSTATE,
|
||||||
ARM_REG_LR,
|
UC_ARM_REG_LR,
|
||||||
ARM_REG_PC,
|
UC_ARM_REG_PC,
|
||||||
ARM_REG_SP,
|
UC_ARM_REG_SP,
|
||||||
ARM_REG_SPSR,
|
UC_ARM_REG_SPSR,
|
||||||
ARM_REG_D0,
|
UC_ARM_REG_D0,
|
||||||
ARM_REG_D1,
|
UC_ARM_REG_D1,
|
||||||
ARM_REG_D2,
|
UC_ARM_REG_D2,
|
||||||
ARM_REG_D3,
|
UC_ARM_REG_D3,
|
||||||
ARM_REG_D4,
|
UC_ARM_REG_D4,
|
||||||
ARM_REG_D5,
|
UC_ARM_REG_D5,
|
||||||
ARM_REG_D6,
|
UC_ARM_REG_D6,
|
||||||
ARM_REG_D7,
|
UC_ARM_REG_D7,
|
||||||
ARM_REG_D8,
|
UC_ARM_REG_D8,
|
||||||
ARM_REG_D9,
|
UC_ARM_REG_D9,
|
||||||
ARM_REG_D10,
|
UC_ARM_REG_D10,
|
||||||
ARM_REG_D11,
|
UC_ARM_REG_D11,
|
||||||
ARM_REG_D12,
|
UC_ARM_REG_D12,
|
||||||
ARM_REG_D13,
|
UC_ARM_REG_D13,
|
||||||
ARM_REG_D14,
|
UC_ARM_REG_D14,
|
||||||
ARM_REG_D15,
|
UC_ARM_REG_D15,
|
||||||
ARM_REG_D16,
|
UC_ARM_REG_D16,
|
||||||
ARM_REG_D17,
|
UC_ARM_REG_D17,
|
||||||
ARM_REG_D18,
|
UC_ARM_REG_D18,
|
||||||
ARM_REG_D19,
|
UC_ARM_REG_D19,
|
||||||
ARM_REG_D20,
|
UC_ARM_REG_D20,
|
||||||
ARM_REG_D21,
|
UC_ARM_REG_D21,
|
||||||
ARM_REG_D22,
|
UC_ARM_REG_D22,
|
||||||
ARM_REG_D23,
|
UC_ARM_REG_D23,
|
||||||
ARM_REG_D24,
|
UC_ARM_REG_D24,
|
||||||
ARM_REG_D25,
|
UC_ARM_REG_D25,
|
||||||
ARM_REG_D26,
|
UC_ARM_REG_D26,
|
||||||
ARM_REG_D27,
|
UC_ARM_REG_D27,
|
||||||
ARM_REG_D28,
|
UC_ARM_REG_D28,
|
||||||
ARM_REG_D29,
|
UC_ARM_REG_D29,
|
||||||
ARM_REG_D30,
|
UC_ARM_REG_D30,
|
||||||
ARM_REG_D31,
|
UC_ARM_REG_D31,
|
||||||
ARM_REG_FPINST2,
|
UC_ARM_REG_FPINST2,
|
||||||
ARM_REG_MVFR0,
|
UC_ARM_REG_MVFR0,
|
||||||
ARM_REG_MVFR1,
|
UC_ARM_REG_MVFR1,
|
||||||
ARM_REG_MVFR2,
|
UC_ARM_REG_MVFR2,
|
||||||
ARM_REG_Q0,
|
UC_ARM_REG_Q0,
|
||||||
ARM_REG_Q1,
|
UC_ARM_REG_Q1,
|
||||||
ARM_REG_Q2,
|
UC_ARM_REG_Q2,
|
||||||
ARM_REG_Q3,
|
UC_ARM_REG_Q3,
|
||||||
ARM_REG_Q4,
|
UC_ARM_REG_Q4,
|
||||||
ARM_REG_Q5,
|
UC_ARM_REG_Q5,
|
||||||
ARM_REG_Q6,
|
UC_ARM_REG_Q6,
|
||||||
ARM_REG_Q7,
|
UC_ARM_REG_Q7,
|
||||||
ARM_REG_Q8,
|
UC_ARM_REG_Q8,
|
||||||
ARM_REG_Q9,
|
UC_ARM_REG_Q9,
|
||||||
ARM_REG_Q10,
|
UC_ARM_REG_Q10,
|
||||||
ARM_REG_Q11,
|
UC_ARM_REG_Q11,
|
||||||
ARM_REG_Q12,
|
UC_ARM_REG_Q12,
|
||||||
ARM_REG_Q13,
|
UC_ARM_REG_Q13,
|
||||||
ARM_REG_Q14,
|
UC_ARM_REG_Q14,
|
||||||
ARM_REG_Q15,
|
UC_ARM_REG_Q15,
|
||||||
ARM_REG_R0,
|
UC_ARM_REG_R0,
|
||||||
ARM_REG_R1,
|
UC_ARM_REG_R1,
|
||||||
ARM_REG_R2,
|
UC_ARM_REG_R2,
|
||||||
ARM_REG_R3,
|
UC_ARM_REG_R3,
|
||||||
ARM_REG_R4,
|
UC_ARM_REG_R4,
|
||||||
ARM_REG_R5,
|
UC_ARM_REG_R5,
|
||||||
ARM_REG_R6,
|
UC_ARM_REG_R6,
|
||||||
ARM_REG_R7,
|
UC_ARM_REG_R7,
|
||||||
ARM_REG_R8,
|
UC_ARM_REG_R8,
|
||||||
ARM_REG_R9,
|
UC_ARM_REG_R9,
|
||||||
ARM_REG_R10,
|
UC_ARM_REG_R10,
|
||||||
ARM_REG_R11,
|
UC_ARM_REG_R11,
|
||||||
ARM_REG_R12,
|
UC_ARM_REG_R12,
|
||||||
ARM_REG_S0,
|
UC_ARM_REG_S0,
|
||||||
ARM_REG_S1,
|
UC_ARM_REG_S1,
|
||||||
ARM_REG_S2,
|
UC_ARM_REG_S2,
|
||||||
ARM_REG_S3,
|
UC_ARM_REG_S3,
|
||||||
ARM_REG_S4,
|
UC_ARM_REG_S4,
|
||||||
ARM_REG_S5,
|
UC_ARM_REG_S5,
|
||||||
ARM_REG_S6,
|
UC_ARM_REG_S6,
|
||||||
ARM_REG_S7,
|
UC_ARM_REG_S7,
|
||||||
ARM_REG_S8,
|
UC_ARM_REG_S8,
|
||||||
ARM_REG_S9,
|
UC_ARM_REG_S9,
|
||||||
ARM_REG_S10,
|
UC_ARM_REG_S10,
|
||||||
ARM_REG_S11,
|
UC_ARM_REG_S11,
|
||||||
ARM_REG_S12,
|
UC_ARM_REG_S12,
|
||||||
ARM_REG_S13,
|
UC_ARM_REG_S13,
|
||||||
ARM_REG_S14,
|
UC_ARM_REG_S14,
|
||||||
ARM_REG_S15,
|
UC_ARM_REG_S15,
|
||||||
ARM_REG_S16,
|
UC_ARM_REG_S16,
|
||||||
ARM_REG_S17,
|
UC_ARM_REG_S17,
|
||||||
ARM_REG_S18,
|
UC_ARM_REG_S18,
|
||||||
ARM_REG_S19,
|
UC_ARM_REG_S19,
|
||||||
ARM_REG_S20,
|
UC_ARM_REG_S20,
|
||||||
ARM_REG_S21,
|
UC_ARM_REG_S21,
|
||||||
ARM_REG_S22,
|
UC_ARM_REG_S22,
|
||||||
ARM_REG_S23,
|
UC_ARM_REG_S23,
|
||||||
ARM_REG_S24,
|
UC_ARM_REG_S24,
|
||||||
ARM_REG_S25,
|
UC_ARM_REG_S25,
|
||||||
ARM_REG_S26,
|
UC_ARM_REG_S26,
|
||||||
ARM_REG_S27,
|
UC_ARM_REG_S27,
|
||||||
ARM_REG_S28,
|
UC_ARM_REG_S28,
|
||||||
ARM_REG_S29,
|
UC_ARM_REG_S29,
|
||||||
ARM_REG_S30,
|
UC_ARM_REG_S30,
|
||||||
ARM_REG_S31,
|
UC_ARM_REG_S31,
|
||||||
|
|
||||||
ARM_REG_ENDING, // <-- mark the end of the list or registers
|
UC_ARM_REG_ENDING, // <-- mark the end of the list or registers
|
||||||
|
|
||||||
//> alias registers
|
//> alias registers
|
||||||
ARM_REG_R13 = ARM_REG_SP,
|
UC_ARM_REG_R13 = UC_ARM_REG_SP,
|
||||||
ARM_REG_R14 = ARM_REG_LR,
|
UC_ARM_REG_R14 = UC_ARM_REG_LR,
|
||||||
ARM_REG_R15 = ARM_REG_PC,
|
UC_ARM_REG_R15 = UC_ARM_REG_PC,
|
||||||
|
|
||||||
ARM_REG_SB = ARM_REG_R9,
|
UC_ARM_REG_SB = UC_ARM_REG_R9,
|
||||||
ARM_REG_SL = ARM_REG_R10,
|
UC_ARM_REG_SL = UC_ARM_REG_R10,
|
||||||
ARM_REG_FP = ARM_REG_R11,
|
UC_ARM_REG_FP = UC_ARM_REG_R11,
|
||||||
ARM_REG_IP = ARM_REG_R12,
|
UC_ARM_REG_IP = UC_ARM_REG_R12,
|
||||||
} arm_reg;
|
} uc_arm_reg;
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -13,282 +13,282 @@ extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
//> ARM64 registers
|
//> ARM64 registers
|
||||||
typedef enum arm64_reg {
|
typedef enum uc_arm64_reg {
|
||||||
ARM64_REG_INVALID = 0,
|
UC_ARM64_REG_INVALID = 0,
|
||||||
|
|
||||||
ARM64_REG_X29,
|
UC_ARM64_REG_X29,
|
||||||
ARM64_REG_X30,
|
UC_ARM64_REG_X30,
|
||||||
ARM64_REG_NZCV,
|
UC_ARM64_REG_NZCV,
|
||||||
ARM64_REG_SP,
|
UC_ARM64_REG_SP,
|
||||||
ARM64_REG_WSP,
|
UC_ARM64_REG_WSP,
|
||||||
ARM64_REG_WZR,
|
UC_ARM64_REG_WZR,
|
||||||
ARM64_REG_XZR,
|
UC_ARM64_REG_XZR,
|
||||||
ARM64_REG_B0,
|
UC_ARM64_REG_B0,
|
||||||
ARM64_REG_B1,
|
UC_ARM64_REG_B1,
|
||||||
ARM64_REG_B2,
|
UC_ARM64_REG_B2,
|
||||||
ARM64_REG_B3,
|
UC_ARM64_REG_B3,
|
||||||
ARM64_REG_B4,
|
UC_ARM64_REG_B4,
|
||||||
ARM64_REG_B5,
|
UC_ARM64_REG_B5,
|
||||||
ARM64_REG_B6,
|
UC_ARM64_REG_B6,
|
||||||
ARM64_REG_B7,
|
UC_ARM64_REG_B7,
|
||||||
ARM64_REG_B8,
|
UC_ARM64_REG_B8,
|
||||||
ARM64_REG_B9,
|
UC_ARM64_REG_B9,
|
||||||
ARM64_REG_B10,
|
UC_ARM64_REG_B10,
|
||||||
ARM64_REG_B11,
|
UC_ARM64_REG_B11,
|
||||||
ARM64_REG_B12,
|
UC_ARM64_REG_B12,
|
||||||
ARM64_REG_B13,
|
UC_ARM64_REG_B13,
|
||||||
ARM64_REG_B14,
|
UC_ARM64_REG_B14,
|
||||||
ARM64_REG_B15,
|
UC_ARM64_REG_B15,
|
||||||
ARM64_REG_B16,
|
UC_ARM64_REG_B16,
|
||||||
ARM64_REG_B17,
|
UC_ARM64_REG_B17,
|
||||||
ARM64_REG_B18,
|
UC_ARM64_REG_B18,
|
||||||
ARM64_REG_B19,
|
UC_ARM64_REG_B19,
|
||||||
ARM64_REG_B20,
|
UC_ARM64_REG_B20,
|
||||||
ARM64_REG_B21,
|
UC_ARM64_REG_B21,
|
||||||
ARM64_REG_B22,
|
UC_ARM64_REG_B22,
|
||||||
ARM64_REG_B23,
|
UC_ARM64_REG_B23,
|
||||||
ARM64_REG_B24,
|
UC_ARM64_REG_B24,
|
||||||
ARM64_REG_B25,
|
UC_ARM64_REG_B25,
|
||||||
ARM64_REG_B26,
|
UC_ARM64_REG_B26,
|
||||||
ARM64_REG_B27,
|
UC_ARM64_REG_B27,
|
||||||
ARM64_REG_B28,
|
UC_ARM64_REG_B28,
|
||||||
ARM64_REG_B29,
|
UC_ARM64_REG_B29,
|
||||||
ARM64_REG_B30,
|
UC_ARM64_REG_B30,
|
||||||
ARM64_REG_B31,
|
UC_ARM64_REG_B31,
|
||||||
ARM64_REG_D0,
|
UC_ARM64_REG_D0,
|
||||||
ARM64_REG_D1,
|
UC_ARM64_REG_D1,
|
||||||
ARM64_REG_D2,
|
UC_ARM64_REG_D2,
|
||||||
ARM64_REG_D3,
|
UC_ARM64_REG_D3,
|
||||||
ARM64_REG_D4,
|
UC_ARM64_REG_D4,
|
||||||
ARM64_REG_D5,
|
UC_ARM64_REG_D5,
|
||||||
ARM64_REG_D6,
|
UC_ARM64_REG_D6,
|
||||||
ARM64_REG_D7,
|
UC_ARM64_REG_D7,
|
||||||
ARM64_REG_D8,
|
UC_ARM64_REG_D8,
|
||||||
ARM64_REG_D9,
|
UC_ARM64_REG_D9,
|
||||||
ARM64_REG_D10,
|
UC_ARM64_REG_D10,
|
||||||
ARM64_REG_D11,
|
UC_ARM64_REG_D11,
|
||||||
ARM64_REG_D12,
|
UC_ARM64_REG_D12,
|
||||||
ARM64_REG_D13,
|
UC_ARM64_REG_D13,
|
||||||
ARM64_REG_D14,
|
UC_ARM64_REG_D14,
|
||||||
ARM64_REG_D15,
|
UC_ARM64_REG_D15,
|
||||||
ARM64_REG_D16,
|
UC_ARM64_REG_D16,
|
||||||
ARM64_REG_D17,
|
UC_ARM64_REG_D17,
|
||||||
ARM64_REG_D18,
|
UC_ARM64_REG_D18,
|
||||||
ARM64_REG_D19,
|
UC_ARM64_REG_D19,
|
||||||
ARM64_REG_D20,
|
UC_ARM64_REG_D20,
|
||||||
ARM64_REG_D21,
|
UC_ARM64_REG_D21,
|
||||||
ARM64_REG_D22,
|
UC_ARM64_REG_D22,
|
||||||
ARM64_REG_D23,
|
UC_ARM64_REG_D23,
|
||||||
ARM64_REG_D24,
|
UC_ARM64_REG_D24,
|
||||||
ARM64_REG_D25,
|
UC_ARM64_REG_D25,
|
||||||
ARM64_REG_D26,
|
UC_ARM64_REG_D26,
|
||||||
ARM64_REG_D27,
|
UC_ARM64_REG_D27,
|
||||||
ARM64_REG_D28,
|
UC_ARM64_REG_D28,
|
||||||
ARM64_REG_D29,
|
UC_ARM64_REG_D29,
|
||||||
ARM64_REG_D30,
|
UC_ARM64_REG_D30,
|
||||||
ARM64_REG_D31,
|
UC_ARM64_REG_D31,
|
||||||
ARM64_REG_H0,
|
UC_ARM64_REG_H0,
|
||||||
ARM64_REG_H1,
|
UC_ARM64_REG_H1,
|
||||||
ARM64_REG_H2,
|
UC_ARM64_REG_H2,
|
||||||
ARM64_REG_H3,
|
UC_ARM64_REG_H3,
|
||||||
ARM64_REG_H4,
|
UC_ARM64_REG_H4,
|
||||||
ARM64_REG_H5,
|
UC_ARM64_REG_H5,
|
||||||
ARM64_REG_H6,
|
UC_ARM64_REG_H6,
|
||||||
ARM64_REG_H7,
|
UC_ARM64_REG_H7,
|
||||||
ARM64_REG_H8,
|
UC_ARM64_REG_H8,
|
||||||
ARM64_REG_H9,
|
UC_ARM64_REG_H9,
|
||||||
ARM64_REG_H10,
|
UC_ARM64_REG_H10,
|
||||||
ARM64_REG_H11,
|
UC_ARM64_REG_H11,
|
||||||
ARM64_REG_H12,
|
UC_ARM64_REG_H12,
|
||||||
ARM64_REG_H13,
|
UC_ARM64_REG_H13,
|
||||||
ARM64_REG_H14,
|
UC_ARM64_REG_H14,
|
||||||
ARM64_REG_H15,
|
UC_ARM64_REG_H15,
|
||||||
ARM64_REG_H16,
|
UC_ARM64_REG_H16,
|
||||||
ARM64_REG_H17,
|
UC_ARM64_REG_H17,
|
||||||
ARM64_REG_H18,
|
UC_ARM64_REG_H18,
|
||||||
ARM64_REG_H19,
|
UC_ARM64_REG_H19,
|
||||||
ARM64_REG_H20,
|
UC_ARM64_REG_H20,
|
||||||
ARM64_REG_H21,
|
UC_ARM64_REG_H21,
|
||||||
ARM64_REG_H22,
|
UC_ARM64_REG_H22,
|
||||||
ARM64_REG_H23,
|
UC_ARM64_REG_H23,
|
||||||
ARM64_REG_H24,
|
UC_ARM64_REG_H24,
|
||||||
ARM64_REG_H25,
|
UC_ARM64_REG_H25,
|
||||||
ARM64_REG_H26,
|
UC_ARM64_REG_H26,
|
||||||
ARM64_REG_H27,
|
UC_ARM64_REG_H27,
|
||||||
ARM64_REG_H28,
|
UC_ARM64_REG_H28,
|
||||||
ARM64_REG_H29,
|
UC_ARM64_REG_H29,
|
||||||
ARM64_REG_H30,
|
UC_ARM64_REG_H30,
|
||||||
ARM64_REG_H31,
|
UC_ARM64_REG_H31,
|
||||||
ARM64_REG_Q0,
|
UC_ARM64_REG_Q0,
|
||||||
ARM64_REG_Q1,
|
UC_ARM64_REG_Q1,
|
||||||
ARM64_REG_Q2,
|
UC_ARM64_REG_Q2,
|
||||||
ARM64_REG_Q3,
|
UC_ARM64_REG_Q3,
|
||||||
ARM64_REG_Q4,
|
UC_ARM64_REG_Q4,
|
||||||
ARM64_REG_Q5,
|
UC_ARM64_REG_Q5,
|
||||||
ARM64_REG_Q6,
|
UC_ARM64_REG_Q6,
|
||||||
ARM64_REG_Q7,
|
UC_ARM64_REG_Q7,
|
||||||
ARM64_REG_Q8,
|
UC_ARM64_REG_Q8,
|
||||||
ARM64_REG_Q9,
|
UC_ARM64_REG_Q9,
|
||||||
ARM64_REG_Q10,
|
UC_ARM64_REG_Q10,
|
||||||
ARM64_REG_Q11,
|
UC_ARM64_REG_Q11,
|
||||||
ARM64_REG_Q12,
|
UC_ARM64_REG_Q12,
|
||||||
ARM64_REG_Q13,
|
UC_ARM64_REG_Q13,
|
||||||
ARM64_REG_Q14,
|
UC_ARM64_REG_Q14,
|
||||||
ARM64_REG_Q15,
|
UC_ARM64_REG_Q15,
|
||||||
ARM64_REG_Q16,
|
UC_ARM64_REG_Q16,
|
||||||
ARM64_REG_Q17,
|
UC_ARM64_REG_Q17,
|
||||||
ARM64_REG_Q18,
|
UC_ARM64_REG_Q18,
|
||||||
ARM64_REG_Q19,
|
UC_ARM64_REG_Q19,
|
||||||
ARM64_REG_Q20,
|
UC_ARM64_REG_Q20,
|
||||||
ARM64_REG_Q21,
|
UC_ARM64_REG_Q21,
|
||||||
ARM64_REG_Q22,
|
UC_ARM64_REG_Q22,
|
||||||
ARM64_REG_Q23,
|
UC_ARM64_REG_Q23,
|
||||||
ARM64_REG_Q24,
|
UC_ARM64_REG_Q24,
|
||||||
ARM64_REG_Q25,
|
UC_ARM64_REG_Q25,
|
||||||
ARM64_REG_Q26,
|
UC_ARM64_REG_Q26,
|
||||||
ARM64_REG_Q27,
|
UC_ARM64_REG_Q27,
|
||||||
ARM64_REG_Q28,
|
UC_ARM64_REG_Q28,
|
||||||
ARM64_REG_Q29,
|
UC_ARM64_REG_Q29,
|
||||||
ARM64_REG_Q30,
|
UC_ARM64_REG_Q30,
|
||||||
ARM64_REG_Q31,
|
UC_ARM64_REG_Q31,
|
||||||
ARM64_REG_S0,
|
UC_ARM64_REG_S0,
|
||||||
ARM64_REG_S1,
|
UC_ARM64_REG_S1,
|
||||||
ARM64_REG_S2,
|
UC_ARM64_REG_S2,
|
||||||
ARM64_REG_S3,
|
UC_ARM64_REG_S3,
|
||||||
ARM64_REG_S4,
|
UC_ARM64_REG_S4,
|
||||||
ARM64_REG_S5,
|
UC_ARM64_REG_S5,
|
||||||
ARM64_REG_S6,
|
UC_ARM64_REG_S6,
|
||||||
ARM64_REG_S7,
|
UC_ARM64_REG_S7,
|
||||||
ARM64_REG_S8,
|
UC_ARM64_REG_S8,
|
||||||
ARM64_REG_S9,
|
UC_ARM64_REG_S9,
|
||||||
ARM64_REG_S10,
|
UC_ARM64_REG_S10,
|
||||||
ARM64_REG_S11,
|
UC_ARM64_REG_S11,
|
||||||
ARM64_REG_S12,
|
UC_ARM64_REG_S12,
|
||||||
ARM64_REG_S13,
|
UC_ARM64_REG_S13,
|
||||||
ARM64_REG_S14,
|
UC_ARM64_REG_S14,
|
||||||
ARM64_REG_S15,
|
UC_ARM64_REG_S15,
|
||||||
ARM64_REG_S16,
|
UC_ARM64_REG_S16,
|
||||||
ARM64_REG_S17,
|
UC_ARM64_REG_S17,
|
||||||
ARM64_REG_S18,
|
UC_ARM64_REG_S18,
|
||||||
ARM64_REG_S19,
|
UC_ARM64_REG_S19,
|
||||||
ARM64_REG_S20,
|
UC_ARM64_REG_S20,
|
||||||
ARM64_REG_S21,
|
UC_ARM64_REG_S21,
|
||||||
ARM64_REG_S22,
|
UC_ARM64_REG_S22,
|
||||||
ARM64_REG_S23,
|
UC_ARM64_REG_S23,
|
||||||
ARM64_REG_S24,
|
UC_ARM64_REG_S24,
|
||||||
ARM64_REG_S25,
|
UC_ARM64_REG_S25,
|
||||||
ARM64_REG_S26,
|
UC_ARM64_REG_S26,
|
||||||
ARM64_REG_S27,
|
UC_ARM64_REG_S27,
|
||||||
ARM64_REG_S28,
|
UC_ARM64_REG_S28,
|
||||||
ARM64_REG_S29,
|
UC_ARM64_REG_S29,
|
||||||
ARM64_REG_S30,
|
UC_ARM64_REG_S30,
|
||||||
ARM64_REG_S31,
|
UC_ARM64_REG_S31,
|
||||||
ARM64_REG_W0,
|
UC_ARM64_REG_W0,
|
||||||
ARM64_REG_W1,
|
UC_ARM64_REG_W1,
|
||||||
ARM64_REG_W2,
|
UC_ARM64_REG_W2,
|
||||||
ARM64_REG_W3,
|
UC_ARM64_REG_W3,
|
||||||
ARM64_REG_W4,
|
UC_ARM64_REG_W4,
|
||||||
ARM64_REG_W5,
|
UC_ARM64_REG_W5,
|
||||||
ARM64_REG_W6,
|
UC_ARM64_REG_W6,
|
||||||
ARM64_REG_W7,
|
UC_ARM64_REG_W7,
|
||||||
ARM64_REG_W8,
|
UC_ARM64_REG_W8,
|
||||||
ARM64_REG_W9,
|
UC_ARM64_REG_W9,
|
||||||
ARM64_REG_W10,
|
UC_ARM64_REG_W10,
|
||||||
ARM64_REG_W11,
|
UC_ARM64_REG_W11,
|
||||||
ARM64_REG_W12,
|
UC_ARM64_REG_W12,
|
||||||
ARM64_REG_W13,
|
UC_ARM64_REG_W13,
|
||||||
ARM64_REG_W14,
|
UC_ARM64_REG_W14,
|
||||||
ARM64_REG_W15,
|
UC_ARM64_REG_W15,
|
||||||
ARM64_REG_W16,
|
UC_ARM64_REG_W16,
|
||||||
ARM64_REG_W17,
|
UC_ARM64_REG_W17,
|
||||||
ARM64_REG_W18,
|
UC_ARM64_REG_W18,
|
||||||
ARM64_REG_W19,
|
UC_ARM64_REG_W19,
|
||||||
ARM64_REG_W20,
|
UC_ARM64_REG_W20,
|
||||||
ARM64_REG_W21,
|
UC_ARM64_REG_W21,
|
||||||
ARM64_REG_W22,
|
UC_ARM64_REG_W22,
|
||||||
ARM64_REG_W23,
|
UC_ARM64_REG_W23,
|
||||||
ARM64_REG_W24,
|
UC_ARM64_REG_W24,
|
||||||
ARM64_REG_W25,
|
UC_ARM64_REG_W25,
|
||||||
ARM64_REG_W26,
|
UC_ARM64_REG_W26,
|
||||||
ARM64_REG_W27,
|
UC_ARM64_REG_W27,
|
||||||
ARM64_REG_W28,
|
UC_ARM64_REG_W28,
|
||||||
ARM64_REG_W29,
|
UC_ARM64_REG_W29,
|
||||||
ARM64_REG_W30,
|
UC_ARM64_REG_W30,
|
||||||
ARM64_REG_X0,
|
UC_ARM64_REG_X0,
|
||||||
ARM64_REG_X1,
|
UC_ARM64_REG_X1,
|
||||||
ARM64_REG_X2,
|
UC_ARM64_REG_X2,
|
||||||
ARM64_REG_X3,
|
UC_ARM64_REG_X3,
|
||||||
ARM64_REG_X4,
|
UC_ARM64_REG_X4,
|
||||||
ARM64_REG_X5,
|
UC_ARM64_REG_X5,
|
||||||
ARM64_REG_X6,
|
UC_ARM64_REG_X6,
|
||||||
ARM64_REG_X7,
|
UC_ARM64_REG_X7,
|
||||||
ARM64_REG_X8,
|
UC_ARM64_REG_X8,
|
||||||
ARM64_REG_X9,
|
UC_ARM64_REG_X9,
|
||||||
ARM64_REG_X10,
|
UC_ARM64_REG_X10,
|
||||||
ARM64_REG_X11,
|
UC_ARM64_REG_X11,
|
||||||
ARM64_REG_X12,
|
UC_ARM64_REG_X12,
|
||||||
ARM64_REG_X13,
|
UC_ARM64_REG_X13,
|
||||||
ARM64_REG_X14,
|
UC_ARM64_REG_X14,
|
||||||
ARM64_REG_X15,
|
UC_ARM64_REG_X15,
|
||||||
ARM64_REG_X16,
|
UC_ARM64_REG_X16,
|
||||||
ARM64_REG_X17,
|
UC_ARM64_REG_X17,
|
||||||
ARM64_REG_X18,
|
UC_ARM64_REG_X18,
|
||||||
ARM64_REG_X19,
|
UC_ARM64_REG_X19,
|
||||||
ARM64_REG_X20,
|
UC_ARM64_REG_X20,
|
||||||
ARM64_REG_X21,
|
UC_ARM64_REG_X21,
|
||||||
ARM64_REG_X22,
|
UC_ARM64_REG_X22,
|
||||||
ARM64_REG_X23,
|
UC_ARM64_REG_X23,
|
||||||
ARM64_REG_X24,
|
UC_ARM64_REG_X24,
|
||||||
ARM64_REG_X25,
|
UC_ARM64_REG_X25,
|
||||||
ARM64_REG_X26,
|
UC_ARM64_REG_X26,
|
||||||
ARM64_REG_X27,
|
UC_ARM64_REG_X27,
|
||||||
ARM64_REG_X28,
|
UC_ARM64_REG_X28,
|
||||||
|
|
||||||
ARM64_REG_V0,
|
UC_ARM64_REG_V0,
|
||||||
ARM64_REG_V1,
|
UC_ARM64_REG_V1,
|
||||||
ARM64_REG_V2,
|
UC_ARM64_REG_V2,
|
||||||
ARM64_REG_V3,
|
UC_ARM64_REG_V3,
|
||||||
ARM64_REG_V4,
|
UC_ARM64_REG_V4,
|
||||||
ARM64_REG_V5,
|
UC_ARM64_REG_V5,
|
||||||
ARM64_REG_V6,
|
UC_ARM64_REG_V6,
|
||||||
ARM64_REG_V7,
|
UC_ARM64_REG_V7,
|
||||||
ARM64_REG_V8,
|
UC_ARM64_REG_V8,
|
||||||
ARM64_REG_V9,
|
UC_ARM64_REG_V9,
|
||||||
ARM64_REG_V10,
|
UC_ARM64_REG_V10,
|
||||||
ARM64_REG_V11,
|
UC_ARM64_REG_V11,
|
||||||
ARM64_REG_V12,
|
UC_ARM64_REG_V12,
|
||||||
ARM64_REG_V13,
|
UC_ARM64_REG_V13,
|
||||||
ARM64_REG_V14,
|
UC_ARM64_REG_V14,
|
||||||
ARM64_REG_V15,
|
UC_ARM64_REG_V15,
|
||||||
ARM64_REG_V16,
|
UC_ARM64_REG_V16,
|
||||||
ARM64_REG_V17,
|
UC_ARM64_REG_V17,
|
||||||
ARM64_REG_V18,
|
UC_ARM64_REG_V18,
|
||||||
ARM64_REG_V19,
|
UC_ARM64_REG_V19,
|
||||||
ARM64_REG_V20,
|
UC_ARM64_REG_V20,
|
||||||
ARM64_REG_V21,
|
UC_ARM64_REG_V21,
|
||||||
ARM64_REG_V22,
|
UC_ARM64_REG_V22,
|
||||||
ARM64_REG_V23,
|
UC_ARM64_REG_V23,
|
||||||
ARM64_REG_V24,
|
UC_ARM64_REG_V24,
|
||||||
ARM64_REG_V25,
|
UC_ARM64_REG_V25,
|
||||||
ARM64_REG_V26,
|
UC_ARM64_REG_V26,
|
||||||
ARM64_REG_V27,
|
UC_ARM64_REG_V27,
|
||||||
ARM64_REG_V28,
|
UC_ARM64_REG_V28,
|
||||||
ARM64_REG_V29,
|
UC_ARM64_REG_V29,
|
||||||
ARM64_REG_V30,
|
UC_ARM64_REG_V30,
|
||||||
ARM64_REG_V31,
|
UC_ARM64_REG_V31,
|
||||||
|
|
||||||
//> pseudo registers
|
//> pseudo registers
|
||||||
ARM64_REG_PC, // program counter register
|
UC_ARM64_REG_PC, // program counter register
|
||||||
|
|
||||||
ARM64_REG_ENDING, // <-- mark the end of the list of registers
|
UC_ARM64_REG_ENDING, // <-- mark the end of the list of registers
|
||||||
|
|
||||||
//> alias registers
|
//> alias registers
|
||||||
|
|
||||||
ARM64_REG_IP1 = ARM64_REG_X16,
|
UC_ARM64_REG_IP1 = UC_ARM64_REG_X16,
|
||||||
ARM64_REG_IP0 = ARM64_REG_X17,
|
UC_ARM64_REG_IP0 = UC_ARM64_REG_X17,
|
||||||
ARM64_REG_FP = ARM64_REG_X29,
|
UC_ARM64_REG_FP = UC_ARM64_REG_X29,
|
||||||
ARM64_REG_LR = ARM64_REG_X30,
|
UC_ARM64_REG_LR = UC_ARM64_REG_X30,
|
||||||
} arm64_reg;
|
} uc_arm64_reg;
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,207 +17,207 @@ extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
//> MIPS registers
|
//> MIPS registers
|
||||||
typedef enum mips_reg {
|
typedef enum UC_MIPS_REG {
|
||||||
MIPS_REG_INVALID = 0,
|
UC_MIPS_REG_INVALID = 0,
|
||||||
//> General purpose registers
|
//> General purpose registers
|
||||||
MIPS_REG_PC,
|
UC_MIPS_REG_PC,
|
||||||
|
|
||||||
MIPS_REG_0,
|
UC_MIPS_REG_0,
|
||||||
MIPS_REG_1,
|
UC_MIPS_REG_1,
|
||||||
MIPS_REG_2,
|
UC_MIPS_REG_2,
|
||||||
MIPS_REG_3,
|
UC_MIPS_REG_3,
|
||||||
MIPS_REG_4,
|
UC_MIPS_REG_4,
|
||||||
MIPS_REG_5,
|
UC_MIPS_REG_5,
|
||||||
MIPS_REG_6,
|
UC_MIPS_REG_6,
|
||||||
MIPS_REG_7,
|
UC_MIPS_REG_7,
|
||||||
MIPS_REG_8,
|
UC_MIPS_REG_8,
|
||||||
MIPS_REG_9,
|
UC_MIPS_REG_9,
|
||||||
MIPS_REG_10,
|
UC_MIPS_REG_10,
|
||||||
MIPS_REG_11,
|
UC_MIPS_REG_11,
|
||||||
MIPS_REG_12,
|
UC_MIPS_REG_12,
|
||||||
MIPS_REG_13,
|
UC_MIPS_REG_13,
|
||||||
MIPS_REG_14,
|
UC_MIPS_REG_14,
|
||||||
MIPS_REG_15,
|
UC_MIPS_REG_15,
|
||||||
MIPS_REG_16,
|
UC_MIPS_REG_16,
|
||||||
MIPS_REG_17,
|
UC_MIPS_REG_17,
|
||||||
MIPS_REG_18,
|
UC_MIPS_REG_18,
|
||||||
MIPS_REG_19,
|
UC_MIPS_REG_19,
|
||||||
MIPS_REG_20,
|
UC_MIPS_REG_20,
|
||||||
MIPS_REG_21,
|
UC_MIPS_REG_21,
|
||||||
MIPS_REG_22,
|
UC_MIPS_REG_22,
|
||||||
MIPS_REG_23,
|
UC_MIPS_REG_23,
|
||||||
MIPS_REG_24,
|
UC_MIPS_REG_24,
|
||||||
MIPS_REG_25,
|
UC_MIPS_REG_25,
|
||||||
MIPS_REG_26,
|
UC_MIPS_REG_26,
|
||||||
MIPS_REG_27,
|
UC_MIPS_REG_27,
|
||||||
MIPS_REG_28,
|
UC_MIPS_REG_28,
|
||||||
MIPS_REG_29,
|
UC_MIPS_REG_29,
|
||||||
MIPS_REG_30,
|
UC_MIPS_REG_30,
|
||||||
MIPS_REG_31,
|
UC_MIPS_REG_31,
|
||||||
|
|
||||||
//> DSP registers
|
//> DSP registers
|
||||||
MIPS_REG_DSPCCOND,
|
UC_MIPS_REG_DSPCCOND,
|
||||||
MIPS_REG_DSPCARRY,
|
UC_MIPS_REG_DSPCARRY,
|
||||||
MIPS_REG_DSPEFI,
|
UC_MIPS_REG_DSPEFI,
|
||||||
MIPS_REG_DSPOUTFLAG,
|
UC_MIPS_REG_DSPOUTFLAG,
|
||||||
MIPS_REG_DSPOUTFLAG16_19,
|
UC_MIPS_REG_DSPOUTFLAG16_19,
|
||||||
MIPS_REG_DSPOUTFLAG20,
|
UC_MIPS_REG_DSPOUTFLAG20,
|
||||||
MIPS_REG_DSPOUTFLAG21,
|
UC_MIPS_REG_DSPOUTFLAG21,
|
||||||
MIPS_REG_DSPOUTFLAG22,
|
UC_MIPS_REG_DSPOUTFLAG22,
|
||||||
MIPS_REG_DSPOUTFLAG23,
|
UC_MIPS_REG_DSPOUTFLAG23,
|
||||||
MIPS_REG_DSPPOS,
|
UC_MIPS_REG_DSPPOS,
|
||||||
MIPS_REG_DSPSCOUNT,
|
UC_MIPS_REG_DSPSCOUNT,
|
||||||
|
|
||||||
//> ACC registers
|
//> ACC registers
|
||||||
MIPS_REG_AC0,
|
UC_MIPS_REG_AC0,
|
||||||
MIPS_REG_AC1,
|
UC_MIPS_REG_AC1,
|
||||||
MIPS_REG_AC2,
|
UC_MIPS_REG_AC2,
|
||||||
MIPS_REG_AC3,
|
UC_MIPS_REG_AC3,
|
||||||
|
|
||||||
//> COP registers
|
//> COP registers
|
||||||
MIPS_REG_CC0,
|
UC_MIPS_REG_CC0,
|
||||||
MIPS_REG_CC1,
|
UC_MIPS_REG_CC1,
|
||||||
MIPS_REG_CC2,
|
UC_MIPS_REG_CC2,
|
||||||
MIPS_REG_CC3,
|
UC_MIPS_REG_CC3,
|
||||||
MIPS_REG_CC4,
|
UC_MIPS_REG_CC4,
|
||||||
MIPS_REG_CC5,
|
UC_MIPS_REG_CC5,
|
||||||
MIPS_REG_CC6,
|
UC_MIPS_REG_CC6,
|
||||||
MIPS_REG_CC7,
|
UC_MIPS_REG_CC7,
|
||||||
|
|
||||||
//> FPU registers
|
//> FPU registers
|
||||||
MIPS_REG_F0,
|
UC_MIPS_REG_F0,
|
||||||
MIPS_REG_F1,
|
UC_MIPS_REG_F1,
|
||||||
MIPS_REG_F2,
|
UC_MIPS_REG_F2,
|
||||||
MIPS_REG_F3,
|
UC_MIPS_REG_F3,
|
||||||
MIPS_REG_F4,
|
UC_MIPS_REG_F4,
|
||||||
MIPS_REG_F5,
|
UC_MIPS_REG_F5,
|
||||||
MIPS_REG_F6,
|
UC_MIPS_REG_F6,
|
||||||
MIPS_REG_F7,
|
UC_MIPS_REG_F7,
|
||||||
MIPS_REG_F8,
|
UC_MIPS_REG_F8,
|
||||||
MIPS_REG_F9,
|
UC_MIPS_REG_F9,
|
||||||
MIPS_REG_F10,
|
UC_MIPS_REG_F10,
|
||||||
MIPS_REG_F11,
|
UC_MIPS_REG_F11,
|
||||||
MIPS_REG_F12,
|
UC_MIPS_REG_F12,
|
||||||
MIPS_REG_F13,
|
UC_MIPS_REG_F13,
|
||||||
MIPS_REG_F14,
|
UC_MIPS_REG_F14,
|
||||||
MIPS_REG_F15,
|
UC_MIPS_REG_F15,
|
||||||
MIPS_REG_F16,
|
UC_MIPS_REG_F16,
|
||||||
MIPS_REG_F17,
|
UC_MIPS_REG_F17,
|
||||||
MIPS_REG_F18,
|
UC_MIPS_REG_F18,
|
||||||
MIPS_REG_F19,
|
UC_MIPS_REG_F19,
|
||||||
MIPS_REG_F20,
|
UC_MIPS_REG_F20,
|
||||||
MIPS_REG_F21,
|
UC_MIPS_REG_F21,
|
||||||
MIPS_REG_F22,
|
UC_MIPS_REG_F22,
|
||||||
MIPS_REG_F23,
|
UC_MIPS_REG_F23,
|
||||||
MIPS_REG_F24,
|
UC_MIPS_REG_F24,
|
||||||
MIPS_REG_F25,
|
UC_MIPS_REG_F25,
|
||||||
MIPS_REG_F26,
|
UC_MIPS_REG_F26,
|
||||||
MIPS_REG_F27,
|
UC_MIPS_REG_F27,
|
||||||
MIPS_REG_F28,
|
UC_MIPS_REG_F28,
|
||||||
MIPS_REG_F29,
|
UC_MIPS_REG_F29,
|
||||||
MIPS_REG_F30,
|
UC_MIPS_REG_F30,
|
||||||
MIPS_REG_F31,
|
UC_MIPS_REG_F31,
|
||||||
|
|
||||||
MIPS_REG_FCC0,
|
UC_MIPS_REG_FCC0,
|
||||||
MIPS_REG_FCC1,
|
UC_MIPS_REG_FCC1,
|
||||||
MIPS_REG_FCC2,
|
UC_MIPS_REG_FCC2,
|
||||||
MIPS_REG_FCC3,
|
UC_MIPS_REG_FCC3,
|
||||||
MIPS_REG_FCC4,
|
UC_MIPS_REG_FCC4,
|
||||||
MIPS_REG_FCC5,
|
UC_MIPS_REG_FCC5,
|
||||||
MIPS_REG_FCC6,
|
UC_MIPS_REG_FCC6,
|
||||||
MIPS_REG_FCC7,
|
UC_MIPS_REG_FCC7,
|
||||||
|
|
||||||
//> AFPR128
|
//> AFPR128
|
||||||
MIPS_REG_W0,
|
UC_MIPS_REG_W0,
|
||||||
MIPS_REG_W1,
|
UC_MIPS_REG_W1,
|
||||||
MIPS_REG_W2,
|
UC_MIPS_REG_W2,
|
||||||
MIPS_REG_W3,
|
UC_MIPS_REG_W3,
|
||||||
MIPS_REG_W4,
|
UC_MIPS_REG_W4,
|
||||||
MIPS_REG_W5,
|
UC_MIPS_REG_W5,
|
||||||
MIPS_REG_W6,
|
UC_MIPS_REG_W6,
|
||||||
MIPS_REG_W7,
|
UC_MIPS_REG_W7,
|
||||||
MIPS_REG_W8,
|
UC_MIPS_REG_W8,
|
||||||
MIPS_REG_W9,
|
UC_MIPS_REG_W9,
|
||||||
MIPS_REG_W10,
|
UC_MIPS_REG_W10,
|
||||||
MIPS_REG_W11,
|
UC_MIPS_REG_W11,
|
||||||
MIPS_REG_W12,
|
UC_MIPS_REG_W12,
|
||||||
MIPS_REG_W13,
|
UC_MIPS_REG_W13,
|
||||||
MIPS_REG_W14,
|
UC_MIPS_REG_W14,
|
||||||
MIPS_REG_W15,
|
UC_MIPS_REG_W15,
|
||||||
MIPS_REG_W16,
|
UC_MIPS_REG_W16,
|
||||||
MIPS_REG_W17,
|
UC_MIPS_REG_W17,
|
||||||
MIPS_REG_W18,
|
UC_MIPS_REG_W18,
|
||||||
MIPS_REG_W19,
|
UC_MIPS_REG_W19,
|
||||||
MIPS_REG_W20,
|
UC_MIPS_REG_W20,
|
||||||
MIPS_REG_W21,
|
UC_MIPS_REG_W21,
|
||||||
MIPS_REG_W22,
|
UC_MIPS_REG_W22,
|
||||||
MIPS_REG_W23,
|
UC_MIPS_REG_W23,
|
||||||
MIPS_REG_W24,
|
UC_MIPS_REG_W24,
|
||||||
MIPS_REG_W25,
|
UC_MIPS_REG_W25,
|
||||||
MIPS_REG_W26,
|
UC_MIPS_REG_W26,
|
||||||
MIPS_REG_W27,
|
UC_MIPS_REG_W27,
|
||||||
MIPS_REG_W28,
|
UC_MIPS_REG_W28,
|
||||||
MIPS_REG_W29,
|
UC_MIPS_REG_W29,
|
||||||
MIPS_REG_W30,
|
UC_MIPS_REG_W30,
|
||||||
MIPS_REG_W31,
|
UC_MIPS_REG_W31,
|
||||||
|
|
||||||
MIPS_REG_HI,
|
UC_MIPS_REG_HI,
|
||||||
MIPS_REG_LO,
|
UC_MIPS_REG_LO,
|
||||||
|
|
||||||
MIPS_REG_P0,
|
UC_MIPS_REG_P0,
|
||||||
MIPS_REG_P1,
|
UC_MIPS_REG_P1,
|
||||||
MIPS_REG_P2,
|
UC_MIPS_REG_P2,
|
||||||
|
|
||||||
MIPS_REG_MPL0,
|
UC_MIPS_REG_MPL0,
|
||||||
MIPS_REG_MPL1,
|
UC_MIPS_REG_MPL1,
|
||||||
MIPS_REG_MPL2,
|
UC_MIPS_REG_MPL2,
|
||||||
|
|
||||||
MIPS_REG_ENDING, // <-- mark the end of the list or registers
|
UC_MIPS_REG_ENDING, // <-- mark the end of the list or registers
|
||||||
|
|
||||||
// alias registers
|
// alias registers
|
||||||
MIPS_REG_ZERO = MIPS_REG_0,
|
UC_MIPS_REG_ZERO = UC_MIPS_REG_0,
|
||||||
MIPS_REG_AT = MIPS_REG_1,
|
UC_MIPS_REG_AT = UC_MIPS_REG_1,
|
||||||
MIPS_REG_V0 = MIPS_REG_2,
|
UC_MIPS_REG_V0 = UC_MIPS_REG_2,
|
||||||
MIPS_REG_V1 = MIPS_REG_3,
|
UC_MIPS_REG_V1 = UC_MIPS_REG_3,
|
||||||
MIPS_REG_A0 = MIPS_REG_4,
|
UC_MIPS_REG_A0 = UC_MIPS_REG_4,
|
||||||
MIPS_REG_A1 = MIPS_REG_5,
|
UC_MIPS_REG_A1 = UC_MIPS_REG_5,
|
||||||
MIPS_REG_A2 = MIPS_REG_6,
|
UC_MIPS_REG_A2 = UC_MIPS_REG_6,
|
||||||
MIPS_REG_A3 = MIPS_REG_7,
|
UC_MIPS_REG_A3 = UC_MIPS_REG_7,
|
||||||
MIPS_REG_T0 = MIPS_REG_8,
|
UC_MIPS_REG_T0 = UC_MIPS_REG_8,
|
||||||
MIPS_REG_T1 = MIPS_REG_9,
|
UC_MIPS_REG_T1 = UC_MIPS_REG_9,
|
||||||
MIPS_REG_T2 = MIPS_REG_10,
|
UC_MIPS_REG_T2 = UC_MIPS_REG_10,
|
||||||
MIPS_REG_T3 = MIPS_REG_11,
|
UC_MIPS_REG_T3 = UC_MIPS_REG_11,
|
||||||
MIPS_REG_T4 = MIPS_REG_12,
|
UC_MIPS_REG_T4 = UC_MIPS_REG_12,
|
||||||
MIPS_REG_T5 = MIPS_REG_13,
|
UC_MIPS_REG_T5 = UC_MIPS_REG_13,
|
||||||
MIPS_REG_T6 = MIPS_REG_14,
|
UC_MIPS_REG_T6 = UC_MIPS_REG_14,
|
||||||
MIPS_REG_T7 = MIPS_REG_15,
|
UC_MIPS_REG_T7 = UC_MIPS_REG_15,
|
||||||
MIPS_REG_S0 = MIPS_REG_16,
|
UC_MIPS_REG_S0 = UC_MIPS_REG_16,
|
||||||
MIPS_REG_S1 = MIPS_REG_17,
|
UC_MIPS_REG_S1 = UC_MIPS_REG_17,
|
||||||
MIPS_REG_S2 = MIPS_REG_18,
|
UC_MIPS_REG_S2 = UC_MIPS_REG_18,
|
||||||
MIPS_REG_S3 = MIPS_REG_19,
|
UC_MIPS_REG_S3 = UC_MIPS_REG_19,
|
||||||
MIPS_REG_S4 = MIPS_REG_20,
|
UC_MIPS_REG_S4 = UC_MIPS_REG_20,
|
||||||
MIPS_REG_S5 = MIPS_REG_21,
|
UC_MIPS_REG_S5 = UC_MIPS_REG_21,
|
||||||
MIPS_REG_S6 = MIPS_REG_22,
|
UC_MIPS_REG_S6 = UC_MIPS_REG_22,
|
||||||
MIPS_REG_S7 = MIPS_REG_23,
|
UC_MIPS_REG_S7 = UC_MIPS_REG_23,
|
||||||
MIPS_REG_T8 = MIPS_REG_24,
|
UC_MIPS_REG_T8 = UC_MIPS_REG_24,
|
||||||
MIPS_REG_T9 = MIPS_REG_25,
|
UC_MIPS_REG_T9 = UC_MIPS_REG_25,
|
||||||
MIPS_REG_K0 = MIPS_REG_26,
|
UC_MIPS_REG_K0 = UC_MIPS_REG_26,
|
||||||
MIPS_REG_K1 = MIPS_REG_27,
|
UC_MIPS_REG_K1 = UC_MIPS_REG_27,
|
||||||
MIPS_REG_GP = MIPS_REG_28,
|
UC_MIPS_REG_GP = UC_MIPS_REG_28,
|
||||||
MIPS_REG_SP = MIPS_REG_29,
|
UC_MIPS_REG_SP = UC_MIPS_REG_29,
|
||||||
MIPS_REG_FP = MIPS_REG_30, MIPS_REG_S8 = MIPS_REG_30,
|
UC_MIPS_REG_FP = UC_MIPS_REG_30, UC_MIPS_REG_S8 = UC_MIPS_REG_30,
|
||||||
MIPS_REG_RA = MIPS_REG_31,
|
UC_MIPS_REG_RA = UC_MIPS_REG_31,
|
||||||
|
|
||||||
MIPS_REG_HI0 = MIPS_REG_AC0,
|
UC_MIPS_REG_HI0 = UC_MIPS_REG_AC0,
|
||||||
MIPS_REG_HI1 = MIPS_REG_AC1,
|
UC_MIPS_REG_HI1 = UC_MIPS_REG_AC1,
|
||||||
MIPS_REG_HI2 = MIPS_REG_AC2,
|
UC_MIPS_REG_HI2 = UC_MIPS_REG_AC2,
|
||||||
MIPS_REG_HI3 = MIPS_REG_AC3,
|
UC_MIPS_REG_HI3 = UC_MIPS_REG_AC3,
|
||||||
|
|
||||||
MIPS_REG_LO0 = MIPS_REG_HI0,
|
UC_MIPS_REG_LO0 = UC_MIPS_REG_HI0,
|
||||||
MIPS_REG_LO1 = MIPS_REG_HI1,
|
UC_MIPS_REG_LO1 = UC_MIPS_REG_HI1,
|
||||||
MIPS_REG_LO2 = MIPS_REG_HI2,
|
UC_MIPS_REG_LO2 = UC_MIPS_REG_HI2,
|
||||||
MIPS_REG_LO3 = MIPS_REG_HI3,
|
UC_MIPS_REG_LO3 = UC_MIPS_REG_HI3,
|
||||||
} mips_reg;
|
} UC_MIPS_REG;
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -20,108 +20,108 @@ extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
//> SPARC registers
|
//> SPARC registers
|
||||||
typedef enum sparc_reg {
|
typedef enum uc_sparc_reg {
|
||||||
SPARC_REG_INVALID = 0,
|
UC_SPARC_REG_INVALID = 0,
|
||||||
|
|
||||||
SPARC_REG_F0,
|
UC_SPARC_REG_F0,
|
||||||
SPARC_REG_F1,
|
UC_SPARC_REG_F1,
|
||||||
SPARC_REG_F2,
|
UC_SPARC_REG_F2,
|
||||||
SPARC_REG_F3,
|
UC_SPARC_REG_F3,
|
||||||
SPARC_REG_F4,
|
UC_SPARC_REG_F4,
|
||||||
SPARC_REG_F5,
|
UC_SPARC_REG_F5,
|
||||||
SPARC_REG_F6,
|
UC_SPARC_REG_F6,
|
||||||
SPARC_REG_F7,
|
UC_SPARC_REG_F7,
|
||||||
SPARC_REG_F8,
|
UC_SPARC_REG_F8,
|
||||||
SPARC_REG_F9,
|
UC_SPARC_REG_F9,
|
||||||
SPARC_REG_F10,
|
UC_SPARC_REG_F10,
|
||||||
SPARC_REG_F11,
|
UC_SPARC_REG_F11,
|
||||||
SPARC_REG_F12,
|
UC_SPARC_REG_F12,
|
||||||
SPARC_REG_F13,
|
UC_SPARC_REG_F13,
|
||||||
SPARC_REG_F14,
|
UC_SPARC_REG_F14,
|
||||||
SPARC_REG_F15,
|
UC_SPARC_REG_F15,
|
||||||
SPARC_REG_F16,
|
UC_SPARC_REG_F16,
|
||||||
SPARC_REG_F17,
|
UC_SPARC_REG_F17,
|
||||||
SPARC_REG_F18,
|
UC_SPARC_REG_F18,
|
||||||
SPARC_REG_F19,
|
UC_SPARC_REG_F19,
|
||||||
SPARC_REG_F20,
|
UC_SPARC_REG_F20,
|
||||||
SPARC_REG_F21,
|
UC_SPARC_REG_F21,
|
||||||
SPARC_REG_F22,
|
UC_SPARC_REG_F22,
|
||||||
SPARC_REG_F23,
|
UC_SPARC_REG_F23,
|
||||||
SPARC_REG_F24,
|
UC_SPARC_REG_F24,
|
||||||
SPARC_REG_F25,
|
UC_SPARC_REG_F25,
|
||||||
SPARC_REG_F26,
|
UC_SPARC_REG_F26,
|
||||||
SPARC_REG_F27,
|
UC_SPARC_REG_F27,
|
||||||
SPARC_REG_F28,
|
UC_SPARC_REG_F28,
|
||||||
SPARC_REG_F29,
|
UC_SPARC_REG_F29,
|
||||||
SPARC_REG_F30,
|
UC_SPARC_REG_F30,
|
||||||
SPARC_REG_F31,
|
UC_SPARC_REG_F31,
|
||||||
SPARC_REG_F32,
|
UC_SPARC_REG_F32,
|
||||||
SPARC_REG_F34,
|
UC_SPARC_REG_F34,
|
||||||
SPARC_REG_F36,
|
UC_SPARC_REG_F36,
|
||||||
SPARC_REG_F38,
|
UC_SPARC_REG_F38,
|
||||||
SPARC_REG_F40,
|
UC_SPARC_REG_F40,
|
||||||
SPARC_REG_F42,
|
UC_SPARC_REG_F42,
|
||||||
SPARC_REG_F44,
|
UC_SPARC_REG_F44,
|
||||||
SPARC_REG_F46,
|
UC_SPARC_REG_F46,
|
||||||
SPARC_REG_F48,
|
UC_SPARC_REG_F48,
|
||||||
SPARC_REG_F50,
|
UC_SPARC_REG_F50,
|
||||||
SPARC_REG_F52,
|
UC_SPARC_REG_F52,
|
||||||
SPARC_REG_F54,
|
UC_SPARC_REG_F54,
|
||||||
SPARC_REG_F56,
|
UC_SPARC_REG_F56,
|
||||||
SPARC_REG_F58,
|
UC_SPARC_REG_F58,
|
||||||
SPARC_REG_F60,
|
UC_SPARC_REG_F60,
|
||||||
SPARC_REG_F62,
|
UC_SPARC_REG_F62,
|
||||||
SPARC_REG_FCC0, // Floating condition codes
|
UC_SPARC_REG_FCC0, // Floating condition codes
|
||||||
SPARC_REG_FCC1,
|
UC_SPARC_REG_FCC1,
|
||||||
SPARC_REG_FCC2,
|
UC_SPARC_REG_FCC2,
|
||||||
SPARC_REG_FCC3,
|
UC_SPARC_REG_FCC3,
|
||||||
SPARC_REG_FP,
|
UC_SPARC_REG_FP,
|
||||||
SPARC_REG_G0,
|
UC_SPARC_REG_G0,
|
||||||
SPARC_REG_G1,
|
UC_SPARC_REG_G1,
|
||||||
SPARC_REG_G2,
|
UC_SPARC_REG_G2,
|
||||||
SPARC_REG_G3,
|
UC_SPARC_REG_G3,
|
||||||
SPARC_REG_G4,
|
UC_SPARC_REG_G4,
|
||||||
SPARC_REG_G5,
|
UC_SPARC_REG_G5,
|
||||||
SPARC_REG_G6,
|
UC_SPARC_REG_G6,
|
||||||
SPARC_REG_G7,
|
UC_SPARC_REG_G7,
|
||||||
SPARC_REG_I0,
|
UC_SPARC_REG_I0,
|
||||||
SPARC_REG_I1,
|
UC_SPARC_REG_I1,
|
||||||
SPARC_REG_I2,
|
UC_SPARC_REG_I2,
|
||||||
SPARC_REG_I3,
|
UC_SPARC_REG_I3,
|
||||||
SPARC_REG_I4,
|
UC_SPARC_REG_I4,
|
||||||
SPARC_REG_I5,
|
UC_SPARC_REG_I5,
|
||||||
SPARC_REG_I7,
|
UC_SPARC_REG_I7,
|
||||||
SPARC_REG_ICC, // Integer condition codes
|
UC_SPARC_REG_ICC, // Integer condition codes
|
||||||
SPARC_REG_L0,
|
UC_SPARC_REG_L0,
|
||||||
SPARC_REG_L1,
|
UC_SPARC_REG_L1,
|
||||||
SPARC_REG_L2,
|
UC_SPARC_REG_L2,
|
||||||
SPARC_REG_L3,
|
UC_SPARC_REG_L3,
|
||||||
SPARC_REG_L4,
|
UC_SPARC_REG_L4,
|
||||||
SPARC_REG_L5,
|
UC_SPARC_REG_L5,
|
||||||
SPARC_REG_L6,
|
UC_SPARC_REG_L6,
|
||||||
SPARC_REG_L7,
|
UC_SPARC_REG_L7,
|
||||||
SPARC_REG_O0,
|
UC_SPARC_REG_O0,
|
||||||
SPARC_REG_O1,
|
UC_SPARC_REG_O1,
|
||||||
SPARC_REG_O2,
|
UC_SPARC_REG_O2,
|
||||||
SPARC_REG_O3,
|
UC_SPARC_REG_O3,
|
||||||
SPARC_REG_O4,
|
UC_SPARC_REG_O4,
|
||||||
SPARC_REG_O5,
|
UC_SPARC_REG_O5,
|
||||||
SPARC_REG_O7,
|
UC_SPARC_REG_O7,
|
||||||
SPARC_REG_SP,
|
UC_SPARC_REG_SP,
|
||||||
SPARC_REG_Y,
|
UC_SPARC_REG_Y,
|
||||||
|
|
||||||
// special register
|
// special register
|
||||||
SPARC_REG_XCC,
|
UC_SPARC_REG_XCC,
|
||||||
|
|
||||||
// pseudo register
|
// pseudo register
|
||||||
SPARC_REG_PC, // program counter register
|
UC_SPARC_REG_PC, // program counter register
|
||||||
|
|
||||||
SPARC_REG_ENDING, // <-- mark the end of the list of registers
|
UC_SPARC_REG_ENDING, // <-- mark the end of the list of registers
|
||||||
|
|
||||||
// extras
|
// extras
|
||||||
SPARC_REG_O6 = SPARC_REG_SP,
|
UC_SPARC_REG_O6 = UC_SPARC_REG_SP,
|
||||||
SPARC_REG_I6 = SPARC_REG_FP,
|
UC_SPARC_REG_I6 = UC_SPARC_REG_FP,
|
||||||
} sparc_reg;
|
} uc_sparc_reg;
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -43,18 +43,18 @@ int arm64_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
|
|
||||||
mycpu = first_cpu;
|
mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= ARM64_REG_X0 && regid <= ARM64_REG_X28)
|
if (regid >= UC_ARM64_REG_X0 && regid <= UC_ARM64_REG_X28)
|
||||||
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[regid - ARM64_REG_X0];
|
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[regid - UC_ARM64_REG_X0];
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case ARM64_REG_X29:
|
case UC_ARM64_REG_X29:
|
||||||
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[29];
|
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[29];
|
||||||
break;
|
break;
|
||||||
case ARM64_REG_X30:
|
case UC_ARM64_REG_X30:
|
||||||
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[30];
|
*(int64_t *)value = ARM_CPU(uc, mycpu)->env.xregs[30];
|
||||||
break;
|
break;
|
||||||
case ARM64_REG_PC:
|
case UC_ARM64_REG_PC:
|
||||||
*(uint64_t *)value = ARM_CPU(uc, mycpu)->env.pc;
|
*(uint64_t *)value = ARM_CPU(uc, mycpu)->env.pc;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -75,18 +75,18 @@ int arm64_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
|
|
||||||
mycpu = first_cpu;
|
mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= ARM64_REG_X0 && regid <= ARM64_REG_X28)
|
if (regid >= UC_ARM64_REG_X0 && regid <= UC_ARM64_REG_X28)
|
||||||
ARM_CPU(uc, mycpu)->env.xregs[regid - ARM64_REG_X0] = *(int64_t *)value;
|
ARM_CPU(uc, mycpu)->env.xregs[regid - UC_ARM64_REG_X0] = *(int64_t *)value;
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case ARM64_REG_X29:
|
case UC_ARM64_REG_X29:
|
||||||
ARM_CPU(uc, mycpu)->env.xregs[29] = *(int64_t *)value;
|
ARM_CPU(uc, mycpu)->env.xregs[29] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case ARM64_REG_X30:
|
case UC_ARM64_REG_X30:
|
||||||
ARM_CPU(uc, mycpu)->env.xregs[30] = *(int64_t *)value;
|
ARM_CPU(uc, mycpu)->env.xregs[30] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case ARM64_REG_PC:
|
case UC_ARM64_REG_PC:
|
||||||
ARM_CPU(uc, mycpu)->env.pc = *(uint64_t *)value;
|
ARM_CPU(uc, mycpu)->env.pc = *(uint64_t *)value;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -48,20 +48,20 @@ int arm_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
break;
|
break;
|
||||||
case UC_MODE_ARM:
|
case UC_MODE_ARM:
|
||||||
case UC_MODE_THUMB:
|
case UC_MODE_THUMB:
|
||||||
if (regid >= ARM_REG_R0 && regid <= ARM_REG_R12)
|
if (regid >= UC_ARM_REG_R0 && regid <= UC_ARM_REG_R12)
|
||||||
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[regid - ARM_REG_R0];
|
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[regid - UC_ARM_REG_R0];
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
//case ARM_REG_SP:
|
//case UC_ARM_REG_SP:
|
||||||
case ARM_REG_R13:
|
case UC_ARM_REG_R13:
|
||||||
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[13];
|
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[13];
|
||||||
break;
|
break;
|
||||||
//case ARM_REG_LR:
|
//case UC_ARM_REG_LR:
|
||||||
case ARM_REG_R14:
|
case UC_ARM_REG_R14:
|
||||||
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[14];
|
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[14];
|
||||||
break;
|
break;
|
||||||
//case ARM_REG_PC:
|
//case UC_ARM_REG_PC:
|
||||||
case ARM_REG_R15:
|
case UC_ARM_REG_R15:
|
||||||
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[15];
|
*(int32_t *)value = ARM_CPU(uc, mycpu)->env.regs[15];
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -91,20 +91,20 @@ int arm_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
|
|
||||||
case UC_MODE_ARM:
|
case UC_MODE_ARM:
|
||||||
case UC_MODE_THUMB:
|
case UC_MODE_THUMB:
|
||||||
if (regid >= ARM_REG_R0 && regid <= ARM_REG_R12)
|
if (regid >= UC_ARM_REG_R0 && regid <= UC_ARM_REG_R12)
|
||||||
ARM_CPU(uc, mycpu)->env.regs[regid - ARM_REG_R0] = *(int32_t *)value;
|
ARM_CPU(uc, mycpu)->env.regs[regid - UC_ARM_REG_R0] = *(int32_t *)value;
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
//case ARM_REG_SP:
|
//case UC_ARM_REG_SP:
|
||||||
case ARM_REG_R13:
|
case UC_ARM_REG_R13:
|
||||||
ARM_CPU(uc, mycpu)->env.regs[13] = *(int32_t *)value;
|
ARM_CPU(uc, mycpu)->env.regs[13] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
//case ARM_REG_LR:
|
//case UC_ARM_REG_LR:
|
||||||
case ARM_REG_R14:
|
case UC_ARM_REG_R14:
|
||||||
ARM_CPU(uc, mycpu)->env.regs[14] = *(int32_t *)value;
|
ARM_CPU(uc, mycpu)->env.regs[14] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
//case ARM_REG_PC:
|
//case UC_ARM_REG_PC:
|
||||||
case ARM_REG_R15:
|
case UC_ARM_REG_R15:
|
||||||
ARM_CPU(uc, mycpu)->env.regs[15] = *(int32_t *)value;
|
ARM_CPU(uc, mycpu)->env.regs[15] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -147,19 +147,19 @@ int x86_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
case UC_MODE_16:
|
case UC_MODE_16:
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].selector;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].selector;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].selector;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].selector;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].selector;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].selector;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].selector;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].selector;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].selector;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].selector;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
@ -168,109 +168,109 @@ int x86_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
case X86_REG_CR0 ... X86_REG_CR4:
|
case UC_X86_REG_CR0 ... UC_X86_REG_CR4:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.cr[regid - X86_REG_CR0];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.cr[regid - UC_X86_REG_CR0];
|
||||||
break;
|
break;
|
||||||
case X86_REG_DR0 ... X86_REG_DR7:
|
case UC_X86_REG_DR0 ... UC_X86_REG_DR7:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.dr[regid - X86_REG_DR0];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.dr[regid - UC_X86_REG_DR0];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EFLAGS:
|
case UC_X86_REG_EFLAGS:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.eflags;
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.eflags;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EAX:
|
case UC_X86_REG_EAX:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EAX];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EAX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_AX:
|
case UC_X86_REG_AX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AH:
|
case UC_X86_REG_AH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AL:
|
case UC_X86_REG_AL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBX:
|
case UC_X86_REG_EBX:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBX];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_BX:
|
case UC_X86_REG_BX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BH:
|
case UC_X86_REG_BH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BL:
|
case UC_X86_REG_BL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ECX:
|
case UC_X86_REG_ECX:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ECX];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ECX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_CX:
|
case UC_X86_REG_CX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CH:
|
case UC_X86_REG_CH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CL:
|
case UC_X86_REG_CL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDX:
|
case UC_X86_REG_EDX:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDX];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_DX:
|
case UC_X86_REG_DX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DH:
|
case UC_X86_REG_DH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DL:
|
case UC_X86_REG_DL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESP:
|
case UC_X86_REG_ESP:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESP];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESP];
|
||||||
break;
|
break;
|
||||||
case X86_REG_SP:
|
case UC_X86_REG_SP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBP:
|
case UC_X86_REG_EBP:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBP];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBP];
|
||||||
break;
|
break;
|
||||||
case X86_REG_BP:
|
case UC_X86_REG_BP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESI:
|
case UC_X86_REG_ESI:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESI];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESI];
|
||||||
break;
|
break;
|
||||||
case X86_REG_SI:
|
case UC_X86_REG_SI:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDI:
|
case UC_X86_REG_EDI:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDI];
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDI];
|
||||||
break;
|
break;
|
||||||
case X86_REG_DI:
|
case UC_X86_REG_DI:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EIP:
|
case UC_X86_REG_EIP:
|
||||||
*(int32_t *)value = X86_CPU(uc, mycpu)->env.eip;
|
*(int32_t *)value = X86_CPU(uc, mycpu)->env.eip;
|
||||||
break;
|
break;
|
||||||
case X86_REG_IP:
|
case UC_X86_REG_IP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.eip);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.eip);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CS:
|
case UC_X86_REG_CS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_CS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_CS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].base;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -281,244 +281,244 @@ int x86_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
case X86_REG_CR0 ... X86_REG_CR4:
|
case UC_X86_REG_CR0 ... UC_X86_REG_CR4:
|
||||||
*(int64_t *)value = X86_CPU(uc, mycpu)->env.cr[regid - X86_REG_CR0];
|
*(int64_t *)value = X86_CPU(uc, mycpu)->env.cr[regid - UC_X86_REG_CR0];
|
||||||
break;
|
break;
|
||||||
case X86_REG_DR0 ... X86_REG_DR7:
|
case UC_X86_REG_DR0 ... UC_X86_REG_DR7:
|
||||||
*(int64_t *)value = X86_CPU(uc, mycpu)->env.dr[regid - X86_REG_DR0];
|
*(int64_t *)value = X86_CPU(uc, mycpu)->env.dr[regid - UC_X86_REG_DR0];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EFLAGS:
|
case UC_X86_REG_EFLAGS:
|
||||||
*(int64_t *)value = X86_CPU(uc, mycpu)->env.eflags;
|
*(int64_t *)value = X86_CPU(uc, mycpu)->env.eflags;
|
||||||
break;
|
break;
|
||||||
case X86_REG_RAX:
|
case UC_X86_REG_RAX:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EAX];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EAX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EAX:
|
case UC_X86_REG_EAX:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AX:
|
case UC_X86_REG_AX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AH:
|
case UC_X86_REG_AH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AL:
|
case UC_X86_REG_AL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RBX:
|
case UC_X86_REG_RBX:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBX];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBX:
|
case UC_X86_REG_EBX:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BX:
|
case UC_X86_REG_BX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BH:
|
case UC_X86_REG_BH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BL:
|
case UC_X86_REG_BL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RCX:
|
case UC_X86_REG_RCX:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ECX];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ECX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_ECX:
|
case UC_X86_REG_ECX:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CX:
|
case UC_X86_REG_CX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CH:
|
case UC_X86_REG_CH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CL:
|
case UC_X86_REG_CL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RDX:
|
case UC_X86_REG_RDX:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDX];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDX];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDX:
|
case UC_X86_REG_EDX:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DX:
|
case UC_X86_REG_DX:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DH:
|
case UC_X86_REG_DH:
|
||||||
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int8_t *)value = READ_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DL:
|
case UC_X86_REG_DL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RSP:
|
case UC_X86_REG_RSP:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESP];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESP];
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESP:
|
case UC_X86_REG_ESP:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SP:
|
case UC_X86_REG_SP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SPL:
|
case UC_X86_REG_SPL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RBP:
|
case UC_X86_REG_RBP:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBP];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EBP];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBP:
|
case UC_X86_REG_EBP:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BP:
|
case UC_X86_REG_BP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BPL:
|
case UC_X86_REG_BPL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBP]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RSI:
|
case UC_X86_REG_RSI:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESI];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_ESI];
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESI:
|
case UC_X86_REG_ESI:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SI:
|
case UC_X86_REG_SI:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SIL:
|
case UC_X86_REG_SIL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RDI:
|
case UC_X86_REG_RDI:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDI];
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.regs[R_EDI];
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDI:
|
case UC_X86_REG_EDI:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DI:
|
case UC_X86_REG_DI:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DIL:
|
case UC_X86_REG_DIL:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDI]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RIP:
|
case UC_X86_REG_RIP:
|
||||||
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.eip;
|
*(uint64_t *)value = X86_CPU(uc, mycpu)->env.eip;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EIP:
|
case UC_X86_REG_EIP:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.eip);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.eip);
|
||||||
break;
|
break;
|
||||||
case X86_REG_IP:
|
case UC_X86_REG_IP:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.eip);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.eip);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CS:
|
case UC_X86_REG_CS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_CS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_CS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_DS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_SS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_ES].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_FS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].base;
|
*(int16_t *)value = X86_CPU(uc, mycpu)->env.segs[R_GS].base;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8:
|
case UC_X86_REG_R8:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8D:
|
case UC_X86_REG_R8D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8W:
|
case UC_X86_REG_R8W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[8]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8B:
|
case UC_X86_REG_R8B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[8]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[8]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9:
|
case UC_X86_REG_R9:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9D:
|
case UC_X86_REG_R9D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9W:
|
case UC_X86_REG_R9W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[9]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9B:
|
case UC_X86_REG_R9B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[9]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[9]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10:
|
case UC_X86_REG_R10:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10D:
|
case UC_X86_REG_R10D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10W:
|
case UC_X86_REG_R10W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[10]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10B:
|
case UC_X86_REG_R10B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[10]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[10]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11:
|
case UC_X86_REG_R11:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11D:
|
case UC_X86_REG_R11D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11W:
|
case UC_X86_REG_R11W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[11]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11B:
|
case UC_X86_REG_R11B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[11]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[11]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12:
|
case UC_X86_REG_R12:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12D:
|
case UC_X86_REG_R12D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12W:
|
case UC_X86_REG_R12W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[12]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12B:
|
case UC_X86_REG_R12B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[12]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[12]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13:
|
case UC_X86_REG_R13:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13D:
|
case UC_X86_REG_R13D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13W:
|
case UC_X86_REG_R13W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[13]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13B:
|
case UC_X86_REG_R13B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[13]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[13]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14:
|
case UC_X86_REG_R14:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14D:
|
case UC_X86_REG_R14D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14W:
|
case UC_X86_REG_R14W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[14]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14B:
|
case UC_X86_REG_R14B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[14]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[14]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15:
|
case UC_X86_REG_R15:
|
||||||
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
*(int64_t *)value = READ_QWORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15D:
|
case UC_X86_REG_R15D:
|
||||||
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
*(int32_t *)value = READ_DWORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15W:
|
case UC_X86_REG_R15W:
|
||||||
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
*(int16_t *)value = READ_WORD(X86_CPU(uc, mycpu)->env.regs[15]);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15B:
|
case UC_X86_REG_R15B:
|
||||||
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[15]);
|
*(int8_t *)value = READ_BYTE_L(X86_CPU(uc, mycpu)->env.regs[15]);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -550,19 +550,19 @@ int x86_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
case UC_MODE_16:
|
case UC_MODE_16:
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_ES].selector = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_ES].selector = *(int16_t *)value;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_SS].selector = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_SS].selector = *(int16_t *)value;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_DS].selector = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_DS].selector = *(int16_t *)value;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_FS].selector = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_FS].selector = *(int16_t *)value;
|
||||||
return 0;
|
return 0;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_GS].selector = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_GS].selector = *(int16_t *)value;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
@ -571,109 +571,109 @@ int x86_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
case X86_REG_CR0 ... X86_REG_CR4:
|
case UC_X86_REG_CR0 ... UC_X86_REG_CR4:
|
||||||
X86_CPU(uc, mycpu)->env.cr[regid - X86_REG_CR0] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.cr[regid - UC_X86_REG_CR0] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DR0 ... X86_REG_DR7:
|
case UC_X86_REG_DR0 ... UC_X86_REG_DR7:
|
||||||
X86_CPU(uc, mycpu)->env.dr[regid - X86_REG_DR0] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.dr[regid - UC_X86_REG_DR0] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EFLAGS:
|
case UC_X86_REG_EFLAGS:
|
||||||
X86_CPU(uc, mycpu)->env.eflags = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.eflags = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EAX:
|
case UC_X86_REG_EAX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EAX] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EAX] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_AX:
|
case UC_X86_REG_AX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AH:
|
case UC_X86_REG_AH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AL:
|
case UC_X86_REG_AL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBX:
|
case UC_X86_REG_EBX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EBX] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EBX] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_BX:
|
case UC_X86_REG_BX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BH:
|
case UC_X86_REG_BH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BL:
|
case UC_X86_REG_BL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ECX:
|
case UC_X86_REG_ECX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ECX] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ECX] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_CX:
|
case UC_X86_REG_CX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CH:
|
case UC_X86_REG_CH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CL:
|
case UC_X86_REG_CL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDX:
|
case UC_X86_REG_EDX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EDX] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EDX] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DX:
|
case UC_X86_REG_DX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DH:
|
case UC_X86_REG_DH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DL:
|
case UC_X86_REG_DL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESP:
|
case UC_X86_REG_ESP:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ESP] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ESP] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SP:
|
case UC_X86_REG_SP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBP:
|
case UC_X86_REG_EBP:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EBP] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EBP] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_BP:
|
case UC_X86_REG_BP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESI:
|
case UC_X86_REG_ESI:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ESI] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ESI] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SI:
|
case UC_X86_REG_SI:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDI:
|
case UC_X86_REG_EDI:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EDI] = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EDI] = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DI:
|
case UC_X86_REG_DI:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_EIP:
|
case UC_X86_REG_EIP:
|
||||||
X86_CPU(uc, mycpu)->env.eip = *(int32_t *)value;
|
X86_CPU(uc, mycpu)->env.eip = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_IP:
|
case UC_X86_REG_IP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.eip, *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.eip, *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CS:
|
case UC_X86_REG_CS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_CS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_CS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_DS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_DS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_SS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_SS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_ES].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_ES].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_FS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_FS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_GS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_GS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -684,244 +684,244 @@ int x86_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
case X86_REG_CR0 ... X86_REG_CR4:
|
case UC_X86_REG_CR0 ... UC_X86_REG_CR4:
|
||||||
X86_CPU(uc, mycpu)->env.cr[regid - X86_REG_CR0] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.cr[regid - UC_X86_REG_CR0] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DR0 ... X86_REG_DR7:
|
case UC_X86_REG_DR0 ... UC_X86_REG_DR7:
|
||||||
X86_CPU(uc, mycpu)->env.dr[regid - X86_REG_DR0] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.dr[regid - UC_X86_REG_DR0] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EFLAGS:
|
case UC_X86_REG_EFLAGS:
|
||||||
X86_CPU(uc, mycpu)->env.eflags = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.eflags = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_RAX:
|
case UC_X86_REG_RAX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EAX] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EAX] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EAX:
|
case UC_X86_REG_EAX:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AX:
|
case UC_X86_REG_AX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AH:
|
case UC_X86_REG_AH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_AL:
|
case UC_X86_REG_AL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EAX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RBX:
|
case UC_X86_REG_RBX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EBX] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EBX] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBX:
|
case UC_X86_REG_EBX:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BX:
|
case UC_X86_REG_BX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BH:
|
case UC_X86_REG_BH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BL:
|
case UC_X86_REG_BL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RCX:
|
case UC_X86_REG_RCX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ECX] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ECX] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ECX:
|
case UC_X86_REG_ECX:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CX:
|
case UC_X86_REG_CX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CH:
|
case UC_X86_REG_CH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CL:
|
case UC_X86_REG_CL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ECX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RDX:
|
case UC_X86_REG_RDX:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EDX] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EDX] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDX:
|
case UC_X86_REG_EDX:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DX:
|
case UC_X86_REG_DX:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DH:
|
case UC_X86_REG_DH:
|
||||||
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
WRITE_BYTE_H(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DL:
|
case UC_X86_REG_DL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDX], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RSP:
|
case UC_X86_REG_RSP:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ESP] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ESP] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESP:
|
case UC_X86_REG_ESP:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SP:
|
case UC_X86_REG_SP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SPL:
|
case UC_X86_REG_SPL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESP], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RBP:
|
case UC_X86_REG_RBP:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EBP] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EBP] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EBP:
|
case UC_X86_REG_EBP:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BP:
|
case UC_X86_REG_BP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_BPL:
|
case UC_X86_REG_BPL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EBP], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RSI:
|
case UC_X86_REG_RSI:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_ESI] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_ESI] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ESI:
|
case UC_X86_REG_ESI:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SI:
|
case UC_X86_REG_SI:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_SIL:
|
case UC_X86_REG_SIL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_ESI], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RDI:
|
case UC_X86_REG_RDI:
|
||||||
X86_CPU(uc, mycpu)->env.regs[R_EDI] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[R_EDI] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EDI:
|
case UC_X86_REG_EDI:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DI:
|
case UC_X86_REG_DI:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_DIL:
|
case UC_X86_REG_DIL:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[R_EDI], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_RIP:
|
case UC_X86_REG_RIP:
|
||||||
X86_CPU(uc, mycpu)->env.eip = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.eip = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_EIP:
|
case UC_X86_REG_EIP:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.eip, *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.eip, *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_IP:
|
case UC_X86_REG_IP:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.eip, *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.eip, *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_CS:
|
case UC_X86_REG_CS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_CS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_CS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_DS:
|
case UC_X86_REG_DS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_DS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_DS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_SS:
|
case UC_X86_REG_SS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_SS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_SS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_ES:
|
case UC_X86_REG_ES:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_ES].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_ES].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_FS:
|
case UC_X86_REG_FS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_FS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_FS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_GS:
|
case UC_X86_REG_GS:
|
||||||
X86_CPU(uc, mycpu)->env.segs[R_GS].base = *(int16_t *)value;
|
X86_CPU(uc, mycpu)->env.segs[R_GS].base = *(int16_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8:
|
case UC_X86_REG_R8:
|
||||||
X86_CPU(uc, mycpu)->env.regs[8] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[8] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8D:
|
case UC_X86_REG_R8D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[8], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[8], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8W:
|
case UC_X86_REG_R8W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[8], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[8], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R8B:
|
case UC_X86_REG_R8B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[8], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[8], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9:
|
case UC_X86_REG_R9:
|
||||||
X86_CPU(uc, mycpu)->env.regs[9] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[9] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9D:
|
case UC_X86_REG_R9D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[9], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[9], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9W:
|
case UC_X86_REG_R9W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[9], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[9], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R9B:
|
case UC_X86_REG_R9B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[9], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[9], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10:
|
case UC_X86_REG_R10:
|
||||||
X86_CPU(uc, mycpu)->env.regs[10] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[10] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10D:
|
case UC_X86_REG_R10D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[10], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[10], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10W:
|
case UC_X86_REG_R10W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[10], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[10], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R10B:
|
case UC_X86_REG_R10B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[10], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[10], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11:
|
case UC_X86_REG_R11:
|
||||||
X86_CPU(uc, mycpu)->env.regs[11] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[11] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11D:
|
case UC_X86_REG_R11D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[11], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[11], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11W:
|
case UC_X86_REG_R11W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[11], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[11], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R11B:
|
case UC_X86_REG_R11B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[11], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[11], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12:
|
case UC_X86_REG_R12:
|
||||||
X86_CPU(uc, mycpu)->env.regs[12] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[12] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12D:
|
case UC_X86_REG_R12D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[12], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[12], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12W:
|
case UC_X86_REG_R12W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[12], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[12], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R12B:
|
case UC_X86_REG_R12B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[12], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[12], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13:
|
case UC_X86_REG_R13:
|
||||||
X86_CPU(uc, mycpu)->env.regs[13] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[13] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13D:
|
case UC_X86_REG_R13D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[13], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[13], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13W:
|
case UC_X86_REG_R13W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[13], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[13], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R13B:
|
case UC_X86_REG_R13B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[13], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[13], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14:
|
case UC_X86_REG_R14:
|
||||||
X86_CPU(uc, mycpu)->env.regs[14] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[14] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14D:
|
case UC_X86_REG_R14D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[14], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[14], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14W:
|
case UC_X86_REG_R14W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[14], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[14], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R14B:
|
case UC_X86_REG_R14B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[14], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[14], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15:
|
case UC_X86_REG_R15:
|
||||||
X86_CPU(uc, mycpu)->env.regs[15] = *(int64_t *)value;
|
X86_CPU(uc, mycpu)->env.regs[15] = *(int64_t *)value;
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15D:
|
case UC_X86_REG_R15D:
|
||||||
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[15], *(int32_t *)value);
|
WRITE_DWORD(X86_CPU(uc, mycpu)->env.regs[15], *(int32_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15W:
|
case UC_X86_REG_R15W:
|
||||||
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[15], *(int16_t *)value);
|
WRITE_WORD(X86_CPU(uc, mycpu)->env.regs[15], *(int16_t *)value);
|
||||||
break;
|
break;
|
||||||
case X86_REG_R15B:
|
case UC_X86_REG_R15B:
|
||||||
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[15], *(int8_t *)value);
|
WRITE_BYTE_L(X86_CPU(uc, mycpu)->env.regs[15], *(int8_t *)value);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -37,12 +37,12 @@ int mips_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= MIPS_REG_0 && regid <= MIPS_REG_31)
|
if (regid >= UC_MIPS_REG_0 && regid <= UC_MIPS_REG_31)
|
||||||
*(int32_t *)value = MIPS_CPU(uc, mycpu)->env.active_tc.gpr[regid - MIPS_REG_0];
|
*(int32_t *)value = MIPS_CPU(uc, mycpu)->env.active_tc.gpr[regid - UC_MIPS_REG_0];
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case MIPS_REG_PC:
|
case UC_MIPS_REG_PC:
|
||||||
*(int32_t *)value = MIPS_CPU(uc, mycpu)->env.active_tc.PC;
|
*(int32_t *)value = MIPS_CPU(uc, mycpu)->env.active_tc.PC;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -62,12 +62,12 @@ int mips_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= MIPS_REG_0 && regid <= MIPS_REG_31)
|
if (regid >= UC_MIPS_REG_0 && regid <= UC_MIPS_REG_31)
|
||||||
MIPS_CPU(uc, mycpu)->env.active_tc.gpr[regid - MIPS_REG_0] = *(int32_t *)value;
|
MIPS_CPU(uc, mycpu)->env.active_tc.gpr[regid - UC_MIPS_REG_0] = *(int32_t *)value;
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case MIPS_REG_PC:
|
case UC_MIPS_REG_PC:
|
||||||
MIPS_CPU(uc, mycpu)->env.active_tc.PC = *(int32_t *)value;
|
MIPS_CPU(uc, mycpu)->env.active_tc.PC = *(int32_t *)value;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -51,12 +51,12 @@ int sparc_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= SPARC_REG_G0 && regid <= SPARC_REG_G7)
|
if (regid >= UC_SPARC_REG_G0 && regid <= UC_SPARC_REG_G7)
|
||||||
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.gregs[regid - SPARC_REG_G0];
|
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.gregs[regid - UC_SPARC_REG_G0];
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case SPARC_REG_PC:
|
case UC_SPARC_REG_PC:
|
||||||
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.pc;
|
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.pc;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -76,12 +76,12 @@ int sparc_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= SPARC_REG_G0 && regid <= SPARC_REG_G7)
|
if (regid >= UC_SPARC_REG_G0 && regid <= UC_SPARC_REG_G7)
|
||||||
SPARC_CPU(uc, mycpu)->env.gregs[regid - SPARC_REG_G0] = *(int32_t *)value;
|
SPARC_CPU(uc, mycpu)->env.gregs[regid - UC_SPARC_REG_G0] = *(int32_t *)value;
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case SPARC_REG_PC:
|
case UC_SPARC_REG_PC:
|
||||||
SPARC_CPU(uc, mycpu)->env.pc = *(uint32_t *)value;
|
SPARC_CPU(uc, mycpu)->env.pc = *(uint32_t *)value;
|
||||||
SPARC_CPU(uc, mycpu)->env.npc = *(uint32_t *)value + 4;
|
SPARC_CPU(uc, mycpu)->env.npc = *(uint32_t *)value + 4;
|
||||||
break;
|
break;
|
||||||
|
|
|
||||||
|
|
@ -34,12 +34,12 @@ int sparc_reg_read(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= SPARC_REG_G0 && regid <= SPARC_REG_G7)
|
if (regid >= UC_SPARC_REG_G0 && regid <= UC_SPARC_REG_G7)
|
||||||
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.gregs[regid - SPARC_REG_G0];
|
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.gregs[regid - UC_SPARC_REG_G0];
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case SPARC_REG_PC:
|
case UC_SPARC_REG_PC:
|
||||||
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.pc;
|
*(int32_t *)value = SPARC_CPU(uc, mycpu)->env.pc;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
@ -59,12 +59,12 @@ int sparc_reg_write(uch handle, unsigned int regid, void *value)
|
||||||
struct uc_struct *uc = (struct uc_struct *) handle;
|
struct uc_struct *uc = (struct uc_struct *) handle;
|
||||||
CPUState *mycpu = first_cpu;
|
CPUState *mycpu = first_cpu;
|
||||||
|
|
||||||
if (regid >= SPARC_REG_G0 && regid <= SPARC_REG_G7)
|
if (regid >= UC_SPARC_REG_G0 && regid <= UC_SPARC_REG_G7)
|
||||||
SPARC_CPU(uc, mycpu)->env.gregs[regid - SPARC_REG_G0] = *(int32_t *)value;
|
SPARC_CPU(uc, mycpu)->env.gregs[regid - UC_SPARC_REG_G0] = *(int32_t *)value;
|
||||||
else {
|
else {
|
||||||
switch(regid) {
|
switch(regid) {
|
||||||
default: break;
|
default: break;
|
||||||
case SPARC_REG_PC:
|
case UC_SPARC_REG_PC:
|
||||||
SPARC_CPU(uc, mycpu)->env.pc = *(uint32_t *)value;
|
SPARC_CPU(uc, mycpu)->env.pc = *(uint32_t *)value;
|
||||||
SPARC_CPU(uc, mycpu)->env.npc = *(uint32_t *)value + 4;
|
SPARC_CPU(uc, mycpu)->env.npc = *(uint32_t *)value + 4;
|
||||||
break;
|
break;
|
||||||
|
|
|
||||||
|
|
@ -20,7 +20,7 @@ mu.mem_write(CODE_ADDR, binary1)
|
||||||
# emu for maximum 1 sec.
|
# emu for maximum 1 sec.
|
||||||
mu.emu_start(CODE_ADDR, len(binary1), UC_SECOND_SCALE)
|
mu.emu_start(CODE_ADDR, len(binary1), UC_SECOND_SCALE)
|
||||||
|
|
||||||
print("RAX = %x" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %x" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
# write machine code to be emulated to memory
|
# write machine code to be emulated to memory
|
||||||
mu.mem_write(CODE_ADDR, binary2)
|
mu.mem_write(CODE_ADDR, binary2)
|
||||||
|
|
@ -28,5 +28,5 @@ mu.mem_write(CODE_ADDR, binary2)
|
||||||
# emu for maximum 1 sec.
|
# emu for maximum 1 sec.
|
||||||
mu.emu_start(CODE_ADDR, len(binary2), UC_SECOND_SCALE)
|
mu.emu_start(CODE_ADDR, len(binary2), UC_SECOND_SCALE)
|
||||||
|
|
||||||
print("RAX = %x" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %x" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -17,13 +17,13 @@ def hook_code(uc, address, size, user_data):
|
||||||
# callback for tracing Linux interrupt
|
# callback for tracing Linux interrupt
|
||||||
def hook_intr(uc, intno, user_data):
|
def hook_intr(uc, intno, user_data):
|
||||||
# only handle Linux syscall
|
# only handle Linux syscall
|
||||||
rip = uc.reg_read(X86_REG_RIP)
|
rip = uc.reg_read(UC_X86_REG_RIP)
|
||||||
if intno != 0x80:
|
if intno != 0x80:
|
||||||
print("=== 0x%x: got interrupt %x, quit" %(rip, intno));
|
print("=== 0x%x: got interrupt %x, quit" %(rip, intno));
|
||||||
uc.emu_stop()
|
uc.emu_stop()
|
||||||
return
|
return
|
||||||
|
|
||||||
eax = uc.reg_read(X86_REG_EAX)
|
eax = uc.reg_read(UC_X86_REG_EAX)
|
||||||
print(">>> 0x%x: interrupt 0x%x, EAX = 0x%x" %(rip, intno, eax))
|
print(">>> 0x%x: interrupt 0x%x, EAX = 0x%x" %(rip, intno, eax))
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -40,7 +40,7 @@ mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||||
mu.hook_add(UC_HOOK_INTR, hook_intr)
|
mu.hook_add(UC_HOOK_INTR, hook_intr)
|
||||||
|
|
||||||
# setup stack
|
# setup stack
|
||||||
mu.reg_write(X86_REG_RSP, 1024 * 1024)
|
mu.reg_write(UC_X86_REG_RSP, 1024 * 1024)
|
||||||
|
|
||||||
# fill in memory with 0xCC (software breakpoint int 3)
|
# fill in memory with 0xCC (software breakpoint int 3)
|
||||||
for i in xrange(1 * 1024):
|
for i in xrange(1 * 1024):
|
||||||
|
|
|
||||||
|
|
@ -16,17 +16,17 @@ mu.mem_write(0, binary1 + binary2)
|
||||||
# emu for maximum 1 instruction.
|
# emu for maximum 1 instruction.
|
||||||
mu.emu_start(0, 5, 0, 1)
|
mu.emu_start(0, 5, 0, 1)
|
||||||
|
|
||||||
print("RAX = %u" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %u" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_RIP)
|
pos = mu.reg_read(UC_X86_REG_RIP)
|
||||||
|
|
||||||
print("RIP = %x" %pos)
|
print("RIP = %x" %pos)
|
||||||
|
|
||||||
mu.emu_start(5, 10, 0, 1)
|
mu.emu_start(5, 10, 0, 1)
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_RIP)
|
pos = mu.reg_read(UC_X86_REG_RIP)
|
||||||
|
|
||||||
print("RIP = %x" %pos)
|
print("RIP = %x" %pos)
|
||||||
|
|
||||||
print("RAX = %u" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %u" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -16,17 +16,17 @@ mu.mem_write(0, binary1 + binary2)
|
||||||
# emu for maximum 1 instruction.
|
# emu for maximum 1 instruction.
|
||||||
mu.emu_start(0, 10, 0, 1)
|
mu.emu_start(0, 10, 0, 1)
|
||||||
|
|
||||||
print("RAX = %u" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %u" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_RIP)
|
pos = mu.reg_read(UC_X86_REG_RIP)
|
||||||
|
|
||||||
print("RIP = %x" %pos)
|
print("RIP = %x" %pos)
|
||||||
|
|
||||||
mu.emu_start(5, 10, 0, 1)
|
mu.emu_start(5, 10, 0, 1)
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_RIP)
|
pos = mu.reg_read(UC_X86_REG_RIP)
|
||||||
|
|
||||||
print("RIP = %x" %pos)
|
print("RIP = %x" %pos)
|
||||||
|
|
||||||
print("RAX = %u" %mu.reg_read(X86_REG_RAX))
|
print("RAX = %u" %mu.reg_read(UC_X86_REG_RAX))
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -15,9 +15,9 @@ mu.mem_write(0, binary1)
|
||||||
# emu for maximum 1 instruction.
|
# emu for maximum 1 instruction.
|
||||||
mu.emu_start(0, 10, 0, 1)
|
mu.emu_start(0, 10, 0, 1)
|
||||||
|
|
||||||
print("EAX = %u" %mu.reg_read(X86_REG_EAX))
|
print("EAX = %u" %mu.reg_read(UC_X86_REG_EAX))
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_EIP)
|
pos = mu.reg_read(UC_X86_REG_EIP)
|
||||||
|
|
||||||
print("EIP = %x" %pos)
|
print("EIP = %x" %pos)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -16,17 +16,17 @@ pos = 0
|
||||||
# emu for maximum 1 instruction.
|
# emu for maximum 1 instruction.
|
||||||
mu.emu_start(pos, len(binary1), 0, 1)
|
mu.emu_start(pos, len(binary1), 0, 1)
|
||||||
|
|
||||||
print("EAX = %u" %mu.reg_read(X86_REG_EAX))
|
print("EAX = %u" %mu.reg_read(UC_X86_REG_EAX))
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_EIP)
|
pos = mu.reg_read(UC_X86_REG_EIP)
|
||||||
|
|
||||||
print("EIP = %x" %pos)
|
print("EIP = %x" %pos)
|
||||||
|
|
||||||
# emu to the end
|
# emu to the end
|
||||||
mu.emu_start(pos, len(binary1))
|
mu.emu_start(pos, len(binary1))
|
||||||
|
|
||||||
print("EAX = %u" %mu.reg_read(X86_REG_EAX))
|
print("EAX = %u" %mu.reg_read(UC_X86_REG_EAX))
|
||||||
|
|
||||||
pos = mu.reg_read(X86_REG_EIP)
|
pos = mu.reg_read(UC_X86_REG_EIP)
|
||||||
|
|
||||||
print("EIP = %x" %pos)
|
print("EIP = %x" %pos)
|
||||||
|
|
|
||||||
|
|
@ -53,9 +53,9 @@ static void test_arm(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, ARM_REG_R0, &r0);
|
uc_reg_write(handle, UC_ARM_REG_R0, &r0);
|
||||||
uc_reg_write(handle, ARM_REG_R2, &r2);
|
uc_reg_write(handle, UC_ARM_REG_R2, &r2);
|
||||||
uc_reg_write(handle, ARM_REG_R3, &r3);
|
uc_reg_write(handle, UC_ARM_REG_R3, &r3);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -73,8 +73,8 @@ static void test_arm(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, ARM_REG_R0, &r0);
|
uc_reg_read(handle, UC_ARM_REG_R0, &r0);
|
||||||
uc_reg_read(handle, ARM_REG_R1, &r1);
|
uc_reg_read(handle, UC_ARM_REG_R1, &r1);
|
||||||
printf(">>> R0 = 0x%x\n", r0);
|
printf(">>> R0 = 0x%x\n", r0);
|
||||||
printf(">>> R1 = 0x%x\n", r1);
|
printf(">>> R1 = 0x%x\n", r1);
|
||||||
|
|
||||||
|
|
@ -106,7 +106,7 @@ static void test_thumb(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)THUMB_CODE, sizeof(THUMB_CODE) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)THUMB_CODE, sizeof(THUMB_CODE) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, ARM_REG_SP, &sp);
|
uc_reg_write(handle, UC_ARM_REG_SP, &sp);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -124,7 +124,7 @@ static void test_thumb(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, ARM_REG_SP, &sp);
|
uc_reg_read(handle, UC_ARM_REG_SP, &sp);
|
||||||
printf(">>> SP = 0x%x\n", sp);
|
printf(">>> SP = 0x%x\n", sp);
|
||||||
|
|
||||||
uc_close(&handle);
|
uc_close(&handle);
|
||||||
|
|
|
||||||
|
|
@ -51,9 +51,9 @@ static void test_arm64(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, ARM64_REG_X11, &x11);
|
uc_reg_write(handle, UC_ARM64_REG_X11, &x11);
|
||||||
uc_reg_write(handle, ARM64_REG_X13, &x13);
|
uc_reg_write(handle, UC_ARM64_REG_X13, &x13);
|
||||||
uc_reg_write(handle, ARM64_REG_X15, &x15);
|
uc_reg_write(handle, UC_ARM64_REG_X15, &x15);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -71,7 +71,7 @@ static void test_arm64(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, ARM64_REG_X11, &x11);
|
uc_reg_read(handle, UC_ARM64_REG_X11, &x11);
|
||||||
printf(">>> X11 = 0x%" PRIx64 "\n", x11);
|
printf(">>> X11 = 0x%" PRIx64 "\n", x11);
|
||||||
|
|
||||||
uc_close(&handle);
|
uc_close(&handle);
|
||||||
|
|
|
||||||
|
|
@ -50,7 +50,7 @@ static void test_mips_eb(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)MIPS_CODE_EB, sizeof(MIPS_CODE_EB) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)MIPS_CODE_EB, sizeof(MIPS_CODE_EB) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, MIPS_REG_1, &r1);
|
uc_reg_write(handle, UC_MIPS_REG_1, &r1);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -68,7 +68,7 @@ static void test_mips_eb(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, MIPS_REG_1, &r1);
|
uc_reg_read(handle, UC_MIPS_REG_1, &r1);
|
||||||
printf(">>> R1 = 0x%x\n", r1);
|
printf(">>> R1 = 0x%x\n", r1);
|
||||||
|
|
||||||
uc_close(&handle);
|
uc_close(&handle);
|
||||||
|
|
@ -100,7 +100,7 @@ static void test_mips_el(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)MIPS_CODE_EL, sizeof(MIPS_CODE_EL) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)MIPS_CODE_EL, sizeof(MIPS_CODE_EL) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, MIPS_REG_1, &r1);
|
uc_reg_write(handle, UC_MIPS_REG_1, &r1);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -118,7 +118,7 @@ static void test_mips_el(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, MIPS_REG_1, &r1);
|
uc_reg_read(handle, UC_MIPS_REG_1, &r1);
|
||||||
printf(">>> R1 = 0x%x\n", r1);
|
printf(">>> R1 = 0x%x\n", r1);
|
||||||
|
|
||||||
uc_close(&handle);
|
uc_close(&handle);
|
||||||
|
|
|
||||||
|
|
@ -52,9 +52,9 @@ static void test_sparc(void)
|
||||||
uc_mem_write(handle, ADDRESS, (uint8_t *)SPARC_CODE, sizeof(SPARC_CODE) - 1);
|
uc_mem_write(handle, ADDRESS, (uint8_t *)SPARC_CODE, sizeof(SPARC_CODE) - 1);
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, SPARC_REG_G1, &g1);
|
uc_reg_write(handle, UC_SPARC_REG_G1, &g1);
|
||||||
uc_reg_write(handle, SPARC_REG_G2, &g2);
|
uc_reg_write(handle, UC_SPARC_REG_G2, &g2);
|
||||||
uc_reg_write(handle, SPARC_REG_G3, &g3);
|
uc_reg_write(handle, UC_SPARC_REG_G3, &g3);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -73,7 +73,7 @@ static void test_sparc(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, SPARC_REG_G3, &g3);
|
uc_reg_read(handle, UC_SPARC_REG_G3, &g3);
|
||||||
printf(">>> G3 = 0x%x\n", g3);
|
printf(">>> G3 = 0x%x\n", g3);
|
||||||
|
|
||||||
uc_close(&handle);
|
uc_close(&handle);
|
||||||
|
|
|
||||||
|
|
@ -41,7 +41,7 @@ static void hook_code(uch handle, uint64_t address, uint32_t size, void *user_da
|
||||||
int eflags;
|
int eflags;
|
||||||
printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EFLAGS, &eflags);
|
uc_reg_read(handle, UC_X86_REG_EFLAGS, &eflags);
|
||||||
printf(">>> --- EFLAGS is 0x%x\n", eflags);
|
printf(">>> --- EFLAGS is 0x%x\n", eflags);
|
||||||
|
|
||||||
// Uncomment below code to stop the emulation using uc_emu_stop()
|
// Uncomment below code to stop the emulation using uc_emu_stop()
|
||||||
|
|
@ -54,7 +54,7 @@ static void hook_code64(uch handle, uint64_t address, uint32_t size, void *user_
|
||||||
{
|
{
|
||||||
uint64_t rip;
|
uint64_t rip;
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_RIP, &rip);
|
uc_reg_read(handle, UC_X86_REG_RIP, &rip);
|
||||||
printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
||||||
printf(">>> RIP is 0x%"PRIx64 "\n", rip);
|
printf(">>> RIP is 0x%"PRIx64 "\n", rip);
|
||||||
|
|
||||||
|
|
@ -103,7 +103,7 @@ static uint32_t hook_in(uch handle, uint32_t port, int size, void *user_data)
|
||||||
{
|
{
|
||||||
uint32_t eip;
|
uint32_t eip;
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EIP, &eip);
|
uc_reg_read(handle, UC_X86_REG_EIP, &eip);
|
||||||
|
|
||||||
printf("--- reading from port 0x%x, size: %u, address: 0x%x\n", port, size, eip);
|
printf("--- reading from port 0x%x, size: %u, address: 0x%x\n", port, size, eip);
|
||||||
|
|
||||||
|
|
@ -129,7 +129,7 @@ static void hook_out(uch handle, uint32_t port, int size, uint32_t value, void *
|
||||||
uint32_t tmp;
|
uint32_t tmp;
|
||||||
uint32_t eip;
|
uint32_t eip;
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EIP, &eip);
|
uc_reg_read(handle, UC_X86_REG_EIP, &eip);
|
||||||
|
|
||||||
printf("--- writing to port 0x%x, size: %u, value: 0x%x, address: 0x%x\n", port, size, value, eip);
|
printf("--- writing to port 0x%x, size: %u, value: 0x%x, address: 0x%x\n", port, size, value, eip);
|
||||||
|
|
||||||
|
|
@ -138,13 +138,13 @@ static void hook_out(uch handle, uint32_t port, int size, uint32_t value, void *
|
||||||
default:
|
default:
|
||||||
return; // should never reach this
|
return; // should never reach this
|
||||||
case 1:
|
case 1:
|
||||||
uc_reg_read(handle, X86_REG_AL, &tmp);
|
uc_reg_read(handle, UC_X86_REG_AL, &tmp);
|
||||||
break;
|
break;
|
||||||
case 2:
|
case 2:
|
||||||
uc_reg_read(handle, X86_REG_AX, &tmp);
|
uc_reg_read(handle, UC_X86_REG_AX, &tmp);
|
||||||
break;
|
break;
|
||||||
case 4:
|
case 4:
|
||||||
uc_reg_read(handle, X86_REG_EAX, &tmp);
|
uc_reg_read(handle, UC_X86_REG_EAX, &tmp);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -180,8 +180,8 @@ static void test_i386(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_write(handle, X86_REG_EDX, &r_edx);
|
uc_reg_write(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -199,8 +199,8 @@ static void test_i386(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
printf(">>> EDX = 0x%x\n", r_edx);
|
printf(">>> EDX = 0x%x\n", r_edx);
|
||||||
|
|
||||||
|
|
@ -286,8 +286,8 @@ static void test_i386_loop(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_write(handle, X86_REG_EDX, &r_edx);
|
uc_reg_write(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// emulate machine code in 2 seconds, so we can quit even
|
// emulate machine code in 2 seconds, so we can quit even
|
||||||
// if the code loops
|
// if the code loops
|
||||||
|
|
@ -300,8 +300,8 @@ static void test_i386_loop(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
printf(">>> EDX = 0x%x\n", r_edx);
|
printf(">>> EDX = 0x%x\n", r_edx);
|
||||||
|
|
||||||
|
|
@ -338,8 +338,8 @@ static void test_i386_invalid_mem_read(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_write(handle, X86_REG_EDX, &r_edx);
|
uc_reg_write(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -357,8 +357,8 @@ static void test_i386_invalid_mem_read(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
printf(">>> EDX = 0x%x\n", r_edx);
|
printf(">>> EDX = 0x%x\n", r_edx);
|
||||||
|
|
||||||
|
|
@ -396,8 +396,8 @@ static void test_i386_invalid_mem_write(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_write(handle, X86_REG_EDX, &r_edx);
|
uc_reg_write(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -418,8 +418,8 @@ static void test_i386_invalid_mem_write(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
printf(">>> EDX = 0x%x\n", r_edx);
|
printf(">>> EDX = 0x%x\n", r_edx);
|
||||||
|
|
||||||
|
|
@ -467,8 +467,8 @@ static void test_i386_jump_invalid(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_write(handle, X86_REG_EDX, &r_edx);
|
uc_reg_write(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -486,8 +486,8 @@ static void test_i386_jump_invalid(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
printf(">>> EDX = 0x%x\n", r_edx);
|
printf(">>> EDX = 0x%x\n", r_edx);
|
||||||
|
|
||||||
|
|
@ -524,8 +524,8 @@ static void test_i386_inout(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_EAX, &r_eax);
|
uc_reg_write(handle, UC_X86_REG_EAX, &r_eax);
|
||||||
uc_reg_write(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_write(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -534,9 +534,9 @@ static void test_i386_inout(void)
|
||||||
uc_hook_add(handle, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
||||||
// handle IN instruction
|
// handle IN instruction
|
||||||
uc_hook_add(handle, &trace3, UC_HOOK_INSN, hook_in, NULL, X86_INS_IN);
|
uc_hook_add(handle, &trace3, UC_HOOK_INSN, hook_in, NULL, UC_X86_INS_IN);
|
||||||
// handle OUT instruction
|
// handle OUT instruction
|
||||||
uc_hook_add(handle, &trace4, UC_HOOK_INSN, hook_out, NULL, X86_INS_OUT);
|
uc_hook_add(handle, &trace4, UC_HOOK_INSN, hook_out, NULL, UC_X86_INS_OUT);
|
||||||
|
|
||||||
// emulate machine code in infinite time
|
// emulate machine code in infinite time
|
||||||
err = uc_emu_start(handle, ADDRESS, ADDRESS + sizeof(X86_CODE32_INOUT) - 1, 0, 0);
|
err = uc_emu_start(handle, ADDRESS, ADDRESS + sizeof(X86_CODE32_INOUT) - 1, 0, 0);
|
||||||
|
|
@ -548,8 +548,8 @@ static void test_i386_inout(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EAX, &r_eax);
|
uc_reg_read(handle, UC_X86_REG_EAX, &r_eax);
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
printf(">>> EAX = 0x%x\n", r_eax);
|
printf(">>> EAX = 0x%x\n", r_eax);
|
||||||
printf(">>> ECX = 0x%x\n", r_ecx);
|
printf(">>> ECX = 0x%x\n", r_ecx);
|
||||||
|
|
||||||
|
|
@ -599,22 +599,22 @@ static void test_x86_64(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_RSP, &rsp);
|
uc_reg_write(handle, UC_X86_REG_RSP, &rsp);
|
||||||
|
|
||||||
uc_reg_write(handle, X86_REG_RAX, &rax);
|
uc_reg_write(handle, UC_X86_REG_RAX, &rax);
|
||||||
uc_reg_write(handle, X86_REG_RBX, &rbx);
|
uc_reg_write(handle, UC_X86_REG_RBX, &rbx);
|
||||||
uc_reg_write(handle, X86_REG_RCX, &rcx);
|
uc_reg_write(handle, UC_X86_REG_RCX, &rcx);
|
||||||
uc_reg_write(handle, X86_REG_RDX, &rdx);
|
uc_reg_write(handle, UC_X86_REG_RDX, &rdx);
|
||||||
uc_reg_write(handle, X86_REG_RSI, &rsi);
|
uc_reg_write(handle, UC_X86_REG_RSI, &rsi);
|
||||||
uc_reg_write(handle, X86_REG_RDI, &rdi);
|
uc_reg_write(handle, UC_X86_REG_RDI, &rdi);
|
||||||
uc_reg_write(handle, X86_REG_R8, &r8);
|
uc_reg_write(handle, UC_X86_REG_R8, &r8);
|
||||||
uc_reg_write(handle, X86_REG_R9, &r9);
|
uc_reg_write(handle, UC_X86_REG_R9, &r9);
|
||||||
uc_reg_write(handle, X86_REG_R10, &r10);
|
uc_reg_write(handle, UC_X86_REG_R10, &r10);
|
||||||
uc_reg_write(handle, X86_REG_R11, &r11);
|
uc_reg_write(handle, UC_X86_REG_R11, &r11);
|
||||||
uc_reg_write(handle, X86_REG_R12, &r12);
|
uc_reg_write(handle, UC_X86_REG_R12, &r12);
|
||||||
uc_reg_write(handle, X86_REG_R13, &r13);
|
uc_reg_write(handle, UC_X86_REG_R13, &r13);
|
||||||
uc_reg_write(handle, X86_REG_R14, &r14);
|
uc_reg_write(handle, UC_X86_REG_R14, &r14);
|
||||||
uc_reg_write(handle, X86_REG_R15, &r15);
|
uc_reg_write(handle, UC_X86_REG_R15, &r15);
|
||||||
|
|
||||||
// tracing all basic blocks with customized callback
|
// tracing all basic blocks with customized callback
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
uc_hook_add(handle, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);
|
||||||
|
|
@ -639,20 +639,20 @@ static void test_x86_64(void)
|
||||||
// now print out some registers
|
// now print out some registers
|
||||||
printf(">>> Emulation done. Below is the CPU context\n");
|
printf(">>> Emulation done. Below is the CPU context\n");
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_RAX, &rax);
|
uc_reg_read(handle, UC_X86_REG_RAX, &rax);
|
||||||
uc_reg_read(handle, X86_REG_RBX, &rbx);
|
uc_reg_read(handle, UC_X86_REG_RBX, &rbx);
|
||||||
uc_reg_read(handle, X86_REG_RCX, &rcx);
|
uc_reg_read(handle, UC_X86_REG_RCX, &rcx);
|
||||||
uc_reg_read(handle, X86_REG_RDX, &rdx);
|
uc_reg_read(handle, UC_X86_REG_RDX, &rdx);
|
||||||
uc_reg_read(handle, X86_REG_RSI, &rsi);
|
uc_reg_read(handle, UC_X86_REG_RSI, &rsi);
|
||||||
uc_reg_read(handle, X86_REG_RDI, &rdi);
|
uc_reg_read(handle, UC_X86_REG_RDI, &rdi);
|
||||||
uc_reg_read(handle, X86_REG_R8, &r8);
|
uc_reg_read(handle, UC_X86_REG_R8, &r8);
|
||||||
uc_reg_read(handle, X86_REG_R9, &r9);
|
uc_reg_read(handle, UC_X86_REG_R9, &r9);
|
||||||
uc_reg_read(handle, X86_REG_R10, &r10);
|
uc_reg_read(handle, UC_X86_REG_R10, &r10);
|
||||||
uc_reg_read(handle, X86_REG_R11, &r11);
|
uc_reg_read(handle, UC_X86_REG_R11, &r11);
|
||||||
uc_reg_read(handle, X86_REG_R12, &r12);
|
uc_reg_read(handle, UC_X86_REG_R12, &r12);
|
||||||
uc_reg_read(handle, X86_REG_R13, &r13);
|
uc_reg_read(handle, UC_X86_REG_R13, &r13);
|
||||||
uc_reg_read(handle, X86_REG_R14, &r14);
|
uc_reg_read(handle, UC_X86_REG_R14, &r14);
|
||||||
uc_reg_read(handle, X86_REG_R15, &r15);
|
uc_reg_read(handle, UC_X86_REG_R15, &r15);
|
||||||
|
|
||||||
printf(">>> RAX = 0x%" PRIx64 "\n", rax);
|
printf(">>> RAX = 0x%" PRIx64 "\n", rax);
|
||||||
printf(">>> RBX = 0x%" PRIx64 "\n", rbx);
|
printf(">>> RBX = 0x%" PRIx64 "\n", rbx);
|
||||||
|
|
|
||||||
|
|
@ -27,7 +27,7 @@ static void hook_code(uch handle, uint64_t address, uint32_t size, void *user_da
|
||||||
|
|
||||||
printf("Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
printf("Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EIP, &r_eip);
|
uc_reg_read(handle, UC_X86_REG_EIP, &r_eip);
|
||||||
printf("*** EIP = %x ***: ", r_eip);
|
printf("*** EIP = %x ***: ", r_eip);
|
||||||
|
|
||||||
size = MIN(sizeof(tmp), size);
|
size = MIN(sizeof(tmp), size);
|
||||||
|
|
@ -53,8 +53,8 @@ static void hook_intr(uch handle, uint32_t intno, void *user_data)
|
||||||
if (intno != 0x80)
|
if (intno != 0x80)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
uc_reg_read(handle, X86_REG_EAX, &r_eax);
|
uc_reg_read(handle, UC_X86_REG_EAX, &r_eax);
|
||||||
uc_reg_read(handle, X86_REG_EIP, &r_eip);
|
uc_reg_read(handle, UC_X86_REG_EIP, &r_eip);
|
||||||
|
|
||||||
switch(r_eax) {
|
switch(r_eax) {
|
||||||
default:
|
default:
|
||||||
|
|
@ -66,10 +66,10 @@ static void hook_intr(uch handle, uint32_t intno, void *user_data)
|
||||||
break;
|
break;
|
||||||
case 4: // sys_write
|
case 4: // sys_write
|
||||||
// ECX = buffer address
|
// ECX = buffer address
|
||||||
uc_reg_read(handle, X86_REG_ECX, &r_ecx);
|
uc_reg_read(handle, UC_X86_REG_ECX, &r_ecx);
|
||||||
|
|
||||||
// EDX = buffer size
|
// EDX = buffer size
|
||||||
uc_reg_read(handle, X86_REG_EDX, &r_edx);
|
uc_reg_read(handle, UC_X86_REG_EDX, &r_edx);
|
||||||
|
|
||||||
// read the buffer in
|
// read the buffer in
|
||||||
size = MIN(sizeof(buffer)-1, r_edx);
|
size = MIN(sizeof(buffer)-1, r_edx);
|
||||||
|
|
@ -113,7 +113,7 @@ static void test_i386(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
// initialize machine registers
|
// initialize machine registers
|
||||||
uc_reg_write(handle, X86_REG_ESP, &r_esp);
|
uc_reg_write(handle, UC_X86_REG_ESP, &r_esp);
|
||||||
|
|
||||||
// tracing all instructions by having @begin > @end
|
// tracing all instructions by having @begin > @end
|
||||||
uc_hook_add(handle, &trace1, UC_HOOK_CODE, hook_code, NULL, 1, 0);
|
uc_hook_add(handle, &trace1, UC_HOOK_CODE, hook_code, NULL, 1, 0);
|
||||||
|
|
|
||||||
22
uc.c
22
uc.c
|
|
@ -435,13 +435,13 @@ uc_err uc_emu_start(uch handle, uint64_t begin, uint64_t until, uint64_t timeout
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
case UC_MODE_16:
|
case UC_MODE_16:
|
||||||
uc_reg_write(handle, X86_REG_IP, &begin);
|
uc_reg_write(handle, UC_X86_REG_IP, &begin);
|
||||||
break;
|
break;
|
||||||
case UC_MODE_32:
|
case UC_MODE_32:
|
||||||
uc_reg_write(handle, X86_REG_EIP, &begin);
|
uc_reg_write(handle, UC_X86_REG_EIP, &begin);
|
||||||
break;
|
break;
|
||||||
case UC_MODE_64:
|
case UC_MODE_64:
|
||||||
uc_reg_write(handle, X86_REG_RIP, &begin);
|
uc_reg_write(handle, UC_X86_REG_RIP, &begin);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
@ -452,23 +452,23 @@ uc_err uc_emu_start(uch handle, uint64_t begin, uint64_t until, uint64_t timeout
|
||||||
break;
|
break;
|
||||||
case UC_MODE_THUMB:
|
case UC_MODE_THUMB:
|
||||||
case UC_MODE_ARM:
|
case UC_MODE_ARM:
|
||||||
uc_reg_write(handle, ARM_REG_R15, &begin);
|
uc_reg_write(handle, UC_ARM_REG_R15, &begin);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case UC_ARCH_ARM64:
|
case UC_ARCH_ARM64:
|
||||||
uc_reg_write(handle, ARM64_REG_PC, &begin);
|
uc_reg_write(handle, UC_ARM64_REG_PC, &begin);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case UC_ARCH_MIPS:
|
case UC_ARCH_MIPS:
|
||||||
// TODO: MIPS32/MIPS64/BIGENDIAN etc
|
// TODO: MIPS32/MIPS64/BIGENDIAN etc
|
||||||
uc_reg_write(handle, MIPS_REG_PC, &begin);
|
uc_reg_write(handle, UC_MIPS_REG_PC, &begin);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case UC_ARCH_SPARC:
|
case UC_ARCH_SPARC:
|
||||||
// TODO: Sparc/Sparc64
|
// TODO: Sparc/Sparc64
|
||||||
uc_reg_write(handle, SPARC_REG_PC, &begin);
|
uc_reg_write(handle, UC_SPARC_REG_PC, &begin);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -623,7 +623,7 @@ static uc_err _hook_insn(struct uc_struct *uc, unsigned int insn_id, void *callb
|
||||||
case UC_ARCH_X86:
|
case UC_ARCH_X86:
|
||||||
switch(insn_id) {
|
switch(insn_id) {
|
||||||
default: break;
|
default: break;
|
||||||
case X86_INS_OUT:
|
case UC_X86_INS_OUT:
|
||||||
// FIXME: only one event handler at the same time
|
// FIXME: only one event handler at the same time
|
||||||
i = hook_find_new(uc);
|
i = hook_find_new(uc);
|
||||||
if (i) {
|
if (i) {
|
||||||
|
|
@ -634,7 +634,7 @@ static uc_err _hook_insn(struct uc_struct *uc, unsigned int insn_id, void *callb
|
||||||
return UC_ERR_OK;
|
return UC_ERR_OK;
|
||||||
} else
|
} else
|
||||||
return UC_ERR_OOM;
|
return UC_ERR_OOM;
|
||||||
case X86_INS_IN:
|
case UC_X86_INS_IN:
|
||||||
// FIXME: only one event handler at the same time
|
// FIXME: only one event handler at the same time
|
||||||
i = hook_find_new(uc);
|
i = hook_find_new(uc);
|
||||||
if (i) {
|
if (i) {
|
||||||
|
|
@ -645,8 +645,8 @@ static uc_err _hook_insn(struct uc_struct *uc, unsigned int insn_id, void *callb
|
||||||
return UC_ERR_OK;
|
return UC_ERR_OK;
|
||||||
} else
|
} else
|
||||||
return UC_ERR_OOM;
|
return UC_ERR_OOM;
|
||||||
case X86_INS_SYSCALL:
|
case UC_X86_INS_SYSCALL:
|
||||||
case X86_INS_SYSENTER:
|
case UC_X86_INS_SYSENTER:
|
||||||
// FIXME: only one event handler at the same time
|
// FIXME: only one event handler at the same time
|
||||||
i = hook_find_new(uc);
|
i = hook_find_new(uc);
|
||||||
if (i) {
|
if (i) {
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue