evoasm 0.0.2.pre7

data/ext/evoasm_ext/extconf.rb

@@ -0,0 +1,31 @@
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+if have_header('capstone/capstone.h')
+  $LDFLAGS << ' -lcapstone'
+end
+
+$warnflags.gsub! '-Wdeclaration-after-statement', ''
+
+$CFLAGS << ' -std=c11 -pedantic -fstrict-aliasing'
+$warnflags << ' -Wextra -Wall -Wno-unused-label -Wuninitialized'\
+              ' -Wswitch-default  -Wstrict-aliasing=3 -Wunreachable-code'\
+              ' -Wundef -Wpointer-arith -Wwrite-strings -Wconversion -Winit-self -Wno-unused-parameter'
+
+$LDFLAGS << ''
+
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /clang/
+  $warnflags << ' -Wno-unknown-warning-option -Wno-parentheses-equality -Wno-error=ignored-attributes'\
+                ' -Wno-missing-field-initializers -Wno-missing-braces'
+end
+
+if enable_config('debug')
+  $warnflags << ' -Werror -Wno-error=unused-function -Wno-error=pedantic'\
+             ' -Wno-error=implicit-function-declaration'
+  $defs.push('-DEVOASM_MIN_LOG_LEVEL=EVOASM_LOG_LEVEL_DEBUG')
+  $CFLAGS.gsub!(/-O\d/, '')
+  $CFLAGS << ' -O0 -g3 -fno-omit-frame-pointer'
+end
+
+create_makefile('evoasm_ext')

data/lib/evoasm/cli/search.rb

@@ -0,0 +1,127 @@
+require 'yaml'
+require 'pastel'
+require 'pry'
+
+module Evoasm
+  module Cli
+    class Search
+      attr_reader :filename
+
+      def initialize(filename, options)
+        @filename = filename
+        raise ArgumentError, 'filename is nil' if filename.nil?
+
+        if options.any?{|o| o =~ /\--log-level=(\d)/}
+          Evoasm.log_level = $1.to_i
+        end
+      end
+
+      def start!
+        x64 = X64.new
+        params = YAML.load(File.read filename)
+        insts = filter_insts x64.instructions, params['instructions']
+
+        p insts.map(&:name)
+        pastel = Pastel.new
+
+        program_size = parse_range params['program_size']
+        kernel_size = parse_range params['kernel_size']
+        program_counter = 0
+        max_programs = params['max_programs']
+        recur_limit = params['recur_limit'] || 0
+
+        domains = convert_domains_hash params['domains']
+        parameters = (params['parameters'] || %i(reg0 reg1 reg2 imm0 imm1)).map(&:to_sym)
+
+        start_ts = Time.now
+
+        search = Evoasm::Search.new x64,
+                   examples: params['examples'],
+                   instructions: insts,
+                   kernel_size: kernel_size,
+                   program_size: program_size,
+                   population_size: params['population_size'],
+                   parameters: parameters,
+                   domains: domains,
+                   recur_limit: recur_limit
+
+        search.start!(params['max_loss'] || 0.0) do |program, loss|
+          ts = Time.now
+          puts pastel.bold "Program #{program_counter}, #{ts.strftime '%H:%M:%S'} (found after #{(ts - start_ts).to_i} seconds)"
+
+          if program.buffer.respond_to? :disassemble
+            puts program.buffer.disassemble.join "\n"
+          else
+            puts program.instructions.map(&:name)
+          end
+
+          puts
+
+          if params['console'] != false
+            binding.pry
+          end
+
+          program_counter += 1
+
+          if program_counter == max_programs
+            # stops search
+            return false
+          end
+        end
+      end
+
+      private
+      def filter_insts(insts, params)
+        op_types = %i(rm reg imm)
+        reg_types = %i(rflags)
+        bad_regs = %i(SP IP)
+
+        grep_regexp = params && Regexp.new(params['grep']) rescue nil
+        grep_v_regexp = params && Regexp.new(params['grep_v']) rescue nil
+
+        reg_types.concat params['reg_types'].map(&:to_sym)
+
+        insts.select do |inst|
+          next false if grep_regexp && inst.name !~ grep_regexp
+          next false if grep_v_regexp && inst.name =~ grep_v_regexp
+          next false if inst.operands.size == 0
+
+          inst.operands.all? do |op|
+            next false unless op_types.include? op.type
+            if op.register
+              next false unless reg_types.include?(op.register.type)
+              next false if bad_regs.include? op.register.name
+            end
+
+            true
+          end
+        end
+      end
+
+      def convert_domains_hash(hash)
+        Hash(hash).map do |k, v|
+          new_k = k.to_sym
+          new_v =
+            case v
+            when Array
+              v.map {|e| e.is_a?(String) ? e.to_sym : e }
+            else
+              v
+            end
+          [new_k, new_v]
+        end.to_h
+      end
+
+      def parse_range(str)
+        case str
+        when Integer
+          str
+        when /^\(?(\d+)\.\.(\.?)(\d+)\)?$/
+          Range.new($1.to_i, $3.to_i, !$2.empty?)
+        else
+          raise ArgumentError, "invalid range '#{str}'"
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/cli.rb

