fisk 1.0.0 → 2.3.0

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,11 +2,226 @@ require "helper"
 require "fisk/helpers"
 
 class RunFiskTest < Fisk::Test
-  def disasm binary
-    cs = Crabstone::Disassembler.new(Crabstone::ARCH_X86, Crabstone::MODE_64)
-    cs.disasm(binary, 0x0000).each {|i|
-      printf("0x%x:\t%s\t\t%s\n",i.address, i.mnemonic, i.op_str)
+  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
+
+    str = " " * 0xFFFFF
+    ptr = Fiddle::Pointer[str]
+
+    fisk.asm jitbuf do
+      push rbp
+      mov rbp, rsp
+      mov rdx, imm32(1)
+      jmp label(:foo)
+      mov r8, imm64(ptr.to_i)
+      mov r8, m64(r8, 0xFFFF)
+      int lit(3) # crash if we don't jump over this
+    put_label :foo
+      mov rax, imm32(0x3)
+      pop rbp
+      ret
+    end
+
+    func = jitbuf.to_function [], Fiddle::TYPE_INT
+    assert_equal 3, func.call
+  end
+
+  def test_label_rel32
+    fisk = Fisk.new
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+
+    str = " " * 0xFFFFF
+    ptr = Fiddle::Pointer[str]
+
+    fisk.asm jitbuf do
+      push rbp
+      mov rbp, rsp
+      mov rdx, imm32(1)
+      mov r8, imm64(ptr.to_i)
+      mov r8, m64(r8, 0xFFFF)
+      xor rax, rax
+    put_label :loop
+      add rax, rdx
+      500.times { nop }
+      inc rdx
+      cmp rdx, imm32(10)
+      jbe label(:loop)
+      pop rbp
+      ret
+    end
+
+    func = jitbuf.to_function [], Fiddle::TYPE_INT
+    assert_equal 11.times.inject(:+), func.call
+  end
+
+  def test_label_rel8
+    fisk = Fisk.new
+    jitbuf = Fisk::Helpers.jitbuffer 4096
+
+    str = " " * 0xFFFFF
+    ptr = Fiddle::Pointer[str]
+
+    fisk.asm jitbuf do
+      push rbp
+      mov rbp, rsp
+      mov rdx, imm32(1)
+      mov r8, imm64(ptr.to_i)
+      mov r8, m64(r8, 0xFFFF)
+      xor rax, rax
+    put_label :loop
+      add rax, rdx
+      inc rdx
+      cmp rdx, imm32(10)
+      jbe label(:loop)
+      pop rbp
+      ret
+    end
+
+    func = jitbuf.to_function [], Fiddle::TYPE_INT
+    assert_equal 11.times.inject(:+), func.call
   end
 
   def test_sum
@@ -18,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)
@@ -39,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