evoasm 0.0.2.pre7 → 0.1.0.pre2

data/lib/evoasm/prng.rb

@@ -0,0 +1,64 @@
+module Evoasm
+  # A fast pseudo-random number generator.
+  class PRNG < FFI::AutoPointer
+
+    # Number of seed elements required
+    SEED_SIZE = 16
+
+    # Default seed values
+    DEFAULT_SEED = (1..SEED_SIZE).to_a
+
+    # @!visibility private
+    def self.release(ptr)
+      Libevoasm.prng_free ptr
+    end
+
+    # Gives the default {PRNG}, seeded with {DEFAULT_SEED}
+    # @return [PRNG] default {PRNG} instance
+    def self.default
+      @default_prng ||= new(DEFAULT_SEED)
+    end
+
+    # @param seed [Array<Integer>] the seed, must have exactly {SEED_SIZE} elements
+    # @return [PRNG] new {PRNG} instance
+    def initialize(seed = DEFAULT_SEED)
+      if seed.size != SEED_SIZE
+        raise ArgumentError, "seed must be have exactly #{SEED_SIZE} elements"
+      end
+
+      ptr = Libevoasm.prng_alloc
+
+      seed_ptr = FFI::MemoryPointer.new :uint64, SEED_SIZE
+      seed_ptr.write_array_of_uint64 seed
+
+      Libevoasm.prng_init ptr, seed_ptr
+      super(ptr)
+    end
+
+    # @return [Integer] a random number in the range (0..2**64 - 2)
+    def rand64
+      Libevoasm.prng_rand64 self
+    end
+
+    # @return [Integer] a random number in the range (0..2**32 - 2)
+    def rand32
+      Libevoasm.prng_rand32 self
+    end
+
+    # @return [Integer] a random number in the range (0..2**16 - 2)
+    def rand16
+      Libevoasm.prng_rand16 self
+    end
+
+    # @return [Integer] a random number in the range (0..2**8 - 2)
+    def rand8
+      Libevoasm.prng_rand8 self
+    end
+
+    # Gives a random number in the range (+min+..+max+ - 1)
+    # @return [Integer] random number
+    def rand_between(min, max)
+      Libevoasm.prng_rand_between self, min, max
+    end
+  end
+end

data/lib/evoasm/program.rb

@@ -1,23 +1,206 @@
-require 'evoasm/search'
+require 'ffi'
 
 module Evoasm
-  class Program
-    include Search::Util
 
-    def run(*input_example)
-      run_all(input_example).first
+  # Represents a program comprising one ore multiple kernels
+  class Program < FFI::AutoPointer
+
+    require_relative 'program/io.rb'
+
+
+    # @!visibility private
+    def self.release(ptr)
+      Libevoasm.program_destroy(ptr)
+      Libevoasm.program_free(ptr)
+    end
+
+    def initialize
+      ptr = Libevoasm.program_alloc
+      super ptr
+    end
+
+    # Runs the program with the given input
+    # @param input_tuple [Array] an input tuple
+    # @return [Array] the output tuple corresponding to the given input
+    def run(*input_tuple)
+      run_all(input_tuple).first
     end
 
+    # Like {#run}, but runs multiple input tuples at once
+    # @param input_examples [Array] an array of input tuples
+    # @return [Array] an array of output tuples
     def run_all(*input_examples)
-      input_examples, input_arity = flatten_examples input_examples
-      p input_examples, input_arity
-      a = __run__ input_examples, input_arity
-      p a
-      a
+      input = Program::Input.new(input_examples)
+
+      output_ptr = Libevoasm.program_run self, input
+
+      if output_ptr.null?
+        raise Error.last
+      end
+
+      Program::Output.new(output_ptr).to_a
+    end
+
+    # Gives the size of the program as the number of kernels
+    # @return [Integer] size
+    def size
+      Libevoasm.program_get_size self
+    end
+
+    # Eliminates intron instructions (instructions without effect)
+    # @return [Program] a new program with introns eliminated
+    def eliminate_introns
+      program = Program.new
+      unless Libevoasm.program_eliminate_introns self, program
+        raise Libevoasm::Error.last
+      end
+
+      program
+    end
+
+    # Gives the disassembly for the specified kernel
+    # @param kernel_index [Integer] index of kernel to disassemble
+    # @return [String] disassembly
+    def disassemble_kernel(kernel_index)
+      code_ptr_ptr = FFI::MemoryPointer.new :pointer
+      code_len = Libevoasm.program_get_kernel_code self, kernel_index, code_ptr_ptr
+      code_ptr = code_ptr_ptr.read_pointer
+      code = code_ptr.read_string(code_len)
+
+      X64.disassemble code, code_ptr.address
+    end
+
+    # Gives the disassembly for all kernels in the program
+    # @return [Array<String>] array of disassembly
+    def disassemble_kernels
+      Array.new(size) do |kernel_index|
+        disassemble_kernel kernel_index
+      end
+    end
+
+    private def io_registers(input, kernel_index)
+      reg_enum_type = Libevoasm.enum_type(:x64_reg_id)
+      reg_enum_type.to_h.each_with_object([]) do |(k, v), acc|
+        unless k == :none
+          io =
+            if input
+              Libevoasm.program_is_input_reg(self, kernel_index, v)
+            else
+              Libevoasm.program_is_output_reg(self, kernel_index, v)
+            end
+
+          acc << k if io
+        end
+      end
     end
 
