fisk 2.0.0 → 2.3.1

data/test/test_register_allocation.rb

@@ -0,0 +1,220 @@
+require "helper"
+
+class RegisterAllocationTest < Fisk::Test
+  attr_reader :fisk
+
+  def setup
+    super
+    @fisk = Fisk.new
+  end
+
+  def test_encode_temp_register_without_assignemt_raises
+    reg = fisk.register
+    fisk.push(reg)
+
+    assert_raises Fisk::Errors::UnassignedRegister do
+      fisk.to_binary
+    end
+  end
+
+  def test_push_r8_with_reg_assignment
+    reg = fisk.register
+    fisk.push(reg)
+    fisk.assign_registers([fisk.r8, fisk.r9])
+
+    i = disasm(fisk.to_binary).first
+    assert_equal "push", i.mnemonic.to_s
+    assert_equal "r8", i.op_str.to_s
+  end
+
+  def test_call_r8_with_reg_assignment
+    reg = fisk.register
+    fisk.mov(reg, fisk.imm64(123))
+    fisk.call(reg)
+    fisk.assign_registers([fisk.r8, fisk.r9])
+
+    i = disasm(fisk.to_binary)[1]
+    assert_equal "call", i.mnemonic.to_s
+    assert_equal "r8", i.op_str.to_s
+  end
+
+  def test_with_memory_operand
+    reg = fisk.register
+    fisk.m64(reg)
+    fisk.assign_registers([fisk.r9])
+  end
+
+  def test_with_unresolved_jumps
+    label = fisk.label "foo"
+    fisk.jmp label
+    fisk.put_label "foo"
+    fisk.assign_registers([fisk.r9])
+  end
+
+  def test_make_temporary_register_with_name
+    name = "aaron"
+    reg = fisk.register name
+
+    assert reg
+    assert_equal "r64", reg.type
+    assert_equal name, reg.name
+  end
+
+  def test_make_temporary_register
+    reg = fisk.register
+
+    assert reg
+    assert_equal "r64", reg.type
+    assert_equal "temp", reg.name
+  end
+
+  def test_two_registers_are_not_same
+    reg1 = fisk.register
+    reg2 = fisk.register
+
+    refute_same reg1, reg2
+  end
+
+  def test_assign_registers
+    reg = fisk.register
+    fisk.mov reg, fisk.imm64(2)
+    fisk.assign_registers([Fisk::Registers::R9])
+    i = disasm(fisk.to_binary).first
+    assert_equal "movabs", i.mnemonic.to_s
+    assert_equal "r9, 2", i.op_str.to_s
+  end
+
+  def test_assign_same_registers
+    reg = fisk.register
+    fisk.mov reg, fisk.imm64(2)
+    fisk.mov fisk.rax, reg
+    fisk.assign_registers([Fisk::Registers::R9])
+    i = disasm(fisk.to_binary)
+    assert_equal "movabs", i[0].mnemonic.to_s
+    assert_equal "r9, 2", i[0].op_str.to_s
+    assert_equal "mov", i[1].mnemonic.to_s
+    assert_equal "rax, r9", i[1].op_str.to_s
+  end
+
+  def test_assign_same_location
+    reg = fisk.register
+    fisk.xor reg, reg
+    fisk.assign_registers([Fisk::Registers::R9])
+    i = disasm(fisk.to_binary)
+    assert_equal "xor", i[0].mnemonic.to_s
+    assert_equal "r9, r9", i[0].op_str.to_s
+  end
+
+  def test_assign_two_registers
+    reg1 = fisk.register
+    reg2 = fisk.register
+    fisk.xor reg1, reg2
+    fisk.assign_registers([Fisk::Registers::R9, Fisk::Registers::R10])
+    i = disasm(fisk.to_binary)
+    assert_equal "xor", i[0].mnemonic.to_s
+    assert_equal ["r9", "r10"].sort, i[0].op_str.to_s.split(", ").sort
+  end
+
+  def test_reuse_register
+    reg1 = fisk.register
+    reg2 = fisk.register
+    fisk.xor reg1, reg1
+    fisk.put_label(:foo) # make two basic blocks
+    fisk.xor reg2, reg2
+    fisk.assign_registers([Fisk::Registers::R9])
+    i = disasm(fisk.to_binary)
+    assert_equal "xor", i[0].mnemonic.to_s
+    assert_equal "r9, r9", i[0].op_str.to_s
+    assert_equal "xor", i[1].mnemonic.to_s
+    assert_equal "r9, r9", i[1].op_str.to_s
+  end
+
+  def test_spill_not_implemented_cfg
+    __ = fisk
+
+    reg1 = fisk.register("temp1")
+    reg2 = fisk.register("temp2")
+    reg3 = fisk.register("temp3")
+
+    __.mov(reg1, fisk.imm32(1))    # block 0
+      .mov(reg2, fisk.imm32(1))
+    .put_label(:head)              # block 1
+      .cmp(reg1, fisk.imm32(100))
+      .jg(fisk.label(:break))
+      .add(reg1, reg2)             # block 2
+      .mov(reg3, fisk.imm32(1))
+      .mov(reg2, reg3)
+      .jmp(fisk.label(:head))
+    .put_label(:break)             # block 3
+
+    assert_raises(NotImplementedError) do
+      fisk.assign_registers([Fisk::Registers::R8, Fisk::Registers::R9])
+    end
+
+    fisk.assign_registers([Fisk::Registers::R8, Fisk::Registers::R9, Fisk::Registers::R10])
+
+    assert_equal "r8", reg1.register.name
+    assert_equal "r9", reg2.register.name
+    assert_equal "r10", reg3.register.name
+  end
+
+  def test_spill_not_implemented
+    reg1 = fisk.register
+    reg2 = fisk.register
+    fisk.xor reg1, reg2
+
+    assert_raises(NotImplementedError) do
+      fisk.assign_registers([Fisk::Registers::R9])
+    end
+  end
+
+  def test_registers_can_be_released
+    reg1 = fisk.register
+    reg2 = fisk.register
+    fisk.xor reg1, reg1
+    fisk.release_register reg1
+    fisk.xor reg2, reg2
+    fisk.release_register reg2
+    fisk.assign_registers([Fisk::Registers::R9], local: true)
+    i = disasm(fisk.to_binary)
+    assert_equal "xor", i[0].mnemonic.to_s
+    assert_equal "r9, r9", i[0].op_str.to_s
+    assert_equal "xor", i[1].mnemonic.to_s
+    assert_equal "r9, r9", i[1].op_str.to_s
+  end
+
+  def test_multiple_releases_is_an_error
+    reg1 = fisk.register
+    fisk.xor reg1, reg1
+    fisk.release_register reg1
+    assert_raises Fisk::Errors::AlreadyReleasedError do
+      fisk.release_register reg1
+    end
+  end
+
+  def test_use_after_invalidation_is_error
+    reg1 = fisk.register
+    fisk.xor reg1, reg1
+    fisk.release_register reg1
+    assert_raises Fisk::Errors::UseAfterInvalidationError do
+      fisk.xor reg1, reg1
+    end
+  end
+
+  def test_release_all_registers
+    reg1 = fisk.register
+    fisk.xor reg1, reg1
+    fisk.release_all_registers
+    assert_raises Fisk::Errors::UseAfterInvalidationError do
+      fisk.xor reg1, reg1
+    end
+  end
+
+  def test_unreleased_registers_raise_exception
+    reg1 = fisk.register
+    fisk.xor reg1, reg1
+    assert_raises Fisk::Errors::UnreleasedRegisterError do
+      fisk.assign_registers([Fisk::Registers::R9], local: true)
+    end
+  end
+end

