From 5e72ce39f0b6a325ab315b7aa8d56de72c3c9bf5 Mon Sep 17 00:00:00 2001 From: Sascha Schirra Date: Tue, 22 Mar 2016 12:17:23 +0100 Subject: [PATCH] ruby binding added --- bindings/README | 1 + bindings/const_generator.py | 16 + bindings/ruby/Makefile | 11 + bindings/ruby/README.md | 20 + bindings/ruby/sample_x86.rb | 511 ++++++ bindings/ruby/unicorn_gem/Gemfile | 3 + bindings/ruby/unicorn_gem/Rakefile | 2 + bindings/ruby/unicorn_gem/ext/extconf.rb | 8 + bindings/ruby/unicorn_gem/ext/unicorn.c | 454 +++++ bindings/ruby/unicorn_gem/ext/unicorn.h | 34 + .../unicorn_gem/lib/unicorn/arm64_const.rb | 277 +++ .../ruby/unicorn_gem/lib/unicorn/arm_const.rb | 128 ++ .../unicorn_gem/lib/unicorn/m68k_const.rb | 27 + .../unicorn_gem/lib/unicorn/mips_const.rb | 198 ++ .../unicorn_gem/lib/unicorn/sparc_const.rb | 99 + .../unicorn_gem/lib/unicorn/unicorn_const.rb | 98 + .../ruby/unicorn_gem/lib/unicorn/version.rb | 3 + .../ruby/unicorn_gem/lib/unicorn/x86_const.rb | 1598 +++++++++++++++++ bindings/ruby/unicorn_gem/pkg/.gitignore | 10 + .../ruby/unicorn_gem/pkg/unicorn-0.9.0.gem | Bin 0 -> 20992 bytes bindings/ruby/unicorn_gem/unicorn.gemspec | 21 + 21 files changed, 3519 insertions(+) create mode 100644 bindings/ruby/Makefile create mode 100644 bindings/ruby/README.md create mode 100644 bindings/ruby/sample_x86.rb create mode 100644 bindings/ruby/unicorn_gem/Gemfile create mode 100644 bindings/ruby/unicorn_gem/Rakefile create mode 100644 bindings/ruby/unicorn_gem/ext/extconf.rb create mode 100644 bindings/ruby/unicorn_gem/ext/unicorn.c create mode 100644 bindings/ruby/unicorn_gem/ext/unicorn.h create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/arm64_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/arm_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/m68k_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/mips_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/sparc_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/unicorn_const.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/version.rb create mode 100644 bindings/ruby/unicorn_gem/lib/unicorn/x86_const.rb create mode 100644 bindings/ruby/unicorn_gem/pkg/.gitignore create mode 100644 bindings/ruby/unicorn_gem/pkg/unicorn-0.9.0.gem create mode 100644 bindings/ruby/unicorn_gem/unicorn.gemspec diff --git a/bindings/README b/bindings/README index c3abec91..4c4a2430 100644 --- a/bindings/README +++ b/bindings/README @@ -7,6 +7,7 @@ The following bindings are contributed by community. - Go binding: by Ryan Hileman. - .NET binding: by Antonio Parata. - MSVC binding: by Zak Escano +- Ruby binding: by Sascha Schirra More bindings created & maintained externally by community are available as follows. diff --git a/bindings/const_generator.py b/bindings/const_generator.py index 826340b2..c224d082 100644 --- a/bindings/const_generator.py +++ b/bindings/const_generator.py @@ -24,6 +24,22 @@ template = { 'comment_open': '#', 'comment_close': '', }, + 'ruby': { + 'header': "# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [%s_const.rb]\n\nmodule Unicorn\n", + 'footer': "end", + 'line_format': '\tUC_%s = %s\n', + 'out_file': './ruby/unicorn_gem/lib/unicorn/%s_const.rb', + # prefixes for constant filenames of all archs - case sensitive + 'arm.h': 'arm', + 'arm64.h': 'arm64', + 'mips.h': 'mips', + 'x86.h': 'x86', + 'sparc.h': 'sparc', + 'm68k.h': 'm68k', + 'unicorn.h': 'unicorn', + 'comment_open': '#', + 'comment_close': '', + }, 'go': { 'header': "package unicorn\n// For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [%s_const.go]\nconst (\n", 'footer': ")", diff --git a/bindings/ruby/Makefile b/bindings/ruby/Makefile new file mode 100644 index 00000000..6e801fc6 --- /dev/null +++ b/bindings/ruby/Makefile @@ -0,0 +1,11 @@ +# Ruby binding for Unicorn engine. Sascha Schirra + +.PHONY: gen_const + +install: + $(MAKE) gen_const + cd unicorn_gem && rake build + cd unicorn_gem && gem install --local pkg/unicorn-0.9.0.gem + +gen_const: + cd .. && python const_generator.py ruby diff --git a/bindings/ruby/README.md b/bindings/ruby/README.md new file mode 100644 index 00000000..c8bf4566 --- /dev/null +++ b/bindings/ruby/README.md @@ -0,0 +1,20 @@ +Installation +============ + +1. Softwarerequirements + +Linux +- ruby >= 1.9.3 +- rubygems +- make +- gcc + +Mac OS +- ruby >= 1.9.3 +- rubygems +- make +- XCode + +2. Install unicorn + + diff --git a/bindings/ruby/sample_x86.rb b/bindings/ruby/sample_x86.rb new file mode 100644 index 00000000..e951927b --- /dev/null +++ b/bindings/ruby/sample_x86.rb @@ -0,0 +1,511 @@ +#!/usr/bin/env ruby +require 'unicorn' +require 'unicorn/x86_const' + +include Unicorn + +X86_CODE32 = "\x41\x4a" # INC ecx; DEC edx +X86_CODE32_LOOP = "\x41\x4a\xeb\xfe" # INC ecx; DEC edx; JMP self-loop +X86_CODE32_MEM_READ = "\x8B\x0D\xAA\xAA\xAA\xAA\x41\x4a" # mov ecx,[0xaaaaaaaa]; INC ecx; DEC edx +X86_CODE32_MEM_WRITE = "\x89\x0D\xAA\xAA\xAA\xAA\x41\x4a" # mov [0xaaaaaaaa], ecx; INC ecx; DEC edx +X86_CODE64 = "\x41\xBC\x3B\xB0\x28\x2A\x49\x0F\xC9\x90\x4D\x0F\xAD\xCF\x49\x87\xFD\x90\x48\x81\xD2\x8A\xCE\x77\x35\x48\xF7\xD9\x4D\x29\xF4\x49\x81\xC9\xF6\x8A\xC6\x53\x4D\x87\xED\x48\x0F\xAD\xD2\x49\xF7\xD4\x48\xF7\xE1\x4D\x19\xC5\x4D\x89\xC5\x48\xF7\xD6\x41\xB8\x4F\x8D\x6B\x59\x4D\x87\xD0\x68\x6A\x1E\x09\x3C\x59" +X86_CODE32_INOUT = "\x41\xE4\x3F\x4a\xE6\x46\x43" # INC ecx; IN AL, 0x3f; DEC edx; OUT 0x46, AL; INC ebx +X86_CODE64_SYSCALL = "\x0f\x05" # SYSCALL +X86_CODE16 = "\x00\x00" # add byte ptr [bx + si], al + +# memory address where emulation starts +ADDRESS = 0x1000000 + + +# callback for tracing basic blocks +HOOK_BLOCK = Proc.new do |uc, address, size, user_data | + puts(">>> Tracing basic block at 0x%x, block size = 0x%x" % [address, size]) +end + +# callback for tracing instructions +HOOK_CODE = Proc.new do |uc, address, size, user_data| + puts(">>> Tracing instruction at 0x%x, instruction size = %u" % [address, size]) +end + + +# callback for tracing invalid memory access (READ or WRITE) +HOOK_MEM_INVALID = lambda do |uc, access, address, size, value, user_data| + if access == UC_MEM_WRITE_UNMAPPED + puts(">>> Missing memory is being WRITE at 0x%x, data size = %u, data value = 0x%x" % [address, size, value]) + # map this memory in with 2MB in size + uc.mem_map(0xaaaa0000, 2 * 1024*1024) + # return True to indicate we want to continue emulation + return true + else + puts(">>> Missing memory is being READ at 0x%x" % address) + # return False to indicate we want to stop emulation + return false + end +end + + +# callback for tracing memory access (READ or WRITE) +HOOK_MEM_ACCESS = Proc.new do |uc, access, address, size, value, user_data| + if access == UC_MEM_WRITE + puts(">>> Memory is being WRITE at 0x%x, data size = %u, data value = 0x%x" % [address, size, value]) + else # READ + puts(">>> Memory is being READ at 0x%x, data size = %u" % [address, size]) + end +end + +# callback for IN instruction +HOOK_IN = lambda do |uc, port, size, user_data| + eip = uc.reg_read(UC_X86_REG_EIP) + puts("--- reading from port 0x%x, size: %u, address: 0x%x" % [port, size, eip]) + if size == 1 + # read 1 byte to AL + return 0xf1 + end + if size == 2 + # read 2 byte to AX + return 0xf2 + end + if size == 4 + # read 4 byte to EAX + return 0xf4 + end + # we should never reach here + return 0 +end + + +# callback for OUT instruction +HOOK_OUT = Proc.new do |uc, port, size, value, user_data| + + eip = uc.reg_read(UC_X86_REG_EIP) + puts("--- 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 + v = 0 + if size == 1 + # read 1 byte in AL + v = uc.reg_read(UC_X86_REG_AL) + end + if size == 2 + # read 2 bytes in AX + v = uc.reg_read(UC_X86_REG_AX) + end + if size == 4 + # read 4 bytes in EAX + v = uc.reg_read(UC_X86_REG_EAX) + end + + puts("--- register value = 0x%x" %v) +end + + +# Test X86 32 bit +def test_i386() + puts("Emulate i386 code") + begin + # Initialize emulator in X86-32bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_32 + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE32) + + # initialize machine registers + mu.reg_write(UC_X86_REG_ECX, 0x1234) + mu.reg_write(UC_X86_REG_EDX, 0x7890) + + # tracing all basic blocks with customized callback + mu.hook_add(UC_HOOK_BLOCK, HOOK_BLOCK) + + # tracing all instructions with customized callback + mu.hook_add(UC_HOOK_CODE, HOOK_CODE) + mu.hook_add(UC_HOOK_MEM_READ_UNMAPPED, HOOK_MEM_INVALID) + + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE32.bytesize) + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + r_ecx = mu.reg_read(UC_X86_REG_ECX) + r_edx = mu.reg_read(UC_X86_REG_EDX) + puts(">>> ECX = 0x%x" % r_ecx) + puts(">>> EDX = 0x%x" % r_edx) + + # read from memory + tmp = mu.mem_read(ADDRESS, 2) + print(">>> Read 2 bytes from [0x%x] =" % (ADDRESS)) + tmp.each_byte { |i| print(" 0x%x" % i) } + + + puts + + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + +def test_i386_loop() + puts("Emulate i386 code with infinite loop - wait for 2 seconds then stop emulation") + begin + # Initialize emulator in X86-32bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_32 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE32_LOOP) + + # initialize machine registers + mu.reg_write(UC_X86_REG_ECX, 0x1234) + mu.reg_write(UC_X86_REG_EDX, 0x7890) + + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE32_LOOP.bytesize, 2 * UC_SECOND_SCALE) + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + r_ecx = mu.reg_read(UC_X86_REG_ECX) + r_edx = mu.reg_read(UC_X86_REG_EDX) + puts(">>> ECX = 0x%x" % r_ecx) + puts(">>> EDX = 0x%x" % r_edx) + + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + +def test_i386_invalid_mem_read() + puts("Emulate i386 code that read from invalid memory") + begin + # Initialize emulator in X86-32bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_32 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE32_MEM_READ) + + # initialize machine registers + mu.reg_write(UC_X86_REG_ECX, 0x1234) + mu.reg_write(UC_X86_REG_EDX, 0x7890) + + # tracing all basic blocks with customized callback + mu.hook_add(UC_HOOK_BLOCK, HOOK_BLOCK) + + # tracing all instructions with customized callback + mu.hook_add(UC_HOOK_CODE, HOOK_CODE) + + begin + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE32_MEM_READ.bytesize) + rescue UcError => e + puts("ERROR: %s" % e) + end + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + r_ecx = mu.reg_read(UC_X86_REG_ECX) + r_edx = mu.reg_read(UC_X86_REG_EDX) + puts(">>> ECX = 0x%x" % r_ecx) + puts(">>> EDX = 0x%x" % r_edx) + + rescue UcError => e + print("ERROR: %s" % e) + end +end + + +def test_i386_invalid_mem_write() + puts("Emulate i386 code that write to invalid memory") + begin + # Initialize emulator in X86-32bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_32 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE32_MEM_WRITE) + + # initialize machine registers + mu.reg_write(UC_X86_REG_ECX, 0x1234) + mu.reg_write(UC_X86_REG_EDX, 0x7890) + + # tracing all basic blocks with customized callback + #mu.hook_add(UC_HOOK_BLOCK, HOOK_BLOCK) + + # tracing all instructions with customized callback + #mu.hook_add(UC_HOOK_CODE, HOOK_CODE) + + # intercept invalid memory events + mu.hook_add(UC_HOOK_MEM_READ_UNMAPPED | UC_HOOK_MEM_WRITE_UNMAPPED, HOOK_MEM_INVALID) + + begin + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE32_MEM_WRITE.bytesize) + rescue UcError => e + puts "ERROR: %s" % e + end + + # now print out some registers + puts ">>> Emulation done. Below is the CPU context" + + r_ecx = mu.reg_read(UC_X86_REG_ECX) + r_edx = mu.reg_read(UC_X86_REG_EDX) + puts ">>> ECX = 0x%x" % r_ecx + puts ">>> EDX = 0x%x" % r_edx + + begin + # read from memory + print ">>> Read 4 bytes from [0x%x] = " % (0xaaaaaaaa) + tmp = mu.mem_read(0xaaaaaaaa, 4) + tmp.each_byte { |i| print(" 0x%x" % i) } + puts + + print ">>> Read 4 bytes from [0x%x] = " % 0xffffffaa + tmp = mu.mem_read(0xffffffaa, 4) + tmp.each_byte { |i| puts(" 0x%x" % i) } + puts + + rescue UcError => e + puts "ERROR: %s" % e + end + + rescue UcError => e + puts "ERROR: %s" % e + end +end + +# Test X86 32 bit with IN/OUT instruction +def test_i386_inout() + puts("Emulate i386 code with IN/OUT instructions") + begin + # Initialize emulator in X86-32bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_32 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE32_INOUT) + + # initialize machine registers + mu.reg_write(UC_X86_REG_EAX, 0x1234) + mu.reg_write(UC_X86_REG_ECX, 0x6789) + + # tracing all basic blocks with customized callback + mu.hook_add(UC_HOOK_BLOCK, HOOK_BLOCK) + + # tracing all instructions with customized callback + mu.hook_add(UC_HOOK_CODE, HOOK_CODE) + + # handle IN & OUT instruction + mu.hook_add(UC_HOOK_INSN, HOOK_IN, nil, 1, 0, UC_X86_INS_IN) + mu.hook_add(UC_HOOK_INSN, HOOK_OUT, nil, 1, 0, UC_X86_INS_OUT) + + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE32_INOUT.bytesize) + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + r_ecx = mu.reg_read(UC_X86_REG_ECX) + r_eax = mu.reg_read(UC_X86_REG_EAX) + puts ">>> EAX = 0x%x" % r_eax + puts ">>> ECX = 0x%x" % r_ecx + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + +def test_x86_64() + puts("Emulate x86_64 code") + begin + # Initialize emulator in X86-64bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_64 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE64) + + # initialize machine registers + mu.reg_write(UC_X86_REG_RAX, 0x71f3029efd49d41d) + mu.reg_write(UC_X86_REG_RBX, 0xd87b45277f133ddb) + mu.reg_write(UC_X86_REG_RCX, 0xab40d1ffd8afc461) + mu.reg_write(UC_X86_REG_RDX, 0x919317b4a733f01) + mu.reg_write(UC_X86_REG_RSI, 0x4c24e753a17ea358) + mu.reg_write(UC_X86_REG_RDI, 0xe509a57d2571ce96) + mu.reg_write(UC_X86_REG_R8, 0xea5b108cc2b9ab1f) + mu.reg_write(UC_X86_REG_R9, 0x19ec097c8eb618c1) + mu.reg_write(UC_X86_REG_R10, 0xec45774f00c5f682) + mu.reg_write(UC_X86_REG_R11, 0xe17e9dbec8c074aa) + mu.reg_write(UC_X86_REG_R12, 0x80f86a8dc0f6d457) + mu.reg_write(UC_X86_REG_R13, 0x48288ca5671c5492) + mu.reg_write(UC_X86_REG_R14, 0x595f72f6e4017f6e) + mu.reg_write(UC_X86_REG_R15, 0x1efd97aea331cccc) + + # setup stack + mu.reg_write(UC_X86_REG_RSP, ADDRESS + 0x200000) + + # tracing all basic blocks with customized callback + mu.hook_add(UC_HOOK_BLOCK, HOOK_BLOCK) + + # tracing all instructions in range [ADDRESS, ADDRESS+20] + mu.hook_add(UC_HOOK_CODE, HOOK_CODE, 0, ADDRESS, ADDRESS+20) + + # tracing all memory READ & WRITE access + mu.hook_add(UC_HOOK_MEM_WRITE, HOOK_MEM_ACCESS) + mu.hook_add(UC_HOOK_MEM_READ, HOOK_MEM_ACCESS) + # actually you can also use READ_WRITE to trace all memory access + #mu.hook_add(UC_HOOK_MEM_READ | UC_HOOK_MEM_WRITE, hook_mem_access) + + begin + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE64.bytesize) + rescue UcError => e + puts("ERROR: %s" % e) + end + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + rax = mu.reg_read(UC_X86_REG_RAX) + rbx = mu.reg_read(UC_X86_REG_RBX) + rcx = mu.reg_read(UC_X86_REG_RCX) + rdx = mu.reg_read(UC_X86_REG_RDX) + rsi = mu.reg_read(UC_X86_REG_RSI) + rdi = mu.reg_read(UC_X86_REG_RDI) + r8 = mu.reg_read(UC_X86_REG_R8) + r9 = mu.reg_read(UC_X86_REG_R9) + r10 = mu.reg_read(UC_X86_REG_R10) + r11 = mu.reg_read(UC_X86_REG_R11) + r12 = mu.reg_read(UC_X86_REG_R12) + r13 = mu.reg_read(UC_X86_REG_R13) + r14 = mu.reg_read(UC_X86_REG_R14) + r15 = mu.reg_read(UC_X86_REG_R15) + + puts(">>> RAX = %d" % rax) + puts(">>> RBX = %d" % rbx) + puts(">>> RCX = %d" % rcx) + puts(">>> RDX = %d" % rdx) + puts(">>> RSI = %d" % rsi) + puts(">>> RDI = %d" % rdi) + puts(">>> R8 = %d" % r8) + puts(">>> R9 = %d" % r9) + puts(">>> R10 = %d" % r10) + puts(">>> R11 = %d" % r11) + puts(">>> R12 = %d" % r12) + puts(">>> R13 = %d" % r13) + puts(">>> R14 = %d" % r14) + puts(">>> R15 = %d" % r15) + #BUG + mu.emu_start(ADDRESS, ADDRESS + X86_CODE64.bytesize) + + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + +def test_x86_64_syscall() + puts("Emulate x86_64 code with 'syscall' instruction") + begin + # Initialize emulator in X86-64bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_64 + + # map 2MB memory for this emulation + mu.mem_map(ADDRESS, 2 * 1024 * 1024) + + # write machine code to be emulated to memory + mu.mem_write(ADDRESS, X86_CODE64_SYSCALL) + + hook_syscall = Proc.new do |mu, user_data| + rax = mu.reg_read(UC_X86_REG_RAX) + if rax == 0x100 + mu.reg_write(UC_X86_REG_RAX, 0x200) + else + puts('ERROR: was not expecting rax=%d in syscall' % rax) + end + end + + # hook interrupts for syscall + mu.hook_add(UC_HOOK_INSN, hook_syscall, nil, 1, 0, UC_X86_INS_SYSCALL) + + # syscall handler is expecting rax=0x100 + mu.reg_write(UC_X86_REG_RAX, 0x100) + + begin + # emulate machine code in infinite time + mu.emu_start(ADDRESS, ADDRESS + X86_CODE64_SYSCALL.bytesize) + rescue UcError => e + puts("ERROR: %s" % e) + end + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + rax = mu.reg_read(UC_X86_REG_RAX) + puts(">>> RAX = 0x%x" % rax) + + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + +def test_x86_16() + puts("Emulate x86 16-bit code") + begin + # Initialize emulator in X86-16bit mode + mu = Uc.new UC_ARCH_X86, UC_MODE_16 + + # map 8KB memory for this emulation + mu.mem_map(0, 8 * 1024) + + # set CPU registers + mu.reg_write(UC_X86_REG_EAX, 7) + mu.reg_write(UC_X86_REG_EBX, 5) + mu.reg_write(UC_X86_REG_ESI, 6) + + # write machine code to be emulated to memory + mu.mem_write(0, X86_CODE16) + + # emulate machine code in infinite time + mu.emu_start(0, X86_CODE16.bytesize) + + # now print out some registers + puts(">>> Emulation done. Below is the CPU context") + + tmp = mu.mem_read(11, 1) + puts("[0x%x] = 0x%x" % [11, tmp[0].ord]) + + rescue UcError => e + puts("ERROR: %s" % e) + end +end + + + test_i386() + puts("=" * 20) + test_i386_loop() + puts("=" * 20) + test_i386_invalid_mem_read() + puts("=" * 20) + test_i386_invalid_mem_write() + puts("=" * 20) + test_i386_inout() + puts("=" * 20) + test_x86_64() + puts("=" * 20) + test_x86_64_syscall() + puts("=" * 20) + test_x86_16() diff --git a/bindings/ruby/unicorn_gem/Gemfile b/bindings/ruby/unicorn_gem/Gemfile new file mode 100644 index 00000000..fa75df15 --- /dev/null +++ b/bindings/ruby/unicorn_gem/Gemfile @@ -0,0 +1,3 @@ +source 'https://rubygems.org' + +gemspec diff --git a/bindings/ruby/unicorn_gem/Rakefile b/bindings/ruby/unicorn_gem/Rakefile new file mode 100644 index 00000000..43022f71 --- /dev/null +++ b/bindings/ruby/unicorn_gem/Rakefile @@ -0,0 +1,2 @@ +require "bundler/gem_tasks" +task :default => :spec diff --git a/bindings/ruby/unicorn_gem/ext/extconf.rb b/bindings/ruby/unicorn_gem/ext/extconf.rb new file mode 100644 index 00000000..cdbfc837 --- /dev/null +++ b/bindings/ruby/unicorn_gem/ext/extconf.rb @@ -0,0 +1,8 @@ +require 'mkmf' + +extension_name = 'unicorn' + +dir_config(extension_name) +have_library('unicorn') + +create_makefile(extension_name) \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/ext/unicorn.c b/bindings/ruby/unicorn_gem/ext/unicorn.c new file mode 100644 index 00000000..09d1d580 --- /dev/null +++ b/bindings/ruby/unicorn_gem/ext/unicorn.c @@ -0,0 +1,454 @@ +/* + +Ruby bindings for the Unicorn Emulator Engine + +Copyright(c) 2016 Sascha Schirra + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +version 2 as published by the Free Software Foundation. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ +#include "ruby.h" +#include +#include +#include "unicorn.h" + +VALUE UnicornModule = Qnil; +VALUE UcClass = Qnil; +VALUE UcError = Qnil; + + + +void Init_unicorn() { + rb_require("unicorn/unicorn_const"); + UnicornModule = rb_define_module("Unicorn"); + UcError = rb_define_class_under(UnicornModule, "UcError", rb_eStandardError); + + UcClass = rb_define_class_under(UnicornModule, "Uc", rb_cObject); + rb_define_method(UcClass, "initialize", m_uc_initialize, 2); + rb_define_method(UcClass, "emu_start", m_uc_emu_start, -1); + rb_define_method(UcClass, "emu_stop", m_uc_emu_stop, 0); + rb_define_method(UcClass, "reg_read", m_uc_reg_read, 1); + rb_define_method(UcClass, "reg_write", m_uc_reg_write, 2); + rb_define_method(UcClass, "mem_read", m_uc_mem_read, 2); + rb_define_method(UcClass, "mem_write", m_uc_mem_write, 2); + rb_define_method(UcClass, "mem_map", m_uc_mem_map, -1); + //rb_define_method(UcClass, "mem_map_ptr", m_uc_mem_map_pzt, 4); + rb_define_method(UcClass, "mem_unmap", m_uc_mem_unmap, 2); + rb_define_method(UcClass, "mem_protect", m_uc_mem_protect, 3); + rb_define_method(UcClass, "hook_add", m_uc_hook_add, -1); + rb_define_method(UcClass, "hook_del", m_uc_hook_del, 1); + rb_define_method(UcClass, "query", m_uc_hook_del, 1); + + +} + +VALUE m_uc_initialize(VALUE self, VALUE arch, VALUE mode) { + uc_engine *_uc; + uc_err err; + err = uc_open(NUM2INT(arch), NUM2INT(mode), &_uc); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + + VALUE uc = Data_Wrap_Struct(UcClass, 0, uc_close, _uc); + rb_iv_set(self, "@uch", uc); + + return self; +} + +VALUE m_uc_emu_start(int argc, VALUE* argv, VALUE self){ + VALUE begin; + VALUE until; + VALUE timeout; + VALUE count; + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + + rb_scan_args(argc, argv, "22",&begin, &until, &timeout, &count); + if (NIL_P(timeout)) + timeout = INT2NUM(0); + + if (NIL_P(count)) + count = INT2NUM(0); + + err = uc_emu_start(_uc, NUM2ULL(begin), NUM2ULL(until), NUM2INT(timeout), NUM2INT(count)); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_emu_stop(VALUE self){ + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + + err = uc_emu_stop(_uc); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_reg_read(VALUE self, VALUE reg_id){ + + uc_err err; + int32_t tmp_reg = NUM2INT(reg_id); + int64_t reg_value = 0; + VALUE to_ret; + uc_x86_mmr mmr; + + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + switch(tmp_reg){ + case UC_X86_REG_GDTR: + case UC_X86_REG_IDTR: + case UC_X86_REG_LDTR: + case UC_X86_REG_TR: + mmr.selector = 0; + mmr.base = 0; + mmr.limit = 0; + mmr.flags = 0; + err = uc_reg_read(_uc, tmp_reg, &mmr); + + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + VALUE mmr_ary = rb_ary_new(); + reg_value = mmr.selector; + rb_ary_store(mmr_ary, 0, UINT2NUM(reg_value)); + rb_ary_store(mmr_ary, 1, ULL2NUM(mmr.base)); + rb_ary_store(mmr_ary, 2, UINT2NUM(mmr.limit)); + rb_ary_store(mmr_ary, 3, UINT2NUM(mmr.flags)); + return mmr_ary; + default: + + err = uc_reg_read(_uc, tmp_reg, ®_value); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return LL2NUM(reg_value); + } + +} + +VALUE m_uc_reg_write(VALUE self, VALUE reg_id, VALUE reg_value){ + uc_err err; + int32_t tmp_reg = NUM2INT(reg_id); + uc_x86_mmr mmr; + int64_t tmp; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + + switch(tmp_reg){ + case UC_X86_REG_GDTR: + case UC_X86_REG_IDTR: + case UC_X86_REG_LDTR: + case UC_X86_REG_TR: + Check_Type(reg_value, T_ARRAY); + + mmr.selector = NUM2USHORT(rb_ary_entry(reg_value,0)); + mmr.base = NUM2ULL(rb_ary_entry(reg_value,1)); + mmr.limit = NUM2UINT(rb_ary_entry(reg_value,2)); + mmr.flags = NUM2UINT(rb_ary_entry(reg_value,3)); + err = uc_reg_write(_uc, tmp_reg, &mmr); + break; + default: + tmp = NUM2ULL(reg_value); + + err = uc_reg_write(_uc, NUM2INT(reg_id), &tmp); + break; + } + + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_mem_read(VALUE self, VALUE address, VALUE size){ + size_t isize = NUM2UINT(size); + uint8_t bytes[isize]; + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + + err = uc_mem_read(_uc, NUM2ULL(address), &bytes, isize); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return rb_str_new(bytes, isize); +} + +VALUE m_uc_mem_write(VALUE self, VALUE address, VALUE bytes){ + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + err = uc_mem_write(_uc, NUM2ULL(address), StringValuePtr(bytes), RSTRING_LEN(bytes)); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_mem_map(int argc, VALUE* argv, VALUE self){ + uc_err err; + VALUE address; + VALUE size; + VALUE perms; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + rb_scan_args(argc, argv, "21",&address, &size, &perms); + if (NIL_P(perms)) + perms = INT2NUM(UC_PROT_ALL); + + err = uc_mem_map(_uc, NUM2ULL(address), NUM2UINT(size), NUM2UINT(perms)); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +// VALUE m_uc_mem_map_ptr(VALUE self, VALUE address, VALUE size, VALUE perms, VALUE ptr){ +// uc_err err; + +// err = uc_mem_map_ptr(_uc, NUM2INT(address), NUM2INT(size), NUM2INT(perms), NUM2INT(ptr)); +// if (err != UC_ERR_OK) { +// rb_raise(UcError, "%s", uc_strerror(err)); +// } +// return Qnil; +// } + +VALUE m_uc_mem_unmap(VALUE self, VALUE address, VALUE size){ + uc_err err; + uc_engine *_uc; + _uc = (uc_engine*) NUM2ULL(rb_iv_get(self, "@uch")); + err = uc_mem_unmap(_uc, NUM2ULL(address), NUM2UINT(size)); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_mem_protect(VALUE self, VALUE address, VALUE size, VALUE perms){ + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + err = uc_mem_protect(_uc, NUM2ULL(address), NUM2UINT(size), NUM2UINT(perms)); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +static void cb_hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + rb_funcall(cb, rb_intern("call"), 4, rUc, ULL2NUM(address), UINT2NUM(size), ud); + +} + +static void cb_hook_mem_access(uc_engine *uc, uint32_t access, uint64_t address, uint32_t size, int64_t value, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + + rb_funcall(cb, rb_intern("call"), 6, rUc, UINT2NUM(access), ULL2NUM(address), UINT2NUM(size), LL2NUM(value), ud); + +} + +static bool cb_hook_mem_invalid(uc_engine *uc, uint32_t access, uint64_t address, uint32_t size, int64_t value, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + return RTEST(rb_funcall(cb, rb_intern("call"), 6, rUc, UINT2NUM(access), ULL2NUM(address), UINT2NUM(size), LL2NUM(value), ud)); +} + +static uint32_t cb_hook_insn_in(uc_engine *uc, uint32_t port, int size, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + return NUM2UINT(rb_funcall(cb, rb_intern("call"), 4, rUc, UINT2NUM(port), INT2NUM(size), ud)); + +} + +static void cb_hook_insn_out(uc_engine *uc, uint32_t port, int size, uint32_t value, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + rb_funcall(cb, rb_intern("call"), 5, rUc, UINT2NUM(port), INT2NUM(size), UINT2NUM(value), ud); + +} + +static void cb_hook_insn_syscall(uc_engine *uc, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + rb_funcall(cb, rb_intern("call"), 2, rUc, ud); + +} + +static void cb_hook_intr(uc_engine *uc, uint64_t address, uint32_t size, int64_t value, void *user_data){ + VALUE passthrough = (VALUE)user_data; + VALUE cb; + VALUE ud; + VALUE rUc; + + cb = rb_ary_entry(passthrough, 0); + ud = rb_ary_entry(passthrough, 1); + rUc = rb_ary_entry(passthrough, 2); + rb_funcall(cb, rb_intern("call"), 5, rUc, ULL2NUM(address), UINT2NUM(size), LL2NUM(value), ud); + +} + + +VALUE m_uc_hook_add(int argc, VALUE* argv, VALUE self){ + VALUE hook_type; + VALUE callback; + VALUE user_data; + VALUE begin; + VALUE end; + VALUE arg1; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + rb_scan_args(argc, argv, "24",&hook_type, &callback, &user_data, &begin, &end, &arg1); + if (NIL_P(begin)) + begin = ULL2NUM(1); + + if (NIL_P(end)) + end = ULL2NUM(0); + + if (NIL_P(arg1)) + arg1 = INT2NUM(0); + + + VALUE passthrough; + uc_hook trace; + uc_err err; + + + if (rb_class_of(callback) != rb_cProc) + rb_raise(UcError, "Expected Proc callback"); + + passthrough = rb_ary_new(); + rb_ary_store(passthrough, 0, callback); + rb_ary_store(passthrough, 1, user_data); + rb_ary_store(passthrough, 2, self); + + uint32_t htype = NUM2UINT(hook_type); + if(htype == UC_HOOK_INSN){ + + switch(NUM2INT(arg1)){ + case UC_X86_INS_IN: + err = uc_hook_add(_uc, &trace, htype, cb_hook_insn_in,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end), NUM2INT(arg1)); + break; + case UC_X86_INS_OUT: + err = uc_hook_add(_uc, &trace, htype, cb_hook_insn_out,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end), NUM2INT(arg1)); + break; + case UC_X86_INS_SYSCALL: + case UC_X86_INS_SYSENTER: + err = uc_hook_add(_uc, &trace, htype, cb_hook_insn_syscall,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end), NUM2INT(arg1)); + break; + } + err = uc_hook_add(_uc, &trace, htype, cb_hook_intr,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end)); + } + else if(htype == UC_HOOK_INTR){ + err = uc_hook_add(_uc, &trace, htype, cb_hook_intr,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end)); + } + else if(htype == UC_HOOK_CODE || htype == UC_HOOK_BLOCK){ + + err = uc_hook_add(_uc, &trace, htype, cb_hook_code,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end)); + } + else if (htype & UC_HOOK_MEM_READ_UNMAPPED + || htype & UC_HOOK_MEM_WRITE_UNMAPPED + || htype & UC_HOOK_MEM_FETCH_UNMAPPED + || htype & UC_HOOK_MEM_READ_PROT + || htype & UC_HOOK_MEM_WRITE_PROT + || htype & UC_HOOK_MEM_FETCH_PROT + || htype & UC_HOOK_MEM_READ_INVALID + || htype & UC_HOOK_MEM_WRITE_INVALID + || htype & UC_HOOK_MEM_FETCH_INVALID + || htype & UC_HOOK_MEM_UNMAPPED + || htype & UC_HOOK_MEM_PROT + || htype & UC_HOOK_MEM_INVALID) { + err = uc_hook_add(_uc, &trace, htype, cb_hook_mem_invalid,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end)); + } + else{ + err = uc_hook_add(_uc, &trace, htype, cb_hook_mem_access,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end)); + } + + + + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return INT2NUM(trace); +} + +VALUE m_uc_hook_del(VALUE self, VALUE hook){ + int h = NUM2INT(hook); + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + err = uc_hook_del(_uc, h); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return Qnil; +} + +VALUE m_uc_query(VALUE self, VALUE query_mode){ + int qm = NUM2INT(query_mode); + size_t result; + uc_err err; + uc_engine *_uc; + Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc); + err = uc_query(_uc, qm, &result); + if (err != UC_ERR_OK) { + rb_raise(UcError, "%s", uc_strerror(err)); + } + return INT2NUM(result); +} diff --git a/bindings/ruby/unicorn_gem/ext/unicorn.h b/bindings/ruby/unicorn_gem/ext/unicorn.h new file mode 100644 index 00000000..30b417d9 --- /dev/null +++ b/bindings/ruby/unicorn_gem/ext/unicorn.h @@ -0,0 +1,34 @@ +/* + +Ruby bindings for the Unicorn Emulator Engine + +Copyright(c) 2016 Sascha Schirra + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +version 2 as published by the Free Software Foundation. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +*/ +VALUE m_uc_initialize(VALUE self, VALUE arch, VALUE mode); +VALUE m_uc_emu_start(int argc, VALUE* argv, VALUE self); +VALUE m_uc_emu_stop(VALUE self); +VALUE m_uc_reg_read(VALUE self, VALUE reg_id); +VALUE m_uc_reg_write(VALUE self, VALUE reg_id, VALUE reg_value); +VALUE m_uc_mem_read(VALUE self, VALUE address, VALUE size); +VALUE m_uc_mem_write(VALUE self, VALUE address, VALUE bytes); +VALUE m_uc_mem_map(int argc, VALUE* argv, VALUE self); +//VALUE m_uc_mem_map_ptr(VALUE self, VALUE address, VALUE size, VALUE perms, VALUE ptr); +VALUE m_uc_mem_unmap(VALUE self, VALUE address, VALUE size); +VALUE m_uc_mem_protect(VALUE self, VALUE address, VALUE size, VALUE perms); +VALUE m_uc_hook_add(int argc, VALUE* argv, VALUE self); +VALUE m_uc_hook_del(VALUE self, VALUE hook); +VALUE m_uc_query(VALUE self, VALUE query_mode); \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/arm64_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/arm64_const.rb new file mode 100644 index 00000000..7767d96b --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/arm64_const.rb @@ -0,0 +1,277 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [arm64_const.rb] + +module Unicorn + +# ARM64 registers + + UC_ARM64_REG_INVALID = 0 + UC_ARM64_REG_X29 = 1 + UC_ARM64_REG_X30 = 2 + UC_ARM64_REG_NZCV = 3 + UC_ARM64_REG_SP = 4 + UC_ARM64_REG_WSP = 5 + UC_ARM64_REG_WZR = 6 + UC_ARM64_REG_XZR = 7 + UC_ARM64_REG_B0 = 8 + UC_ARM64_REG_B1 = 9 + UC_ARM64_REG_B2 = 10 + UC_ARM64_REG_B3 = 11 + UC_ARM64_REG_B4 = 12 + UC_ARM64_REG_B5 = 13 + UC_ARM64_REG_B6 = 14 + UC_ARM64_REG_B7 = 15 + UC_ARM64_REG_B8 = 16 + UC_ARM64_REG_B9 = 17 + UC_ARM64_REG_B10 = 18 + UC_ARM64_REG_B11 = 19 + UC_ARM64_REG_B12 = 20 + UC_ARM64_REG_B13 = 21 + UC_ARM64_REG_B14 = 22 + UC_ARM64_REG_B15 = 23 + UC_ARM64_REG_B16 = 24 + UC_ARM64_REG_B17 = 25 + UC_ARM64_REG_B18 = 26 + UC_ARM64_REG_B19 = 27 + UC_ARM64_REG_B20 = 28 + UC_ARM64_REG_B21 = 29 + UC_ARM64_REG_B22 = 30 + UC_ARM64_REG_B23 = 31 + UC_ARM64_REG_B24 = 32 + UC_ARM64_REG_B25 = 33 + UC_ARM64_REG_B26 = 34 + UC_ARM64_REG_B27 = 35 + UC_ARM64_REG_B28 = 36 + UC_ARM64_REG_B29 = 37 + UC_ARM64_REG_B30 = 38 + UC_ARM64_REG_B31 = 39 + UC_ARM64_REG_D0 = 40 + UC_ARM64_REG_D1 = 41 + UC_ARM64_REG_D2 = 42 + UC_ARM64_REG_D3 = 43 + UC_ARM64_REG_D4 = 44 + UC_ARM64_REG_D5 = 45 + UC_ARM64_REG_D6 = 46 + UC_ARM64_REG_D7 = 47 + UC_ARM64_REG_D8 = 48 + UC_ARM64_REG_D9 = 49 + UC_ARM64_REG_D10 = 50 + UC_ARM64_REG_D11 = 51 + UC_ARM64_REG_D12 = 52 + UC_ARM64_REG_D13 = 53 + UC_ARM64_REG_D14 = 54 + UC_ARM64_REG_D15 = 55 + UC_ARM64_REG_D16 = 56 + UC_ARM64_REG_D17 = 57 + UC_ARM64_REG_D18 = 58 + UC_ARM64_REG_D19 = 59 + UC_ARM64_REG_D20 = 60 + UC_ARM64_REG_D21 = 61 + UC_ARM64_REG_D22 = 62 + UC_ARM64_REG_D23 = 63 + UC_ARM64_REG_D24 = 64 + UC_ARM64_REG_D25 = 65 + UC_ARM64_REG_D26 = 66 + UC_ARM64_REG_D27 = 67 + UC_ARM64_REG_D28 = 68 + UC_ARM64_REG_D29 = 69 + UC_ARM64_REG_D30 = 70 + UC_ARM64_REG_D31 = 71 + UC_ARM64_REG_H0 = 72 + UC_ARM64_REG_H1 = 73 + UC_ARM64_REG_H2 = 74 + UC_ARM64_REG_H3 = 75 + UC_ARM64_REG_H4 = 76 + UC_ARM64_REG_H5 = 77 + UC_ARM64_REG_H6 = 78 + UC_ARM64_REG_H7 = 79 + UC_ARM64_REG_H8 = 80 + UC_ARM64_REG_H9 = 81 + UC_ARM64_REG_H10 = 82 + UC_ARM64_REG_H11 = 83 + UC_ARM64_REG_H12 = 84 + UC_ARM64_REG_H13 = 85 + UC_ARM64_REG_H14 = 86 + UC_ARM64_REG_H15 = 87 + UC_ARM64_REG_H16 = 88 + UC_ARM64_REG_H17 = 89 + UC_ARM64_REG_H18 = 90 + UC_ARM64_REG_H19 = 91 + UC_ARM64_REG_H20 = 92 + UC_ARM64_REG_H21 = 93 + UC_ARM64_REG_H22 = 94 + UC_ARM64_REG_H23 = 95 + UC_ARM64_REG_H24 = 96 + UC_ARM64_REG_H25 = 97 + UC_ARM64_REG_H26 = 98 + UC_ARM64_REG_H27 = 99 + UC_ARM64_REG_H28 = 100 + UC_ARM64_REG_H29 = 101 + UC_ARM64_REG_H30 = 102 + UC_ARM64_REG_H31 = 103 + UC_ARM64_REG_Q0 = 104 + UC_ARM64_REG_Q1 = 105 + UC_ARM64_REG_Q2 = 106 + UC_ARM64_REG_Q3 = 107 + UC_ARM64_REG_Q4 = 108 + UC_ARM64_REG_Q5 = 109 + UC_ARM64_REG_Q6 = 110 + UC_ARM64_REG_Q7 = 111 + UC_ARM64_REG_Q8 = 112 + UC_ARM64_REG_Q9 = 113 + UC_ARM64_REG_Q10 = 114 + UC_ARM64_REG_Q11 = 115 + UC_ARM64_REG_Q12 = 116 + UC_ARM64_REG_Q13 = 117 + UC_ARM64_REG_Q14 = 118 + UC_ARM64_REG_Q15 = 119 + UC_ARM64_REG_Q16 = 120 + UC_ARM64_REG_Q17 = 121 + UC_ARM64_REG_Q18 = 122 + UC_ARM64_REG_Q19 = 123 + UC_ARM64_REG_Q20 = 124 + UC_ARM64_REG_Q21 = 125 + UC_ARM64_REG_Q22 = 126 + UC_ARM64_REG_Q23 = 127 + UC_ARM64_REG_Q24 = 128 + UC_ARM64_REG_Q25 = 129 + UC_ARM64_REG_Q26 = 130 + UC_ARM64_REG_Q27 = 131 + UC_ARM64_REG_Q28 = 132 + UC_ARM64_REG_Q29 = 133 + UC_ARM64_REG_Q30 = 134 + UC_ARM64_REG_Q31 = 135 + UC_ARM64_REG_S0 = 136 + UC_ARM64_REG_S1 = 137 + UC_ARM64_REG_S2 = 138 + UC_ARM64_REG_S3 = 139 + UC_ARM64_REG_S4 = 140 + UC_ARM64_REG_S5 = 141 + UC_ARM64_REG_S6 = 142 + UC_ARM64_REG_S7 = 143 + UC_ARM64_REG_S8 = 144 + UC_ARM64_REG_S9 = 145 + UC_ARM64_REG_S10 = 146 + UC_ARM64_REG_S11 = 147 + UC_ARM64_REG_S12 = 148 + UC_ARM64_REG_S13 = 149 + UC_ARM64_REG_S14 = 150 + UC_ARM64_REG_S15 = 151 + UC_ARM64_REG_S16 = 152 + UC_ARM64_REG_S17 = 153 + UC_ARM64_REG_S18 = 154 + UC_ARM64_REG_S19 = 155 + UC_ARM64_REG_S20 = 156 + UC_ARM64_REG_S21 = 157 + UC_ARM64_REG_S22 = 158 + UC_ARM64_REG_S23 = 159 + UC_ARM64_REG_S24 = 160 + UC_ARM64_REG_S25 = 161 + UC_ARM64_REG_S26 = 162 + UC_ARM64_REG_S27 = 163 + UC_ARM64_REG_S28 = 164 + UC_ARM64_REG_S29 = 165 + UC_ARM64_REG_S30 = 166 + UC_ARM64_REG_S31 = 167 + UC_ARM64_REG_W0 = 168 + UC_ARM64_REG_W1 = 169 + UC_ARM64_REG_W2 = 170 + UC_ARM64_REG_W3 = 171 + UC_ARM64_REG_W4 = 172 + UC_ARM64_REG_W5 = 173 + UC_ARM64_REG_W6 = 174 + UC_ARM64_REG_W7 = 175 + UC_ARM64_REG_W8 = 176 + UC_ARM64_REG_W9 = 177 + UC_ARM64_REG_W10 = 178 + UC_ARM64_REG_W11 = 179 + UC_ARM64_REG_W12 = 180 + UC_ARM64_REG_W13 = 181 + UC_ARM64_REG_W14 = 182 + UC_ARM64_REG_W15 = 183 + UC_ARM64_REG_W16 = 184 + UC_ARM64_REG_W17 = 185 + UC_ARM64_REG_W18 = 186 + UC_ARM64_REG_W19 = 187 + UC_ARM64_REG_W20 = 188 + UC_ARM64_REG_W21 = 189 + UC_ARM64_REG_W22 = 190 + UC_ARM64_REG_W23 = 191 + UC_ARM64_REG_W24 = 192 + UC_ARM64_REG_W25 = 193 + UC_ARM64_REG_W26 = 194 + UC_ARM64_REG_W27 = 195 + UC_ARM64_REG_W28 = 196 + UC_ARM64_REG_W29 = 197 + UC_ARM64_REG_W30 = 198 + UC_ARM64_REG_X0 = 199 + UC_ARM64_REG_X1 = 200 + UC_ARM64_REG_X2 = 201 + UC_ARM64_REG_X3 = 202 + UC_ARM64_REG_X4 = 203 + UC_ARM64_REG_X5 = 204 + UC_ARM64_REG_X6 = 205 + UC_ARM64_REG_X7 = 206 + UC_ARM64_REG_X8 = 207 + UC_ARM64_REG_X9 = 208 + UC_ARM64_REG_X10 = 209 + UC_ARM64_REG_X11 = 210 + UC_ARM64_REG_X12 = 211 + UC_ARM64_REG_X13 = 212 + UC_ARM64_REG_X14 = 213 + UC_ARM64_REG_X15 = 214 + UC_ARM64_REG_X16 = 215 + UC_ARM64_REG_X17 = 216 + UC_ARM64_REG_X18 = 217 + UC_ARM64_REG_X19 = 218 + UC_ARM64_REG_X20 = 219 + UC_ARM64_REG_X21 = 220 + UC_ARM64_REG_X22 = 221 + UC_ARM64_REG_X23 = 222 + UC_ARM64_REG_X24 = 223 + UC_ARM64_REG_X25 = 224 + UC_ARM64_REG_X26 = 225 + UC_ARM64_REG_X27 = 226 + UC_ARM64_REG_X28 = 227 + UC_ARM64_REG_V0 = 228 + UC_ARM64_REG_V1 = 229 + UC_ARM64_REG_V2 = 230 + UC_ARM64_REG_V3 = 231 + UC_ARM64_REG_V4 = 232 + UC_ARM64_REG_V5 = 233 + UC_ARM64_REG_V6 = 234 + UC_ARM64_REG_V7 = 235 + UC_ARM64_REG_V8 = 236 + UC_ARM64_REG_V9 = 237 + UC_ARM64_REG_V10 = 238 + UC_ARM64_REG_V11 = 239 + UC_ARM64_REG_V12 = 240 + UC_ARM64_REG_V13 = 241 + UC_ARM64_REG_V14 = 242 + UC_ARM64_REG_V15 = 243 + UC_ARM64_REG_V16 = 244 + UC_ARM64_REG_V17 = 245 + UC_ARM64_REG_V18 = 246 + UC_ARM64_REG_V19 = 247 + UC_ARM64_REG_V20 = 248 + UC_ARM64_REG_V21 = 249 + UC_ARM64_REG_V22 = 250 + UC_ARM64_REG_V23 = 251 + UC_ARM64_REG_V24 = 252 + UC_ARM64_REG_V25 = 253 + UC_ARM64_REG_V26 = 254 + UC_ARM64_REG_V27 = 255 + UC_ARM64_REG_V28 = 256 + UC_ARM64_REG_V29 = 257 + UC_ARM64_REG_V30 = 258 + UC_ARM64_REG_V31 = 259 + +# pseudo registers + UC_ARM64_REG_PC = 260 + UC_ARM64_REG_ENDING = 261 + +# alias registers + UC_ARM64_REG_IP1 = 215 + UC_ARM64_REG_IP0 = 216 + UC_ARM64_REG_FP = 1 + UC_ARM64_REG_LR = 2 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/arm_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/arm_const.rb new file mode 100644 index 00000000..2a80d44c --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/arm_const.rb @@ -0,0 +1,128 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [arm_const.rb] + +module Unicorn + +# ARM registers + + UC_ARM_REG_INVALID = 0 + UC_ARM_REG_APSR = 1 + UC_ARM_REG_APSR_NZCV = 2 + UC_ARM_REG_CPSR = 3 + UC_ARM_REG_FPEXC = 4 + UC_ARM_REG_FPINST = 5 + UC_ARM_REG_FPSCR = 6 + UC_ARM_REG_FPSCR_NZCV = 7 + UC_ARM_REG_FPSID = 8 + UC_ARM_REG_ITSTATE = 9 + UC_ARM_REG_LR = 10 + UC_ARM_REG_PC = 11 + UC_ARM_REG_SP = 12 + UC_ARM_REG_SPSR = 13 + UC_ARM_REG_D0 = 14 + UC_ARM_REG_D1 = 15 + UC_ARM_REG_D2 = 16 + UC_ARM_REG_D3 = 17 + UC_ARM_REG_D4 = 18 + UC_ARM_REG_D5 = 19 + UC_ARM_REG_D6 = 20 + UC_ARM_REG_D7 = 21 + UC_ARM_REG_D8 = 22 + UC_ARM_REG_D9 = 23 + UC_ARM_REG_D10 = 24 + UC_ARM_REG_D11 = 25 + UC_ARM_REG_D12 = 26 + UC_ARM_REG_D13 = 27 + UC_ARM_REG_D14 = 28 + UC_ARM_REG_D15 = 29 + UC_ARM_REG_D16 = 30 + UC_ARM_REG_D17 = 31 + UC_ARM_REG_D18 = 32 + UC_ARM_REG_D19 = 33 + UC_ARM_REG_D20 = 34 + UC_ARM_REG_D21 = 35 + UC_ARM_REG_D22 = 36 + UC_ARM_REG_D23 = 37 + UC_ARM_REG_D24 = 38 + UC_ARM_REG_D25 = 39 + UC_ARM_REG_D26 = 40 + UC_ARM_REG_D27 = 41 + UC_ARM_REG_D28 = 42 + UC_ARM_REG_D29 = 43 + UC_ARM_REG_D30 = 44 + UC_ARM_REG_D31 = 45 + UC_ARM_REG_FPINST2 = 46 + UC_ARM_REG_MVFR0 = 47 + UC_ARM_REG_MVFR1 = 48 + UC_ARM_REG_MVFR2 = 49 + UC_ARM_REG_Q0 = 50 + UC_ARM_REG_Q1 = 51 + UC_ARM_REG_Q2 = 52 + UC_ARM_REG_Q3 = 53 + UC_ARM_REG_Q4 = 54 + UC_ARM_REG_Q5 = 55 + UC_ARM_REG_Q6 = 56 + UC_ARM_REG_Q7 = 57 + UC_ARM_REG_Q8 = 58 + UC_ARM_REG_Q9 = 59 + UC_ARM_REG_Q10 = 60 + UC_ARM_REG_Q11 = 61 + UC_ARM_REG_Q12 = 62 + UC_ARM_REG_Q13 = 63 + UC_ARM_REG_Q14 = 64 + UC_ARM_REG_Q15 = 65 + UC_ARM_REG_R0 = 66 + UC_ARM_REG_R1 = 67 + UC_ARM_REG_R2 = 68 + UC_ARM_REG_R3 = 69 + UC_ARM_REG_R4 = 70 + UC_ARM_REG_R5 = 71 + UC_ARM_REG_R6 = 72 + UC_ARM_REG_R7 = 73 + UC_ARM_REG_R8 = 74 + UC_ARM_REG_R9 = 75 + UC_ARM_REG_R10 = 76 + UC_ARM_REG_R11 = 77 + UC_ARM_REG_R12 = 78 + UC_ARM_REG_S0 = 79 + UC_ARM_REG_S1 = 80 + UC_ARM_REG_S2 = 81 + UC_ARM_REG_S3 = 82 + UC_ARM_REG_S4 = 83 + UC_ARM_REG_S5 = 84 + UC_ARM_REG_S6 = 85 + UC_ARM_REG_S7 = 86 + UC_ARM_REG_S8 = 87 + UC_ARM_REG_S9 = 88 + UC_ARM_REG_S10 = 89 + UC_ARM_REG_S11 = 90 + UC_ARM_REG_S12 = 91 + UC_ARM_REG_S13 = 92 + UC_ARM_REG_S14 = 93 + UC_ARM_REG_S15 = 94 + UC_ARM_REG_S16 = 95 + UC_ARM_REG_S17 = 96 + UC_ARM_REG_S18 = 97 + UC_ARM_REG_S19 = 98 + UC_ARM_REG_S20 = 99 + UC_ARM_REG_S21 = 100 + UC_ARM_REG_S22 = 101 + UC_ARM_REG_S23 = 102 + UC_ARM_REG_S24 = 103 + UC_ARM_REG_S25 = 104 + UC_ARM_REG_S26 = 105 + UC_ARM_REG_S27 = 106 + UC_ARM_REG_S28 = 107 + UC_ARM_REG_S29 = 108 + UC_ARM_REG_S30 = 109 + UC_ARM_REG_S31 = 110 + UC_ARM_REG_ENDING = 111 + +# alias registers + UC_ARM_REG_R13 = 12 + UC_ARM_REG_R14 = 10 + UC_ARM_REG_R15 = 11 + UC_ARM_REG_SB = 75 + UC_ARM_REG_SL = 76 + UC_ARM_REG_FP = 77 + UC_ARM_REG_IP = 78 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/m68k_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/m68k_const.rb new file mode 100644 index 00000000..2c53636d --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/m68k_const.rb @@ -0,0 +1,27 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [m68k_const.rb] + +module Unicorn + +# M68K registers + + UC_M68K_REG_INVALID = 0 + UC_M68K_REG_A0 = 1 + UC_M68K_REG_A1 = 2 + UC_M68K_REG_A2 = 3 + UC_M68K_REG_A3 = 4 + UC_M68K_REG_A4 = 5 + UC_M68K_REG_A5 = 6 + UC_M68K_REG_A6 = 7 + UC_M68K_REG_A7 = 8 + UC_M68K_REG_D0 = 9 + UC_M68K_REG_D1 = 10 + UC_M68K_REG_D2 = 11 + UC_M68K_REG_D3 = 12 + UC_M68K_REG_D4 = 13 + UC_M68K_REG_D5 = 14 + UC_M68K_REG_D6 = 15 + UC_M68K_REG_D7 = 16 + UC_M68K_REG_SR = 17 + UC_M68K_REG_PC = 18 + UC_M68K_REG_ENDING = 19 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/mips_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/mips_const.rb new file mode 100644 index 00000000..d92e94e5 --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/mips_const.rb @@ -0,0 +1,198 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [mips_const.rb] + +module Unicorn + +# MIPS registers + + UC_MIPS_REG_INVALID = 0 + +# General purpose registers + UC_MIPS_REG_PC = 1 + UC_MIPS_REG_0 = 2 + UC_MIPS_REG_1 = 3 + UC_MIPS_REG_2 = 4 + UC_MIPS_REG_3 = 5 + UC_MIPS_REG_4 = 6 + UC_MIPS_REG_5 = 7 + UC_MIPS_REG_6 = 8 + UC_MIPS_REG_7 = 9 + UC_MIPS_REG_8 = 10 + UC_MIPS_REG_9 = 11 + UC_MIPS_REG_10 = 12 + UC_MIPS_REG_11 = 13 + UC_MIPS_REG_12 = 14 + UC_MIPS_REG_13 = 15 + UC_MIPS_REG_14 = 16 + UC_MIPS_REG_15 = 17 + UC_MIPS_REG_16 = 18 + UC_MIPS_REG_17 = 19 + UC_MIPS_REG_18 = 20 + UC_MIPS_REG_19 = 21 + UC_MIPS_REG_20 = 22 + UC_MIPS_REG_21 = 23 + UC_MIPS_REG_22 = 24 + UC_MIPS_REG_23 = 25 + UC_MIPS_REG_24 = 26 + UC_MIPS_REG_25 = 27 + UC_MIPS_REG_26 = 28 + UC_MIPS_REG_27 = 29 + UC_MIPS_REG_28 = 30 + UC_MIPS_REG_29 = 31 + UC_MIPS_REG_30 = 32 + UC_MIPS_REG_31 = 33 + +# DSP registers + UC_MIPS_REG_DSPCCOND = 34 + UC_MIPS_REG_DSPCARRY = 35 + UC_MIPS_REG_DSPEFI = 36 + UC_MIPS_REG_DSPOUTFLAG = 37 + UC_MIPS_REG_DSPOUTFLAG16_19 = 38 + UC_MIPS_REG_DSPOUTFLAG20 = 39 + UC_MIPS_REG_DSPOUTFLAG21 = 40 + UC_MIPS_REG_DSPOUTFLAG22 = 41 + UC_MIPS_REG_DSPOUTFLAG23 = 42 + UC_MIPS_REG_DSPPOS = 43 + UC_MIPS_REG_DSPSCOUNT = 44 + +# ACC registers + UC_MIPS_REG_AC0 = 45 + UC_MIPS_REG_AC1 = 46 + UC_MIPS_REG_AC2 = 47 + UC_MIPS_REG_AC3 = 48 + +# COP registers + UC_MIPS_REG_CC0 = 49 + UC_MIPS_REG_CC1 = 50 + UC_MIPS_REG_CC2 = 51 + UC_MIPS_REG_CC3 = 52 + UC_MIPS_REG_CC4 = 53 + UC_MIPS_REG_CC5 = 54 + UC_MIPS_REG_CC6 = 55 + UC_MIPS_REG_CC7 = 56 + +# FPU registers + UC_MIPS_REG_F0 = 57 + UC_MIPS_REG_F1 = 58 + UC_MIPS_REG_F2 = 59 + UC_MIPS_REG_F3 = 60 + UC_MIPS_REG_F4 = 61 + UC_MIPS_REG_F5 = 62 + UC_MIPS_REG_F6 = 63 + UC_MIPS_REG_F7 = 64 + UC_MIPS_REG_F8 = 65 + UC_MIPS_REG_F9 = 66 + UC_MIPS_REG_F10 = 67 + UC_MIPS_REG_F11 = 68 + UC_MIPS_REG_F12 = 69 + UC_MIPS_REG_F13 = 70 + UC_MIPS_REG_F14 = 71 + UC_MIPS_REG_F15 = 72 + UC_MIPS_REG_F16 = 73 + UC_MIPS_REG_F17 = 74 + UC_MIPS_REG_F18 = 75 + UC_MIPS_REG_F19 = 76 + UC_MIPS_REG_F20 = 77 + UC_MIPS_REG_F21 = 78 + UC_MIPS_REG_F22 = 79 + UC_MIPS_REG_F23 = 80 + UC_MIPS_REG_F24 = 81 + UC_MIPS_REG_F25 = 82 + UC_MIPS_REG_F26 = 83 + UC_MIPS_REG_F27 = 84 + UC_MIPS_REG_F28 = 85 + UC_MIPS_REG_F29 = 86 + UC_MIPS_REG_F30 = 87 + UC_MIPS_REG_F31 = 88 + UC_MIPS_REG_FCC0 = 89 + UC_MIPS_REG_FCC1 = 90 + UC_MIPS_REG_FCC2 = 91 + UC_MIPS_REG_FCC3 = 92 + UC_MIPS_REG_FCC4 = 93 + UC_MIPS_REG_FCC5 = 94 + UC_MIPS_REG_FCC6 = 95 + UC_MIPS_REG_FCC7 = 96 + +# AFPR128 + UC_MIPS_REG_W0 = 97 + UC_MIPS_REG_W1 = 98 + UC_MIPS_REG_W2 = 99 + UC_MIPS_REG_W3 = 100 + UC_MIPS_REG_W4 = 101 + UC_MIPS_REG_W5 = 102 + UC_MIPS_REG_W6 = 103 + UC_MIPS_REG_W7 = 104 + UC_MIPS_REG_W8 = 105 + UC_MIPS_REG_W9 = 106 + UC_MIPS_REG_W10 = 107 + UC_MIPS_REG_W11 = 108 + UC_MIPS_REG_W12 = 109 + UC_MIPS_REG_W13 = 110 + UC_MIPS_REG_W14 = 111 + UC_MIPS_REG_W15 = 112 + UC_MIPS_REG_W16 = 113 + UC_MIPS_REG_W17 = 114 + UC_MIPS_REG_W18 = 115 + UC_MIPS_REG_W19 = 116 + UC_MIPS_REG_W20 = 117 + UC_MIPS_REG_W21 = 118 + UC_MIPS_REG_W22 = 119 + UC_MIPS_REG_W23 = 120 + UC_MIPS_REG_W24 = 121 + UC_MIPS_REG_W25 = 122 + UC_MIPS_REG_W26 = 123 + UC_MIPS_REG_W27 = 124 + UC_MIPS_REG_W28 = 125 + UC_MIPS_REG_W29 = 126 + UC_MIPS_REG_W30 = 127 + UC_MIPS_REG_W31 = 128 + UC_MIPS_REG_HI = 129 + UC_MIPS_REG_LO = 130 + UC_MIPS_REG_P0 = 131 + UC_MIPS_REG_P1 = 132 + UC_MIPS_REG_P2 = 133 + UC_MIPS_REG_MPL0 = 134 + UC_MIPS_REG_MPL1 = 135 + UC_MIPS_REG_MPL2 = 136 + UC_MIPS_REG_ENDING = 137 + UC_MIPS_REG_ZERO = 2 + UC_MIPS_REG_AT = 3 + UC_MIPS_REG_V0 = 4 + UC_MIPS_REG_V1 = 5 + UC_MIPS_REG_A0 = 6 + UC_MIPS_REG_A1 = 7 + UC_MIPS_REG_A2 = 8 + UC_MIPS_REG_A3 = 9 + UC_MIPS_REG_T0 = 10 + UC_MIPS_REG_T1 = 11 + UC_MIPS_REG_T2 = 12 + UC_MIPS_REG_T3 = 13 + UC_MIPS_REG_T4 = 14 + UC_MIPS_REG_T5 = 15 + UC_MIPS_REG_T6 = 16 + UC_MIPS_REG_T7 = 17 + UC_MIPS_REG_S0 = 18 + UC_MIPS_REG_S1 = 19 + UC_MIPS_REG_S2 = 20 + UC_MIPS_REG_S3 = 21 + UC_MIPS_REG_S4 = 22 + UC_MIPS_REG_S5 = 23 + UC_MIPS_REG_S6 = 24 + UC_MIPS_REG_S7 = 25 + UC_MIPS_REG_T8 = 26 + UC_MIPS_REG_T9 = 27 + UC_MIPS_REG_K0 = 28 + UC_MIPS_REG_K1 = 29 + UC_MIPS_REG_GP = 30 + UC_MIPS_REG_SP = 31 + UC_MIPS_REG_FP = 32 + UC_MIPS_REG_S8 = 32 + UC_MIPS_REG_RA = 33 + UC_MIPS_REG_HI0 = 45 + UC_MIPS_REG_HI1 = 46 + UC_MIPS_REG_HI2 = 47 + UC_MIPS_REG_HI3 = 48 + UC_MIPS_REG_LO0 = 45 + UC_MIPS_REG_LO1 = 46 + UC_MIPS_REG_LO2 = 47 + UC_MIPS_REG_LO3 = 48 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/sparc_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/sparc_const.rb new file mode 100644 index 00000000..85d9eef1 --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/sparc_const.rb @@ -0,0 +1,99 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [sparc_const.rb] + +module Unicorn + +# SPARC registers + + UC_SPARC_REG_INVALID = 0 + UC_SPARC_REG_F0 = 1 + UC_SPARC_REG_F1 = 2 + UC_SPARC_REG_F2 = 3 + UC_SPARC_REG_F3 = 4 + UC_SPARC_REG_F4 = 5 + UC_SPARC_REG_F5 = 6 + UC_SPARC_REG_F6 = 7 + UC_SPARC_REG_F7 = 8 + UC_SPARC_REG_F8 = 9 + UC_SPARC_REG_F9 = 10 + UC_SPARC_REG_F10 = 11 + UC_SPARC_REG_F11 = 12 + UC_SPARC_REG_F12 = 13 + UC_SPARC_REG_F13 = 14 + UC_SPARC_REG_F14 = 15 + UC_SPARC_REG_F15 = 16 + UC_SPARC_REG_F16 = 17 + UC_SPARC_REG_F17 = 18 + UC_SPARC_REG_F18 = 19 + UC_SPARC_REG_F19 = 20 + UC_SPARC_REG_F20 = 21 + UC_SPARC_REG_F21 = 22 + UC_SPARC_REG_F22 = 23 + UC_SPARC_REG_F23 = 24 + UC_SPARC_REG_F24 = 25 + UC_SPARC_REG_F25 = 26 + UC_SPARC_REG_F26 = 27 + UC_SPARC_REG_F27 = 28 + UC_SPARC_REG_F28 = 29 + UC_SPARC_REG_F29 = 30 + UC_SPARC_REG_F30 = 31 + UC_SPARC_REG_F31 = 32 + UC_SPARC_REG_F32 = 33 + UC_SPARC_REG_F34 = 34 + UC_SPARC_REG_F36 = 35 + UC_SPARC_REG_F38 = 36 + UC_SPARC_REG_F40 = 37 + UC_SPARC_REG_F42 = 38 + UC_SPARC_REG_F44 = 39 + UC_SPARC_REG_F46 = 40 + UC_SPARC_REG_F48 = 41 + UC_SPARC_REG_F50 = 42 + UC_SPARC_REG_F52 = 43 + UC_SPARC_REG_F54 = 44 + UC_SPARC_REG_F56 = 45 + UC_SPARC_REG_F58 = 46 + UC_SPARC_REG_F60 = 47 + UC_SPARC_REG_F62 = 48 + UC_SPARC_REG_FCC0 = 49 + UC_SPARC_REG_FCC1 = 50 + UC_SPARC_REG_FCC2 = 51 + UC_SPARC_REG_FCC3 = 52 + UC_SPARC_REG_G0 = 53 + UC_SPARC_REG_G1 = 54 + UC_SPARC_REG_G2 = 55 + UC_SPARC_REG_G3 = 56 + UC_SPARC_REG_G4 = 57 + UC_SPARC_REG_G5 = 58 + UC_SPARC_REG_G6 = 59 + UC_SPARC_REG_G7 = 60 + UC_SPARC_REG_I0 = 61 + UC_SPARC_REG_I1 = 62 + UC_SPARC_REG_I2 = 63 + UC_SPARC_REG_I3 = 64 + UC_SPARC_REG_I4 = 65 + UC_SPARC_REG_I5 = 66 + UC_SPARC_REG_FP = 67 + UC_SPARC_REG_I7 = 68 + UC_SPARC_REG_ICC = 69 + UC_SPARC_REG_L0 = 70 + UC_SPARC_REG_L1 = 71 + UC_SPARC_REG_L2 = 72 + UC_SPARC_REG_L3 = 73 + UC_SPARC_REG_L4 = 74 + UC_SPARC_REG_L5 = 75 + UC_SPARC_REG_L6 = 76 + UC_SPARC_REG_L7 = 77 + UC_SPARC_REG_O0 = 78 + UC_SPARC_REG_O1 = 79 + UC_SPARC_REG_O2 = 80 + UC_SPARC_REG_O3 = 81 + UC_SPARC_REG_O4 = 82 + UC_SPARC_REG_O5 = 83 + UC_SPARC_REG_SP = 84 + UC_SPARC_REG_O7 = 85 + UC_SPARC_REG_Y = 86 + UC_SPARC_REG_XCC = 87 + UC_SPARC_REG_PC = 88 + UC_SPARC_REG_ENDING = 89 + UC_SPARC_REG_O6 = 84 + UC_SPARC_REG_I6 = 67 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/unicorn_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/unicorn_const.rb new file mode 100644 index 00000000..7fe8a994 --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/unicorn_const.rb @@ -0,0 +1,98 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [unicorn_const.rb] + +module Unicorn + UC_API_MAJOR = 1 + + UC_API_MINOR = 0 + UC_SECOND_SCALE = 1000000 + UC_MILISECOND_SCALE = 1000 + UC_ARCH_ARM = 1 + UC_ARCH_ARM64 = 2 + UC_ARCH_MIPS = 3 + UC_ARCH_X86 = 4 + UC_ARCH_PPC = 5 + UC_ARCH_SPARC = 6 + UC_ARCH_M68K = 7 + UC_ARCH_MAX = 8 + + UC_MODE_LITTLE_ENDIAN = 0 + UC_MODE_BIG_ENDIAN = 1073741824 + + UC_MODE_ARM = 0 + UC_MODE_THUMB = 16 + UC_MODE_MCLASS = 32 + UC_MODE_V8 = 64 + UC_MODE_MICRO = 16 + UC_MODE_MIPS3 = 32 + UC_MODE_MIPS32R6 = 64 + UC_MODE_MIPS32 = 4 + UC_MODE_MIPS64 = 8 + UC_MODE_16 = 2 + UC_MODE_32 = 4 + UC_MODE_64 = 8 + UC_MODE_PPC32 = 4 + UC_MODE_PPC64 = 8 + UC_MODE_QPX = 16 + UC_MODE_SPARC32 = 4 + UC_MODE_SPARC64 = 8 + UC_MODE_V9 = 16 + + UC_ERR_OK = 0 + UC_ERR_NOMEM = 1 + UC_ERR_ARCH = 2 + UC_ERR_HANDLE = 3 + UC_ERR_MODE = 4 + UC_ERR_VERSION = 5 + UC_ERR_READ_UNMAPPED = 6 + UC_ERR_WRITE_UNMAPPED = 7 + UC_ERR_FETCH_UNMAPPED = 8 + UC_ERR_HOOK = 9 + UC_ERR_INSN_INVALID = 10 + UC_ERR_MAP = 11 + UC_ERR_WRITE_PROT = 12 + UC_ERR_READ_PROT = 13 + UC_ERR_FETCH_PROT = 14 + UC_ERR_ARG = 15 + UC_ERR_READ_UNALIGNED = 16 + UC_ERR_WRITE_UNALIGNED = 17 + UC_ERR_FETCH_UNALIGNED = 18 + UC_ERR_HOOK_EXIST = 19 + UC_ERR_RESOURCE = 20 + UC_MEM_READ = 16 + UC_MEM_WRITE = 17 + UC_MEM_FETCH = 18 + UC_MEM_READ_UNMAPPED = 19 + UC_MEM_WRITE_UNMAPPED = 20 + UC_MEM_FETCH_UNMAPPED = 21 + UC_MEM_WRITE_PROT = 22 + UC_MEM_READ_PROT = 23 + UC_MEM_FETCH_PROT = 24 + UC_HOOK_INTR = 1 + UC_HOOK_INSN = 2 + UC_HOOK_CODE = 4 + UC_HOOK_BLOCK = 8 + UC_HOOK_MEM_READ_UNMAPPED = 16 + UC_HOOK_MEM_WRITE_UNMAPPED = 32 + UC_HOOK_MEM_FETCH_UNMAPPED = 64 + UC_HOOK_MEM_READ_PROT = 128 + UC_HOOK_MEM_WRITE_PROT = 256 + UC_HOOK_MEM_FETCH_PROT = 512 + UC_HOOK_MEM_READ = 1024 + UC_HOOK_MEM_WRITE = 2048 + UC_HOOK_MEM_FETCH = 4096 + UC_HOOK_MEM_UNMAPPED = 112 + UC_HOOK_MEM_PROT = 896 + UC_HOOK_MEM_READ_INVALID = 144 + UC_HOOK_MEM_WRITE_INVALID = 288 + UC_HOOK_MEM_FETCH_INVALID = 576 + UC_HOOK_MEM_INVALID = 1008 + UC_HOOK_MEM_VALID = 7168 + UC_QUERY_MODE = 1 + UC_QUERY_PAGE_SIZE = 2 + + UC_PROT_NONE = 0 + UC_PROT_READ = 1 + UC_PROT_WRITE = 2 + UC_PROT_EXEC = 4 + UC_PROT_ALL = 7 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/version.rb b/bindings/ruby/unicorn_gem/lib/unicorn/version.rb new file mode 100644 index 00000000..1ebff38c --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/version.rb @@ -0,0 +1,3 @@ +module Unicorn + VERSION = "0.9.0" +end diff --git a/bindings/ruby/unicorn_gem/lib/unicorn/x86_const.rb b/bindings/ruby/unicorn_gem/lib/unicorn/x86_const.rb new file mode 100644 index 00000000..2226de17 --- /dev/null +++ b/bindings/ruby/unicorn_gem/lib/unicorn/x86_const.rb @@ -0,0 +1,1598 @@ +# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [x86_const.rb] + +module Unicorn + +# X86 registers + + UC_X86_REG_INVALID = 0 + UC_X86_REG_AH = 1 + UC_X86_REG_AL = 2 + UC_X86_REG_AX = 3 + UC_X86_REG_BH = 4 + UC_X86_REG_BL = 5 + UC_X86_REG_BP = 6 + UC_X86_REG_BPL = 7 + UC_X86_REG_BX = 8 + UC_X86_REG_CH = 9 + UC_X86_REG_CL = 10 + UC_X86_REG_CS = 11 + UC_X86_REG_CX = 12 + UC_X86_REG_DH = 13 + UC_X86_REG_DI = 14 + UC_X86_REG_DIL = 15 + UC_X86_REG_DL = 16 + UC_X86_REG_DS = 17 + UC_X86_REG_DX = 18 + UC_X86_REG_EAX = 19 + UC_X86_REG_EBP = 20 + UC_X86_REG_EBX = 21 + UC_X86_REG_ECX = 22 + UC_X86_REG_EDI = 23 + UC_X86_REG_EDX = 24 + UC_X86_REG_EFLAGS = 25 + UC_X86_REG_EIP = 26 + UC_X86_REG_EIZ = 27 + UC_X86_REG_ES = 28 + UC_X86_REG_ESI = 29 + UC_X86_REG_ESP = 30 + UC_X86_REG_FPSW = 31 + UC_X86_REG_FS = 32 + UC_X86_REG_GS = 33 + UC_X86_REG_IP = 34 + UC_X86_REG_RAX = 35 + UC_X86_REG_RBP = 36 + UC_X86_REG_RBX = 37 + UC_X86_REG_RCX = 38 + UC_X86_REG_RDI = 39 + UC_X86_REG_RDX = 40 + UC_X86_REG_RIP = 41 + UC_X86_REG_RIZ = 42 + UC_X86_REG_RSI = 43 + UC_X86_REG_RSP = 44 + UC_X86_REG_SI = 45 + UC_X86_REG_SIL = 46 + UC_X86_REG_SP = 47 + UC_X86_REG_SPL = 48 + UC_X86_REG_SS = 49 + UC_X86_REG_CR0 = 50 + UC_X86_REG_CR1 = 51 + UC_X86_REG_CR2 = 52 + UC_X86_REG_CR3 = 53 + UC_X86_REG_CR4 = 54 + UC_X86_REG_CR5 = 55 + UC_X86_REG_CR6 = 56 + UC_X86_REG_CR7 = 57 + UC_X86_REG_CR8 = 58 + UC_X86_REG_CR9 = 59 + UC_X86_REG_CR10 = 60 + UC_X86_REG_CR11 = 61 + UC_X86_REG_CR12 = 62 + UC_X86_REG_CR13 = 63 + UC_X86_REG_CR14 = 64 + UC_X86_REG_CR15 = 65 + UC_X86_REG_DR0 = 66 + UC_X86_REG_DR1 = 67 + UC_X86_REG_DR2 = 68 + UC_X86_REG_DR3 = 69 + UC_X86_REG_DR4 = 70 + UC_X86_REG_DR5 = 71 + UC_X86_REG_DR6 = 72 + UC_X86_REG_DR7 = 73 + UC_X86_REG_DR8 = 74 + UC_X86_REG_DR9 = 75 + UC_X86_REG_DR10 = 76 + UC_X86_REG_DR11 = 77 + UC_X86_REG_DR12 = 78 + UC_X86_REG_DR13 = 79 + UC_X86_REG_DR14 = 80 + UC_X86_REG_DR15 = 81 + UC_X86_REG_FP0 = 82 + UC_X86_REG_FP1 = 83 + UC_X86_REG_FP2 = 84 + UC_X86_REG_FP3 = 85 + UC_X86_REG_FP4 = 86 + UC_X86_REG_FP5 = 87 + UC_X86_REG_FP6 = 88 + UC_X86_REG_FP7 = 89 + UC_X86_REG_K0 = 90 + UC_X86_REG_K1 = 91 + UC_X86_REG_K2 = 92 + UC_X86_REG_K3 = 93 + UC_X86_REG_K4 = 94 + UC_X86_REG_K5 = 95 + UC_X86_REG_K6 = 96 + UC_X86_REG_K7 = 97 + UC_X86_REG_MM0 = 98 + UC_X86_REG_MM1 = 99 + UC_X86_REG_MM2 = 100 + UC_X86_REG_MM3 = 101 + UC_X86_REG_MM4 = 102 + UC_X86_REG_MM5 = 103 + UC_X86_REG_MM6 = 104 + UC_X86_REG_MM7 = 105 + UC_X86_REG_R8 = 106 + UC_X86_REG_R9 = 107 + UC_X86_REG_R10 = 108 + UC_X86_REG_R11 = 109 + UC_X86_REG_R12 = 110 + UC_X86_REG_R13 = 111 + UC_X86_REG_R14 = 112 + UC_X86_REG_R15 = 113 + UC_X86_REG_ST0 = 114 + UC_X86_REG_ST1 = 115 + UC_X86_REG_ST2 = 116 + UC_X86_REG_ST3 = 117 + UC_X86_REG_ST4 = 118 + UC_X86_REG_ST5 = 119 + UC_X86_REG_ST6 = 120 + UC_X86_REG_ST7 = 121 + UC_X86_REG_XMM0 = 122 + UC_X86_REG_XMM1 = 123 + UC_X86_REG_XMM2 = 124 + UC_X86_REG_XMM3 = 125 + UC_X86_REG_XMM4 = 126 + UC_X86_REG_XMM5 = 127 + UC_X86_REG_XMM6 = 128 + UC_X86_REG_XMM7 = 129 + UC_X86_REG_XMM8 = 130 + UC_X86_REG_XMM9 = 131 + UC_X86_REG_XMM10 = 132 + UC_X86_REG_XMM11 = 133 + UC_X86_REG_XMM12 = 134 + UC_X86_REG_XMM13 = 135 + UC_X86_REG_XMM14 = 136 + UC_X86_REG_XMM15 = 137 + UC_X86_REG_XMM16 = 138 + UC_X86_REG_XMM17 = 139 + UC_X86_REG_XMM18 = 140 + UC_X86_REG_XMM19 = 141 + UC_X86_REG_XMM20 = 142 + UC_X86_REG_XMM21 = 143 + UC_X86_REG_XMM22 = 144 + UC_X86_REG_XMM23 = 145 + UC_X86_REG_XMM24 = 146 + UC_X86_REG_XMM25 = 147 + UC_X86_REG_XMM26 = 148 + UC_X86_REG_XMM27 = 149 + UC_X86_REG_XMM28 = 150 + UC_X86_REG_XMM29 = 151 + UC_X86_REG_XMM30 = 152 + UC_X86_REG_XMM31 = 153 + UC_X86_REG_YMM0 = 154 + UC_X86_REG_YMM1 = 155 + UC_X86_REG_YMM2 = 156 + UC_X86_REG_YMM3 = 157 + UC_X86_REG_YMM4 = 158 + UC_X86_REG_YMM5 = 159 + UC_X86_REG_YMM6 = 160 + UC_X86_REG_YMM7 = 161 + UC_X86_REG_YMM8 = 162 + UC_X86_REG_YMM9 = 163 + UC_X86_REG_YMM10 = 164 + UC_X86_REG_YMM11 = 165 + UC_X86_REG_YMM12 = 166 + UC_X86_REG_YMM13 = 167 + UC_X86_REG_YMM14 = 168 + UC_X86_REG_YMM15 = 169 + UC_X86_REG_YMM16 = 170 + UC_X86_REG_YMM17 = 171 + UC_X86_REG_YMM18 = 172 + UC_X86_REG_YMM19 = 173 + UC_X86_REG_YMM20 = 174 + UC_X86_REG_YMM21 = 175 + UC_X86_REG_YMM22 = 176 + UC_X86_REG_YMM23 = 177 + UC_X86_REG_YMM24 = 178 + UC_X86_REG_YMM25 = 179 + UC_X86_REG_YMM26 = 180 + UC_X86_REG_YMM27 = 181 + UC_X86_REG_YMM28 = 182 + UC_X86_REG_YMM29 = 183 + UC_X86_REG_YMM30 = 184 + UC_X86_REG_YMM31 = 185 + UC_X86_REG_ZMM0 = 186 + UC_X86_REG_ZMM1 = 187 + UC_X86_REG_ZMM2 = 188 + UC_X86_REG_ZMM3 = 189 + UC_X86_REG_ZMM4 = 190 + UC_X86_REG_ZMM5 = 191 + UC_X86_REG_ZMM6 = 192 + UC_X86_REG_ZMM7 = 193 + UC_X86_REG_ZMM8 = 194 + UC_X86_REG_ZMM9 = 195 + UC_X86_REG_ZMM10 = 196 + UC_X86_REG_ZMM11 = 197 + UC_X86_REG_ZMM12 = 198 + UC_X86_REG_ZMM13 = 199 + UC_X86_REG_ZMM14 = 200 + UC_X86_REG_ZMM15 = 201 + UC_X86_REG_ZMM16 = 202 + UC_X86_REG_ZMM17 = 203 + UC_X86_REG_ZMM18 = 204 + UC_X86_REG_ZMM19 = 205 + UC_X86_REG_ZMM20 = 206 + UC_X86_REG_ZMM21 = 207 + UC_X86_REG_ZMM22 = 208 + UC_X86_REG_ZMM23 = 209 + UC_X86_REG_ZMM24 = 210 + UC_X86_REG_ZMM25 = 211 + UC_X86_REG_ZMM26 = 212 + UC_X86_REG_ZMM27 = 213 + UC_X86_REG_ZMM28 = 214 + UC_X86_REG_ZMM29 = 215 + UC_X86_REG_ZMM30 = 216 + UC_X86_REG_ZMM31 = 217 + UC_X86_REG_R8B = 218 + UC_X86_REG_R9B = 219 + UC_X86_REG_R10B = 220 + UC_X86_REG_R11B = 221 + UC_X86_REG_R12B = 222 + UC_X86_REG_R13B = 223 + UC_X86_REG_R14B = 224 + UC_X86_REG_R15B = 225 + UC_X86_REG_R8D = 226 + UC_X86_REG_R9D = 227 + UC_X86_REG_R10D = 228 + UC_X86_REG_R11D = 229 + UC_X86_REG_R12D = 230 + UC_X86_REG_R13D = 231 + UC_X86_REG_R14D = 232 + UC_X86_REG_R15D = 233 + UC_X86_REG_R8W = 234 + UC_X86_REG_R9W = 235 + UC_X86_REG_R10W = 236 + UC_X86_REG_R11W = 237 + UC_X86_REG_R12W = 238 + UC_X86_REG_R13W = 239 + UC_X86_REG_R14W = 240 + UC_X86_REG_R15W = 241 + UC_X86_REG_IDTR = 242 + UC_X86_REG_GDTR = 243 + UC_X86_REG_LDTR = 244 + UC_X86_REG_TR = 245 + UC_X86_REG_FPCW = 246 + UC_X86_REG_FPTAG = 247 + UC_X86_REG_ENDING = 248 + +# X86 instructions + + UC_X86_INS_INVALID = 0 + UC_X86_INS_AAA = 1 + UC_X86_INS_AAD = 2 + UC_X86_INS_AAM = 3 + UC_X86_INS_AAS = 4 + UC_X86_INS_FABS = 5 + UC_X86_INS_ADC = 6 + UC_X86_INS_ADCX = 7 + UC_X86_INS_ADD = 8 + UC_X86_INS_ADDPD = 9 + UC_X86_INS_ADDPS = 10 + UC_X86_INS_ADDSD = 11 + UC_X86_INS_ADDSS = 12 + UC_X86_INS_ADDSUBPD = 13 + UC_X86_INS_ADDSUBPS = 14 + UC_X86_INS_FADD = 15 + UC_X86_INS_FIADD = 16 + UC_X86_INS_FADDP = 17 + UC_X86_INS_ADOX = 18 + UC_X86_INS_AESDECLAST = 19 + UC_X86_INS_AESDEC = 20 + UC_X86_INS_AESENCLAST = 21 + UC_X86_INS_AESENC = 22 + UC_X86_INS_AESIMC = 23 + UC_X86_INS_AESKEYGENASSIST = 24 + UC_X86_INS_AND = 25 + UC_X86_INS_ANDN = 26 + UC_X86_INS_ANDNPD = 27 + UC_X86_INS_ANDNPS = 28 + UC_X86_INS_ANDPD = 29 + UC_X86_INS_ANDPS = 30 + UC_X86_INS_ARPL = 31 + UC_X86_INS_BEXTR = 32 + UC_X86_INS_BLCFILL = 33 + UC_X86_INS_BLCI = 34 + UC_X86_INS_BLCIC = 35 + UC_X86_INS_BLCMSK = 36 + UC_X86_INS_BLCS = 37 + UC_X86_INS_BLENDPD = 38 + UC_X86_INS_BLENDPS = 39 + UC_X86_INS_BLENDVPD = 40 + UC_X86_INS_BLENDVPS = 41 + UC_X86_INS_BLSFILL = 42 + UC_X86_INS_BLSI = 43 + UC_X86_INS_BLSIC = 44 + UC_X86_INS_BLSMSK = 45 + UC_X86_INS_BLSR = 46 + UC_X86_INS_BOUND = 47 + UC_X86_INS_BSF = 48 + UC_X86_INS_BSR = 49 + UC_X86_INS_BSWAP = 50 + UC_X86_INS_BT = 51 + UC_X86_INS_BTC = 52 + UC_X86_INS_BTR = 53 + UC_X86_INS_BTS = 54 + UC_X86_INS_BZHI = 55 + UC_X86_INS_CALL = 56 + UC_X86_INS_CBW = 57 + UC_X86_INS_CDQ = 58 + UC_X86_INS_CDQE = 59 + UC_X86_INS_FCHS = 60 + UC_X86_INS_CLAC = 61 + UC_X86_INS_CLC = 62 + UC_X86_INS_CLD = 63 + UC_X86_INS_CLFLUSH = 64 + UC_X86_INS_CLFLUSHOPT = 65 + UC_X86_INS_CLGI = 66 + UC_X86_INS_CLI = 67 + UC_X86_INS_CLTS = 68 + UC_X86_INS_CLWB = 69 + UC_X86_INS_CMC = 70 + UC_X86_INS_CMOVA = 71 + UC_X86_INS_CMOVAE = 72 + UC_X86_INS_CMOVB = 73 + UC_X86_INS_CMOVBE = 74 + UC_X86_INS_FCMOVBE = 75 + UC_X86_INS_FCMOVB = 76 + UC_X86_INS_CMOVE = 77 + UC_X86_INS_FCMOVE = 78 + UC_X86_INS_CMOVG = 79 + UC_X86_INS_CMOVGE = 80 + UC_X86_INS_CMOVL = 81 + UC_X86_INS_CMOVLE = 82 + UC_X86_INS_FCMOVNBE = 83 + UC_X86_INS_FCMOVNB = 84 + UC_X86_INS_CMOVNE = 85 + UC_X86_INS_FCMOVNE = 86 + UC_X86_INS_CMOVNO = 87 + UC_X86_INS_CMOVNP = 88 + UC_X86_INS_FCMOVNU = 89 + UC_X86_INS_CMOVNS = 90 + UC_X86_INS_CMOVO = 91 + UC_X86_INS_CMOVP = 92 + UC_X86_INS_FCMOVU = 93 + UC_X86_INS_CMOVS = 94 + UC_X86_INS_CMP = 95 + UC_X86_INS_CMPPD = 96 + UC_X86_INS_CMPPS = 97 + UC_X86_INS_CMPSB = 98 + UC_X86_INS_CMPSD = 99 + UC_X86_INS_CMPSQ = 100 + UC_X86_INS_CMPSS = 101 + UC_X86_INS_CMPSW = 102 + UC_X86_INS_CMPXCHG16B = 103 + UC_X86_INS_CMPXCHG = 104 + UC_X86_INS_CMPXCHG8B = 105 + UC_X86_INS_COMISD = 106 + UC_X86_INS_COMISS = 107 + UC_X86_INS_FCOMP = 108 + UC_X86_INS_FCOMPI = 109 + UC_X86_INS_FCOMI = 110 + UC_X86_INS_FCOM = 111 + UC_X86_INS_FCOS = 112 + UC_X86_INS_CPUID = 113 + UC_X86_INS_CQO = 114 + UC_X86_INS_CRC32 = 115 + UC_X86_INS_CVTDQ2PD = 116 + UC_X86_INS_CVTDQ2PS = 117 + UC_X86_INS_CVTPD2DQ = 118 + UC_X86_INS_CVTPD2PS = 119 + UC_X86_INS_CVTPS2DQ = 120 + UC_X86_INS_CVTPS2PD = 121 + UC_X86_INS_CVTSD2SI = 122 + UC_X86_INS_CVTSD2SS = 123 + UC_X86_INS_CVTSI2SD = 124 + UC_X86_INS_CVTSI2SS = 125 + UC_X86_INS_CVTSS2SD = 126 + UC_X86_INS_CVTSS2SI = 127 + UC_X86_INS_CVTTPD2DQ = 128 + UC_X86_INS_CVTTPS2DQ = 129 + UC_X86_INS_CVTTSD2SI = 130 + UC_X86_INS_CVTTSS2SI = 131 + UC_X86_INS_CWD = 132 + UC_X86_INS_CWDE = 133 + UC_X86_INS_DAA = 134 + UC_X86_INS_DAS = 135 + UC_X86_INS_DATA16 = 136 + UC_X86_INS_DEC = 137 + UC_X86_INS_DIV = 138 + UC_X86_INS_DIVPD = 139 + UC_X86_INS_DIVPS = 140 + UC_X86_INS_FDIVR = 141 + UC_X86_INS_FIDIVR = 142 + UC_X86_INS_FDIVRP = 143 + UC_X86_INS_DIVSD = 144 + UC_X86_INS_DIVSS = 145 + UC_X86_INS_FDIV = 146 + UC_X86_INS_FIDIV = 147 + UC_X86_INS_FDIVP = 148 + UC_X86_INS_DPPD = 149 + UC_X86_INS_DPPS = 150 + UC_X86_INS_RET = 151 + UC_X86_INS_ENCLS = 152 + UC_X86_INS_ENCLU = 153 + UC_X86_INS_ENTER = 154 + UC_X86_INS_EXTRACTPS = 155 + UC_X86_INS_EXTRQ = 156 + UC_X86_INS_F2XM1 = 157 + UC_X86_INS_LCALL = 158 + UC_X86_INS_LJMP = 159 + UC_X86_INS_FBLD = 160 + UC_X86_INS_FBSTP = 161 + UC_X86_INS_FCOMPP = 162 + UC_X86_INS_FDECSTP = 163 + UC_X86_INS_FEMMS = 164 + UC_X86_INS_FFREE = 165 + UC_X86_INS_FICOM = 166 + UC_X86_INS_FICOMP = 167 + UC_X86_INS_FINCSTP = 168 + UC_X86_INS_FLDCW = 169 + UC_X86_INS_FLDENV = 170 + UC_X86_INS_FLDL2E = 171 + UC_X86_INS_FLDL2T = 172 + UC_X86_INS_FLDLG2 = 173 + UC_X86_INS_FLDLN2 = 174 + UC_X86_INS_FLDPI = 175 + UC_X86_INS_FNCLEX = 176 + UC_X86_INS_FNINIT = 177 + UC_X86_INS_FNOP = 178 + UC_X86_INS_FNSTCW = 179 + UC_X86_INS_FNSTSW = 180 + UC_X86_INS_FPATAN = 181 + UC_X86_INS_FPREM = 182 + UC_X86_INS_FPREM1 = 183 + UC_X86_INS_FPTAN = 184 + UC_X86_INS_FFREEP = 185 + UC_X86_INS_FRNDINT = 186 + UC_X86_INS_FRSTOR = 187 + UC_X86_INS_FNSAVE = 188 + UC_X86_INS_FSCALE = 189 + UC_X86_INS_FSETPM = 190 + UC_X86_INS_FSINCOS = 191 + UC_X86_INS_FNSTENV = 192 + UC_X86_INS_FXAM = 193 + UC_X86_INS_FXRSTOR = 194 + UC_X86_INS_FXRSTOR64 = 195 + UC_X86_INS_FXSAVE = 196 + UC_X86_INS_FXSAVE64 = 197 + UC_X86_INS_FXTRACT = 198 + UC_X86_INS_FYL2X = 199 + UC_X86_INS_FYL2XP1 = 200 + UC_X86_INS_MOVAPD = 201 + UC_X86_INS_MOVAPS = 202 + UC_X86_INS_ORPD = 203 + UC_X86_INS_ORPS = 204 + UC_X86_INS_VMOVAPD = 205 + UC_X86_INS_VMOVAPS = 206 + UC_X86_INS_XORPD = 207 + UC_X86_INS_XORPS = 208 + UC_X86_INS_GETSEC = 209 + UC_X86_INS_HADDPD = 210 + UC_X86_INS_HADDPS = 211 + UC_X86_INS_HLT = 212 + UC_X86_INS_HSUBPD = 213 + UC_X86_INS_HSUBPS = 214 + UC_X86_INS_IDIV = 215 + UC_X86_INS_FILD = 216 + UC_X86_INS_IMUL = 217 + UC_X86_INS_IN = 218 + UC_X86_INS_INC = 219 + UC_X86_INS_INSB = 220 + UC_X86_INS_INSERTPS = 221 + UC_X86_INS_INSERTQ = 222 + UC_X86_INS_INSD = 223 + UC_X86_INS_INSW = 224 + UC_X86_INS_INT = 225 + UC_X86_INS_INT1 = 226 + UC_X86_INS_INT3 = 227 + UC_X86_INS_INTO = 228 + UC_X86_INS_INVD = 229 + UC_X86_INS_INVEPT = 230 + UC_X86_INS_INVLPG = 231 + UC_X86_INS_INVLPGA = 232 + UC_X86_INS_INVPCID = 233 + UC_X86_INS_INVVPID = 234 + UC_X86_INS_IRET = 235 + UC_X86_INS_IRETD = 236 + UC_X86_INS_IRETQ = 237 + UC_X86_INS_FISTTP = 238 + UC_X86_INS_FIST = 239 + UC_X86_INS_FISTP = 240 + UC_X86_INS_UCOMISD = 241 + UC_X86_INS_UCOMISS = 242 + UC_X86_INS_VCOMISD = 243 + UC_X86_INS_VCOMISS = 244 + UC_X86_INS_VCVTSD2SS = 245 + UC_X86_INS_VCVTSI2SD = 246 + UC_X86_INS_VCVTSI2SS = 247 + UC_X86_INS_VCVTSS2SD = 248 + UC_X86_INS_VCVTTSD2SI = 249 + UC_X86_INS_VCVTTSD2USI = 250 + UC_X86_INS_VCVTTSS2SI = 251 + UC_X86_INS_VCVTTSS2USI = 252 + UC_X86_INS_VCVTUSI2SD = 253 + UC_X86_INS_VCVTUSI2SS = 254 + UC_X86_INS_VUCOMISD = 255 + UC_X86_INS_VUCOMISS = 256 + UC_X86_INS_JAE = 257 + UC_X86_INS_JA = 258 + UC_X86_INS_JBE = 259 + UC_X86_INS_JB = 260 + UC_X86_INS_JCXZ = 261 + UC_X86_INS_JECXZ = 262 + UC_X86_INS_JE = 263 + UC_X86_INS_JGE = 264 + UC_X86_INS_JG = 265 + UC_X86_INS_JLE = 266 + UC_X86_INS_JL = 267 + UC_X86_INS_JMP = 268 + UC_X86_INS_JNE = 269 + UC_X86_INS_JNO = 270 + UC_X86_INS_JNP = 271 + UC_X86_INS_JNS = 272 + UC_X86_INS_JO = 273 + UC_X86_INS_JP = 274 + UC_X86_INS_JRCXZ = 275 + UC_X86_INS_JS = 276 + UC_X86_INS_KANDB = 277 + UC_X86_INS_KANDD = 278 + UC_X86_INS_KANDNB = 279 + UC_X86_INS_KANDND = 280 + UC_X86_INS_KANDNQ = 281 + UC_X86_INS_KANDNW = 282 + UC_X86_INS_KANDQ = 283 + UC_X86_INS_KANDW = 284 + UC_X86_INS_KMOVB = 285 + UC_X86_INS_KMOVD = 286 + UC_X86_INS_KMOVQ = 287 + UC_X86_INS_KMOVW = 288 + UC_X86_INS_KNOTB = 289 + UC_X86_INS_KNOTD = 290 + UC_X86_INS_KNOTQ = 291 + UC_X86_INS_KNOTW = 292 + UC_X86_INS_KORB = 293 + UC_X86_INS_KORD = 294 + UC_X86_INS_KORQ = 295 + UC_X86_INS_KORTESTB = 296 + UC_X86_INS_KORTESTD = 297 + UC_X86_INS_KORTESTQ = 298 + UC_X86_INS_KORTESTW = 299 + UC_X86_INS_KORW = 300 + UC_X86_INS_KSHIFTLB = 301 + UC_X86_INS_KSHIFTLD = 302 + UC_X86_INS_KSHIFTLQ = 303 + UC_X86_INS_KSHIFTLW = 304 + UC_X86_INS_KSHIFTRB = 305 + UC_X86_INS_KSHIFTRD = 306 + UC_X86_INS_KSHIFTRQ = 307 + UC_X86_INS_KSHIFTRW = 308 + UC_X86_INS_KUNPCKBW = 309 + UC_X86_INS_KXNORB = 310 + UC_X86_INS_KXNORD = 311 + UC_X86_INS_KXNORQ = 312 + UC_X86_INS_KXNORW = 313 + UC_X86_INS_KXORB = 314 + UC_X86_INS_KXORD = 315 + UC_X86_INS_KXORQ = 316 + UC_X86_INS_KXORW = 317 + UC_X86_INS_LAHF = 318 + UC_X86_INS_LAR = 319 + UC_X86_INS_LDDQU = 320 + UC_X86_INS_LDMXCSR = 321 + UC_X86_INS_LDS = 322 + UC_X86_INS_FLDZ = 323 + UC_X86_INS_FLD1 = 324 + UC_X86_INS_FLD = 325 + UC_X86_INS_LEA = 326 + UC_X86_INS_LEAVE = 327 + UC_X86_INS_LES = 328 + UC_X86_INS_LFENCE = 329 + UC_X86_INS_LFS = 330 + UC_X86_INS_LGDT = 331 + UC_X86_INS_LGS = 332 + UC_X86_INS_LIDT = 333 + UC_X86_INS_LLDT = 334 + UC_X86_INS_LMSW = 335 + UC_X86_INS_OR = 336 + UC_X86_INS_SUB = 337 + UC_X86_INS_XOR = 338 + UC_X86_INS_LODSB = 339 + UC_X86_INS_LODSD = 340 + UC_X86_INS_LODSQ = 341 + UC_X86_INS_LODSW = 342 + UC_X86_INS_LOOP = 343 + UC_X86_INS_LOOPE = 344 + UC_X86_INS_LOOPNE = 345 + UC_X86_INS_RETF = 346 + UC_X86_INS_RETFQ = 347 + UC_X86_INS_LSL = 348 + UC_X86_INS_LSS = 349 + UC_X86_INS_LTR = 350 + UC_X86_INS_XADD = 351 + UC_X86_INS_LZCNT = 352 + UC_X86_INS_MASKMOVDQU = 353 + UC_X86_INS_MAXPD = 354 + UC_X86_INS_MAXPS = 355 + UC_X86_INS_MAXSD = 356 + UC_X86_INS_MAXSS = 357 + UC_X86_INS_MFENCE = 358 + UC_X86_INS_MINPD = 359 + UC_X86_INS_MINPS = 360 + UC_X86_INS_MINSD = 361 + UC_X86_INS_MINSS = 362 + UC_X86_INS_CVTPD2PI = 363 + UC_X86_INS_CVTPI2PD = 364 + UC_X86_INS_CVTPI2PS = 365 + UC_X86_INS_CVTPS2PI = 366 + UC_X86_INS_CVTTPD2PI = 367 + UC_X86_INS_CVTTPS2PI = 368 + UC_X86_INS_EMMS = 369 + UC_X86_INS_MASKMOVQ = 370 + UC_X86_INS_MOVD = 371 + UC_X86_INS_MOVDQ2Q = 372 + UC_X86_INS_MOVNTQ = 373 + UC_X86_INS_MOVQ2DQ = 374 + UC_X86_INS_MOVQ = 375 + UC_X86_INS_PABSB = 376 + UC_X86_INS_PABSD = 377 + UC_X86_INS_PABSW = 378 + UC_X86_INS_PACKSSDW = 379 + UC_X86_INS_PACKSSWB = 380 + UC_X86_INS_PACKUSWB = 381 + UC_X86_INS_PADDB = 382 + UC_X86_INS_PADDD = 383 + UC_X86_INS_PADDQ = 384 + UC_X86_INS_PADDSB = 385 + UC_X86_INS_PADDSW = 386 + UC_X86_INS_PADDUSB = 387 + UC_X86_INS_PADDUSW = 388 + UC_X86_INS_PADDW = 389 + UC_X86_INS_PALIGNR = 390 + UC_X86_INS_PANDN = 391 + UC_X86_INS_PAND = 392 + UC_X86_INS_PAVGB = 393 + UC_X86_INS_PAVGW = 394 + UC_X86_INS_PCMPEQB = 395 + UC_X86_INS_PCMPEQD = 396 + UC_X86_INS_PCMPEQW = 397 + UC_X86_INS_PCMPGTB = 398 + UC_X86_INS_PCMPGTD = 399 + UC_X86_INS_PCMPGTW = 400 + UC_X86_INS_PEXTRW = 401 + UC_X86_INS_PHADDSW = 402 + UC_X86_INS_PHADDW = 403 + UC_X86_INS_PHADDD = 404 + UC_X86_INS_PHSUBD = 405 + UC_X86_INS_PHSUBSW = 406 + UC_X86_INS_PHSUBW = 407 + UC_X86_INS_PINSRW = 408 + UC_X86_INS_PMADDUBSW = 409 + UC_X86_INS_PMADDWD = 410 + UC_X86_INS_PMAXSW = 411 + UC_X86_INS_PMAXUB = 412 + UC_X86_INS_PMINSW = 413 + UC_X86_INS_PMINUB = 414 + UC_X86_INS_PMOVMSKB = 415 + UC_X86_INS_PMULHRSW = 416 + UC_X86_INS_PMULHUW = 417 + UC_X86_INS_PMULHW = 418 + UC_X86_INS_PMULLW = 419 + UC_X86_INS_PMULUDQ = 420 + UC_X86_INS_POR = 421 + UC_X86_INS_PSADBW = 422 + UC_X86_INS_PSHUFB = 423 + UC_X86_INS_PSHUFW = 424 + UC_X86_INS_PSIGNB = 425 + UC_X86_INS_PSIGND = 426 + UC_X86_INS_PSIGNW = 427 + UC_X86_INS_PSLLD = 428 + UC_X86_INS_PSLLQ = 429 + UC_X86_INS_PSLLW = 430 + UC_X86_INS_PSRAD = 431 + UC_X86_INS_PSRAW = 432 + UC_X86_INS_PSRLD = 433 + UC_X86_INS_PSRLQ = 434 + UC_X86_INS_PSRLW = 435 + UC_X86_INS_PSUBB = 436 + UC_X86_INS_PSUBD = 437 + UC_X86_INS_PSUBQ = 438 + UC_X86_INS_PSUBSB = 439 + UC_X86_INS_PSUBSW = 440 + UC_X86_INS_PSUBUSB = 441 + UC_X86_INS_PSUBUSW = 442 + UC_X86_INS_PSUBW = 443 + UC_X86_INS_PUNPCKHBW = 444 + UC_X86_INS_PUNPCKHDQ = 445 + UC_X86_INS_PUNPCKHWD = 446 + UC_X86_INS_PUNPCKLBW = 447 + UC_X86_INS_PUNPCKLDQ = 448 + UC_X86_INS_PUNPCKLWD = 449 + UC_X86_INS_PXOR = 450 + UC_X86_INS_MONITOR = 451 + UC_X86_INS_MONTMUL = 452 + UC_X86_INS_MOV = 453 + UC_X86_INS_MOVABS = 454 + UC_X86_INS_MOVBE = 455 + UC_X86_INS_MOVDDUP = 456 + UC_X86_INS_MOVDQA = 457 + UC_X86_INS_MOVDQU = 458 + UC_X86_INS_MOVHLPS = 459 + UC_X86_INS_MOVHPD = 460 + UC_X86_INS_MOVHPS = 461 + UC_X86_INS_MOVLHPS = 462 + UC_X86_INS_MOVLPD = 463 + UC_X86_INS_MOVLPS = 464 + UC_X86_INS_MOVMSKPD = 465 + UC_X86_INS_MOVMSKPS = 466 + UC_X86_INS_MOVNTDQA = 467 + UC_X86_INS_MOVNTDQ = 468 + UC_X86_INS_MOVNTI = 469 + UC_X86_INS_MOVNTPD = 470 + UC_X86_INS_MOVNTPS = 471 + UC_X86_INS_MOVNTSD = 472 + UC_X86_INS_MOVNTSS = 473 + UC_X86_INS_MOVSB = 474 + UC_X86_INS_MOVSD = 475 + UC_X86_INS_MOVSHDUP = 476 + UC_X86_INS_MOVSLDUP = 477 + UC_X86_INS_MOVSQ = 478 + UC_X86_INS_MOVSS = 479 + UC_X86_INS_MOVSW = 480 + UC_X86_INS_MOVSX = 481 + UC_X86_INS_MOVSXD = 482 + UC_X86_INS_MOVUPD = 483 + UC_X86_INS_MOVUPS = 484 + UC_X86_INS_MOVZX = 485 + UC_X86_INS_MPSADBW = 486 + UC_X86_INS_MUL = 487 + UC_X86_INS_MULPD = 488 + UC_X86_INS_MULPS = 489 + UC_X86_INS_MULSD = 490 + UC_X86_INS_MULSS = 491 + UC_X86_INS_MULX = 492 + UC_X86_INS_FMUL = 493 + UC_X86_INS_FIMUL = 494 + UC_X86_INS_FMULP = 495 + UC_X86_INS_MWAIT = 496 + UC_X86_INS_NEG = 497 + UC_X86_INS_NOP = 498 + UC_X86_INS_NOT = 499 + UC_X86_INS_OUT = 500 + UC_X86_INS_OUTSB = 501 + UC_X86_INS_OUTSD = 502 + UC_X86_INS_OUTSW = 503 + UC_X86_INS_PACKUSDW = 504 + UC_X86_INS_PAUSE = 505 + UC_X86_INS_PAVGUSB = 506 + UC_X86_INS_PBLENDVB = 507 + UC_X86_INS_PBLENDW = 508 + UC_X86_INS_PCLMULQDQ = 509 + UC_X86_INS_PCMPEQQ = 510 + UC_X86_INS_PCMPESTRI = 511 + UC_X86_INS_PCMPESTRM = 512 + UC_X86_INS_PCMPGTQ = 513 + UC_X86_INS_PCMPISTRI = 514 + UC_X86_INS_PCMPISTRM = 515 + UC_X86_INS_PCOMMIT = 516 + UC_X86_INS_PDEP = 517 + UC_X86_INS_PEXT = 518 + UC_X86_INS_PEXTRB = 519 + UC_X86_INS_PEXTRD = 520 + UC_X86_INS_PEXTRQ = 521 + UC_X86_INS_PF2ID = 522 + UC_X86_INS_PF2IW = 523 + UC_X86_INS_PFACC = 524 + UC_X86_INS_PFADD = 525 + UC_X86_INS_PFCMPEQ = 526 + UC_X86_INS_PFCMPGE = 527 + UC_X86_INS_PFCMPGT = 528 + UC_X86_INS_PFMAX = 529 + UC_X86_INS_PFMIN = 530 + UC_X86_INS_PFMUL = 531 + UC_X86_INS_PFNACC = 532 + UC_X86_INS_PFPNACC = 533 + UC_X86_INS_PFRCPIT1 = 534 + UC_X86_INS_PFRCPIT2 = 535 + UC_X86_INS_PFRCP = 536 + UC_X86_INS_PFRSQIT1 = 537 + UC_X86_INS_PFRSQRT = 538 + UC_X86_INS_PFSUBR = 539 + UC_X86_INS_PFSUB = 540 + UC_X86_INS_PHMINPOSUW = 541 + UC_X86_INS_PI2FD = 542 + UC_X86_INS_PI2FW = 543 + UC_X86_INS_PINSRB = 544 + UC_X86_INS_PINSRD = 545 + UC_X86_INS_PINSRQ = 546 + UC_X86_INS_PMAXSB = 547 + UC_X86_INS_PMAXSD = 548 + UC_X86_INS_PMAXUD = 549 + UC_X86_INS_PMAXUW = 550 + UC_X86_INS_PMINSB = 551 + UC_X86_INS_PMINSD = 552 + UC_X86_INS_PMINUD = 553 + UC_X86_INS_PMINUW = 554 + UC_X86_INS_PMOVSXBD = 555 + UC_X86_INS_PMOVSXBQ = 556 + UC_X86_INS_PMOVSXBW = 557 + UC_X86_INS_PMOVSXDQ = 558 + UC_X86_INS_PMOVSXWD = 559 + UC_X86_INS_PMOVSXWQ = 560 + UC_X86_INS_PMOVZXBD = 561 + UC_X86_INS_PMOVZXBQ = 562 + UC_X86_INS_PMOVZXBW = 563 + UC_X86_INS_PMOVZXDQ = 564 + UC_X86_INS_PMOVZXWD = 565 + UC_X86_INS_PMOVZXWQ = 566 + UC_X86_INS_PMULDQ = 567 + UC_X86_INS_PMULHRW = 568 + UC_X86_INS_PMULLD = 569 + UC_X86_INS_POP = 570 + UC_X86_INS_POPAW = 571 + UC_X86_INS_POPAL = 572 + UC_X86_INS_POPCNT = 573 + UC_X86_INS_POPF = 574 + UC_X86_INS_POPFD = 575 + UC_X86_INS_POPFQ = 576 + UC_X86_INS_PREFETCH = 577 + UC_X86_INS_PREFETCHNTA = 578 + UC_X86_INS_PREFETCHT0 = 579 + UC_X86_INS_PREFETCHT1 = 580 + UC_X86_INS_PREFETCHT2 = 581 + UC_X86_INS_PREFETCHW = 582 + UC_X86_INS_PSHUFD = 583 + UC_X86_INS_PSHUFHW = 584 + UC_X86_INS_PSHUFLW = 585 + UC_X86_INS_PSLLDQ = 586 + UC_X86_INS_PSRLDQ = 587 + UC_X86_INS_PSWAPD = 588 + UC_X86_INS_PTEST = 589 + UC_X86_INS_PUNPCKHQDQ = 590 + UC_X86_INS_PUNPCKLQDQ = 591 + UC_X86_INS_PUSH = 592 + UC_X86_INS_PUSHAW = 593 + UC_X86_INS_PUSHAL = 594 + UC_X86_INS_PUSHF = 595 + UC_X86_INS_PUSHFD = 596 + UC_X86_INS_PUSHFQ = 597 + UC_X86_INS_RCL = 598 + UC_X86_INS_RCPPS = 599 + UC_X86_INS_RCPSS = 600 + UC_X86_INS_RCR = 601 + UC_X86_INS_RDFSBASE = 602 + UC_X86_INS_RDGSBASE = 603 + UC_X86_INS_RDMSR = 604 + UC_X86_INS_RDPMC = 605 + UC_X86_INS_RDRAND = 606 + UC_X86_INS_RDSEED = 607 + UC_X86_INS_RDTSC = 608 + UC_X86_INS_RDTSCP = 609 + UC_X86_INS_ROL = 610 + UC_X86_INS_ROR = 611 + UC_X86_INS_RORX = 612 + UC_X86_INS_ROUNDPD = 613 + UC_X86_INS_ROUNDPS = 614 + UC_X86_INS_ROUNDSD = 615 + UC_X86_INS_ROUNDSS = 616 + UC_X86_INS_RSM = 617 + UC_X86_INS_RSQRTPS = 618 + UC_X86_INS_RSQRTSS = 619 + UC_X86_INS_SAHF = 620 + UC_X86_INS_SAL = 621 + UC_X86_INS_SALC = 622 + UC_X86_INS_SAR = 623 + UC_X86_INS_SARX = 624 + UC_X86_INS_SBB = 625 + UC_X86_INS_SCASB = 626 + UC_X86_INS_SCASD = 627 + UC_X86_INS_SCASQ = 628 + UC_X86_INS_SCASW = 629 + UC_X86_INS_SETAE = 630 + UC_X86_INS_SETA = 631 + UC_X86_INS_SETBE = 632 + UC_X86_INS_SETB = 633 + UC_X86_INS_SETE = 634 + UC_X86_INS_SETGE = 635 + UC_X86_INS_SETG = 636 + UC_X86_INS_SETLE = 637 + UC_X86_INS_SETL = 638 + UC_X86_INS_SETNE = 639 + UC_X86_INS_SETNO = 640 + UC_X86_INS_SETNP = 641 + UC_X86_INS_SETNS = 642 + UC_X86_INS_SETO = 643 + UC_X86_INS_SETP = 644 + UC_X86_INS_SETS = 645 + UC_X86_INS_SFENCE = 646 + UC_X86_INS_SGDT = 647 + UC_X86_INS_SHA1MSG1 = 648 + UC_X86_INS_SHA1MSG2 = 649 + UC_X86_INS_SHA1NEXTE = 650 + UC_X86_INS_SHA1RNDS4 = 651 + UC_X86_INS_SHA256MSG1 = 652 + UC_X86_INS_SHA256MSG2 = 653 + UC_X86_INS_SHA256RNDS2 = 654 + UC_X86_INS_SHL = 655 + UC_X86_INS_SHLD = 656 + UC_X86_INS_SHLX = 657 + UC_X86_INS_SHR = 658 + UC_X86_INS_SHRD = 659 + UC_X86_INS_SHRX = 660 + UC_X86_INS_SHUFPD = 661 + UC_X86_INS_SHUFPS = 662 + UC_X86_INS_SIDT = 663 + UC_X86_INS_FSIN = 664 + UC_X86_INS_SKINIT = 665 + UC_X86_INS_SLDT = 666 + UC_X86_INS_SMSW = 667 + UC_X86_INS_SQRTPD = 668 + UC_X86_INS_SQRTPS = 669 + UC_X86_INS_SQRTSD = 670 + UC_X86_INS_SQRTSS = 671 + UC_X86_INS_FSQRT = 672 + UC_X86_INS_STAC = 673 + UC_X86_INS_STC = 674 + UC_X86_INS_STD = 675 + UC_X86_INS_STGI = 676 + UC_X86_INS_STI = 677 + UC_X86_INS_STMXCSR = 678 + UC_X86_INS_STOSB = 679 + UC_X86_INS_STOSD = 680 + UC_X86_INS_STOSQ = 681 + UC_X86_INS_STOSW = 682 + UC_X86_INS_STR = 683 + UC_X86_INS_FST = 684 + UC_X86_INS_FSTP = 685 + UC_X86_INS_FSTPNCE = 686 + UC_X86_INS_FXCH = 687 + UC_X86_INS_SUBPD = 688 + UC_X86_INS_SUBPS = 689 + UC_X86_INS_FSUBR = 690 + UC_X86_INS_FISUBR = 691 + UC_X86_INS_FSUBRP = 692 + UC_X86_INS_SUBSD = 693 + UC_X86_INS_SUBSS = 694 + UC_X86_INS_FSUB = 695 + UC_X86_INS_FISUB = 696 + UC_X86_INS_FSUBP = 697 + UC_X86_INS_SWAPGS = 698 + UC_X86_INS_SYSCALL = 699 + UC_X86_INS_SYSENTER = 700 + UC_X86_INS_SYSEXIT = 701 + UC_X86_INS_SYSRET = 702 + UC_X86_INS_T1MSKC = 703 + UC_X86_INS_TEST = 704 + UC_X86_INS_UD2 = 705 + UC_X86_INS_FTST = 706 + UC_X86_INS_TZCNT = 707 + UC_X86_INS_TZMSK = 708 + UC_X86_INS_FUCOMPI = 709 + UC_X86_INS_FUCOMI = 710 + UC_X86_INS_FUCOMPP = 711 + UC_X86_INS_FUCOMP = 712 + UC_X86_INS_FUCOM = 713 + UC_X86_INS_UD2B = 714 + UC_X86_INS_UNPCKHPD = 715 + UC_X86_INS_UNPCKHPS = 716 + UC_X86_INS_UNPCKLPD = 717 + UC_X86_INS_UNPCKLPS = 718 + UC_X86_INS_VADDPD = 719 + UC_X86_INS_VADDPS = 720 + UC_X86_INS_VADDSD = 721 + UC_X86_INS_VADDSS = 722 + UC_X86_INS_VADDSUBPD = 723 + UC_X86_INS_VADDSUBPS = 724 + UC_X86_INS_VAESDECLAST = 725 + UC_X86_INS_VAESDEC = 726 + UC_X86_INS_VAESENCLAST = 727 + UC_X86_INS_VAESENC = 728 + UC_X86_INS_VAESIMC = 729 + UC_X86_INS_VAESKEYGENASSIST = 730 + UC_X86_INS_VALIGND = 731 + UC_X86_INS_VALIGNQ = 732 + UC_X86_INS_VANDNPD = 733 + UC_X86_INS_VANDNPS = 734 + UC_X86_INS_VANDPD = 735 + UC_X86_INS_VANDPS = 736 + UC_X86_INS_VBLENDMPD = 737 + UC_X86_INS_VBLENDMPS = 738 + UC_X86_INS_VBLENDPD = 739 + UC_X86_INS_VBLENDPS = 740 + UC_X86_INS_VBLENDVPD = 741 + UC_X86_INS_VBLENDVPS = 742 + UC_X86_INS_VBROADCASTF128 = 743 + UC_X86_INS_VBROADCASTI32X4 = 744 + UC_X86_INS_VBROADCASTI64X4 = 745 + UC_X86_INS_VBROADCASTSD = 746 + UC_X86_INS_VBROADCASTSS = 747 + UC_X86_INS_VCMPPD = 748 + UC_X86_INS_VCMPPS = 749 + UC_X86_INS_VCMPSD = 750 + UC_X86_INS_VCMPSS = 751 + UC_X86_INS_VCOMPRESSPD = 752 + UC_X86_INS_VCOMPRESSPS = 753 + UC_X86_INS_VCVTDQ2PD = 754 + UC_X86_INS_VCVTDQ2PS = 755 + UC_X86_INS_VCVTPD2DQX = 756 + UC_X86_INS_VCVTPD2DQ = 757 + UC_X86_INS_VCVTPD2PSX = 758 + UC_X86_INS_VCVTPD2PS = 759 + UC_X86_INS_VCVTPD2UDQ = 760 + UC_X86_INS_VCVTPH2PS = 761 + UC_X86_INS_VCVTPS2DQ = 762 + UC_X86_INS_VCVTPS2PD = 763 + UC_X86_INS_VCVTPS2PH = 764 + UC_X86_INS_VCVTPS2UDQ = 765 + UC_X86_INS_VCVTSD2SI = 766 + UC_X86_INS_VCVTSD2USI = 767 + UC_X86_INS_VCVTSS2SI = 768 + UC_X86_INS_VCVTSS2USI = 769 + UC_X86_INS_VCVTTPD2DQX = 770 + UC_X86_INS_VCVTTPD2DQ = 771 + UC_X86_INS_VCVTTPD2UDQ = 772 + UC_X86_INS_VCVTTPS2DQ = 773 + UC_X86_INS_VCVTTPS2UDQ = 774 + UC_X86_INS_VCVTUDQ2PD = 775 + UC_X86_INS_VCVTUDQ2PS = 776 + UC_X86_INS_VDIVPD = 777 + UC_X86_INS_VDIVPS = 778 + UC_X86_INS_VDIVSD = 779 + UC_X86_INS_VDIVSS = 780 + UC_X86_INS_VDPPD = 781 + UC_X86_INS_VDPPS = 782 + UC_X86_INS_VERR = 783 + UC_X86_INS_VERW = 784 + UC_X86_INS_VEXP2PD = 785 + UC_X86_INS_VEXP2PS = 786 + UC_X86_INS_VEXPANDPD = 787 + UC_X86_INS_VEXPANDPS = 788 + UC_X86_INS_VEXTRACTF128 = 789 + UC_X86_INS_VEXTRACTF32X4 = 790 + UC_X86_INS_VEXTRACTF64X4 = 791 + UC_X86_INS_VEXTRACTI128 = 792 + UC_X86_INS_VEXTRACTI32X4 = 793 + UC_X86_INS_VEXTRACTI64X4 = 794 + UC_X86_INS_VEXTRACTPS = 795 + UC_X86_INS_VFMADD132PD = 796 + UC_X86_INS_VFMADD132PS = 797 + UC_X86_INS_VFMADDPD = 798 + UC_X86_INS_VFMADD213PD = 799 + UC_X86_INS_VFMADD231PD = 800 + UC_X86_INS_VFMADDPS = 801 + UC_X86_INS_VFMADD213PS = 802 + UC_X86_INS_VFMADD231PS = 803 + UC_X86_INS_VFMADDSD = 804 + UC_X86_INS_VFMADD213SD = 805 + UC_X86_INS_VFMADD132SD = 806 + UC_X86_INS_VFMADD231SD = 807 + UC_X86_INS_VFMADDSS = 808 + UC_X86_INS_VFMADD213SS = 809 + UC_X86_INS_VFMADD132SS = 810 + UC_X86_INS_VFMADD231SS = 811 + UC_X86_INS_VFMADDSUB132PD = 812 + UC_X86_INS_VFMADDSUB132PS = 813 + UC_X86_INS_VFMADDSUBPD = 814 + UC_X86_INS_VFMADDSUB213PD = 815 + UC_X86_INS_VFMADDSUB231PD = 816 + UC_X86_INS_VFMADDSUBPS = 817 + UC_X86_INS_VFMADDSUB213PS = 818 + UC_X86_INS_VFMADDSUB231PS = 819 + UC_X86_INS_VFMSUB132PD = 820 + UC_X86_INS_VFMSUB132PS = 821 + UC_X86_INS_VFMSUBADD132PD = 822 + UC_X86_INS_VFMSUBADD132PS = 823 + UC_X86_INS_VFMSUBADDPD = 824 + UC_X86_INS_VFMSUBADD213PD = 825 + UC_X86_INS_VFMSUBADD231PD = 826 + UC_X86_INS_VFMSUBADDPS = 827 + UC_X86_INS_VFMSUBADD213PS = 828 + UC_X86_INS_VFMSUBADD231PS = 829 + UC_X86_INS_VFMSUBPD = 830 + UC_X86_INS_VFMSUB213PD = 831 + UC_X86_INS_VFMSUB231PD = 832 + UC_X86_INS_VFMSUBPS = 833 + UC_X86_INS_VFMSUB213PS = 834 + UC_X86_INS_VFMSUB231PS = 835 + UC_X86_INS_VFMSUBSD = 836 + UC_X86_INS_VFMSUB213SD = 837 + UC_X86_INS_VFMSUB132SD = 838 + UC_X86_INS_VFMSUB231SD = 839 + UC_X86_INS_VFMSUBSS = 840 + UC_X86_INS_VFMSUB213SS = 841 + UC_X86_INS_VFMSUB132SS = 842 + UC_X86_INS_VFMSUB231SS = 843 + UC_X86_INS_VFNMADD132PD = 844 + UC_X86_INS_VFNMADD132PS = 845 + UC_X86_INS_VFNMADDPD = 846 + UC_X86_INS_VFNMADD213PD = 847 + UC_X86_INS_VFNMADD231PD = 848 + UC_X86_INS_VFNMADDPS = 849 + UC_X86_INS_VFNMADD213PS = 850 + UC_X86_INS_VFNMADD231PS = 851 + UC_X86_INS_VFNMADDSD = 852 + UC_X86_INS_VFNMADD213SD = 853 + UC_X86_INS_VFNMADD132SD = 854 + UC_X86_INS_VFNMADD231SD = 855 + UC_X86_INS_VFNMADDSS = 856 + UC_X86_INS_VFNMADD213SS = 857 + UC_X86_INS_VFNMADD132SS = 858 + UC_X86_INS_VFNMADD231SS = 859 + UC_X86_INS_VFNMSUB132PD = 860 + UC_X86_INS_VFNMSUB132PS = 861 + UC_X86_INS_VFNMSUBPD = 862 + UC_X86_INS_VFNMSUB213PD = 863 + UC_X86_INS_VFNMSUB231PD = 864 + UC_X86_INS_VFNMSUBPS = 865 + UC_X86_INS_VFNMSUB213PS = 866 + UC_X86_INS_VFNMSUB231PS = 867 + UC_X86_INS_VFNMSUBSD = 868 + UC_X86_INS_VFNMSUB213SD = 869 + UC_X86_INS_VFNMSUB132SD = 870 + UC_X86_INS_VFNMSUB231SD = 871 + UC_X86_INS_VFNMSUBSS = 872 + UC_X86_INS_VFNMSUB213SS = 873 + UC_X86_INS_VFNMSUB132SS = 874 + UC_X86_INS_VFNMSUB231SS = 875 + UC_X86_INS_VFRCZPD = 876 + UC_X86_INS_VFRCZPS = 877 + UC_X86_INS_VFRCZSD = 878 + UC_X86_INS_VFRCZSS = 879 + UC_X86_INS_VORPD = 880 + UC_X86_INS_VORPS = 881 + UC_X86_INS_VXORPD = 882 + UC_X86_INS_VXORPS = 883 + UC_X86_INS_VGATHERDPD = 884 + UC_X86_INS_VGATHERDPS = 885 + UC_X86_INS_VGATHERPF0DPD = 886 + UC_X86_INS_VGATHERPF0DPS = 887 + UC_X86_INS_VGATHERPF0QPD = 888 + UC_X86_INS_VGATHERPF0QPS = 889 + UC_X86_INS_VGATHERPF1DPD = 890 + UC_X86_INS_VGATHERPF1DPS = 891 + UC_X86_INS_VGATHERPF1QPD = 892 + UC_X86_INS_VGATHERPF1QPS = 893 + UC_X86_INS_VGATHERQPD = 894 + UC_X86_INS_VGATHERQPS = 895 + UC_X86_INS_VHADDPD = 896 + UC_X86_INS_VHADDPS = 897 + UC_X86_INS_VHSUBPD = 898 + UC_X86_INS_VHSUBPS = 899 + UC_X86_INS_VINSERTF128 = 900 + UC_X86_INS_VINSERTF32X4 = 901 + UC_X86_INS_VINSERTF32X8 = 902 + UC_X86_INS_VINSERTF64X2 = 903 + UC_X86_INS_VINSERTF64X4 = 904 + UC_X86_INS_VINSERTI128 = 905 + UC_X86_INS_VINSERTI32X4 = 906 + UC_X86_INS_VINSERTI32X8 = 907 + UC_X86_INS_VINSERTI64X2 = 908 + UC_X86_INS_VINSERTI64X4 = 909 + UC_X86_INS_VINSERTPS = 910 + UC_X86_INS_VLDDQU = 911 + UC_X86_INS_VLDMXCSR = 912 + UC_X86_INS_VMASKMOVDQU = 913 + UC_X86_INS_VMASKMOVPD = 914 + UC_X86_INS_VMASKMOVPS = 915 + UC_X86_INS_VMAXPD = 916 + UC_X86_INS_VMAXPS = 917 + UC_X86_INS_VMAXSD = 918 + UC_X86_INS_VMAXSS = 919 + UC_X86_INS_VMCALL = 920 + UC_X86_INS_VMCLEAR = 921 + UC_X86_INS_VMFUNC = 922 + UC_X86_INS_VMINPD = 923 + UC_X86_INS_VMINPS = 924 + UC_X86_INS_VMINSD = 925 + UC_X86_INS_VMINSS = 926 + UC_X86_INS_VMLAUNCH = 927 + UC_X86_INS_VMLOAD = 928 + UC_X86_INS_VMMCALL = 929 + UC_X86_INS_VMOVQ = 930 + UC_X86_INS_VMOVDDUP = 931 + UC_X86_INS_VMOVD = 932 + UC_X86_INS_VMOVDQA32 = 933 + UC_X86_INS_VMOVDQA64 = 934 + UC_X86_INS_VMOVDQA = 935 + UC_X86_INS_VMOVDQU16 = 936 + UC_X86_INS_VMOVDQU32 = 937 + UC_X86_INS_VMOVDQU64 = 938 + UC_X86_INS_VMOVDQU8 = 939 + UC_X86_INS_VMOVDQU = 940 + UC_X86_INS_VMOVHLPS = 941 + UC_X86_INS_VMOVHPD = 942 + UC_X86_INS_VMOVHPS = 943 + UC_X86_INS_VMOVLHPS = 944 + UC_X86_INS_VMOVLPD = 945 + UC_X86_INS_VMOVLPS = 946 + UC_X86_INS_VMOVMSKPD = 947 + UC_X86_INS_VMOVMSKPS = 948 + UC_X86_INS_VMOVNTDQA = 949 + UC_X86_INS_VMOVNTDQ = 950 + UC_X86_INS_VMOVNTPD = 951 + UC_X86_INS_VMOVNTPS = 952 + UC_X86_INS_VMOVSD = 953 + UC_X86_INS_VMOVSHDUP = 954 + UC_X86_INS_VMOVSLDUP = 955 + UC_X86_INS_VMOVSS = 956 + UC_X86_INS_VMOVUPD = 957 + UC_X86_INS_VMOVUPS = 958 + UC_X86_INS_VMPSADBW = 959 + UC_X86_INS_VMPTRLD = 960 + UC_X86_INS_VMPTRST = 961 + UC_X86_INS_VMREAD = 962 + UC_X86_INS_VMRESUME = 963 + UC_X86_INS_VMRUN = 964 + UC_X86_INS_VMSAVE = 965 + UC_X86_INS_VMULPD = 966 + UC_X86_INS_VMULPS = 967 + UC_X86_INS_VMULSD = 968 + UC_X86_INS_VMULSS = 969 + UC_X86_INS_VMWRITE = 970 + UC_X86_INS_VMXOFF = 971 + UC_X86_INS_VMXON = 972 + UC_X86_INS_VPABSB = 973 + UC_X86_INS_VPABSD = 974 + UC_X86_INS_VPABSQ = 975 + UC_X86_INS_VPABSW = 976 + UC_X86_INS_VPACKSSDW = 977 + UC_X86_INS_VPACKSSWB = 978 + UC_X86_INS_VPACKUSDW = 979 + UC_X86_INS_VPACKUSWB = 980 + UC_X86_INS_VPADDB = 981 + UC_X86_INS_VPADDD = 982 + UC_X86_INS_VPADDQ = 983 + UC_X86_INS_VPADDSB = 984 + UC_X86_INS_VPADDSW = 985 + UC_X86_INS_VPADDUSB = 986 + UC_X86_INS_VPADDUSW = 987 + UC_X86_INS_VPADDW = 988 + UC_X86_INS_VPALIGNR = 989 + UC_X86_INS_VPANDD = 990 + UC_X86_INS_VPANDND = 991 + UC_X86_INS_VPANDNQ = 992 + UC_X86_INS_VPANDN = 993 + UC_X86_INS_VPANDQ = 994 + UC_X86_INS_VPAND = 995 + UC_X86_INS_VPAVGB = 996 + UC_X86_INS_VPAVGW = 997 + UC_X86_INS_VPBLENDD = 998 + UC_X86_INS_VPBLENDMB = 999 + UC_X86_INS_VPBLENDMD = 1000 + UC_X86_INS_VPBLENDMQ = 1001 + UC_X86_INS_VPBLENDMW = 1002 + UC_X86_INS_VPBLENDVB = 1003 + UC_X86_INS_VPBLENDW = 1004 + UC_X86_INS_VPBROADCASTB = 1005 + UC_X86_INS_VPBROADCASTD = 1006 + UC_X86_INS_VPBROADCASTMB2Q = 1007 + UC_X86_INS_VPBROADCASTMW2D = 1008 + UC_X86_INS_VPBROADCASTQ = 1009 + UC_X86_INS_VPBROADCASTW = 1010 + UC_X86_INS_VPCLMULQDQ = 1011 + UC_X86_INS_VPCMOV = 1012 + UC_X86_INS_VPCMPB = 1013 + UC_X86_INS_VPCMPD = 1014 + UC_X86_INS_VPCMPEQB = 1015 + UC_X86_INS_VPCMPEQD = 1016 + UC_X86_INS_VPCMPEQQ = 1017 + UC_X86_INS_VPCMPEQW = 1018 + UC_X86_INS_VPCMPESTRI = 1019 + UC_X86_INS_VPCMPESTRM = 1020 + UC_X86_INS_VPCMPGTB = 1021 + UC_X86_INS_VPCMPGTD = 1022 + UC_X86_INS_VPCMPGTQ = 1023 + UC_X86_INS_VPCMPGTW = 1024 + UC_X86_INS_VPCMPISTRI = 1025 + UC_X86_INS_VPCMPISTRM = 1026 + UC_X86_INS_VPCMPQ = 1027 + UC_X86_INS_VPCMPUB = 1028 + UC_X86_INS_VPCMPUD = 1029 + UC_X86_INS_VPCMPUQ = 1030 + UC_X86_INS_VPCMPUW = 1031 + UC_X86_INS_VPCMPW = 1032 + UC_X86_INS_VPCOMB = 1033 + UC_X86_INS_VPCOMD = 1034 + UC_X86_INS_VPCOMPRESSD = 1035 + UC_X86_INS_VPCOMPRESSQ = 1036 + UC_X86_INS_VPCOMQ = 1037 + UC_X86_INS_VPCOMUB = 1038 + UC_X86_INS_VPCOMUD = 1039 + UC_X86_INS_VPCOMUQ = 1040 + UC_X86_INS_VPCOMUW = 1041 + UC_X86_INS_VPCOMW = 1042 + UC_X86_INS_VPCONFLICTD = 1043 + UC_X86_INS_VPCONFLICTQ = 1044 + UC_X86_INS_VPERM2F128 = 1045 + UC_X86_INS_VPERM2I128 = 1046 + UC_X86_INS_VPERMD = 1047 + UC_X86_INS_VPERMI2D = 1048 + UC_X86_INS_VPERMI2PD = 1049 + UC_X86_INS_VPERMI2PS = 1050 + UC_X86_INS_VPERMI2Q = 1051 + UC_X86_INS_VPERMIL2PD = 1052 + UC_X86_INS_VPERMIL2PS = 1053 + UC_X86_INS_VPERMILPD = 1054 + UC_X86_INS_VPERMILPS = 1055 + UC_X86_INS_VPERMPD = 1056 + UC_X86_INS_VPERMPS = 1057 + UC_X86_INS_VPERMQ = 1058 + UC_X86_INS_VPERMT2D = 1059 + UC_X86_INS_VPERMT2PD = 1060 + UC_X86_INS_VPERMT2PS = 1061 + UC_X86_INS_VPERMT2Q = 1062 + UC_X86_INS_VPEXPANDD = 1063 + UC_X86_INS_VPEXPANDQ = 1064 + UC_X86_INS_VPEXTRB = 1065 + UC_X86_INS_VPEXTRD = 1066 + UC_X86_INS_VPEXTRQ = 1067 + UC_X86_INS_VPEXTRW = 1068 + UC_X86_INS_VPGATHERDD = 1069 + UC_X86_INS_VPGATHERDQ = 1070 + UC_X86_INS_VPGATHERQD = 1071 + UC_X86_INS_VPGATHERQQ = 1072 + UC_X86_INS_VPHADDBD = 1073 + UC_X86_INS_VPHADDBQ = 1074 + UC_X86_INS_VPHADDBW = 1075 + UC_X86_INS_VPHADDDQ = 1076 + UC_X86_INS_VPHADDD = 1077 + UC_X86_INS_VPHADDSW = 1078 + UC_X86_INS_VPHADDUBD = 1079 + UC_X86_INS_VPHADDUBQ = 1080 + UC_X86_INS_VPHADDUBW = 1081 + UC_X86_INS_VPHADDUDQ = 1082 + UC_X86_INS_VPHADDUWD = 1083 + UC_X86_INS_VPHADDUWQ = 1084 + UC_X86_INS_VPHADDWD = 1085 + UC_X86_INS_VPHADDWQ = 1086 + UC_X86_INS_VPHADDW = 1087 + UC_X86_INS_VPHMINPOSUW = 1088 + UC_X86_INS_VPHSUBBW = 1089 + UC_X86_INS_VPHSUBDQ = 1090 + UC_X86_INS_VPHSUBD = 1091 + UC_X86_INS_VPHSUBSW = 1092 + UC_X86_INS_VPHSUBWD = 1093 + UC_X86_INS_VPHSUBW = 1094 + UC_X86_INS_VPINSRB = 1095 + UC_X86_INS_VPINSRD = 1096 + UC_X86_INS_VPINSRQ = 1097 + UC_X86_INS_VPINSRW = 1098 + UC_X86_INS_VPLZCNTD = 1099 + UC_X86_INS_VPLZCNTQ = 1100 + UC_X86_INS_VPMACSDD = 1101 + UC_X86_INS_VPMACSDQH = 1102 + UC_X86_INS_VPMACSDQL = 1103 + UC_X86_INS_VPMACSSDD = 1104 + UC_X86_INS_VPMACSSDQH = 1105 + UC_X86_INS_VPMACSSDQL = 1106 + UC_X86_INS_VPMACSSWD = 1107 + UC_X86_INS_VPMACSSWW = 1108 + UC_X86_INS_VPMACSWD = 1109 + UC_X86_INS_VPMACSWW = 1110 + UC_X86_INS_VPMADCSSWD = 1111 + UC_X86_INS_VPMADCSWD = 1112 + UC_X86_INS_VPMADDUBSW = 1113 + UC_X86_INS_VPMADDWD = 1114 + UC_X86_INS_VPMASKMOVD = 1115 + UC_X86_INS_VPMASKMOVQ = 1116 + UC_X86_INS_VPMAXSB = 1117 + UC_X86_INS_VPMAXSD = 1118 + UC_X86_INS_VPMAXSQ = 1119 + UC_X86_INS_VPMAXSW = 1120 + UC_X86_INS_VPMAXUB = 1121 + UC_X86_INS_VPMAXUD = 1122 + UC_X86_INS_VPMAXUQ = 1123 + UC_X86_INS_VPMAXUW = 1124 + UC_X86_INS_VPMINSB = 1125 + UC_X86_INS_VPMINSD = 1126 + UC_X86_INS_VPMINSQ = 1127 + UC_X86_INS_VPMINSW = 1128 + UC_X86_INS_VPMINUB = 1129 + UC_X86_INS_VPMINUD = 1130 + UC_X86_INS_VPMINUQ = 1131 + UC_X86_INS_VPMINUW = 1132 + UC_X86_INS_VPMOVDB = 1133 + UC_X86_INS_VPMOVDW = 1134 + UC_X86_INS_VPMOVM2B = 1135 + UC_X86_INS_VPMOVM2D = 1136 + UC_X86_INS_VPMOVM2Q = 1137 + UC_X86_INS_VPMOVM2W = 1138 + UC_X86_INS_VPMOVMSKB = 1139 + UC_X86_INS_VPMOVQB = 1140 + UC_X86_INS_VPMOVQD = 1141 + UC_X86_INS_VPMOVQW = 1142 + UC_X86_INS_VPMOVSDB = 1143 + UC_X86_INS_VPMOVSDW = 1144 + UC_X86_INS_VPMOVSQB = 1145 + UC_X86_INS_VPMOVSQD = 1146 + UC_X86_INS_VPMOVSQW = 1147 + UC_X86_INS_VPMOVSXBD = 1148 + UC_X86_INS_VPMOVSXBQ = 1149 + UC_X86_INS_VPMOVSXBW = 1150 + UC_X86_INS_VPMOVSXDQ = 1151 + UC_X86_INS_VPMOVSXWD = 1152 + UC_X86_INS_VPMOVSXWQ = 1153 + UC_X86_INS_VPMOVUSDB = 1154 + UC_X86_INS_VPMOVUSDW = 1155 + UC_X86_INS_VPMOVUSQB = 1156 + UC_X86_INS_VPMOVUSQD = 1157 + UC_X86_INS_VPMOVUSQW = 1158 + UC_X86_INS_VPMOVZXBD = 1159 + UC_X86_INS_VPMOVZXBQ = 1160 + UC_X86_INS_VPMOVZXBW = 1161 + UC_X86_INS_VPMOVZXDQ = 1162 + UC_X86_INS_VPMOVZXWD = 1163 + UC_X86_INS_VPMOVZXWQ = 1164 + UC_X86_INS_VPMULDQ = 1165 + UC_X86_INS_VPMULHRSW = 1166 + UC_X86_INS_VPMULHUW = 1167 + UC_X86_INS_VPMULHW = 1168 + UC_X86_INS_VPMULLD = 1169 + UC_X86_INS_VPMULLQ = 1170 + UC_X86_INS_VPMULLW = 1171 + UC_X86_INS_VPMULUDQ = 1172 + UC_X86_INS_VPORD = 1173 + UC_X86_INS_VPORQ = 1174 + UC_X86_INS_VPOR = 1175 + UC_X86_INS_VPPERM = 1176 + UC_X86_INS_VPROTB = 1177 + UC_X86_INS_VPROTD = 1178 + UC_X86_INS_VPROTQ = 1179 + UC_X86_INS_VPROTW = 1180 + UC_X86_INS_VPSADBW = 1181 + UC_X86_INS_VPSCATTERDD = 1182 + UC_X86_INS_VPSCATTERDQ = 1183 + UC_X86_INS_VPSCATTERQD = 1184 + UC_X86_INS_VPSCATTERQQ = 1185 + UC_X86_INS_VPSHAB = 1186 + UC_X86_INS_VPSHAD = 1187 + UC_X86_INS_VPSHAQ = 1188 + UC_X86_INS_VPSHAW = 1189 + UC_X86_INS_VPSHLB = 1190 + UC_X86_INS_VPSHLD = 1191 + UC_X86_INS_VPSHLQ = 1192 + UC_X86_INS_VPSHLW = 1193 + UC_X86_INS_VPSHUFB = 1194 + UC_X86_INS_VPSHUFD = 1195 + UC_X86_INS_VPSHUFHW = 1196 + UC_X86_INS_VPSHUFLW = 1197 + UC_X86_INS_VPSIGNB = 1198 + UC_X86_INS_VPSIGND = 1199 + UC_X86_INS_VPSIGNW = 1200 + UC_X86_INS_VPSLLDQ = 1201 + UC_X86_INS_VPSLLD = 1202 + UC_X86_INS_VPSLLQ = 1203 + UC_X86_INS_VPSLLVD = 1204 + UC_X86_INS_VPSLLVQ = 1205 + UC_X86_INS_VPSLLW = 1206 + UC_X86_INS_VPSRAD = 1207 + UC_X86_INS_VPSRAQ = 1208 + UC_X86_INS_VPSRAVD = 1209 + UC_X86_INS_VPSRAVQ = 1210 + UC_X86_INS_VPSRAW = 1211 + UC_X86_INS_VPSRLDQ = 1212 + UC_X86_INS_VPSRLD = 1213 + UC_X86_INS_VPSRLQ = 1214 + UC_X86_INS_VPSRLVD = 1215 + UC_X86_INS_VPSRLVQ = 1216 + UC_X86_INS_VPSRLW = 1217 + UC_X86_INS_VPSUBB = 1218 + UC_X86_INS_VPSUBD = 1219 + UC_X86_INS_VPSUBQ = 1220 + UC_X86_INS_VPSUBSB = 1221 + UC_X86_INS_VPSUBSW = 1222 + UC_X86_INS_VPSUBUSB = 1223 + UC_X86_INS_VPSUBUSW = 1224 + UC_X86_INS_VPSUBW = 1225 + UC_X86_INS_VPTESTMD = 1226 + UC_X86_INS_VPTESTMQ = 1227 + UC_X86_INS_VPTESTNMD = 1228 + UC_X86_INS_VPTESTNMQ = 1229 + UC_X86_INS_VPTEST = 1230 + UC_X86_INS_VPUNPCKHBW = 1231 + UC_X86_INS_VPUNPCKHDQ = 1232 + UC_X86_INS_VPUNPCKHQDQ = 1233 + UC_X86_INS_VPUNPCKHWD = 1234 + UC_X86_INS_VPUNPCKLBW = 1235 + UC_X86_INS_VPUNPCKLDQ = 1236 + UC_X86_INS_VPUNPCKLQDQ = 1237 + UC_X86_INS_VPUNPCKLWD = 1238 + UC_X86_INS_VPXORD = 1239 + UC_X86_INS_VPXORQ = 1240 + UC_X86_INS_VPXOR = 1241 + UC_X86_INS_VRCP14PD = 1242 + UC_X86_INS_VRCP14PS = 1243 + UC_X86_INS_VRCP14SD = 1244 + UC_X86_INS_VRCP14SS = 1245 + UC_X86_INS_VRCP28PD = 1246 + UC_X86_INS_VRCP28PS = 1247 + UC_X86_INS_VRCP28SD = 1248 + UC_X86_INS_VRCP28SS = 1249 + UC_X86_INS_VRCPPS = 1250 + UC_X86_INS_VRCPSS = 1251 + UC_X86_INS_VRNDSCALEPD = 1252 + UC_X86_INS_VRNDSCALEPS = 1253 + UC_X86_INS_VRNDSCALESD = 1254 + UC_X86_INS_VRNDSCALESS = 1255 + UC_X86_INS_VROUNDPD = 1256 + UC_X86_INS_VROUNDPS = 1257 + UC_X86_INS_VROUNDSD = 1258 + UC_X86_INS_VROUNDSS = 1259 + UC_X86_INS_VRSQRT14PD = 1260 + UC_X86_INS_VRSQRT14PS = 1261 + UC_X86_INS_VRSQRT14SD = 1262 + UC_X86_INS_VRSQRT14SS = 1263 + UC_X86_INS_VRSQRT28PD = 1264 + UC_X86_INS_VRSQRT28PS = 1265 + UC_X86_INS_VRSQRT28SD = 1266 + UC_X86_INS_VRSQRT28SS = 1267 + UC_X86_INS_VRSQRTPS = 1268 + UC_X86_INS_VRSQRTSS = 1269 + UC_X86_INS_VSCATTERDPD = 1270 + UC_X86_INS_VSCATTERDPS = 1271 + UC_X86_INS_VSCATTERPF0DPD = 1272 + UC_X86_INS_VSCATTERPF0DPS = 1273 + UC_X86_INS_VSCATTERPF0QPD = 1274 + UC_X86_INS_VSCATTERPF0QPS = 1275 + UC_X86_INS_VSCATTERPF1DPD = 1276 + UC_X86_INS_VSCATTERPF1DPS = 1277 + UC_X86_INS_VSCATTERPF1QPD = 1278 + UC_X86_INS_VSCATTERPF1QPS = 1279 + UC_X86_INS_VSCATTERQPD = 1280 + UC_X86_INS_VSCATTERQPS = 1281 + UC_X86_INS_VSHUFPD = 1282 + UC_X86_INS_VSHUFPS = 1283 + UC_X86_INS_VSQRTPD = 1284 + UC_X86_INS_VSQRTPS = 1285 + UC_X86_INS_VSQRTSD = 1286 + UC_X86_INS_VSQRTSS = 1287 + UC_X86_INS_VSTMXCSR = 1288 + UC_X86_INS_VSUBPD = 1289 + UC_X86_INS_VSUBPS = 1290 + UC_X86_INS_VSUBSD = 1291 + UC_X86_INS_VSUBSS = 1292 + UC_X86_INS_VTESTPD = 1293 + UC_X86_INS_VTESTPS = 1294 + UC_X86_INS_VUNPCKHPD = 1295 + UC_X86_INS_VUNPCKHPS = 1296 + UC_X86_INS_VUNPCKLPD = 1297 + UC_X86_INS_VUNPCKLPS = 1298 + UC_X86_INS_VZEROALL = 1299 + UC_X86_INS_VZEROUPPER = 1300 + UC_X86_INS_WAIT = 1301 + UC_X86_INS_WBINVD = 1302 + UC_X86_INS_WRFSBASE = 1303 + UC_X86_INS_WRGSBASE = 1304 + UC_X86_INS_WRMSR = 1305 + UC_X86_INS_XABORT = 1306 + UC_X86_INS_XACQUIRE = 1307 + UC_X86_INS_XBEGIN = 1308 + UC_X86_INS_XCHG = 1309 + UC_X86_INS_XCRYPTCBC = 1310 + UC_X86_INS_XCRYPTCFB = 1311 + UC_X86_INS_XCRYPTCTR = 1312 + UC_X86_INS_XCRYPTECB = 1313 + UC_X86_INS_XCRYPTOFB = 1314 + UC_X86_INS_XEND = 1315 + UC_X86_INS_XGETBV = 1316 + UC_X86_INS_XLATB = 1317 + UC_X86_INS_XRELEASE = 1318 + UC_X86_INS_XRSTOR = 1319 + UC_X86_INS_XRSTOR64 = 1320 + UC_X86_INS_XRSTORS = 1321 + UC_X86_INS_XRSTORS64 = 1322 + UC_X86_INS_XSAVE = 1323 + UC_X86_INS_XSAVE64 = 1324 + UC_X86_INS_XSAVEC = 1325 + UC_X86_INS_XSAVEC64 = 1326 + UC_X86_INS_XSAVEOPT = 1327 + UC_X86_INS_XSAVEOPT64 = 1328 + UC_X86_INS_XSAVES = 1329 + UC_X86_INS_XSAVES64 = 1330 + UC_X86_INS_XSETBV = 1331 + UC_X86_INS_XSHA1 = 1332 + UC_X86_INS_XSHA256 = 1333 + UC_X86_INS_XSTORE = 1334 + UC_X86_INS_XTEST = 1335 + UC_X86_INS_FDISI8087_NOP = 1336 + UC_X86_INS_FENI8087_NOP = 1337 + UC_X86_INS_ENDING = 1338 +end \ No newline at end of file diff --git a/bindings/ruby/unicorn_gem/pkg/.gitignore b/bindings/ruby/unicorn_gem/pkg/.gitignore new file mode 100644 index 00000000..e394af59 --- /dev/null +++ b/bindings/ruby/unicorn_gem/pkg/.gitignore @@ -0,0 +1,10 @@ +/.bundle/ +/.yardoc +/Gemfile.lock +/_yardoc/ +/coverage/ +/doc/ +/pkg/ +/spec/reports/ +/tmp/ +.gem diff --git a/bindings/ruby/unicorn_gem/pkg/unicorn-0.9.0.gem b/bindings/ruby/unicorn_gem/pkg/unicorn-0.9.0.gem new file mode 100644 index 0000000000000000000000000000000000000000..57b7a6b32541290b63026617f81080101054d520 GIT binary patch literal 20992 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 hy(_=6RQ_cDaEIf?qS5k%aB3M} + spec.homepage = "https://unicorn-engine.org" + + spec.files = Dir["lib/unicorn/*.rb"] + Dir["ext/unicorn.c"] + Dir["ext/unicorn.h"] + Dir["ext/extconf.rb"] + spec.require_paths = ["lib","ext"] + spec.extensions = ["ext/extconf.rb"] + spec.add_development_dependency "bundler", "~> 1.11" + spec.add_development_dependency "rake", "~> 10.0" +end