evoasm 0.0.2.pre7 → 0.1.0.pre2

data/test/unit/evoasm/population/parameters_test.rb

@@ -0,0 +1,106 @@
+require 'evoasm/test'
+require 'evoasm/population/parameters'
+
+module Evoasm
+  class Population
+    class ParametersTest < Minitest::Test
+
+      def setup
+        @parameters = Evoasm::Population::Parameters.new :x64
+      end
+
+      def test_mutation_rate
+        @parameters.mutation_rate = 0.001
+        assert_in_epsilon 0.001, @parameters.mutation_rate, 0.0001
+
+        @parameters.mutation_rate = 0.5
+        assert_in_epsilon 0.5, @parameters.mutation_rate, 0.0001
+      end
+
+      def test_deme_size
+        @parameters.deme_size = 100
+        assert_equal 100, @parameters.deme_size
+      end
+
+      def test_deme_count
+        @parameters.deme_count = 12
+        assert_equal 12, @parameters.deme_count
+      end
+
+      def test_validate!
+        error = assert_raises Evoasm::Error do
+          @parameters.validate!
+        end
+
+        # while at it, let's test Error
+        assert_equal :pop_params, error.type
+        assert_kind_of Integer, error.line
+        assert_match /pop-params/, error.filename
+      end
+
+      def test_kernel_size
+        @parameters.kernel_size = 10
+        assert_equal 10, @parameters.kernel_size
+      end
+
+      def test_program_size
+        @parameters.program_size = 4
+        assert_equal 4, @parameters.program_size
+      end
+
+      def test_recur_limit
+        @parameters.recur_limit = 1000
+        assert_equal 1000, @parameters.recur_limit
+      end
+
+      def test_examples
+        examples = {
+          [0, 1] => 0,
+          [1, 0] => 100,
+          [3, 5] => 10000
+        }
+        @parameters.examples = examples
+        assert_equal examples, @parameters.examples
+      end
+
+      def test_parameters
+        parameters = %i(reg0 reg1 reg2)
+        @parameters.parameters = parameters
+        assert_equal parameters, @parameters.parameters
+
+        parameters = %i(does not exist)
+        assert_raises do
+          @parameters.parameters = parameters
+        end
+      end
+
+      def test_domains
+        domains = {
+          reg0: [:a, :c, :b],
+          reg1: [:r11, :r12, :r13],
+          imm0: (0..10)
+        }
+
+        # must set parameter before setting domain
+        assert_raises ArgumentError do
+          @parameters.domains = domains
+        end
+
+        @parameters.parameters = %i(reg0 reg1 imm0)
+        @parameters.domains = domains
+
+        assert_kind_of Evoasm::EnumerationDomain, @parameters.domains[:reg0]
+        assert_kind_of Evoasm::RangeDomain, @parameters.domains[:imm0]
+        assert_equal 0, @parameters.domains[:imm0].min
+        assert_equal 10, @parameters.domains[:imm0].max
+      end
+
+      def test_instructions
+        instructions = %i(adc_al_imm8 adc_rm8_r8)
+        @parameters.instructions = instructions
+
+        assert_equal instructions, @parameters.instructions
+      end
+    end
+  end
+end

data/test/unit/evoasm/population_test.rb

