NCPrePatcher 0.2.0 → 0.3.2

data/lib/ncpp/version.rb

@@ -1,4 +1,4 @@
 
 module NCPP
-  VERSION = '0.2.0'
+  VERSION = '0.3.2'
 end

data/lib/ncpp.rb

@@ -1,6 +1,8 @@
-require_relative 'nitro/nitro.rb'
-require_relative 'unarm/unarm.rb'
-require_relative 'ncpp/interpreter.rb'
+require_relative 'nitro/nitro'
+require_relative 'unarm/unarm'
+require_relative 'unicorn/unicorn'
+require_relative 'keystone/keystone'
+require_relative 'ncpp/interpreter'
 
 require 'json'
 require 'optparse'
@@ -15,6 +17,10 @@ module NCPP
 
   alias $rom $clean_rom # In most cases the clean rom will be desired
 
+  $emu = nil
+  $arm_assembler = nil
+  $thumb_assembler = nil
+
   $config = nil
 
   NCP_CONFIG_FILE_PATH   = 'ncpatcher.json'
@@ -141,6 +147,11 @@ module NCPP
 
     Unarm.load_symbols9(cfg['symbols9'].gsub(/\$\{env:([^}]+)\}/) { ENV[$1] }) unless cfg['symbols9'].empty?
     Unarm.load_symbols7(cfg['symbols7'].gsub(/\$\{env:([^}]+)\}/) { ENV[$1] }) unless cfg['symbols7'].empty?
+
+    $emu = Uc::Emu.new
+    $emu.load_arm9
+    $arm_assembler = Ks::Assembler.new
+    $thumb_assembler = Ks::Assembler.new(mode: Ks::KS_MODE_THUMB)
   end
 
   def self.uninstall(cfg_path = CONFIG_FILE_PATH)
@@ -426,20 +437,6 @@ module NCPP
         end
       end
 
-      # interpreter = CFileInterpreter.new(
-      #   files, $config['gen_path'], $config['command_prefix'], extra_commands, extra_variables,
-      #   safe: safe_mode, puritan: puritan_mode
-      # )
-      # interpreter.run(verbose: !quiet)
-      # lines_parsed += interpreter.lines_parsed
-
-      # unless interpreter.incomplete_files.empty?
-      #   interpreter.incomplete_files.each do |file|
-      #     timestamp_cache.delete(file)
-      #     success = false
-      #   end
-      # end
-
     end
 
     timestamp_cache['NCPP_VERSION'] = VERSION
@@ -447,9 +444,6 @@ module NCPP
     FileUtils.mkdir_p(File.dirname(timestamp_cache_path))
     File.write(timestamp_cache_path, JSON.generate(timestamp_cache))
 
-    # FileUtils.mkdir_p(File.dirname(cmd_cache_path))
-    # File.write(cmd_cache_path, JSON.generate(command_cache))
-
     unless quiet
       if lines_parsed > 0
         msg = "\nParsed #{lines_parsed} line#{'s' if lines_parsed != 1} across " \

data/lib/nitro/nitro.rb

@@ -13,6 +13,7 @@ module NitroBind
   typedef :pointer, :codebin_handle
   typedef :pointer, :ovte_handle
   typedef :pointer, :module_params_handle
+  typedef :pointer, :autoload_entry_handle
 
   attach_function :nitroRom_alloc, [], :rom_handle
   attach_function :nitroRom_release, [:rom_handle], :void
@@ -48,12 +49,15 @@ module NitroBind
   attach_function :codeBin_readCString, [:codebin_handle, :uint32], :string
   attach_function :codeBin_getSize, [:codebin_handle], :uint32
   attach_function :codeBin_getStartAddress, [:codebin_handle], :uint32