-    def disassemble(*args)
-      buffer.disassemble(*args)
+    # Gives the input registers of the specified kernel
+    # @param kernel_index [Integer]
+    # @return [Array<Symbol>] input registers
+    def input_registers(kernel_index = 0)
+      io_registers true, kernel_index
+    end
+
+    # Gives the output registers of the specified kernel
+    # @param kernel_index [Integer]
+    # @return [Array<Symbol>] output registers
+    def output_registers(kernel_index = size - 1)
+      io_registers false, kernel_index
+    end
+
+    private def format_disassembly(disasm)
+      disasm.map do |line|
+        "0x#{line[0].to_s 16}:\t#{line[1]}\t#{line[2]}"
+      end.join("\n")
+    end
+
+    # Disassembles the whole program
+    # @param frame [Bool] whether to include the stack frame and
+    # @param format [Bool] whether to format the assembly
+    # @return [String, Array<String>] the formatted assembly as string
+    #   if format is set, an array of address, opcode, operands triples otherwise.
+    def disassemble(frame = false, format: false)
+      code_ptr_ptr = FFI::MemoryPointer.new :pointer
+      code_len = Libevoasm.program_get_code self, frame, code_ptr_ptr
+      code_ptr = code_ptr_ptr.read_pointer
+      code = code_ptr.read_string(code_len)
+
+      disasm = X64.disassemble code, code_ptr.address
+
+      if format
+        format_disassembly disasm
+      else
+        disasm
+      end
+    end
+
+    # Visualizes the program and its kernels using Graphviz
+    # @return [GV::Graph]
+    def to_gv
+      require 'gv'
+
+      graph = GV::Graph.open 'g'
+
+      disasms = disassemble_kernels
+      addrs = disasms.map do |disasm|
+        disasm.first&.first
+      end
+
+      size.times do |kernel_index|
+        label = '<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">'
+
+        label << '<TR>'
+        label << %Q{<TD COLSPAN="3"><B>Kernel #{kernel_index}</B></TD>}
+        label << '</TR>'
+
+        disasm = disasms[kernel_index]
+        addr = addrs[kernel_index]
+        jmp_addrs = []
+
+        disasm.each do |line|
+          op_str = line[2]
+
+          label << '<TR>'
+          label << %Q{<TD ALIGN="LEFT">0x#{line[0].to_s 16}</TD>}
+          label << %Q{<TD ALIGN="LEFT">#{line[1]}</TD>}
+
+          if op_str =~ /0x(\h+)/
+            jmp_addr = Integer($1, 16)
+            jmp_addrs << jmp_addr
+            port = jmp_addr
+          else
+            port = ''
+          end
+          label << %Q{<TD ALIGN="LEFT" PORT="#{port}">#{op_str}</TD>}
+          label << '</TR>'
+        end
+        label << '</TABLE>'
+
+        node = graph.node addr.to_s,
+                          shape: :none,
+                          label: graph.html(label)
+
+        succs = [kernel_index + 1, kernel_index + Libevoasm.program_get_jmp_off(self, kernel_index)].select do |succ|
+          succ < size
+        end
+
+        succs.each do |succ|
+          succ_addr = addrs[succ]
+          tail_port =
+            if jmp_addrs.include? succ_addr
+              # Remove, in case we have the same
+              # successor multiple times
+              # only one of which goes through the jump
+              jmp_addrs.delete succ_addr
+              succ_addr.to_s
+            else
+              's'
+            end
+          graph.edge 'e', node, graph.node(succ_addr.to_s), tailport: tail_port, headport: 'n'
+        end
+      end
+
+      graph
     end
   end
 end

data/lib/evoasm/program/io.rb

@@ -0,0 +1,144 @@
+require 'evoasm/program'
+
+module Evoasm
+  class Program
+    # Represents one or multiple input/output tuples.
+    class IO < FFI::AutoPointer
+
+      # Maximum arity for tuples
+      MAX_ARITY = 8
+
+      include Enumerable
+
+      # @!visibility private
+      def self.release(ptr)
+        Libevoasm.program_io_free(ptr)
+      end
+
+      # @param tuples [Array] array of input or output tuples
+      def initialize(tuples)
+        if tuples.is_a?(FFI::Pointer)
+          super(tuples)
+        else
+          tuples = tuples
+          arity = determine_arity tuples
+
+          if arity > MAX_ARITY
+            raise ArgumentError, "maximum arity exceeded (#{arity} > #{MAX_ARITY})"
+          end
+
+          flat_tuples = tuples.flatten
+
+          ptr = Libevoasm.program_io_alloc flat_tuples.size
+          load_tuples ptr, flat_tuples, arity
+
+          super(ptr)
+        end
+      end
+
+      # @return [Integer] arity of tuples
+      def arity
+        Libevoasm.program_io_get_arity self
+      end
+
+      # @yield [Array] tuple
+      def each
+        return enum_for(:each) unless block_given?
+        size.times do |tuple_index|
+          yield self[tuple_index]
+        end
+      end
+
+      # Converts to array of tuples
+      def to_a
+        Array.new(size) do |tuple_index|
+          self[tuple_index]
+        end
+      end
+
+      # @return [Integer] the number of input/output values
+      def length
+        Libevoasm.program_io_get_len self
+      end
+
+      # @return [Integer] the number of input/output pairs
+      def size
+        length / arity
+      end
+
+      # @param tuple_index [Integer]
+      # @return [Array] returns the tuple at tuple_index
+      def [](tuple_index)
+        absolute_index = arity * tuple_index
+        if arity > 1
+          Array.new(arity) do |value_index|
+            value_at(absolute_index + value_index)
+          end
+        else
+          value_at(absolute_index)
+        end
+      end
+
+      private
+
+      def value_at(index)
+        type = Libevoasm.program_io_get_type self, index
+        case type
+        when :i64
+          Libevoasm.program_io_get_value_i64 self, index
+        when :f64
+          Libevoasm.program_io_get_value_f64 self, index
+        else
+          raise "unknown value type #{type}"
+        end
+      end
+
+      def load_tuples(ptr, flat_tuples, arity)
+        var_args = flat_tuples.flat_map do |tuple_value|
+          tuple_type, c_type = value_types tuple_value
+          [:io_val_type, tuple_type, c_type, tuple_value]
+        end
+
+        success = Libevoasm.program_io_init ptr, arity, *var_args
+
+        unless success
+          Libevoasm.program_io_unref ptr
+          raise Error.last
+        end
+      end
+
+      def value_types(value)
+        case value
+        when Float
+          [:f64, :double]
+        when Integer
+          [:i64, :int64]
+        else
+          raise ArgumentError,
+                "invalid tuple value '#{value}' of type '#{value.class}'"
+        end
+      end
+
+      def determine_arity(tuples)
+        arity = nil
+        tuples.each do |tuple|
+          tuple_arity = Array(tuple).size
+          if arity && arity != tuple_arity
+            raise ArgumentError,
+                  "invalid arity for tuple '#{tuple}' (#{tuple_arity} for #{arity})"
+          end
+          arity = tuple_arity
+        end
+        arity || 0
+      end
+    end
+
+    # Represents a program's input
+    class Input < IO
+    end
+
+    # Represents a program's output
+    class Output < IO
+    end
+  end
+end

data/lib/evoasm/test.rb

@@ -0,0 +1,8 @@
+require 'evoasm'
+require 'minitest/reporters'
+require 'minitest/autorun'
+
+$LOAD_PATH << File.join(Evoasm.test_dir, 'helpers')
+$LOAD_PATH << File.join(Evoasm.test_dir, 'unit')
+
+Minitest::Reporters.use!

data/lib/evoasm/version.rb

@@ -1,3 +1,3 @@
 module Evoasm
-  VERSION = "0.0.2.pre7"
+  VERSION = "0.1.0.pre2"
 end

data/lib/evoasm/x64.rb

@@ -0,0 +1,115 @@
+require 'evoasm/libevoasm'
+require 'evoasm/capstone'
+require 'evoasm/x64/instruction'
+require 'evoasm/x64/operand'
+require 'evoasm/x64/parameters'
+
+module Evoasm
+  module X64
+    unless Libevoasm.x64_init
+      raise Error.last
+    end
+
+    class << self
+      # Disassembles x86-64 machine code
+      # @param assembly [String] assembly
+      # @param address [Integer] optional address to show in the disassembly
+      # @return [String] disassembly
+      def disassemble(assembly, address = nil)
+        Evoasm::Capstone.disassemble_x64 assembly, address
+      end
+
+      # Encodes a x86-64 machine instruction
+      # @param instruction_name [Symbol] the name of the instruction
+      # @param parameters [X64::Parameters, Hash] the instruction parameters
+      # @param buffer [Buffer] the buffer to emit to, if omitted, the encoded instruction is retured as string
+      # @param basic [Boolean] whether to use the basic encoder
+      # @return [String, nil] the encoded machine code as string, or nil if a buffer was provided
+      def encode(instruction_name, parameters, buffer = nil, basic: false)
+        instruction(instruction_name).encode parameters, buffer, basic: basic
+      end
+
+      # @return [Array<Symbol>] a list of available registers
+      def registers
+        Libevoasm.enum_type(:x64_reg_id).symbols[0..-2]
+      end
+
+      # @return [Array<Symbol>] the list of supported CPU features (obtained via CPUID)
+      def features
+        feature_enum_type = Libevoasm.enum_type(:x64_feature)
+        arch_info = Libevoasm.get_arch_info :x64
+        features_as_flags = Libevoasm.arch_info_get_features arch_info
+        feature_enum_type.symbol_map.each_with_object({}) do |(k, v), features|
+          next if k == :none
+          supported = (features_as_flags & (1 << v)) != 0
+          features[k] = supported
+        end
+      end
+
+      # Gives an {Instruction} object for the given instruction name.
+      # @param instruction_name [Symbol] instruction name
+      # @return [Instruction]
+      def instruction(instruction_name)
+        Instruction.new Libevoasm.x64_inst(instruction_name), instruction_name
+      end
+
+      # Emits a stack frame for the given ABI
+      # @param abi [Symbol] the ABI to use
+      # @param buffer [Buffer] the buffer to emit to
+      # @return [void]
+      def emit_stack_frame(abi = :sysv, buffer)
+        unless Libevoasm.x64_emit_func_prolog abi, buffer
+          raise Error.last
+        end
+
+        yield
+
+        unless Libevoasm.x64_emit_func_epilog abi, buffer
+          raise Error.last
+        end
+      end
+
+      # Gives a list of instructions
+      # @param reg_types [Array] restrict to given register types (e.g. +:gp+ for general-purpose registers)
+      # @param operand_types [Array<Symbol>] restrict to instructions whose operands are of the specified types
+      # @param useless [Bool] whether to include useless instructions
+      # @param basic [Bool] restrict to instructions supported by the basic encoder
+      # @param features [Array<Symbol>] only give instructions covered by the specified feature set
+      # @return [Array<Symbol>] array of instruction names
+      def instruction_names(*reg_types, operand_types: [:reg, :rm, :imm], useless: false, basic: true, features: nil)
+        inst_id_enum_type = Libevoasm.enum_type(:x64_inst_id)
+        feature_enum_type = Libevoasm.enum_type(:x64_feature)
+        insts_flags_enum_type = Libevoasm.enum_type(:x64_insts_flags)
+        op_type_enum_type = Libevoasm.enum_type(:x64_operand_type)
+        reg_type_enum_type = Libevoasm.enum_type(:x64_reg_type)
+
+        flags = []
+
+        flags << :include_useless if useless
+        flags << :only_basic if basic
+        flags_as_flags = insts_flags_enum_type.flags flags, shift: false
+
+        features_as_flags =
+          if features.nil?
+            arch_info = Libevoasm.get_arch_info :x64
+            Libevoasm.arch_info_get_features arch_info
+          else
+            feature_enum_type.flags features, shift: true
+          end
+
+        op_types_as_flags = op_type_enum_type.flags operand_types, shift: true
+        reg_types_as_flags = reg_type_enum_type.flags reg_types, shift: true
+
+        n_insts = inst_id_enum_type[:none]
+        array = FFI::MemoryPointer.new :int, n_insts
+        len = Libevoasm.x64_insts(flags_as_flags, features_as_flags,
+                                   op_types_as_flags, reg_types_as_flags, array)
+
+        instruction_ids = array.read_array_of_type(:int, :read_int, len)
+
+        instruction_ids.map { |e| inst_id_enum_type[e] }
+      end
+
+    end
+  end
+end