fisk 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42d5818c354d7ee2347266ca997e314615a23f832687a30dc05578a2e92b6310
-  data.tar.gz: '06428fa873eed75d9ee07bdedd1fa848a51dfaa826dd38ce661c6b267509e3a8'
+  metadata.gz: bd9dadadf62c43af7898876779ad80e10ab4883cd69ea599b02631efb068e817
+  data.tar.gz: abf1ec8a5b3e61e5fc45abe9b59e74349e91924f9a073179f0db186a686229a6
 SHA512:
-  metadata.gz: 5ccbb718f81f5856f19dfca980a3f7d39e7a96cdc8dcd43922fb7e90e89d16d87d20cb07ccc54cf09809a9c3020504ab3ea8742bad65b77edc83cf94015c5794
-  data.tar.gz: 8e9182cb31c8d29dd260e35d607a525536a5964cacc814898a2ac696ec3f8f2b9671f982a698c8b725e380eb7bff54c07f1a84c6bbc25540ab7bfcd0388ca8e6
+  metadata.gz: 1586760e58ade58534d5e22ca7ee56c0b5faa25d12ec3028c51c82543a65b86025f7d5bc35fe6dc14c8cc1cb9948cb736a669210b1c92e5fc96bb692e21e6837
+  data.tar.gz: 903f6d801e036ca5084e5111bafa06ebf601d5a27b8adc48e25b9200b67ef4de4be6f2998ed4589c934d54fddbdafe7fa7536ff649647fc1e04319270b85e3b0

data/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu, macos]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install libcapstone Linux
+        if: matrix.os == 'ubuntu'
+        run: |
+            sudo apt-get update -y
+            sudo apt-get install -y libcapstone-dev
+
+      - name: Install libcapstone macOS
+        if: matrix.os == 'macos'
+        run: |
+            brew update
+            brew install capstone
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@477b21f02be01bcb8030d50f37cfec92bfa615b6
+        with:
+          ruby-version: 3.0
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,78 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at aaron.patterson at gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
+

data/Gemfile

@@ -1,4 +1,3 @@
 source "https://rubygems.org"
 
-gem "minitest"
-gem "crabstone"
+gemspec

data/Rakefile

@@ -10,8 +10,9 @@ INSNS_DIR    = "lib/fisk/instructions"
 
 file XML_FILE do
   Dir.mkdir 'tmp' unless File.directory?("tmp")
-  cd "tmp"
-  sh "git clone https://github.com/Maratyszcza/Opcodes.git"
+  cd "tmp" do
+    sh "git clone https://github.com/Maratyszcza/Opcodes.git"
+  end
 end
 
 file INSNS_DIR do
@@ -33,3 +34,4 @@ Rake::TestTask.new do |t|
 end
 
 task :test => LIB_FILE
+task :default => :test

data/bin/build-machine.rb

@@ -2,6 +2,20 @@ require "nokogiri"
 require "stringio"
 require "erb"
 
+def modrm_method operands
+  op_types = operands.map { |x| x["type"] }
+  case op_types
+  in [/^m\d*$/, /^r\d+$/]
+    "add_modrm_mem_reg"
+  in [/^r\d+$/, /^m\d*$/]
+    "add_modrm_reg_mem"
+  in [/^r\d+$/, /^r\d+$/]
+    "add_modrm_reg_reg"
+  else
+    "add_modrm"
+  end
+end
+
 def parse_rex v
   if v
     case v

data/bin/instruction.rb.erb

@@ -4,88 +4,61 @@ class Fisk
   module Instructions
 <%- name = instruction["name"] -%>
     # Instruction <%= name %>