@@ -0,0 +1,96 @@
+require 'evoasm/test'
+require 'evoasm/population'
+require 'population_helper'
+
+module Evoasm
+  class PopulationTest < Minitest::Test
+    include PopulationHelper
+
+    def setup
+      set_default_parameters
+      @kernel_size = 2
+      @program_size = 1
+    end
+
+    def test_unseeded
+      error = assert_raises Evoasm::Error do
+        deme = new_population
+        deme.evaluate { |_, _|}
+      end
+
+      assert_match /seed/, error.message
+    end
+
+    def test_no_error
+      start
+    end
+
+    def test_find_median
+      [8, 16].each do |size|
+        ary = Array.new(size) { rand(0..1000) }
+        median = ary.sort.at((ary.size / 2) - 1)
+
+        p ary.sort
+
+        data_ptr = FFI::MemoryPointer.new :float, ary.size
+        data_ptr.write_array_of_float ary
+        assert_equal median, Libevoasm.pop_find_median_loss(data_ptr, ary.size)
+      end
+    end
+
+    def test_no_instructions
+      @instruction_names = []
+      error = assert_raises Evoasm::Error do
+        start
+      end
+
+      assert_match /instructions/, error.message
+    end
+
+    def test_no_parameters
+      @parameters = []
+      error = assert_raises Evoasm::Error do
+        start
+      end
+
+      assert_match /parameters/, error.message
+    end
+
+    def test_no_examples
+      @examples = {}
+      error = assert_raises Evoasm::Error do
+        start
+      end
+
+      assert_match /input|output/, error.message
+    end
+
+    def test_invalid_deme_size
+      @deme_size = 0
+      error = assert_raises Evoasm::Error do
+        start
+      end
+      assert_match /deme size/i, error.message
+    end
+
+    def test_invalid_program_size
+      [0, 2**32].each do |program_size|
+        @program_size = program_size
+        error = assert_raises Evoasm::Error do
+          start
+        end
+        assert_match /program size/i, error.message
+      end
+    end
+
+    def test_invalid_kernel_size
+      [0, 2**32].each do |kernel_size|
+        @kernel_size = kernel_size
+        error = assert_raises Evoasm::Error do
+          start
+        end
+        assert_match /kernel size/i, error.message
+      end
+    end
+  end
+end

data/test/unit/evoasm/prng_test.rb

@@ -0,0 +1,47 @@
+require 'evoasm/test'
+require 'evoasm/prng'
+
+module Evoasm
+  class PRNGTest < Minitest::Test
+    def setup
+      @prng = Evoasm::PRNG.new
+    end
+
+    def test_same_seed
+      same_prng = Evoasm::PRNG.new
+
+      10.times do
+        assert_equal @prng.rand64, same_prng.rand64
+      end
+    end
+
+    def test_different_seed
+      other_prng = Evoasm::PRNG.new (11..26).to_a
+
+      refute_equal @prng.rand64, other_prng.rand64
+    end
+
+    def test_rand8
+      buckets = Array.new(256, 0)
+      sample_size = 100_000
+      sample_size.times do
+        r = @prng.rand8
+        refute_operator r, :>, 255
+        refute_operator r, :<, 0
+        buckets[r] += 1
+      end
+
+      # Not sufficient,
+      # but indicates if something is seriously wrong
+      exp_bucket_size = sample_size / buckets.size
+      mse = 1.0/buckets.size * buckets.inject(0) do |acc, sample|
+        diff = ((sample - exp_bucket_size.to_f)**2 / exp_bucket_size.to_f)
+        p [sample, exp_bucket_size, diff]
+        acc + diff
+      end
+
+      rmse = Math.sqrt mse
+      assert_operator rmse, :<, 2.0
+    end
+  end
+end

data/test/unit/evoasm/x64/cpu_state_test.rb

@@ -0,0 +1,73 @@
+require 'evoasm/test'
+require 'evoasm/x64/cpu_state'
+require 'evoasm/buffer'
+
+module Evoasm
+  module X64
+    class CPUStateTest < Minitest::Test
+      def setup
+        @cpu_state = CPUState.new
+      end
+
+      def test_clean
+        X64.registers.each do |reg|
+          data = @cpu_state[reg]
+          refute_empty data
+          assert data.all? { |e| e == 0 }
+        end
+      end
+
+      def test_set_get
+        @cpu_state[:a] = 0xFF
+        assert_equal [0xFF], @cpu_state[:a]
+
+        @cpu_state[:b] = [0xDEADBEEF]
+        assert_equal [0xDEADBEEF], @cpu_state[:b]
+
+        # FIXME: with AVX512 the array
+        # should be of size 8
+        data = (1..4).to_a
+        @cpu_state[:xmm0] = data
+        assert_equal data, @cpu_state[:xmm0]
+      end
+
+      def test_clone
+        @cpu_state[:b] = 0xFAB
+        cloned_cpu_state = @cpu_state.clone
+
+        assert_equal [0xFAB], cloned_cpu_state[:b]
+      end
+
+      def test_emit_store
+        buffer = Buffer.new 1024
+        Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :a, imm0: 7}, buffer)
+
+        @cpu_state.emit_store buffer
+        Evoasm::X64.encode(:ret, {}, buffer)
+
+        buffer.execute!
+        assert_equal [7], @cpu_state[:a]
+      end
+
+      def test_emit_load
+        buffer = Buffer.new 1024
+
+        @cpu_state[:a] = 0xABCD
+        @cpu_state[:rflags] = [0x1]
+
+        cpu_state_after = CPUState.new
+
+        X64.emit_stack_frame buffer do
+          @cpu_state.emit_load buffer
+          cpu_state_after.emit_store buffer
+        end
+
+        #buffer.__log__ :warn
+        buffer.execute!
+
+        assert_equal [0xABCD], cpu_state_after[:a]
+        assert_equal [0x1], cpu_state_after[:rflags]
+      end
+    end
+  end
+end