@@ -0,0 +1,6 @@
+module Evoasm
+  module Cli
+  end
+end
+
+require 'evoasm/cli/search'

data/lib/evoasm/core_ext/array.rb

@@ -0,0 +1,9 @@
+class Array
+  def keys
+    map { |k, _v| k }
+  end
+
+  def values
+    map { |_k, v| v }
+  end
+end

data/lib/evoasm/core_ext/integer.rb

@@ -0,0 +1,10 @@
+class Integer
+  INT8_MAX = 0x7f
+  INT8_MIN = -INT8_MAX - 1
+  INT16_MAX = 0x7fff
+  INT16_MIN = -INT16_MAX - 1
+  INT32_MAX = 0x7fffffff
+  INT32_MIN = -INT32_MAX - 1
+  INT64_MAX = 0x7fffffffffffffff
+  INT64_MIN = -INT64_MAX - 1
+end

data/lib/evoasm/core_ext/kwstruct.rb

@@ -0,0 +1,13 @@
+# The MIT License (MIT)
+# Copyright (c) 2015 Maxim Chernyak
+class KwStruct < Struct
+  def self.new(*members, &block)
+    super.tap do |struct_class|
+      struct_class.class_eval <<-RUBY
+        def initialize(#{members.map { |m| "#{m}: nil" }.join(', ')})
+          super(#{members.join(', ')})
+        end
+      RUBY
+    end
+  end
+end

data/lib/evoasm/core_ext/range.rb

@@ -0,0 +1,5 @@
+class Range
+  def sample
+    rand self
+  end
+end

data/lib/evoasm/core_ext.rb

@@ -0,0 +1 @@
+require 'evoasm/core_ext/range'

data/lib/evoasm/error.rb

@@ -0,0 +1,20 @@
+module Evoasm
+  class Error
+    def message
+      msg = __message
+
+      case code
+      when :not_encodable
+        "#{msg} #{parameter}"
+      when :missing_param
+        "#{msg} (#{parameter})"
+      when :missing_feature
+        "missing features #{features.join ', '}"
+      when :invalid_access
+        "#{msg} (#{instruction}/#{register})"
+      else
+        msg || code
+      end
+    end
+  end
+end

data/lib/evoasm/examples.rb

@@ -0,0 +1,27 @@
+module Evoasm
+  module Examples
+
+    class << self
+      def convert(examples)
+        examples.inject(nil) do |(in_arity, out_arity), example|
+          inputs, outputs = example
+          example_in_arity = inputs.size
+          example_out_arity = outputs.size
+
+          validate_example inputs, example_in_arity, in_arity
+          validate_example outputs, example_out_arity, out_arity
+
+          [example_in_arity, example_out_arity]
+        end.unshift(examples.flatten)
+      end
+
+      private
+      def validate_example(example, example_arity, arity)
+        if arity && arity != example_arity
+          raise ArgumentError, "invalid arity for example '#{example}'"\
+                                " (#{example_arity} for #{arity})"
+        end
+      end
+    end
+  end
+end

data/lib/evoasm/gen/enum.rb

@@ -0,0 +1,169 @@
+require 'evoasm/gen/strio'
+require 'evoasm/gen/name_util'
+
+module Evoasm
+  module Gen
+    class Enum
+      include NameUtil
+
+      attr_reader :name, :flags
+      alias_method :flags?, :flags
+
+      def initialize(name = nil, elems = [], prefix: nil, flags: false)
+        @name = name
+        @prefix = prefix
+        @map = {}
+        @counter = 0
+        @flags = flags
+        add_all elems
+      end
+
+      def n
+        @counter
+      end
+
+      def to_c(io = StrIO.new, typedef: true)
+        raise 'name missing' if !name
+
+        type_name = c_type_name
+
+        io.puts "#{typedef ? 'typedef ' : ''}enum #{type_name} {"
+        io.indent do
+          each do |elem, value|
+            elem_name = elem_name_to_c elem
+            c_value =
+              if valid_elem?(value)
+                elem_name_to_c value
+              else
+                if flags?
+                  "1 << #{value}"
+                else
+                  "#{value}"
+                end
+              end
+            io.puts "#{elem_name} = #{c_value},"
+          end
+          if !flags?
+            io.puts n_elem_to_c
+          end
+        end
+        io.write '}'
+        io.write " #{type_name}" if typedef
+        io.puts ';'
+        io.puts "#define #{bitsize_to_c} #{bitsize}"
+        unless flags?
+          io.puts "#define #{bitsize_to_c true} #{bitsize true}"
+        else
+          io.puts "#define #{all_to_c} #{all_value}"
+        end
+
+        io.string
+      end
+
+      def bitsize(with_n = false)
+        if flags?
+          @map.size
+        else
+          Math.log2(max + 1 + (with_n ? 1 : 0)).ceil.to_i
+        end
+      end
+
+      def max
+        @map.each_with_index.inject(0) do |acc, (index, (k, v))|
+          if v
+            [v + 1, acc + 1].max
+          else
+            acc + 1
+          end
+        end - 1
+      end
+
+      def c_type(typedef = false)
+        "#{typedef ? '' : 'enum '}#{c_type_name}"
+      end
+
+      def c_type_name
+        name_to_c name, @prefix
+      end
+
+      def all_to_c
+        name_to_c "#{prefix_name}_all", @prefix, const: true
+      end
+
+      def all_value
+        (2**@map.size) - 1
+      end
+
+      def bitsize_to_c(with_n = false)
+        name_to_c "#{prefix_name}_bitsize#{with_n ? '_WITH_N' : ''}", @prefix, const: true
+      end
+
+      def n_elem_to_c
+        name_to_c "n_#{prefix_name}s", @prefix, const: true
+      end
+
+      def keys
+        @map.keys
+      end
+
+      def add(elem, alias_elem = nil)
+        fail ArgumentError, 'can only add symbols or strings' \
+          unless valid_elem?(elem) && (!alias_elem || valid_elem?(alias_elem))
+
+        return if @map.key? elem
+
+        value = alias_elem || @counter
+        @counter += 1 if alias_elem.nil?
+
+        @map[elem] = value
+      end
+
+      def add_all(elems)
+        elems.each do |elem|
+          add elem
+        end
+      end
+
+      def each(&block)
+        return to_enum(:each) if block.nil?
+        @map.each_key do |k|
+          block[k, self[k]]
+        end
+      end
+
+      def alias(key)
+        key = @map[key]
+        case key
+        when Symbol, String
+          key
+        else
+          nil
+        end
+      end
+
+      def [](elem)
+        value = @map[elem]
+
+        if @map.key? value
+          @map.fetch value
+        else
+          value
+        end
+      end
+
+      private
+      def prefix_name
+        name.to_s.sub(/_id$/, '')
+      end
+
+      def elem_name_to_c(elem_name)
+        # convention: _id does not appear in element's name
+        name_to_c elem_name, Array(@prefix) + [prefix_name], const: true
+      end
+
+      def valid_elem?(elem)
+        elem.is_a?(Symbol) || elem.is_a?(String)
+      end
+    end
+  end
+end

data/lib/evoasm/gen/name_util.rb

@@ -0,0 +1,80 @@
+module Evoasm
+  module Gen
+    module NameUtil
+      def namespace
+        'evoasm'
+      end
+
+      def const_name_to_c(name, prefix)
+        name_to_c name, prefix, const: true
+      end
+
+      def name_to_c(name, prefix = nil, const: false)
+        c_name = [namespace, *prefix, name.to_s.sub(/\?$/, '')].compact.join '_'
+        if const
+          c_name.upcase
+        else
+          c_name
+        end
+      end
+
+      def indep_arch_prefix(name = nil)
+        ['arch', name]
+      end
+
+      def arch_prefix(name = nil)
+        [arch, name]
+      end
+
+      def error_code_to_c(name)
+        prefix = name == :ok ? :error_code : indep_arch_prefix(:error_code)
+        const_name_to_c name, prefix
+      end
+
+      def reg_name_to_c(name)
+        const_name_to_c name, arch_prefix(:reg)
+      end
+
+      def exception_to_c(name)
+        const_name_to_c name, arch_prefix(:exception)
+      end
+
+      def reg_type_to_c(name)
+        const_name_to_c name, arch_prefix(:reg_type)
+      end
+
+      def operand_type_to_c(name)
+        const_name_to_c name, arch_prefix(:operand_type)
+      end
+
+      def inst_name_to_c(inst)
+        const_name_to_c inst.name, arch_prefix(:inst)
+      end
+
+      def operand_size_to_c(size)
+        const_name_to_c size, :operand_size
+      end
+
+      def bit_mask_to_c(mask)
+        name =
+          case mask
+          when Range then"#{mask.min}_#{mask.max}"
+          else mask.to_s
+          end
+        const_name_to_c name, arch_prefix(:bit_mask)
+      end
+
+      def feature_name_to_c(name)
+        const_name_to_c name, arch_prefix(:feature)
+      end
+
+      def inst_flag_to_c(flag)
+        const_name_to_c flag, arch_prefix(:inst_flag)
+      end
+
+      def param_name_to_c(name)
+        const_name_to_c name, arch_prefix(:param)
+      end
+    end
+  end
+end

data/lib/evoasm/gen/state.rb

@@ -0,0 +1,176 @@
+require 'set'
+
+module Evoasm::Gen
+  State = Struct.new(:children, :actions, :ret, :_local_params) do
+    attr_accessor :id, :comment, :parents
+
+    def initialize
+      self.children = []
+      self.parents = []
+      self.actions = []
+      self._local_params = []
+    end
+
+    def local_params
+      child_local_params = children.map do |child, _, _|
+        child.local_params
+      end
+      all_local_params = (_local_params + child_local_params)
+      all_local_params.flatten!
+      all_local_params.uniq!
+
+      all_local_params
+    end
+
+    def add_local_param(param)
+      if param.to_s[0] != '_'
+        fail ArgumentError, 'params must start with underscore'
+      end
+
+      _local_params << param unless _local_params.include? param
+    end
+
+    protected def add_parent(parent)
+      parents << parent unless parents.include? parent
+    end
+
+    def add_child(child, cond = nil, priority)
+      child.add_parent self
+      children << [child, cond, priority]
+    end
+
+    %i(sets asserts calls writes debugs).each do |name|
+      action_name = name.to_s[0..-2].to_sym
+      define_method name do
+        actions.select { |action, _| action == action_name }
+        .map { |_, args| args }
+      end
+    end
+
+    private def roots
+      return [self] if parents.empty?
+      parents.flat_map(&:roots)
+    end
+
+    def root
+      roots = roots()
+      fail 'multiple roots' if roots.size > 1
+      roots.first
+    end
+
+    def empty?
+      actions.empty?
+    end
+
+    def terminal?
+      children.empty?
+    end
+
+    def ret?
+      ret != nil
+    end
+
+    def to_gv
+      require 'gv'
+
+      graph = GV::Graph.open 'ast'
+      graph[:ranksep] = 1.5
+      graph[:statesep] = 0.8
+      __to_gv__ graph
+      graph
+    end
+
+    def __to_gv__(graph, gv_parent = nil, cond = nil, attrs = {}, index = nil, seen = {})
+      if seen.key?(self)
+        # return
+      else
+        seen[self] = true
+      end
+
+      edge_label = ''
+      state_label = ''
+
+      if cond
+        if cond.first == :else
+          edge_label << "<b> else</b><br></br>\n"
+        else
+          edge_label << "<b> if</b> #{expr_to_s cond}<br></br>\n"
+        end
+      end
+
+      if attrs
+        attrs.each do |name, value|
+          edge_label << "<b> #{name}</b>: #{value}<br></br>\n"
+        end
+      end
+
+      actions.each do |name, args|
+        state_label << send(:"label_#{name}", *args)
+      end
+
+      state_label << "<i>#{comment}</i>\n" if comment
+
+      gv_state = graph.node object_id.to_s,
+                            shape: (self.ret? ? :house : (state_label.empty? ? :point : :box)),
+                            label: graph.html(state_label)
+
+      children.each_with_index do |(child, cond, attrs), index|
+        child.__to_gv__(graph, gv_state, cond, attrs, index, seen)
+      end
+
+      if gv_parent
+        graph.edge gv_parent.name + '.' + gv_state.name + index.to_s,
+                   gv_parent, gv_state,
+                   label: graph.html(edge_label)
+      end
+
+      graph
+    end
+
+    private
+
+    def label_set(name, value, _options = {})
+      "<b>set</b> #{name} := #{expr_to_s value}<br></br>"
+    end
+
+    def label_assert(cond)
+      "<b>assert</b> #{expr_to_s cond}<br></br>"
+    end
+
+    def label_call(name)
+      "<b>call</b> #{name}<br></br>"
+    end
+
+    def label_debug(_format, *_args)
+      ''
+    end
+
+    def label_write(value, size)
+      label =
+        if value.is_a?(Integer) && size.is_a?(Integer)
+          if size == 8
+            'x%x' % value
+          else
+            "b%0#{size}b" % value
+          end
+        elsif size.is_a? Array
+          Array(value).zip(Array(size)).map do |v, s|
+            "#{expr_to_s v} [#{expr_to_s s}]"
+          end.join ', '
+        else
+          "#{expr_to_s value} [#{expr_to_s size}]"
+        end
+      "<b>output</b> #{label}<br></br>"
+    end
+
+    def expr_to_s(pred)
+      case pred
+      when Array
+        pred, *args = *pred
+        "#{pred}(#{args.map { |a| expr_to_s(a) }.join(', ')})"
+      else
+        pred
+      end
+    end
+  end
+end