-    forms = []
+    <%= name %> = Instruction.new(<%= name.dump %>, [
   <%-
     instruction.children.each do |form|
       next unless form.name == "InstructionForm"
   -%>
-    operands = []
-    encodings = []
     <%-
       operands = form.children.reject(&:text?).find_all { |c| c.name == "Operand" }
+      encodings = form.children.reject(&:text?).find_all { |c| c.name == "Encoding" }
     -%>
     # <%= form["gas-name"] %>: <%= operands.map { |op| op["type"] }.join(", ") %>
-    <%-
-      form.children.each do |child|
-        next if child.text?
-        case child.name
-    -%>
-      <%- when "Operand" -%>
-    operands << OPERAND_TYPES[<%= unique_operands.index(%w{ type input output }.map { |n| child[n] }) %>]
-      <%-
-        when "Encoding"
-          size = 0
-      -%>
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
+      Form.new([
+      <%- operands.each do |child| -%>
+        OPERAND_TYPES[<%= unique_operands.index(%w{ type input output }.map { |n| child[n] }) %>],
+      <%- end -%>
+      ].freeze, [
+      <%- encodings.each do |child| -%>
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
       <%-
         child.children.each do |encoding|
           next if encoding.text?
           case encoding.name
           when "Opcode"
-            size += 1
       -%>
-        add_opcode buffer, 0x<%= sprintf("%02X", encoding["byte"].to_i(16)) %>, <%= parse_operand_value encoding["addend"] %>
-        <%-
-            when "Immediate"
-              size += encoding["size"].to_i
-        -%>
-        add_immediate buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>
-        <%-
-            when "CodeOffset"
-              size += encoding["size"].to_i
-        -%>
-        add_code_offset buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>
-        <%-
-            when "REX"
-              size += 1 unless encoding["mandatory"] == "false"
-        -%>
-        add_rex(buffer, operands,
+            add_opcode(buffer, 0x<%= sprintf("%02X", encoding["byte"].to_i(16)) %>, <%= parse_operand_value encoding["addend"] %>) +
+        <%- when "Immediate" -%>
+            add_immediate(buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>) +
+        <%- when "CodeOffset" -%>
+            add_code_offset(buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>) +
+        <%- when "REX" -%>
+            add_rex(buffer, operands,
               <%= !(encoding["mandatory"] == "false") %>,
               <%= parse_rex encoding["W"] %>,
               <%= parse_rex encoding["R"] %>,
               <%= parse_rex encoding["X"] %>,
-              <%= parse_rex encoding["B"] %>)
-        <%-
-            when "ModRM"
-              size += 1
-        -%>
-        add_modrm(buffer, operands,
+              <%= parse_rex encoding["B"] %>) +
+        <%- when "ModRM" -%>
+            <%= modrm_method(operands) %>(buffer,
               <%= encoding["mode"].to_i(2) %>,
               <%= parse_operand_value encoding["reg"] %>,
-              <%= parse_operand_value encoding["rm"] %>)
+              <%= parse_operand_value encoding["rm"] %>, operands) +
         <%- when "Prefix" -%>
-        add_prefix buffer, operands, 0x<%= sprintf("%02X", encoding["byte"].to_i(16)) %>, <%= encoding["mandatory"] %>
+            add_prefix(buffer, operands, 0x<%= sprintf("%02X", encoding["byte"].to_i(16)) %>, <%= encoding["mandatory"] %>) +
         <%- when "DataOffset" -%>
-        add_data_offset buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>
+            add_data_offset(buffer, <%= parse_operand_value encoding["value"] %>, <%= encoding["size"].to_i %>) +
         <%- else -%>
-        add_<%= encoding.name %> buffer, operands
+            add_<%= encoding.name %>(buffer, operands)
         <%- end -%>
       <%- end -%>
-      end
-
-      def bytesize; <%= size %>; end
-    }.new
-      <%- when "ISA" -%>
-      <%- when "ImplicitOperand" -%>
-      <%-
-          else
-            raise NotImplementedError, child.name
-      -%>
+            0
+          end
+        }.new.freeze,
       <%- end -%>
-    <%- end -%>
-    forms << Form.new(operands, encodings)
+      ].freeze).freeze,
   <%- end -%>
-    <%= name %> = Instruction.new(<%= name.dump %>, forms)
+    ].freeze).freeze
   end
 end

data/fisk.gemspec

@@ -13,4 +13,9 @@ Gem::Specification.new do |s|
   s.test_files  = s.files.grep(%r{^test/})
   s.homepage    = "https://github.com/tenderlove/fisk"
   s.license     = "Apache-2.0"
+
+  s.add_development_dependency 'minitest', '~> 5.14'
+  s.add_development_dependency 'crabstone', '~> 4.0'
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'nokogiri', '~> 1.11'
 end

data/lib/fisk.rb

@@ -9,13 +9,19 @@ require "fisk/errors"
 require "fisk/version"
 
 class Fisk
+  module OperandPredicates
+    def unresolved?;        false; end
+    def register?;          false; end
+    def temp_register?;     false; end
+    def extended_register?; false; end
+    def memory?;            false; end
+    def rip?;               false; end
+  end
+
   class Operand
+    include OperandPredicates
+
     def works? type; self.type == type; end
-    def unknown_label?; false; end
-    def register?; false; end
-    def temp_register?; false; end
-    def extended_register?; false; end
-    def m64?; false; end
 
     def rex_value
       value >> 3