+  attach_function :codeBin_getSectPtr, [:codebin_handle, :uint32, :size_t], :pointer
 
   attach_function :armBin_alloc, [], :codebin_handle
   attach_function :armBin_release, [:codebin_handle], :void
   attach_function :armBin_load, [:codebin_handle, :string, :uint32, :uint32, :uint32, :bool], :bool
   attach_function :armBin_getEntryPointAddress, [:codebin_handle], :uint32
   attach_function :armBin_getModuleParams, [:codebin_handle], :module_params_handle
+  attach_function :armBin_getAutoloadEntry, [:codebin_handle, :size_t], :autoload_entry_handle
+  attach_function :armBin_getAutoloadEntryCount, [:codebin_handle], :size_t
   attach_function :armBin_sanityCheckAddress, [:codebin_handle, :uint32], :bool
 
   attach_function :overlayBin_alloc, [], :codebin_handle
@@ -176,7 +180,7 @@ module Nitro
       raise ArgumentError, 'step must be 1, 2, 4, or 8 (bytes)' unless [1,2,4,8].include? step
       raise ArgumentError, 'range must be a Range' unless range.is_a? Range
 
-      clamped = Range.new([range.begin || start_addr, start_addr].max, [range.end || end_addr, end_addr].min)
+      clamped = Range.new(range.begin || start_addr, [range.end || end_addr, end_addr].min)
 
       clamped.step(step).map { |addr| [send(:"read#{step * 8}", addr), addr] }
     end
@@ -211,17 +215,25 @@ module Nitro
       end
     end
 
-    def read_cstring(start_addr)
-      codeBin_readCString(@ptr, start_addr)
+    def read_cstring(addr)
+      codeBin_readCString(@ptr, addr)
     end
     alias_method :read_cstr, :read_cstring
 
+    def get_section_ptr(addr, sect_size)
+      ptr = FFI::MemoryPointer.new(:pointer, 1)
+      ptr.write_pointer(codeBin_getSectPtr(@ptr, addr, sect_size))
+      raise "Could not read #{sect_size} bytes from address #{addr.to_hex}" if ptr.read_pointer == FFI::Pointer::NULL
+      ptr.read_pointer
+    end
+    alias_method :get_sect_ptr, :get_section_ptr
+
   end
 
   class ArmBin < CodeBin
     include NitroBind
 
-    attr_reader :module_params
+    attr_reader :module_params, :autoload_entries
 
     class ModuleParams < FFI::Struct
       layout :autoload_list_start, :uint32,
@@ -235,10 +247,17 @@ module Nitro
              :nitro_code_le,       :uint32
     end
 
+    class AutoLoadEntry < FFI::Struct
+      layout :address,     :uint32,
+             :size,        :uint32,
+             :bss_size,    :uint32,
+             :data_offset, :uint32
+    end
+
     def initialize(args = {})
       if args.has_key? :file_path
         @ptr = FFI::AutoPointer.new(armBin_alloc, method(:armBin_release))
-        if not File.exist? args[:file_path]
+        if !File.exist?(args[:file_path])
           puts "Error: #{args[:file_path]} does not exist"
           raise 'ArmBin initialization failed'
         end
@@ -253,6 +272,9 @@ module Nitro
       end
 
       @module_params = ModuleParams.new(armBin_getModuleParams(@ptr))
+      @autoload_entries = []
+      autoload_entry_count = armBin_getAutoloadEntryCount(@ptr)
+      autoload_entry_count.times {|id| autoload_entries << AutoLoadEntry.new(armBin_getAutoloadEntry(@ptr,id)) }
     end
 
     def entry_point_address

data/lib/unicorn/arm_const.rb

