evoasm 0.0.2.pre7 → 0.1.0.pre2

data/lib/evoasm/search.rb

@@ -1,40 +0,0 @@
-module Evoasm
-  class Search
-    module Util
-      def flatten_examples(examples)
-        arity = check_arity examples
-
-        [examples.flatten, arity]
-      end
-
-      def check_arity(examples)
-        arity = Array(examples.first).size
-        examples.each do |example|
-          example_arity = Array(example).size
-          if arity && arity != example_arity
-            raise ArgumentError, "invalid arity for example '#{example}'"\
-                                " (#{example_arity} for #{arity})"
-          end
-        end
-        arity
-      end
-    end
-
-    DEFAULT_SEED = (1..64).to_a
-    def initialize(arch, examples:, instructions:, kernel_size:,
-                   program_size:, population_size:, parameters:,
-                   mutation_rate: 0.10, seed: DEFAULT_SEED, domains: {}, recur_limit: 0)
-
-      input_examples, output_examples = examples.keys, examples.values
-      input_examples, input_arity = flatten_examples input_examples
-      output_examples, output_arity = flatten_examples output_examples
-
-      __initialize__ input_examples, input_arity, output_examples, output_arity,
-                   arch, population_size, kernel_size, program_size, instructions,
-                   parameters, mutation_rate, seed, domains, recur_limit
-    end
-
-    include Util
-
-  end
-end

data/lib/evoasm/tasks/gen_task.rb

@@ -1,86 +0,0 @@
-require 'evoasm'
-require 'evoasm/gen/state'
-require 'evoasm/gen/translator'
-
-require 'rake'
-
-module Evoasm
-  module Tasks
-    class GenTask < Rake::TaskLib
-      include Evoasm::Gen
-
-      HEADER_N_LINES = 15
-      CSV_SEPARATOR = ','
-
-      attr_accessor :ruby_bindings
-      attr_reader :name, :archs
-
-      ALL_ARCHS = %i(x64)
-      X64_TABLE_FILENAME = File.join(Evoasm.data, 'tables', 'x64.csv')
-      ARCH_TABLES = {
-        x64: X64_TABLE_FILENAME
-      }
-
-      def initialize(name = 'evoasm:gen', &block)
-        @ruby_bindings = true
-        @name = name
-        @archs = ALL_ARCHS
-
-        block[self] if block
-
-        define
-      end
-
-      def define
-        namespace 'evoasm:gen' do
-          archs.each do |arch|
-            prereqs = [ARCH_TABLES[arch]]
-
-            prereqs << Translator.template_path(arch)
-            target_path = gen_path(Translator.target_filename(arch))
-
-            file target_path => prereqs do
-              puts "Translating"
-              insts = load_insts arch
-              translator = Translator.new(arch, insts, ruby: ruby_bindings)
-              translator.translate! do |filename, content|
-                File.write gen_path(filename), content
-              end
-            end
-
-            task "translate:#{arch}" => target_path
-          end
-
-          task 'translate' => archs.map { |arch| "translate:#{arch}" }
-        end
-
-        task name => 'gen:translate'
-      end
-
-      def gen_path(filename)
-        File.join Evoasm.root, 'ext', 'evoasm_ext', filename
-      end
-
-      def load_insts(arch)
-        send :"load_#{arch}_insts"
-      end
-
-      def load_x64_insts
-        require 'evoasm/gen/x64/inst'
-
-        rows = []
-        File.open X64_TABLE_FILENAME do |file|
-          file.each_line.with_index do |line, line_idx|
-            # header
-            next if line_idx == 0
-
-            row = line.split(CSV_SEPARATOR)
-            rows << row
-          end
-        end
-
-        Gen::X64::Inst.load(rows)
-      end
-    end
-  end
-end

data/lib/evoasm/tasks/template_task.rb

@@ -1,52 +0,0 @@
-require 'rake'
-require 'yaml'
-
-module Evoasm
-  module Tasks
-    class TemplateTask < Rake::TaskLib
-      attr_accessor :source
-      attr_accessor :target
-      attr_accessor :subs
-
-      class << self
-        attr_reader :all
-      end
-      @all = []
-
-      def initialize(&block)
-        block[self] if block
-        define
-      end
-
-      def define
-        srcs = Array(source).map { |f| ext_path f }
-        dsts = Array(target).map { |f| gen_path f }
-        srcs.zip(dsts).each do |src, dst|
-          file dst => src do
-            data = File.read src
-            subs.sort_by{|k, _| k.length }.reverse.each do |name, value|
-              data.gsub! "$#{name}", value.to_s
-              data.gsub! "$#{name.upcase}", value.to_s.upcase
-              p "$-#{name}"
-              data.gsub! "$-#{name}", value.to_s.gsub('_', '-')
-            end
-            File.write dst, data
-          end
-          self.class.all << dst
-        end
-      end
-
-      def ext_dir
-        File.join Evoasm.root, 'ext', 'evoasm_ext'
-      end
-
-      def ext_path(filename)
-        File.join ext_dir, filename
-      end
-
-      def gen_path(filename)
-        File.join ext_dir, 'gen', filename
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1 +0,0 @@
-require 'minitest/autorun'

data/test/x64/test_helper.rb

