fisk 2.0.0 → 2.3.1

data/lib/fisk/encoding.rb

@@ -2,24 +2,75 @@ class Fisk
   class Encoding
     private
 
-    def add_modrm buffer, operands, mode, reg, rm
+    def add_modrm buffer, mode, reg, rm, operands
+      if mem = operands.find(&:memory?)
+        add_modrm_mem mem, buffer, mode, reg, rm
+      else
+        buffer.putc ((mode << 6) | ((reg & 0x7) << 3) | (rm & 0x7))
+        1
+      end
+    end
+
+    def add_modrm_mem mem, buffer, mode, reg, rm
       offset_bytes = 0
-      if mem = operands.find(&:m64?)
-        if mem.displacement != 0
-          if 0xFF == mem.displacement | 0xFF
-            offset_bytes = 1
-            mode |= 0x1
-          else
-            offset_bytes = 4
-            mode |= 0x2
-          end
+      if mem.displacement != 0 || (rm & 0x7) == 5 # RBP / r13 needs an offset
+        if mem.displacement >= -0x7F - 1 && mem.displacement < 0x7F
+          offset_bytes = 1
+          mode |= 0x1
+        else
+          offset_bytes = 4
+          mode |= 0x2
         end
       end
-      reg = reg & 0x7
-      rm = rm & 0x7
-      buffer.putc ((mode << 6) | (reg << 3) | rm)
-      if mem && mem.displacement != 0
-        write_num buffer, mem.displacement, offset_bytes
+
+      count = 1
+
+      modrm_byte = ((mode << 6) | ((reg & 0x7) << 3) | (rm & 0x7))
+      buffer.putc modrm_byte
+
+      # Needs SIB, Table 2-2
+      if rm & 0x7 == 4 # RSP register / r12
+        count += 1
+        buffer.putc 0x24
+      end
+
+      if mem && (mem.displacement != 0 || (rm & 0x7) == 5)
+        count + write_num(buffer, mem.displacement, offset_bytes)
+      else
+        count
+      end
+    end
+
+
+    # Add ModRM with one mem operand and one register operand
+    def add_modrm_mem_reg buffer, mode, reg, rm, operands
+      add_modrm_mem_reg_ buffer, mode, reg, rm, operands[0], operands[1]
+    end
+
+    # Add ModRM with one mem operand and one register operand
+    def add_modrm_reg_mem buffer, mode, reg, rm, operands
+      add_modrm_mem_reg_ buffer, mode, reg, rm, operands[1], operands[0]
+    end
+
+    def add_modrm_mem_reg_ buffer, mode, reg, rm, mem, reg_opnd
+      if mem.rip?
+        buffer.putc 0x5 + ((reg_opnd.value % 8) * 8)
+        return 1 + write_num(buffer, mem.displacement, 4)
+      end
+
+      add_modrm_mem mem, buffer, mode, reg, rm
+    end
+
+    # Add ModRM with two register operands
+    def add_modrm_reg_reg buffer, mode, reg, rm, operands
+      if rip = operands.find(&:rip?)
+        buffer.putc 0x5
+        1 + write_num(buffer, rip.displacement, 4)
+      else
+        reg = reg & 0x7
+        rm = rm & 0x7
+        buffer.putc ((mode << 6) | (reg << 3) | rm)
+        1
       end
     end
 
@@ -36,7 +87,14 @@ class Fisk
     end
 
     def add_rex buffer, operands, mandatory, w, r, x, b
-      return if mandatory == false && !operands.any?(&:extended_register?)
+      return 0 if mandatory == false && !operands.any?(&:extended_register?)
+
+      if mem = operands.find(&:memory?)
+        if mem.extended_register?
+          x = 0
+          b = 1
+        end
+      end
 
       rex = 0b0100
       rex = (rex << 1) | w
@@ -44,11 +102,13 @@ class Fisk
       rex = (rex << 1) | x
       rex = (rex << 1) | b
       buffer.putc rex