@@ -0,0 +1,196 @@
+# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [arm_const.rb]
+
+module UnicornEngine
+
+# ARM CPU
+
+  UC_CPU_ARM_926 = 0
+  UC_CPU_ARM_946 = 1
+  UC_CPU_ARM_1026 = 2
+  UC_CPU_ARM_1136_R2 = 3
+  UC_CPU_ARM_1136 = 4
+  UC_CPU_ARM_1176 = 5
+  UC_CPU_ARM_11MPCORE = 6
+  UC_CPU_ARM_CORTEX_M0 = 7
+  UC_CPU_ARM_CORTEX_M3 = 8
+  UC_CPU_ARM_CORTEX_M4 = 9
+  UC_CPU_ARM_CORTEX_M7 = 10
+  UC_CPU_ARM_CORTEX_M33 = 11
+  UC_CPU_ARM_CORTEX_R5 = 12
+  UC_CPU_ARM_CORTEX_R5F = 13
+  UC_CPU_ARM_CORTEX_A7 = 14
+  UC_CPU_ARM_CORTEX_A8 = 15
+  UC_CPU_ARM_CORTEX_A9 = 16
+  UC_CPU_ARM_CORTEX_A15 = 17
+  UC_CPU_ARM_TI925T = 18
+  UC_CPU_ARM_SA1100 = 19
+  UC_CPU_ARM_SA1110 = 20
+  UC_CPU_ARM_PXA250 = 21
+  UC_CPU_ARM_PXA255 = 22
+  UC_CPU_ARM_PXA260 = 23
+  UC_CPU_ARM_PXA261 = 24
+  UC_CPU_ARM_PXA262 = 25
+  UC_CPU_ARM_PXA270 = 26
+  UC_CPU_ARM_PXA270A0 = 27
+  UC_CPU_ARM_PXA270A1 = 28
+  UC_CPU_ARM_PXA270B0 = 29
+  UC_CPU_ARM_PXA270B1 = 30
+  UC_CPU_ARM_PXA270C0 = 31
+  UC_CPU_ARM_PXA270C5 = 32
+  UC_CPU_ARM_MAX = 33
+  UC_CPU_ARM_ENDING = 34
+
+# 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_C1_C0_2 = 111
+  UC_ARM_REG_C13_C0_2 = 112
+  UC_ARM_REG_C13_C0_3 = 113
+  UC_ARM_REG_IPSR = 114
+  UC_ARM_REG_MSP = 115
+  UC_ARM_REG_PSP = 116
+  UC_ARM_REG_CONTROL = 117
+  UC_ARM_REG_IAPSR = 118
+  UC_ARM_REG_EAPSR = 119
+  UC_ARM_REG_XPSR = 120
+  UC_ARM_REG_EPSR = 121
+  UC_ARM_REG_IEPSR = 122
+  UC_ARM_REG_PRIMASK = 123
+  UC_ARM_REG_BASEPRI = 124
+  UC_ARM_REG_BASEPRI_MAX = 125
+  UC_ARM_REG_FAULTMASK = 126
+  UC_ARM_REG_APSR_NZCVQ = 127
+  UC_ARM_REG_APSR_G = 128
+  UC_ARM_REG_APSR_NZCVQG = 129
+  UC_ARM_REG_IAPSR_NZCVQ = 130
+  UC_ARM_REG_IAPSR_G = 131
+  UC_ARM_REG_IAPSR_NZCVQG = 132
+  UC_ARM_REG_EAPSR_NZCVQ = 133
+  UC_ARM_REG_EAPSR_G = 134
+  UC_ARM_REG_EAPSR_NZCVQG = 135
+  UC_ARM_REG_XPSR_NZCVQ = 136
+  UC_ARM_REG_XPSR_G = 137
+  UC_ARM_REG_XPSR_NZCVQG = 138
+  UC_ARM_REG_CP_REG = 139
+  UC_ARM_REG_ESR = 140
+  UC_ARM_REG_ENDING = 141
+
+# 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

data/lib/unicorn/unicorn.rb