@@ -53,7 +59,36 @@ class Fisk
         value & 0x7
       end
 
-      def extended_register?; @value > 7; end
+      def extended_register?
+        @value > 7 || EXTENDED_R8.include?(self)
+      end
+    end
+
+    class Rip < Operand
+      attr_accessor :displacement
+
+      def initialize displacement
+        @displacement = displacement
+      end
+
+      def works? type
+        type == "m64" || type == "m"
+      end
+
+      def unresolved?
+        @displacement.is_a?(Fisk::UnknownLabel)
+      end
+
+      def memory?; true; end
+      def rip?; true; end
+
+      def rex_value
+        0x0
+      end
+
+      def op_value
+        0x0
+      end
     end
 
     class Temp < Operand
@@ -69,19 +104,56 @@ class Fisk
 
       def temp_register?; true; end
 
+      def op_value
+        reg.op_value
+      end
+
       def extended_register?
-        @register.extended_register?
+        reg.extended_register?
       end
 
       def rex_value
-        @register.rex_value
+        reg.rex_value
       end
 
       def value
-        @register.value
+        reg.value
+      end
+
+      def reg
+        unless @register
+          raise Errors::UnassignedRegister, "Temporary register #{name} hasn't been assigned a real register"
+        end
+
+        @register
       end
     end
 
+    AL  = Register.new "al", "r8", 0
+    CL  = Register.new "cl", "r8", 1
+    DL  = Register.new "dl", "r8", 2
+    BL  = Register.new "bl", "r8", 3
+
+    SPL = Register.new "spl", "r8", 4
+    BPL = Register.new "bpl", "r8", 5
+    SIL = Register.new "sil", "r8", 6
+    DIL = Register.new "dil", "r8", 7
+    EXTENDED_R8 = [SPL, BPL, SIL, DIL]
+
+    AH = Register.new "ah", "r8", 4
+    CH = Register.new "ch", "r8", 5
+    DH = Register.new "dh", "r8", 6
+    BH = Register.new "bh", "r8", 7
+
+    AX = Register.new "ax", "r16", 0
+    CX = Register.new "cx", "r16", 1
+    DX = Register.new "dx", "r16", 2
+    BX = Register.new "bx", "r16", 3
+    SP = Register.new "sp", "r16", 4
+    BP = Register.new "bp", "r16", 5
+    SI = Register.new "si", "r16", 6
+    DI = Register.new "di", "r16", 7
+
     EAX = Register.new "eax", "r32", 0
     ECX = Register.new "ecx", "r32", 1
     EDX = Register.new "edx", "r32", 2
@@ -102,6 +174,9 @@ class Fisk
     8.times do |i|
       i += 8
       const_set "R#{i}", Register.new("r#{i}", "r64", i)
+      const_set "R#{i}D", Register.new("r#{i}d", "r32", i)
+      const_set "R#{i}W", Register.new("r#{i}w", "r16", i)
+      const_set "R#{i}B", Register.new("r#{i}b", "r8", i)
     end
 
     # List of *caller* saved registers for the C calling convention
@@ -111,8 +186,7 @@ class Fisk
     CALLEE_SAVED = [ RBX, RSP, RBP, R12, R13, R14, R15 ]
   end
 
-
-  class M64 < Operand
+  class Memory < Operand
     attr_reader :displacement
 
     def initialize register, displacement
@@ -124,17 +198,33 @@ class Fisk
       @register.value
     end
 
+    def memory?; true; end
+  end
+
+  class M64 < Memory
     def type
       "m64"
     end
+  end
+
+  class M < Memory
+    def type
+      "m"
+    end
+  end
 
-    def m64?; true; end
+  def rip displacement = 0
+    Registers::Rip.new(displacement)
   end
 
   def m64 x, displacement = 0
     M64.new x, displacement
   end
 
+  def m x, displacement = 0
+    M.new x, displacement
+  end
+
   # Define all immediate value methods of different sizes
   [8, 16, 32, 64].each do |size|
     class_eval <<~eostr, __FILE__, __LINE__ + 1
@@ -172,37 +262,50 @@ class Fisk
     end
   end
 
-  class UnknownLabel < Struct.new(:name)
+  class UnknownLabel < Operand
+    attr_reader :name
+
+    def initialize name
+      @name = name
+    end
+
     def works? type
       type == "rel32"
     end
 
-    def unknown_label?; true; end
-    def temp_register?; false; end
+    def unresolved?; true; end
+  end
 
