fisk 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51dd7fb660158423e9c8acde6889de5304d01c7ffc305c3e0cfbf7fff0039acf
-  data.tar.gz: fd1a616b882af138d6016f30018937b7359f9c06e46243fdf55f6c3d5ace618d
+  metadata.gz: '0809155eef95d321b2e39b2c3a801f5ed987f74e409ba40285a30f530964c558'
+  data.tar.gz: 0b44765ae9dd4d4611c9db1af5a49bbe8659ce4dba3e6a7ac8887e17ebdb6e4a
 SHA512:
-  metadata.gz: 922a53a72a875ec8e225b97e51c55f905944f0bb927496691471dc395536bbe2072bea424862814a08d22fd955d5c3dab820faa5c61e50d8f5ca57dd61cfcf12
-  data.tar.gz: 46336f3830380629188494a3784a01217d69a3e9fab48d41dff73300ca10fb3298d814cb20a6e0b62442fc2749036e5c4780f3789e16134fb0a0364b822aef8b
+  metadata.gz: 1835a32e1579e07b1a7cf101a85ea94dee3471cb2c5c64e66a385a59807b8c049e1218c8b8152d7aa562757d585d3d7700b435b5791fd42ddaccabf99a403973
+  data.tar.gz: 90a32029797fb6f0a101fcfc81e3352e69294ac2bd02a48f9f3e077dde900b4d3a917e413b4f65be599cdf3a0fd4f3b0a5419a043774d16292eae9821aaa6e82

data/README.md

@@ -1,7 +1,7 @@
 # Fisk - A Pure Ruby Assembler
 
-This is a pure Ruby assembler (I guess).  I'm not 100% sure if it counts as
-pure Ruby because it just reads an XML file and metaprograms most of it.
+This is a pure Ruby x86-64 assembler (I guess).  I'm not 100% sure if it counts
+as pure Ruby because it just reads an XML file and metaprograms most of it.
 Anyway, you can use it to write assembly in Ruby, then have it assembled.
 
 I named it after Wilson Fisk mainly because it reminds me of [this

data/Rakefile

@@ -5,7 +5,8 @@ ENV["MT_NO_PLUGINS"] = "1"
 
 XML_FILE     = "tmp/Opcodes/opcodes/x86_64.xml"
 LICENCE_FILE = "tmp/Opcodes/license.rst"
-LIB_FILE     = "lib/fisk/machine/generated.rb"
+LIB_FILE     = "lib/fisk/instructions.rb"
+INSNS_DIR    = "lib/fisk/instructions"
 
 file XML_FILE do
   Dir.mkdir 'tmp' unless File.directory?("tmp")
@@ -13,11 +14,16 @@ file XML_FILE do
   sh "git clone https://github.com/Maratyszcza/Opcodes.git"
 end
 
-file LIB_FILE => XML_FILE do
-  ruby "bin/build-machine.rb #{XML_FILE} #{LICENCE_FILE} > #{LIB_FILE}"
+file INSNS_DIR do
+  Dir.mkdir 'lib/fisk/instructions' unless File.directory?("lib/fisk/instructions")
+end
+
+file LIB_FILE => [XML_FILE, INSNS_DIR] do
+  ruby "bin/build-machine.rb #{XML_FILE} #{LICENCE_FILE} #{INSNS_DIR} > #{LIB_FILE}"
 end
 
 CLEAN.include LIB_FILE
+CLEAN.include INSNS_DIR
 
 Rake::TestTask.new do |t|
   t.libs << "test"

data/bin/build-machine.rb

@@ -2,10 +2,52 @@ require "nokogiri"
 require "stringio"
 require "erb"
 
+def parse_rex v
+  if v
+    case v
+    when /^(\d+)$/
+      v
+    when /^#(\d+)$/
+      "(operands[#{$1.to_i}].value >> 3)"
+    else
+      raise NotImplementedError, v
+    end
+  else
+    0
+  end
+end
+
+def parse_operand_value v
+  if v
+    case v
+    when /^(\d+)$/
+      v
+    when /^#(\d+)$/
+      "operands[#{$1.to_i}].value"
+    else
+      raise NotImplementedError, v
+    end
+  else
+    0
+  end
+end
+
 doc = Nokogiri::XML(File.binread(ARGV[0]))
 unique_operands = doc.css("Operand").map { |node|
   %w{ type input output }.map { |x| node[x] }
 }.uniq
 license = File.readlines(ARGV[1])
-erb = ERB.new File.read("bin/machine.rb.erb"), trim_mode: "-"
-puts erb.result(binding)
+insns_dir = ARGV[2]
+
+instruction_template = ERB.new File.read("bin/instruction.rb.erb"), trim_mode: "-"
+
+doc.root.children.each do |instruction|
+  next unless instruction.name == "Instruction"
+  name = instruction["name"]
+  insn_source = instruction_template.result(binding)
+  file_name = File.join(insns_dir, "#{name.downcase}.rb")
+  File.binwrite file_name, insn_source
+end
+
+instructions_rb = ERB.new File.read("bin/instructions.rb.erb"), trim_mode: "-"
+puts instructions_rb.result(binding)

data/bin/instruction.rb.erb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+<%- name = instruction["name"] -%>
+    # Instruction <%= name %>
+    forms = []
+  <%-
+    instruction.children.each do |form|
+      next unless form.name == "InstructionForm"
+  -%>
+    operands = []
+    encodings = []
+    <%-
+      operands = form.children.reject(&:text?).find_all { |c| c.name == "Operand" }
+    -%>
+    # <%= 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
+      <%-
+        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,
+              <%= !(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,
+              <%= encoding["mode"].to_i(2) %>,
+              <%= parse_operand_value encoding["reg"] %>,
+              <%= parse_operand_value encoding["rm"] %>)
+        <%- when "Prefix" -%>
+        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 %>
+        <%- else -%>
+        add_<%= encoding.name %> buffer, operands
+        <%- end -%>
+      <%- end -%>
+      end
+
+      def bytesize; <%= size %>; end
+    }.new
+      <%- when "ISA" -%>
+      <%- when "ImplicitOperand" -%>
+      <%-
+          else
+            raise NotImplementedError, child.name
+      -%>
+      <%- end -%>
+    <%- end -%>
+    forms << Form.new(operands, encodings)
+  <%- end -%>
+    <%= name %> = Instruction.new(<%= name.dump %>, forms)
+  end
+end