@@ -0,0 +1,204 @@
+require 'ffi'
+
+require_relative 'arm_const'
+require_relative 'unicorn_const'
+
+include UnicornEngine
+
+module UnicornBind
+  extend FFI::Library
+  ffi_lib [
+    File.expand_path("unicorn", __dir__),
+    File.expand_path("unicorn.dylib", __dir__),
+    File.expand_path("unicorn.so", __dir__),
+  ]
+
+  typedef :pointer, :uc_engine        # ptr to uc_engine instance
+  typedef :pointer, :uc_engine_handle # ptr to a uc_engine ptr
+  typedef :pointer, :reg_val_ptr
+  typedef :pointer, :reg_val_ptr_arr
+  typedef :pointer, :reg_id_arr
+  typedef :uint64,  :addr
+  typedef :uint,    :uc_arch
+  typedef :uint,    :uc_mode
+  typedef :uint,    :uc_err
+  typedef :uint,    :uc_query_type
+  typedef :uint,    :uc_control_type
+  typedef :int,     :reg_id
+
+  attach_function :uc_version, [:pointer,:pointer], :uint
+  attach_function :uc_arch_supported, [:uc_arch], :bool
+  attach_function :uc_open, [:uc_arch, :uc_mode, :uc_engine_handle], :uc_err
+  attach_function :uc_close, [:uc_engine], :uc_err
+  attach_function :uc_query, [:uc_engine, :uc_query_type, :pointer], :uc_err
+  attach_function :uc_ctl, [:uc_engine, :uc_control_type, :varargs], :uc_err
+  attach_function :uc_errno, [:uc_engine], :uc_err
+  attach_function :uc_strerror, [:uc_err], :string
+  attach_function :uc_reg_write, [:uc_engine, :reg_id, :reg_val_ptr], :uc_err
+  attach_function :uc_reg_read, [:uc_engine, :reg_id, :reg_val_ptr], :uc_err
+  attach_function :uc_reg_write_batch, [:uc_engine, :reg_id_arr, :reg_val_ptr_arr, :int], :uc_err
+  attach_function :uc_reg_read_batch, [:uc_engine, :reg_id_arr, :reg_val_ptr_arr, :int], :uc_err
+  attach_function :uc_mem_write, [:uc_engine, :addr, :pointer, :uint64], :uc_err
+  attach_function :uc_mem_read, [:uc_engine, :addr, :pointer, :uint64], :uc_err
+  attach_function :uc_emu_start, [:uc_engine, :addr, :addr, :uint64, :size_t], :uc_err
+  attach_function :uc_emu_stop, [:uc_engine], :uc_err
+  attach_function :uc_mem_map, [:uc_engine, :addr, :uint64, :uint32], :uc_err
+  attach_function :uc_mem_map_ptr, [:uc_engine, :addr, :uint64, :uint32, :pointer], :uc_err
+  attach_function :uc_mem_unmap, [:uc_engine, :addr, :uint64], :uc_err
+  attach_function :uc_mem_protect, [:uc_engine, :addr, :uint64, :uint32], :uc_err
+
+  REG_ID = {
+    r0:   UC_ARM_REG_R0,
+    r1:   UC_ARM_REG_R1,
+    r2:   UC_ARM_REG_R2,
+    r3:   UC_ARM_REG_R3,
+    r4:   UC_ARM_REG_R4,
+    r5:   UC_ARM_REG_R5,
+    r6:   UC_ARM_REG_R6,
+    r7:   UC_ARM_REG_R7,
+    r8:   UC_ARM_REG_R8,
+    r9:   UC_ARM_REG_R9,
+    r10:  UC_ARM_REG_R10,
+    r11:  UC_ARM_REG_R11,
+    r12:  UC_ARM_REG_R12,
+    sp:   UC_ARM_REG_SP,
+    lr:   UC_ARM_REG_LR,
+    pc:   UC_ARM_REG_PC,
+    cpsr: UC_ARM_REG_CPSR,
+    spsr: UC_ARM_REG_SPSR
+  }.freeze
+end
+
+module Unicorn
+  extend UnicornBind
+
+  class Region
+    attr_reader :addr, :size, :prot, :end_addr
+    def initialize(addr, size, prot = UC_PROT_ALL)
+      @addr = addr
+      @size = size
+      @prot = prot
+      @end_addr = addr + size
+    end
+  end
+
+  NDS_REGIONS = [
+    Region.new(0x1ff8000, 32*1024),      # ITCM         -> 32KB
+    Region.new(0x2000000, 4*1024*1024),  # Main memory  -> 4MB
+    Region.new(0x4000000, 64*1024*1024), # I/O and VRAM -> 64MB
+    Region.new(0xffff000, 32*1024)       # BIOS         -> 32KB
+  ].freeze
+
+  class Section
+    attr_reader :addr, :ptr, :size, :end_addr
+    def initialize(addr, ffi_ptr, size)
+      @addr = addr
+      @ptr = ffi_ptr
+      @size = size
+      @end_addr = addr + size
+    end
+  end
+  Sect = Section
+
+  class Emulator
+    include UnicornBind
+
+    def initialize(arch: UC_ARCH_ARM, mode: UC_MODE_ARM946, regions: NDS_REGIONS, sections: [], registers: {})
+
+      FFI::MemoryPointer.new(:pointer, 1) do |ptr|
+        safe_call(:uc_open, arch, mode, ptr)
+        @engine = FFI::AutoPointer.new(ptr.read_pointer, method(:uc_close))
+      end
+
+      regions.each { add_region(it) } unless regions.empty?
+      sections.each { add_sect(it) } unless sections.empty?
+      registers.each {|r,v| write_register(r,v) } unless registers.empty?
+    end
+
+    def run(from: nil, to: -1, timeout_ms: 0, max_ins: 0)
+      raise "The 'from' parameter must be specified" if from.nil?
+      if to == -1 && timeout_ms == 0 && max_ins == 0
+        raise "The 'to' parameter must be specified if 'timeout_ms' or 'max_ins' are not"
+      end
+      safe_call(:uc_emu_start, @engine, from, to, timeout_ms, max_ins)
+    end
+
+    def add_region(region)
+      safe_call(:uc_mem_map, @engine, region.addr, region.size, region.prot)
+    end
+
+    def add_section(sect)
+      safe_call(:uc_mem_write, @engine, sect.addr, sect.ptr, sect.size)
+    end
+    alias_method :add_sect, :add_section
+
+    def write_mem(addr, byte_str)
+      FFI::MemoryPointer.new(:uint8, byte_str.bytesize) do |ptr|
+        ptr.write_array_of_uint8(byte_str.bytes)
+        safe_call(:uc_mem_write, @engine, addr, ptr, byte_str.bytesize)
+      end
+    end
+
+    def read_mem(addr, size)
+      byte_str = nil
+      FFI::MemoryPointer.new(:uint8, size) do |ptr|
+        safe_call(:uc_mem_read, @engine, addr, ptr, size)
+        byte_str = ptr.read_array_of_uint8(size).pack('C*')
+      end
+      byte_str
+    end
+
+    def write_register(reg, val)
+      FFI::MemoryPointer.new(:int32, 1) do |pv|
+        pv.write_int(val)
+        safe_call(:uc_reg_write, @engine, REG_ID[reg], pv)
+      end
+    end
+    alias_method :write_reg, :write_register
+
+    def write_registers(regs_h)
+      regs_h.each {|r,v| write_register(r,v) }
+    end
+    alias_method :write_regs, :write_registers
+
+    REG_ID.each do |name, id|
+      define_method("write_#{name.to_s}".to_sym) do |val|
+        write_register(name, val)
+      end
+    end
+
+    def read_register(reg)
+      val = nil
+      FFI::MemoryPointer.new(:int32, 1) do |pv|
+        safe_call(:uc_reg_read, @engine, REG_ID[reg], pv)
+        val = pv.read_int32
+      end
+      val
+    end
+    alias_method :read_reg, :read_register
+
+    def read_registers(reg_names = REG_ID.keys)
+      regs_h = {}
+      reg_names.each {|r| regs_h[r] = read_register(r) }
+      regs_h
+    end
+    alias_method :read_regs, :read_registers
+
+    REG_ID.each do |name, id|
+      define_method("read_#{name.to_s}".to_sym) do
+        read_register(name)
+      end
+    end
+
+  private
+    def safe_call(meth_sym, *args)
+      err = send(meth_sym, *args)
+      raise "Error from #{meth_sym.to_s}: #{uc_strerror(err)}" if err != UC_ERR_OK
+    end
+  end
+
+  Emu = Emulator
+
+end
+
+Uc = Unicorn