-    def value
-      label = assembler.label_for(name)
-      label.position - (insn.position + insn.bytesize)
-    end
+  module InstructionPredicates
+    def retry?;              false; end
+    def label?;              false; end
+    def jump?;               false; end
+    def has_temp_registers?; false; end
+    def comment?;            false; end
+    def lazy?;               false; end
   end
 
   class Label < Struct.new(:name)
+    include InstructionPredicates
+
     def label?; true; end
-    def jump?; false; end
-    def has_temp_registers?; false; end
+  end
+
+  class Comment < Struct.new(:message)
+    include InstructionPredicates
+
+    def comment?; true; end
   end
 
   class Instruction
+    include InstructionPredicates
+
     def initialize insn, form, operands
       @insn     = insn
       @form     = form
       @operands = operands
     end
 
-    def jump?
-      false
-    end
-
     def has_temp_registers?
       @operands.any?(&:temp_register?)
     end
@@ -218,22 +321,48 @@ class Fisk
     def encode buffer, labels
       encoding = @form.encodings.first
       encoding.encode buffer, @operands
-      true
     end
+  end
 
-    def bytesize
-      @form.encodings.first.bytesize
+  class UnresolvedRIPInstruction
+    include InstructionPredicates
+
+    def initialize insn, form, operands
+      @insn      = insn
+      @form      = form
+      @operands  = operands
+      @retry     = false
     end
 
-    def label?; false; end
+    def retry?; true; end
+
+    def encode buffer, labels
+      # Use dummy values for any unresolvable operands
+      operands = @operands.map do |op|
+        if op.rip? && op.unresolved?
+          # Try resolving the operands
+          if labels.key?(op.displacement.name)
+            Registers::Rip.new labels[op.displacement.name]
+          else
+            Registers::Rip.new 0x0CAFE
+          end
+        else
+          op
+        end
+      end
+
+      @form.encodings.first.encode buffer, operands
+    end
   end
 
-  class UnresolvedInstruction
+  class UnresolvedJumpInstruction
+    include InstructionPredicates
+
     def initialize insn, form, operand
-      @insn      = insn
-      @form      = form
-      @operand   = operand
-      @saved_pos = nil
+      @insn       = insn
+      @form       = form
+      @operand    = operand
+      @must_retry = false
     end
 
     def jump?
@@ -244,44 +373,43 @@ class Fisk
       @operand.name
     end
 
-    def has_temp_registers?; false; end
+    def retry?
+      true
+    end
 
     def encode buffer, labels
       # Estimate by using a rel32 offset
-      form          = find_form "rel32"
-      encoding      = form.encodings.first
-      operand_klass = Rel32
-
-      if labels.key? @operand.name
-        if @saved_pos
-          # Only use rel32 if we saved the position
-          buffer.seek @saved_pos, IO::SEEK_SET
-        else
-          estimated_offset = labels[@operand.name] - (buffer.pos + encoding.bytesize)
+      form              = find_form "rel32"
+      encoding          = form.encodings.first
+      operand_klass     = Rel32
+
+      if labels.key? target
+        unless @must_retry
+          estimated_offset = labels[target] - (buffer.pos + 6) # 6 seems like a good length
 
           if estimated_offset >= -128 && estimated_offset <= 127
             # fits in a rel8
-            operand_klass = Rel8
-            form          = find_form "rel8"
-            encoding      = form.encodings.first
+            operand_klass     = Rel8
+            form              = find_form "rel8"
+            encoding          = form.encodings.first
           end
         end
 
-        jump_len = -(buffer.pos + encoding.bytesize - labels[@operand.name])
+        # We don't know what the size of the jump will be, so just write
+        # it out with some dummy data and keep track of the buffer position.
+        # Calculate the real jump offset, then rewind and patch the jump with
+        # the right location. 😩
+        pos = buffer.pos
+        encoding.encode buffer, [operand_klass.new(0xFE)]
+        jump_len = -(buffer.pos - labels[target])
+        buffer.seek pos, IO::SEEK_SET
         encoding.encode buffer, [operand_klass.new(jump_len)]
-        true
       else
-        # We've hit a label that doesn't exist yet
-        # Save the buffer position so we can seek back to it later
-        @saved_pos = buffer.pos
-        # Write 5 bytes to reserve our spot
-        encoding.bytesize.times { buffer.putc 0 }
-        false
+        @must_retry = true
+        encoding.encode buffer, [operand_klass.new(0x0CAFE)]
       end
     end
 
-    def label?; false; end
-
     private
 
     def find_form form_type
@@ -337,6 +465,41 @@ class Fisk
     UnknownLabel.new(name)
   end
 