data/bin/instructions.rb.erb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+#
+<%= license.map { |x| "# #{x.chomp} " }.join "\n" %>
+
+require "fisk/encoding"
+
+class Fisk
+  module Instructions
+    Operand     = Struct.new(:type, :input, :output)
+    Form        = Struct.new(:operands, :encodings)
+    Instruction = Struct.new(:name, :forms)
+
+    OPERAND_TYPES = [
+<%- unique_operands.each do |u_op| -%>
+      Operand.new(<%= u_op[0].dump %>, <%= u_op[1] || "nil" %>, <%= u_op[2] || "nil" %>),
+<% end %>
+    ]
+
+    def self.instruction_names
+      constants - [:Operand, :OPERAND_TYPES]
+    end
+<%-
+  doc.root.children.each do |instruction|
+    next unless instruction.name == "Instruction"
+    name = instruction["name"]
+-%>
+    autoload :<%= name %>, "fisk/instructions/<%= name.downcase %>"
+<%-
+  end
+-%>
+    module DSLMethods
+<%-
+  doc.root.children.each do |instruction|
+    next unless instruction.name == "Instruction"
+    name = instruction["name"]
+-%>
+      def <%= name.downcase %>(*params)
+        gen_with_insn Fisk::Instructions::<%= name %>, params
+      end
+<%-
+  end
+-%>
+    end
+  end
+end

data/fisk.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "fisk"
+  s.version     = "2.0.0"
+  s.summary     = "Write assembly in Ruby!"
+  s.description = "Tired of writing Ruby in Ruby? Now you can write assembly in Ruby!"
+  s.authors     = ["Aaron Patterson"]
+  s.email       = "tenderlove@ruby-lang.org"
+  s.files       = `git ls-files -z`.split("\x0")
+  s.test_files  = s.files.grep(%r{^test/})
+  s.homepage    = "https://github.com/tenderlove/fisk"
+  s.license     = "Apache-2.0"
+end

data/lib/fisk.rb

@@ -1,16 +1,32 @@
 # frozen_string_literal: true
 
-require "fisk/machine/encoding"
-require "fisk/machine"
+require "stringio"
+require "fisk/instructions"
 
 class Fisk
+  class Operand < Struct.new(:value)
+    def type; value; end
+    def works? type; self.type == type; end
+    def unknown_label?; false; end
+    def extended_register?; false; end
+    def m64?; false; end
+  end
+
   module Registers
