fisk 1.0.0

data/examples/print-string.rb

@@ -0,0 +1,26 @@
+require "fisk"
+require "fisk/helpers"
+
+module Printer
+  fisk = Fisk.new
+
+  jitbuf = Fisk::Helpers.jitbuffer 4096
+
+  str = "fooooooooo\n"
+  wrapper = Fiddle::Pointer[str]
+
+  fisk.asm(jitbuf) do
+    push rbp
+    mov rdi, imm32(1)            # File number for stdout
+    mov rsi, imm64(wrapper.to_i) # Address of the char * backing str
+    mov rdx, imm32(str.bytesize) # Number of bytes in the string
+    mov rax, imm32(0x02000004)   # write syscall on macOS x86_64
+    syscall
+    pop rbp
+    ret
+  end
+
+  define_singleton_method :print!, &jitbuf.to_function([], Fiddle::TYPE_VOID)
+end
+
+Printer.print!

data/lib/fisk.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "fisk/machine/encoding"
+require "fisk/machine"
+
+class Fisk
+  module Registers
+    class Register < Struct.new(:name, :type, :value)
+      def works? type
+        type == self.name || type == self.type
+      end
+
+      def unknown_label?; false; end
+    end
+
+    EAX = Register.new "eax", "r32", 0
+    ECX = Register.new "ecx", "r32", 1
+    EDX = Register.new "edx", "r32", 2
+    EBX = Register.new "ebx", "r32", 3
+    ESP = Register.new "esp", "r32", 4
+    EBP = Register.new "ebp", "r32", 5
+    ESI = Register.new "esi", "r32", 6
+    EDI = Register.new "edi", "r32", 7
+
+    RAX = Register.new "rax", "r64", 0
+    RCX = Register.new "rcx", "r64", 1
+    RDX = Register.new "rdx", "r64", 2
+    RBX = Register.new "rbx", "r64", 3
+    RSP = Register.new "rsp", "r64", 4
+    RBP = Register.new "rbp", "r64", 5
+    RSI = Register.new "rsi", "r64", 6
+    RDI = Register.new "rdi", "r64", 7
+    8.times do |i|
+      i += 8
+      const_set "R#{i}", Register.new("r#{i}", "r64", i)
+    end
+  end
+
+  class Operand < Struct.new(:value)
+    def type; value; end
+    def works? type; self.type == type; end
+    def unknown_label?; false; end
+  end
+
+  class M64 < Operand
+    def type
+      "m64"
+    end
+  end
+
+  def m64 x
+    M64.new x
+  end
+
+  class Imm8 < Operand
+    def type
+      "imm8"
+    end
+  end
+
+  class Imm32 < Operand
+    def type
+      "imm32"
+    end
+  end
+
+  class Imm64 < Operand
+    def type
+      "imm64"
+    end
+  end
+
+  class Rel8 < Operand
+    def type
+      "rel8"
+    end
+  end
+
+  class Rel32 < Operand
+    def type
+      "rel32"
+    end
+  end
+
+  class MOffs64 < Operand
+    def type
+      "moffs64"
+    end
+  end
+
+  class Lit < Operand
+    def type
+      value.to_s
+    end
+  end
+
+  attr_reader :position
+
+  def initialize
+    @instructions = []
+    @labels = {}
+    @position = 0
+  end
+
+  class UnknownLabel < Struct.new(:name, :assembler, :insn)
+    def works? type
+      type == "rel32"
+    end
+
+    def unknown_label?; true; end
+
+    def value
+      label = assembler.label_for(name)
+      label.position - (insn.position + insn.bytesize)
+    end
+  end
+
+  class Label < Struct.new(:name, :position)
+  end
+
+  def label_for name
+    @labels.fetch name
+  end
+
+  def label name
+    UnknownLabel.new(name, self)
+  end
+
+  def make_label name
+    @labels[name] = Label.new(name, position)
+  end
+
+  Registers.constants.grep(/^[A-Z0-9]*$/).each do |const|
+    val = Registers.const_get const
+    define_method(const.downcase) { val }
+  end
+
+  class Instruction
+    attr_reader :position
+
+    def initialize insn, operands, position
+      @insn     = insn
+      @operands = operands
+      @position = position
+    end
+
+    def encodings
+      @insn.encodings
+    end
+
+    def encode buffer
+      encoding = @insn.encodings.first
+      encoding.encode buffer, @operands
+    end
+
+    def bytesize
+      @insn.encodings.first.bytesize
+    end
+  end
+
+  def gen name, params
+    insns = Machine.instruction_with_name(name)
+    forms = insns.forms.find_all do |insn|
+      if insn.operands.length == params.length
+        params.zip(insn.operands).all? { |want_op, have_op|
+          want_op.works?(have_op.type)
+        }
+      else
+        false
+      end
+    end
+
+    raise NotImplementedError, "couldn't find instruction #{name}" if forms.length == 0
+
+    insn = nil
+
+    insn = forms.first
+
+    insn = Instruction.new(insn, params, position)
+    @position += insn.bytesize
+    @instructions << insn
+    params.each { |param| param.insn = insn if param.unknown_label? }
+
+    self
+  end
+
+  Machine.instructions.keys.each do |insn|
+    define_method(insn.downcase) do |*params|
+      gen insn, params
+    end
+  end
+
+  def moffs64 val
+    MOffs64.new val
+  end
+
+  def imm8 val
+    Imm8.new val
+  end
+
+  def imm32 val
+    Imm32.new val
+  end
+
+  def imm64 val
+    Imm64.new val
+  end
+
+  def rel8 val
+    Rel8.new val
+  end
+
+  def rel32 val
+    Rel32.new val
+  end
+
+  def lit val
+    # to_s because we're getting the value from JSON as a string
+    Lit.new val
+  end
+
+  def asm buf = StringIO.new(''.b), &block
+    @position = 0
+    instance_eval(&block)
+    write_to_buffer buf
+    buf
+  end
+
+  def to_binary
+    io = StringIO.new ''.b
+    write_to_buffer io
+    io.string
+  end
+
+  private
+
+  def write_to_buffer buffer
+    @instructions.each { |insn| insn.encode buffer }
+  end
+end