+  Lazy = Struct.new(:block) do # :nodoc:
+    include InstructionPredicates
+
+    def lazy?; true; end
+
+    def encode buffer, labels
+      block.call buffer.pos
+    end
+  end
+
+  # Record a block that will be called during instruction encoding.  The block
+  # will be yielded the current position of the buffer.
+  #
+  # For example:
+  #
+  #   patch_position = nil
+  #
+  #   fisk.nop
+  #   fisk.lazy { |pos| patch_location = pos }
+  #   fisk.jmp(fisk.label(:foo))
+  #   fisk.lazy { |_|
+  #     fisk.mov(fisk.r8, fisk.imm64(patch_location))
+  #   }
+  #   fisk.write_to(buf)
+  #
+  # The first lazy block will be yielded the position of the buffer immediately
+  # after encoding the `nop` instruction and before encoding the `jmp`
+  # instruction.  The second lazy block will be yielded to after the `jmp`
+  # instruction has been encoded.  This gives you a chance to write the buffer
+  # position from certain points in to your assembly
+  def lazy &block
+    @instructions << Lazy.new(block)
+    self
+  end
+
   # Insert a label named +name+ at the current position in the instructions.
   def put_label name
     @instructions << Label.new(name)
@@ -344,6 +507,12 @@ class Fisk
   end
   alias :make_label :put_label
 
+  # Insert a comment at the current position in the instructions.
+  def comment message
+    @instructions << Comment.new(message)
+    self
+  end
+
   # Allocate and return a new register.  These registers will be replaced with
   # real registers when `assign_registers` is called.
   def register name = "temp"
@@ -452,39 +621,60 @@ class Fisk
   #     mov r9, imm64(32)
   #   end
   #
-  def asm buf = StringIO.new(''.b), &block
+  def asm buf = StringIO.new(''.b), metadata: {}, &block
     instance_eval(&block)
-    write_to buf
+    write_to buf, metadata: metadata
     buf
   end
 
   # Encodes all instructions and returns a binary string with the encoded
   # instructions.
-  def to_binary
+  def to_binary(metadata: {})
     io = StringIO.new ''.b
-    write_to io
+    write_to io, metadata: metadata
     io.string
   end
 
+  RetryRequest = Struct.new(:insn, :io_seek_pos)
+
   # Encode all instructions and write them to +buffer+.  +buffer+ should be an
   # IO object.
-  def write_to buffer
+  def write_to buffer, metadata: {}
     labels = {}
+    comments = {}
     unresolved = []
-    @instructions.each do |insn|
+    instructions = @instructions.dup
+    backup = @instructions.dup
+    @instructions.clear
+
+    while insn = instructions.shift
       if insn.label?
         labels[insn.name] = buffer.pos
+      elsif insn.comment?
+        comments.update({buffer.pos => insn.message}) { |_, *lines| lines.join($/) }
+      elsif insn.lazy?
+        insn.encode buffer, labels
+        instructions.unshift(*@instructions)
+        @instructions.clear
       else
-        unless insn.encode buffer, labels
-          unresolved << insn
+        if insn.retry?
+          retry_req = RetryRequest.new(insn, buffer.pos)
+          unresolved << retry_req
         end
+
+        write_instruction insn, buffer, labels
       end
     end
 
+    metadata[:comments] = comments
+    @instructions = backup
+
     return if unresolved.empty?
 
     pos = buffer.pos
-    unresolved.each do |insn|
+    unresolved.each do |req|
+      insn = req.insn
+      buffer.seek req.io_seek_pos, IO::SEEK_SET
       insn.encode buffer, labels
     end
     buffer.seek pos, IO::SEEK_SET
@@ -520,11 +710,13 @@ class Fisk
     insn = nil
 
     params.each do |param|
-      if param.unknown_label?
-        if params.length > 1
-          raise ArgumentError, "labels only work with single param jump instructions"
+      if param.unresolved?
+        if insns.name =~ /^J/ # I hope all jump instructions start with J!
+          insn = UnresolvedJumpInstruction.new(insns, form, params.first)
+        else
+          # If it's not a jump instruction, assume unresolved RIP relative 😬
+          insn = UnresolvedRIPInstruction.new(insns, form, params)
         end
-        insn = UnresolvedInstruction.new(insns, form, params.first)
       end
 
       if param.temp_register?
@@ -543,4 +735,10 @@ class Fisk
 
     self
   end
+
+  private
+
+  def write_instruction insn, buffer, labels
+    insn.encode buffer, labels
+  end
 end