@@ -1,19 +0,0 @@
-require_relative '../test_helper'
-
-require 'evoasm'
-
-module MiniTest::Assertions
-  include Evoasm
-
-  def assert_disassembles_to(disasm, inst_name, **params)
-    assert_equal disasm,
-        Evoasm::X64.disassemble(@x64.encode(inst_name, params)).first
-  end
-
-  def assert_assembles_to(asm, inst_name, **params)
-    assert_equal asm, @x64.encode(inst_name, params)
-  end
-end
-
-Array.infect_an_assertion :assert_disassembles_to, :must_disassemble_to
-Array.infect_an_assertion :assert_assembles_to, :must_assemble_to

data/test/x64/x64_test.rb

@@ -1,87 +0,0 @@
-require_relative 'test_helper'
-
-class X64Test < Minitest::Test
-  def setup
-    @x64 = Evoasm::X64.new
-    @x64.encode :add_r32_rm32, reg0: :A, reg1: :B
-  end
-
-  def test_rm_reg_reg
-    assert_disassembles_to 'add rax, rbx', :add_r64_rm64,
-      reg0: :A, reg1: :B
-    assert_disassembles_to 'add r11, r12', :add_r64_rm64,
-      reg0: :R11, reg1: :R12
-    assert_disassembles_to 'add eax, ebx', :add_r32_rm32,
-      reg0: :A, reg1: :B
-    assert_disassembles_to 'add ax, bx', :add_r16_rm16,
-      reg0: :A, reg1: :B
-  end
-
-  def test_rm_reg_base
-    assert_disassembles_to 'add rax, qword ptr [rbx]', :add_r64_rm64,
-      reg0: :A, reg_base: :B
-    assert_disassembles_to 'add r11, qword ptr [r12]', :add_r64_rm64,
-      reg0: :R11, reg_base: :R12
-    assert_disassembles_to 'add eax, dword ptr [rbx]', :add_r32_rm32,
-      reg0: :A, reg_base: :B
-    assert_disassembles_to 'add ax, word ptr [rbx]', :add_r16_rm16,
-      reg0: :A, reg_base: :B
-
-    # reg1 should be ignored
-    assert_disassembles_to 'add eax, dword ptr [rbx]', :add_r32_rm32,
-      reg0: :A, reg1: :C, reg_base: :B
-  end
-
-  def test_rm_reg_base32
-    assert_disassembles_to 'add rax, dword ptr [ebx]', :add_r64_rm64,
-      reg0: :A, reg_base: :B, address_size: 32
-
-    assert_disassembles_to 'add eax, dword ptr [ebx]', :add_r32_rm32,
-      reg0: :A, reg_base: :B, address_size: 32
-  end
-
-  def test_rm_reg_sib
-    assert_disassembles_to 'add rax, qword ptr [rbx + rcx*4]', :add_r64_rm64,
-      reg0: :A, reg_base: :B, reg_index: :C, scale: 4
-    assert_disassembles_to 'add rax, qword ptr [rbx + rcx]', :add_r64_rm64,
-      reg0: :A, reg_base: :B, reg_index: :C, scale: 1
-    assert_disassembles_to 'add rax, qword ptr [rbx + rcx*8]', :add_r64_rm64,
-      reg0: :A, reg_base: :B, reg_index: :C, scale: 8
-
-    assert_disassembles_to 'add r10, qword ptr [r11 + r12*4]', :add_r64_rm64,
-      reg0: :R10, reg_base: :R11, reg_index: :R12, scale: 4
-
-  end
-
-  def test_mi
-    assert_disassembles_to 'add rax, 0xa', :add_rm64_imm8,
-      reg0: :A, imm0: 0xa
-
-    assert_disassembles_to 'add qword ptr [rax], 0xa', :add_rm64_imm8,
-      reg_base: :A, imm0: 0xa
-  end
-
-  def test_vex
-    assert_assembles_to "\xC5\xF5\xEC\xC2", :vpaddsb_ymm_ymm_ymmm256,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2, force_long_vex?: false
-    assert_assembles_to "\xC4\xE1u\xEC\xC2", :vpaddsb_ymm_ymm_ymmm256,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2, force_long_vex?: true
-    assert_disassembles_to 'vpaddsb ymm0, ymm1, ymm2', :vpaddsb_ymm_ymm_ymmm256,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2
-    assert_disassembles_to 'vpaddsb ymm0, ymm1, ymm2', :vpaddsb_ymm_ymm_ymmm256,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2, force_long_vex?: true
-
-    assert_assembles_to "\xC5\xF5\xEC\xC2", :vpaddsb_ymm_ymm_ymmm256,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2
-    assert_disassembles_to 'vpaddusb xmm0, xmm1, xmm2', :vpaddusb_xmm_xmm_xmmm128,
-      reg0: :XMM0, reg1: :XMM1, reg2: :XMM2
-    assert_assembles_to "\xC5\xF8\x5A\xCA", :vcvtps2pd_xmm_xmmm64,
-      reg0: :XMM1, reg1: :XMM2
-    assert_assembles_to "\xC5\xEA\x5A\xCB", :vcvtss2sd_xmm_xmm_xmmm32,
-      reg0: :XMM1, reg1: :XMM2, reg2: :XMM3
-
-    assert_assembles_to "\xC4\xE3\x79\x1D\xD1\x00", :vcvtps2ph_xmmm64_xmm_imm8,
-      reg0: :XMM1, reg1: :XMM2, imm0: 0x0
-  end
-
-end