data/test/test_run_fisk.rb

@@ -2,6 +2,148 @@ require "helper"
 require "fisk/helpers"
 
 class RunFiskTest < Fisk::Test
+  def test_buffer_raises_on_seek
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    assert_raises do
+      jitbuf.seek 4097
+    end
+  end
+
+  def test_buffer_raises_on_write
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    4096.times { jitbuf.putc 0x3C }
+    assert_raises do
+      jitbuf.putc 0x3C
+    end
+  end
+
+  def test_jit_jump_absolute
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    fisk = Fisk.new { |__|
+      __.jmp(__.absolute(jitbuf.memory.to_i))
+    }
+    fisk.write_to jitbuf
+    jump = disasm(jitbuf.memory[0, 4096])[0]
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0", jump.op_str.to_s
+  end
+
+  def test_jit_jump_patch
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    jump_pos = nil
+    fisk = Fisk.new { |__|
+      __.push(__.rbp)
+        .mov(__.rbp, __.rsp)
+        .mov(__.rax, __.imm64(-123))
+
+      __.lazy { |pos| jump_pos = pos }
+        .jmp(__.rel32(1234))
+    }
+    fisk.write_to jitbuf
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0x4e5", jump.op_str.to_s
+
+    jitbuf.patch_jump at: jump_pos, to: jitbuf.memory.to_i
+
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0", jump.op_str.to_s
+
+    jitbuf.patch_jump at: jump_pos, to: jitbuf.memory.to_i + 0xFF
+
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0xff", jump.op_str.to_s
+  end
+
+  def test_jit_patch_jump_type
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    jump_pos = nil
+    fisk = Fisk.new { |__|
+      __.push(__.rbp)
+        .mov(__.rbp, __.rsp)
+        .mov(__.rax, __.imm64(-123))
+
+      __.lazy { |pos| jump_pos = pos }
+        .jmp(__.rel32(1234))
+    }
+    fisk.write_to jitbuf
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0x4e5", jump.op_str.to_s
+
+    jitbuf.patch_jump at: jump_pos, to: jitbuf.memory.to_i, type: :jg
+
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+    assert_equal "jg", jump.mnemonic.to_s
+    assert_equal "0", jump.op_str.to_s
+
+    jitbuf.patch_jump at: jump_pos, to: jitbuf.memory.to_i + 0xFF, type: :jne
+
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+    assert_equal "jne", jump.mnemonic.to_s
+    assert_equal "0xff", jump.op_str.to_s
+  end
+
+  def test_jit_patch_maintains_position
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    jump_pos = nil
+    fisk = Fisk.new { |__|
+      __.push(__.rbp)
+        .mov(__.rbp, __.rsp)
+        .mov(__.rax, __.imm64(-123))
+
+      __.lazy { |pos| jump_pos = pos }
+        .jmp(__.rel32(1234))
+    }
+    fisk.write_to jitbuf
+    jump = disasm(jitbuf.memory[0, 4096])[3]
+
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0x4e5", jump.op_str.to_s
+
+    pos = jitbuf.pos
+    jitbuf.patch_jump at: jump_pos, to: jitbuf.memory.to_i, type: :jg
+    assert_equal pos, jitbuf.pos
+  end
+
+  def test_write_jump_moves
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+    fisk = Fisk.new { |__|
+      __.push(__.rbp)
+        .mov(__.rbp, __.rsp)
+        .mov(__.rax, __.imm64(-123))
+    }
+    fisk.write_to jitbuf
+
+    current_pos = jitbuf.pos
+    jitbuf.write_jump(to: jitbuf.address + 0xFF)
+
+    jump = disasm(jitbuf.memory[current_pos, jitbuf.pos])[0]
+
+    assert_equal "jmp", jump.mnemonic.to_s
+    assert_equal "0xff", jump.op_str.to_s
+  end
+
+  def test_negative
+    fisk = Fisk.new
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+
+    fisk.asm jitbuf do
+      push rbp
+      mov rbp, rsp
+      mov rax, imm64(-123)
+      pop rbp
+      ret
+    end
+
+    func = jitbuf.to_function [], Fiddle::TYPE_INT
+    assert_equal(-123, func.call)
+  end
+
   def test_forward_label_rel32
     fisk = Fisk.new
     jitbuf = Fisk::Helpers.jitbuffer 4096