data/lib/fisk/helpers.rb

@@ -0,0 +1,73 @@
+require "fiddle"
+
+class Fisk
+  module Helpers
+    include Fiddle
+
+    class Fiddle::Function
+      def to_proc
+        this = self
+        lambda { |*args| this.call(*args) }
+      end
+    end unless Function.method_defined?(:to_proc)
+
+    # from sys/mman.h on macOS
+    PROT_READ   = 0x01
+    PROT_WRITE  = 0x02
+    PROT_EXEC   = 0x04
+    MAP_PRIVATE = 0x0002
+
+    if RUBY_PLATFORM =~ /darwin/
+      MAP_ANON    = 0x1000
+    else
+      MAP_ANON    = 0x20
+    end
+
+    mmap_ptr = Handle::DEFAULT["mmap"]
+    mmap_func = Function.new mmap_ptr, [TYPE_VOIDP,
+                                        TYPE_SIZE_T,
+                                        TYPE_INT,
+                                        TYPE_INT,
+                                        TYPE_INT,
+                                        TYPE_INT], TYPE_VOIDP, name: "mmap"
+
+    memcpy_ptr = Handle::DEFAULT["memcpy"]
+    memcpy_func = Function.new memcpy_ptr, [TYPE_VOIDP,
+                                            TYPE_VOIDP,
+                                            TYPE_SIZE_T], TYPE_VOIDP, name: "memcpy"
+
+    # Expose the mmap system call
+    define_singleton_method :mmap, &mmap_func
+
+    # Expose the memcpy system call
+    define_singleton_method :memcpy, &memcpy_func
+
+    def self.mmap_jit size
+      ptr = mmap 0, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANON, -1, 0
+      ptr.size = size
+      ptr
+    end
+
+    class JITBuffer
+      attr_reader :memory, :pos
+
+      def initialize memory
+        @memory = memory
+        @pos = 0
+      end
+
+      def putc byte
+        @memory[@pos] = byte
+        @pos += 1
+      end
+
+      def to_function params, ret
+        Fiddle::Function.new memory.to_i, params, ret
+      end
+    end
+
+    def self.jitbuffer size
+      JITBuffer.new mmap_jit size
+    end
+  end
+end

data/lib/fisk/machine.rb

@@ -0,0 +1,35 @@
+class Fisk
+  class Machine
+    Instructions = {}
+
+    Operand = Struct.new(:type, :input, :output)
+
+    def self.instructions
+      Instructions
+    end
+
+    def self.instruction_with_name name
+      Instructions[name]
+    end
+
+    class Form
+      attr_reader :operands, :encodings
+
+      def initialize operands, encodings
+        @operands = operands
+        @encodings = encodings
+      end
+    end
+
+    class Instruction
+      attr_reader :name, :forms
+
+      def initialize name, forms
+        @name = name
+        @forms = forms
+      end
+    end
+  end
+end
+
+require "fisk/machine/generated"

data/lib/fisk/machine/encoding.rb

@@ -0,0 +1,78 @@
+class Fisk
+  class Machine
+    class Encoding
+      private
+
+      def add_modrm buffer, operands, mode, reg, rm
+        reg = get_operand_value(reg, operands) & 0x7
+        rm = get_operand_value(rm, operands) & 0x7
+        buffer.putc ((mode << 6) | (reg << 3) | rm)
+      end
+
+      def add_immediate buffer, operands, value, size
+        value = get_operand_value(value, operands)
+        write_num buffer, value, size
+      end
+
+      def add_code_offset buffer, operands, value, size
+        value = get_operand_value(value, operands)
+        write_num buffer, value, size
+      end
+
+      def add_data_offset buffer, operands, value, size
+        value = get_operand_value(value, operands)
+        write_num buffer, value, size
+      end
+
+      def add_rex buffer, operands, mandatory, w, r, x, b
+        return if mandatory == false
+
+        rex = 0b0100
+        rex = (rex << 1) | check_rex(w, operands)
+        rex = (rex << 1) | check_rex(r, operands)
+        rex = (rex << 1) | check_rex(x, operands)
+        rex = (rex << 1) | check_rex(b, operands)
+        buffer.putc rex
+      end
+
+      def add_opcode buffer, operands, byte, addend
+        if addend
+          byte |= get_operand_value(addend, operands)
+        end
+
+        buffer.putc byte
+      end
+
+      def get_operand_value v, operands
+        case v
+        when /^#(\d+)$/
+          operands[$1.to_i].value
+        when /^(\d+)$/
+          $1.to_i
+        else
+          raise NotImplementedError
+        end
+      end
+
+      def check_rex v, operands
+        return 0 unless v
+
+        case v
+        when /^(\d+)$/
+          v.to_i
+        when /^#(\d+)$/
+          (operands[$1.to_i].value >> 3)
+        else
+          raise NotImplementedError, v
+        end
+      end
+
+      def write_num buffer, num, size
+        size.times {
+          buffer.putc(num & 0xFF)
+          num >>= 8
+        }
+      end
+    end
+  end
+end