data/lib/unicorn/unicorn_const.rb

@@ -0,0 +1,152 @@
+# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [unicorn_const.rb]
+
+module UnicornEngine
+  UC_API_MAJOR = 2
+  UC_API_MINOR = 1
+  UC_API_PATCH = 4
+  UC_API_EXTRA = 255
+  UC_VERSION_MAJOR = 2
+  UC_VERSION_MINOR = 1
+  UC_VERSION_PATCH = 4
+  UC_VERSION_EXTRA = 255
+  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_RISCV = 8
+  UC_ARCH_S390X = 9
+  UC_ARCH_TRICORE = 10
+  UC_ARCH_MAX = 11
+
+  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_ARMBE8 = 1024
+  UC_MODE_ARM926 = 128
+  UC_MODE_ARM946 = 256
+  UC_MODE_ARM1176 = 512
+  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_MODE_RISCV32 = 4
+  UC_MODE_RISCV64 = 8
+
+  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_ERR_EXCEPTION = 21
+  UC_ERR_OVERFLOW = 22
+
+  UC_PROT_NONE = 0
+  UC_PROT_READ = 1
+  UC_PROT_WRITE = 2
+  UC_PROT_EXEC = 4
+  UC_PROT_ALL = 7
+  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_MEM_READ_AFTER = 25
+
+  UC_TCG_OP_SUB = 0
+  UC_TCG_OP_FLAG_CMP = 1
+  UC_TCG_OP_FLAG_DIRECT = 2
+  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_READ_AFTER = 8192
+  UC_HOOK_INSN_INVALID = 16384
+  UC_HOOK_EDGE_GENERATED = 32768
+  UC_HOOK_TCG_OPCODE = 65536
+  UC_HOOK_TLB_FILL = 131072
+  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_QUERY_ARCH = 3
+  UC_QUERY_TIMEOUT = 4
+
+  UC_CTL_IO_NONE = 0
+  UC_CTL_IO_WRITE = 1
+  UC_CTL_IO_READ = 2
+  UC_CTL_IO_READ_WRITE = 3
+
+  UC_TLB_CPU = 0
+  UC_TLB_VIRTUAL = 1
+
+  UC_CTL_UC_MODE = 0
+  UC_CTL_UC_PAGE_SIZE = 1
+  UC_CTL_UC_ARCH = 2
+  UC_CTL_UC_TIMEOUT = 3
+  UC_CTL_UC_USE_EXITS = 4
+  UC_CTL_UC_EXITS_CNT = 5
+  UC_CTL_UC_EXITS = 6
+  UC_CTL_CPU_MODEL = 7
+  UC_CTL_TB_REQUEST_CACHE = 8
+  UC_CTL_TB_REMOVE_CACHE = 9
+  UC_CTL_TB_FLUSH = 10
+  UC_CTL_TLB_FLUSH = 11
+  UC_CTL_TLB_TYPE = 12
+  UC_CTL_TCG_BUFFER_SIZE = 13
+  UC_CTL_CONTEXT_MODE = 14
+  UC_CTL_CONTEXT_CPU = 1
+  UC_CTL_CONTEXT_MEMORY = 2
+end

data/lib/unicorn/version.rb

@@ -0,0 +1,3 @@
+module Unicorn
+  VERSION = "2.1.4"
+end