+      1
     end
 
     def add_opcode buffer, byte, addend
-      byte |= addend
+      byte |= (addend & 0x7)
       buffer.putc byte
+      1
     end
 
     def write_num buffer, num, size
@@ -56,6 +116,12 @@ class Fisk
         buffer.putc(num & 0xFF)
         num >>= 8
       }
+      size
+    end
+
+    def add_prefix buffer, operands, byte, mandatory
+      buffer.putc byte
+      1
     end
   end
 end

data/lib/fisk/errors.rb

@@ -0,0 +1,50 @@
+class Fisk
+  module Errors
+    class Error < StandardError
+    end
+
+    # Raised when an instruction isn't found or can't be generated
+    class InvalidInstructionError < Error
+    end
+
+    # Raised when a temporary register is released more than once
+    class AlreadyReleasedError < Error
+    end
+
+    # Raised when a temporary register is used after it has been released
+    class UseAfterInvalidationError < Error
+    end
+
+    # Raised when a temporary register hasn't been released, but local register
+    # allocation was requested
+    class UnreleasedRegisterError < Error
+    end
+
+    # Raised when a temporary register hasn't been assigned a real register,
+    # but it's used in the encoding process.
+    class UnassignedRegister < Error
+    end
+
+    # Raised when a label is used but the location is never defined.  For
+    # example, the `label` method is called, but there is no corresponding
+    # `put_label`
+    class MissingLabel < Error
+    end
+
+    # Raised when a label is defined multiple times.  For example, calling
+    # `put_label` with the same name twice
+    class LabelAlreadyDefined < Error
+    end
+
+    # Raised when the performance check is enabled, and suboptimal instructions
+    # are found.
+    class SuboptimalPerformance < Error
+      attr_reader :warnings
+
+      def initialize(warnings)
+        super "Suboptimal instructions found!"
+        @warnings = warnings
+      end
+    end
+  end
+end

data/lib/fisk/helpers.rb

@@ -51,18 +51,21 @@ class Fisk
     class JITBuffer
       attr_reader :memory, :pos
 
-      def initialize memory
+      def initialize memory, size
         @memory = memory
         @pos = 0
+        @size = size
       end
 
       def putc byte
+        raise "Buffer full! #{pos} - #{@size}" if pos >= @size
         @memory[@pos] = byte
         @pos += 1
       end
 
       def seek pos, whence = IO::SEEK_SET
         raise NotImplementedError if whence != IO::SEEK_SET
+        raise if pos >= @size
 
         @pos = pos
         self
@@ -71,10 +74,38 @@ class Fisk
       def to_function params, ret
         Fiddle::Function.new memory.to_i, params, ret
       end
+
+      # Write a jump instruction at location +at+ that jumps to the location
+      # specified by +to+. +type+ specifies the type of jump.  This method
+      # maintains the current position of the cursor inside the memory chunk
+      def patch_jump at:, to:, type: :jmp
+        pos = self.pos
+        write_jump(to: to, at: at, type: type)
+        seek pos, IO::SEEK_SET
+      end
+
+      # Write a jump instruction at location +at+ that jumps to the location
+      # specified by +to+. +type+ specifies the type of jump.  Returns the
+      # position in the buffer where the jump instruction was written.
+      #
+      # This method does not maintain the current position of the cursor
+      def write_jump to:, at: self.pos, type: :jmp
+        rel_jump = 0xCAFE
+        2.times do
+          seek at, IO::SEEK_SET
+          Fisk.new { |__| __.public_send(type, __.rel32(rel_jump)) }.write_to(self)
+          rel_jump = to - address
+        end
+        self.pos
+      end
+
+      def address
+        memory.to_i + pos
+      end
     end
 
     def self.jitbuffer size
-      JITBuffer.new mmap_jit size
+      JITBuffer.new mmap_jit(size), size
     end
   end
 end