data/test/unit/evoasm/x64/encoding_test.rb

@@ -0,0 +1,320 @@
+require 'evoasm/test'
+
+require 'x64_helper'
+
+module Evoasm
+  module X64
+    class EncodingTest < Minitest::Test
+      include X64Helper
+
+      def test_direct
+        assert_disassembles_to 'add rax, rbx', :add_r64_rm64,
+                               reg0: :a, reg1: :b
+        assert_disassembles_to 'add rax, r12', :add_r64_rm64,
+                               reg0: :a, reg1: :r12
+        assert_disassembles_to 'add r11, rbx', :add_r64_rm64,
+                               reg0: :r11, 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 eax, r12d', :add_r32_rm32,
+                               reg0: :a, reg1: :r12
+        assert_disassembles_to 'add r11d, ebx', :add_r32_rm32,
+                               reg0: :r11, reg1: :b
+        assert_disassembles_to 'add r11d, r12d', :add_r32_rm32,
+                               reg0: :r11, reg1: :r12
+
+        assert_disassembles_to 'add ax, bx', :add_r16_rm16,
+                               reg0: :a, reg1: :b
+        assert_disassembles_to 'add ax, r12w', :add_r16_rm16,
+                               reg0: :a, reg1: :r12
+        assert_disassembles_to 'add r11w, bx', :add_r16_rm16,
+                               reg0: :r11, reg1: :b
+        assert_disassembles_to 'add r11w, r12w', :add_r16_rm16,
+                               reg0: :r11, reg1: :r12
+
+      end
+
+      def test_indirect
+        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
+
+        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
+
+
+        # Force SIB
+        with_forced_sib = assemble :add_r64_rm64,
+                                   reg0: :r10, reg_base: :r11,
+                                   force_sib?: true
+
+        without_forced_sib = assemble :add_r64_rm64,
+                                      reg0: :r10, reg_base: :r11,
+                                      force_sib?: false
+
+        refute_equal with_forced_sib, without_forced_sib
+
+        assert_equal 'add r10, qword ptr [r11]', disassemble(with_forced_sib)
+        assert_equal 'add r10, qword ptr [r11]', disassemble(without_forced_sib)
+
+        # SP/R12 always need SIB
+        {sp: 'rsp', r12: 'r12'}.each do |reg_base, reg_base_name|
+
+          with_forced_sib = assemble(:add_r64_rm64,
+                                     reg0: :r10,
+                                     reg_base: reg_base,
+                                     force_sib?: true)
+
+          without_forced_sib = assemble(:add_r64_rm64,
+                                        reg0: :r10,
+                                        reg_base: reg_base,
+                                        force_sib?: false)
+
+          assert_equal with_forced_sib, without_forced_sib
+
+          assert_equal "add r10, qword ptr [#{reg_base_name}]",
+                       disassemble(with_forced_sib)
+
+          assert_equal "add r10, qword ptr [#{reg_base_name}]",
+                       disassemble(without_forced_sib)
+        end
+
+        # Force 32-bit displacement
+        with_disp8 = assemble :add_r64_rm64,
+                              reg0: :r10, reg_base: :r11, disp: 0x10
+
+        with_disp32 = assemble :add_r64_rm64,
+                               reg0: :r10, reg_base: :r11, disp: 0x10, force_disp32?: true
+
+        assert_equal 'add r10, qword ptr [r11 + 0x10]', disassemble(with_disp8)
+        assert_equal 'add r10, qword ptr [r11 + 0x10]', disassemble(with_disp32)
+
+        refute_equal with_disp8, with_disp32
+      end
+
+      def test_address_size
+        assert_disassembles_to 'add rax, dword ptr [ebx]', :add_r64_rm64,
+                               reg0: :a, reg_base: :b, addr_size: 32
+
+        assert_disassembles_to 'add eax, dword ptr [ebx]', :add_r32_rm32,
+                               reg0: :a, reg_base: :b, addr_size: 32
+      end
+
+      def test_lock
+        assert_disassembles_to 'lock add qword ptr [rax], rbx', :add_rm64_r64,
+                               reg_base: :a, reg1: :b, lock?: true
+
+        assert_disassembles_to 'lock inc qword ptr [r10]', :inc_rm64,
+                               reg_base: :r10, lock?: true
+      end
+
+      def test_rex
+        assert_disassembles_to 'add rax, rbx', :add_r64_rm64,
+                               reg0: :a, reg1: :b, force_rex?: true
+
+        # needs REX (.W), even if not forced
+        assert_assembles_to "\x48\x03\xC3", :add_r64_rm64,
+                            reg0: :a, reg1: :b, force_rex?: false
+
+        assert_assembles_to "\x48\x03\xC3", :add_r64_rm64,
+                            reg0: :a, reg1: :b, force_rex?: true
+
+        # REX.X is free
+        assert_assembles_to "\x4A\x03\xC3", :add_r64_rm64,
+                            reg0: :a, reg1: :b, rex_x: 0b1
+
+        assert_disassembles_to 'add rax, rbx', :add_r64_rm64,
+                               reg0: :a, reg1: :b, rex_x: 0b1
+
+        # REX is optional
+        assert_disassembles_to 'add eax, ebx', :add_r32_rm32,
+                               reg0: :a, reg1: :b
+
+        assert_assembles_to "\x03\xC3", :add_r32_rm32,
+                            reg0: :a, reg1: :b
+
+        assert_assembles_to "\x40\x03\xC3", :add_r32_rm32,
+                            reg0: :a, reg1: :b, force_rex?: true
+
+        assert_disassembles_to 'add eax, ebx', :add_r32_rm32,
+                               reg0: :a, reg1: :b, force_rex?: true
+
+        # REX.X is free
+        assert_assembles_to "\x42\x03\xC3", :add_r32_rm32,
+                            reg0: :a, reg1: :b, force_rex?: true, rex_x: 0b1
+
+        # REX.X is free
+        assert_assembles_to "\x40\x81\xC0\x10\x00\x00\x00", :add_rm32_imm32,
+                            reg0: :a, imm0: 0x10, force_rex?: true
+
+        assert_assembles_to "\x42\x81\xC0\x10\x00\x00\x00", :add_rm32_imm32,
+                            reg0: :a, imm0: 0x10, force_rex?: true, rex_x: 0b1
+
+        # REX.R is free (register is encoded in ModRM.rm)
+        assert_assembles_to "\x44\x81\xC0\x10\x00\x00\x00", :add_rm32_imm32,
+                            reg0: :a, imm0: 0x10, force_rex?: true, rex_r: 0b1
+
+        assert_assembles_to "\x46\x81\xC0\x10\x00\x00\x00", :add_rm32_imm32,
+                            reg0: :a, imm0: 0x10, force_rex?: true, rex_r: 0b1, rex_x: 0b1
+
+
+      end
+
+      def test_byte_reg
+
+        assert_assembles_to "\x40\x02\xC3", :add_r8_rm8,
+                            reg0: :a, reg1: :b, force_rex?: true
+
+        assert_assembles_to "\x02\xC3", :add_r8_rm8,
+                            reg0: :a, reg1: :b, force_rex?: false
+
+        assert_assembles_to "\x40\x00\xD8", :add_rm8_r8,
+                            reg0: :a, reg1: :b, force_rex?: true
+
+        assert_assembles_to "\x00\xD8", :add_rm8_r8,
+                            reg0: :a, reg1: :b, force_rex?: false
+
+        %i(add_r8_rm8 add_rm8_r8).each do |inst|
+          assert_disassembles_to 'add al, bl', inst,
+                                 reg0: :a, reg1: :b
+
+          assert_disassembles_to 'add r11b, r12b', inst,
+                                 reg0: :r11, reg1: :r12
+
+          assert_disassembles_to 'add al, r12b', inst,
+                                 reg0: :a, reg1: :r12
+
+          assert_disassembles_to 'add al, bl', inst,
+                                 reg0: :a, reg1: :b,
+                                 force_rex?: true
+
+          assert_disassembles_to 'add ah, bl', inst,
+                                 reg0: :a, reg1: :b,
+                                 reg0_high_byte?: true
+
+          assert_disassembles_to 'add ah, al', inst,
+                                 reg0: :a, reg1: :a,
+                                 reg0_high_byte?: true
+
+          assert_disassembles_to 'add ah, bh', inst,
+                                 reg0: :a, reg1: :b,
+                                 reg0_high_byte?: true,
+                                 reg1_high_byte?: true
+
+          assert_disassembles_to 'add al, bh', inst,
+                                 reg0: :a, reg1: :b,
+                                 reg0_high_byte?: false,
+                                 reg1_high_byte?: true
+
+          assert_disassembles_to 'add sil, dil', inst,
+                                 reg0: :si, reg1: :di,
+                                 reg0_high_byte?: false,
+                                 reg1_high_byte?: false
+
+          assert_disassembles_to 'add sil, dil', inst,
+                                 reg0: :si, reg1: :di
+
+          assert_raises Evoasm::Error do
+            Evoasm::X64.encode :add_r8_rm8,
+                               reg0: :si,
+                               reg1: :b,
+                               reg1_high_byte?: true
+          end
+        end
+
+        assert_assembles_to "\x40\xb6\x10", :mov_r8_imm8,
+                            reg0: :si, imm0: 0x10
+
+        assert_disassembles_to 'mov sil, 0x10', :mov_r8_imm8,
+                               reg0: :si, imm0: 0x10
+
+      end
+
+      def test_imm
+        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\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
+        assert_assembles_to "\xC4\xC1\xFA\x2C\xFD", :vcvttss2si_r64_xmmm32,
+                            reg0: :di, reg1: :xmm13
+
+        (0..15).each do |i|
+          assert_disassembles_to "vcvttss2si rdi, xmm#{i}", :vcvttss2si_r64_xmmm32,
+                                 reg0: :di, reg1: :"xmm#{i}"
+
+          assert_disassembles_to "vcvttss2si r12, xmm#{i}", :vcvttss2si_r64_xmmm32,
+                                 reg0: :r12, reg1: :"xmm#{i}"
+        end
+
+        assert_assembles_to "\xC5\xF5\xEC\xC2", :vpaddsb_ymm_ymm_ymmm256,
+                            reg0: :xmm0, reg1: :xmm1, reg2: :xmm2, force_long_vex?: false
+        assert_assembles_to "\xC5\xF5\xEC\xC2", :vpaddsb_ymm_ymm_ymmm256,
+                            reg0: :xmm0, reg1: :xmm1, reg2: :xmm2
+        assert_assembles_to "\xC4\xE1\x75\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?: false
+        assert_disassembles_to 'vpaddsb ymm0, ymm1, ymm2', :vpaddsb_ymm_ymm_ymmm256,
+                               reg0: :xmm0, reg1: :xmm1, reg2: :xmm2, force_long_vex?: true
+
+        assert_disassembles_to 'vblendvpd xmm0, xmm1, xmm2, xmm3', :vblendvpd_xmm_xmm_xmmm128_xmm,
+                               reg0: :xmm0, reg1: :xmm1, reg2: :xmm2, reg3: :xmm3
+      end
+
+      def test_vsib
+        assert_disassembles_to 'vpgatherdd xmm0, dword ptr [rax + xmm1*2], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm0, reg_base: :a, reg_index: :xmm1, scale: 2, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherdd xmm0, dword ptr [rax + xmm1], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm0, reg_base: :a, reg_index: :xmm1, scale: 1, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherdd xmm12, dword ptr [rax + xmm1], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm12, reg_base: :a, reg_index: :xmm1, scale: 1, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherdd xmm12, dword ptr [r12 + xmm1], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm12, reg_base: :r12, reg_index: :xmm1, scale: 1, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherdd xmm12, dword ptr [r12 + xmm12*8], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm12, reg_base: :r12, reg_index: :xmm12, scale: 8, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherdd xmm12, dword ptr [rdi + xmm12*8], xmm2', :vpgatherdd_xmm_vm32x32_xmm,
+                               reg0: :xmm12, reg_base: :di, reg_index: :xmm12, scale: 8, reg1: :xmm2
+
+        assert_disassembles_to 'vpgatherqq ymm12, qword ptr [rdi + ymm12*8], ymm2', :vpgatherqq_ymm_vm64y64_ymm,
+                               reg0: :xmm12, reg_base: :di, reg_index: :xmm12, scale: 8, reg1: :xmm2
+
+      end
+    end
+  end
+end