evoasm 0.0.2.pre7 → 0.1.0.pre2

data/ext/evoasm_ext/extconf.rb

@@ -1,31 +0,0 @@
-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.rb

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

data/lib/evoasm/cli/search.rb

@@ -1,127 +0,0 @@
-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/core_ext.rb

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

data/lib/evoasm/core_ext/array.rb

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

data/lib/evoasm/core_ext/integer.rb

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-# 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

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

data/lib/evoasm/examples.rb

@@ -1,27 +0,0 @@
-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.rb

@@ -1,8 +0,0 @@
-require 'evoasm/gen/version'
-
-module Evoasm
-  module Gen
-  end
-end
-
-require 'evoasm/gen/generator'

data/lib/evoasm/gen/enum.rb

@@ -1,169 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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