@@ -17,7 +159,7 @@ class RunFiskTest < Fisk::Test
       mov r8, imm64(ptr.to_i)
       mov r8, m64(r8, 0xFFFF)
       int lit(3) # crash if we don't jump over this
-    make_label :foo
+    put_label :foo
       mov rax, imm32(0x3)
       pop rbp
       ret
@@ -41,7 +183,7 @@ class RunFiskTest < Fisk::Test
       mov r8, imm64(ptr.to_i)
       mov r8, m64(r8, 0xFFFF)
       xor rax, rax
-    make_label :loop
+    put_label :loop
       add rax, rdx
       500.times { nop }
       inc rdx
@@ -69,7 +211,7 @@ class RunFiskTest < Fisk::Test
       mov r8, imm64(ptr.to_i)
       mov r8, m64(r8, 0xFFFF)
       xor rax, rax
-    make_label :loop
+    put_label :loop
       add rax, rdx
       inc rdx
       cmp rdx, imm32(10)
@@ -91,7 +233,7 @@ class RunFiskTest < Fisk::Test
       mov rbp, rsp
       mov rdx, imm32(1)
       xor rax, rax
-    make_label :loop
+    put_label :loop
       add rax, rdx
       inc rdx
       cmp rdx, imm32(10)
@@ -112,11 +254,11 @@ class RunFiskTest < Fisk::Test
       push rbp
       mov rbp, rsp
       jmp label(:foo)
-      make_label(:bar)
+      put_label(:bar)
       mov rax, imm32(100)
       pop rbp
       ret
-      make_label(:foo)
+      put_label(:foo)
       jmp label(:bar)
       mov rax, imm32(42)
       pop rbp

metadata

@@ -1,21 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: fisk
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.3.1
 platform: ruby
 authors:
 - Aaron Patterson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-01 00:00:00.000000000 Z
-dependencies: []
+date: 2021-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+- !ruby/object:Gem::Dependency
+  name: crabstone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
 description: Tired of writing Ruby in Ruby? Now you can write assembly in Ruby!
 email: tenderlove@ruby-lang.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
+- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE
 - README.md
@@ -26,7 +84,9 @@ files:
 - examples/print-string.rb
 - fisk.gemspec
 - lib/fisk.rb
+- lib/fisk/basic_block.rb
 - lib/fisk/encoding.rb
+- lib/fisk/errors.rb
 - lib/fisk/helpers.rb
 - lib/fisk/instructions.rb
 - lib/fisk/instructions/adc.rb
@@ -1256,8 +1316,13 @@ files:
 - lib/fisk/instructions/xor.rb
 - lib/fisk/instructions/xorpd.rb
 - lib/fisk/instructions/xorps.rb
+- lib/fisk/version.rb
 - test/helper.rb
+- test/test_cfg.rb
 - test/test_fisk.rb
+- test/test_fisk_written_size.rb
+- test/test_performance_check.rb
+- test/test_register_allocation.rb
 - test/test_run_fisk.rb
 homepage: https://github.com/tenderlove/fisk
 licenses:
@@ -1284,5 +1349,9 @@ specification_version: 4
 summary: Write assembly in Ruby!
 test_files:
 - test/helper.rb
+- test/test_cfg.rb
 - test/test_fisk.rb
+- test/test_fisk_written_size.rb
+- test/test_performance_check.rb
+- test/test_register_allocation.rb
 - test/test_run_fisk.rb