-    class Register < Struct.new(:name, :type, :value)
+    class Register < Operand
+      attr_reader :name, :type
+
+      def initialize name, type, value
+        @name = name
+        @type = type
+        super(value)
+      end
+
       def works? type
         type == self.name || type == self.type
       end
 
-      def unknown_label?; false; end
+      def extended_register?; value > 7; end
     end
 
     EAX = Register.new "eax", "r32", 0
@@ -36,20 +52,25 @@ class Fisk
     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
+    attr_reader :displacement
+
+    def initialize register, displacement
+      super(register.value)
+      @register     = register
+      @displacement = displacement
+    end
+
     def type
       "m64"
     end
+
+    def m64?; true; end
   end
 
-  def m64 x
-    M64.new x
+  def m64 x, displacement = 0
+    M64.new x, displacement
   end
 
   class Imm8 < Operand
@@ -102,7 +123,7 @@ class Fisk
     @position = 0
   end
 
-  class UnknownLabel < Struct.new(:name, :assembler, :insn)
+  class UnknownLabel < Struct.new(:name)
     def works? type
       type == "rel32"
     end
@@ -115,19 +136,16 @@ class Fisk
     end
   end
 
-  class Label < Struct.new(:name, :position)
-  end
-
-  def label_for name
-    @labels.fetch name
+  class Label < Struct.new(:name)
+    def label?; true; end
   end
 
   def label name
-    UnknownLabel.new(name, self)
+    UnknownLabel.new(name)
   end
 
   def make_label name
-    @labels[name] = Label.new(name, position)
+    @instructions << Label.new(name)
   end
 
   Registers.constants.grep(/^[A-Z0-9]*$/).each do |const|
@@ -136,60 +154,82 @@ class Fisk
   end
 
   class Instruction
-    attr_reader :position
-
-    def initialize insn, operands, position
+    def initialize insn, form, operands
       @insn     = insn
+      @form     = form
       @operands = operands
-      @position = position
     end
 
     def encodings
-      @insn.encodings
+      @form.encodings
     end
 
-    def encode buffer
-      encoding = @insn.encodings.first
+    def encode buffer, labels
+      encoding = @form.encodings.first
       encoding.encode buffer, @operands
+      true
     end
 
     def bytesize
-      @insn.encodings.first.bytesize
+      @form.encodings.first.bytesize
     end
+
+    def label?; false; 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)
-        }
+  class UnresolvedInstruction
+    def initialize insn, form, operand
+      @insn      = insn
+      @form      = form
+      @operand   = operand
+      @saved_pos = nil
+    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)
+
+          if estimated_offset >= -128 && estimated_offset <= 127
+            # fits in a rel8
+            operand_klass = Rel8
+            form          = find_form "rel8"
+            encoding      = form.encodings.first
+          end
+        end
+
+        jump_len = -(buffer.pos + encoding.bytesize - labels[@operand.name])
+        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
       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? }
+    def label?; false; end
 
-    self
-  end
+    private
 
-  Machine.instructions.keys.each do |insn|
-    define_method(insn.downcase) do |*params|
-      gen insn, params
+    def find_form form_type
+      @insn.forms.find { |form| form.operands.first.type == form_type }
     end
   end
 
+  include Fisk::Instructions::DSLMethods
+
   def moffs64 val
     MOffs64.new val
   end
@@ -235,6 +275,54 @@ class Fisk
   private
 
   def write_to_buffer buffer
-    @instructions.each { |insn| insn.encode buffer }
+    labels = {}
+    unresolved = []
+    @instructions.each do |insn|
+      if insn.label?
+        labels[insn.name] = buffer.pos
+      else
+        unless insn.encode buffer, labels
+          unresolved << insn
+        end
+      end
+    end
+
+    return if unresolved.empty?
+
+    pos = buffer.pos
+    unresolved.each do |insn|
+      insn.encode buffer, labels
+    end
+    buffer.seek pos, IO::SEEK_SET
+  end
+
+  def gen_with_insn insns, params
+    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
+
+    form = forms.first
+
+    insn = if params.any?(&:unknown_label?)
+             if params.length > 1
+               raise ArgumentError, "labels only work with single param jump instructions"
+             end
+             UnresolvedInstruction.new(insns, form, params.first)
+           else
+             Instruction.new(insns, form, params)
+           end
+    @instructions << insn
+
+    self
   end
 end