fisk 2.1.0 → 2.2.0

data/lib/fisk/encoding.rb

@@ -2,11 +2,11 @@ class Fisk
   class Encoding
     private
 
-    def add_modrm buffer, operands, mode, reg, rm
+    def add_modrm buffer, mode, reg, rm, operands
       offset_bytes = 0
-      if mem = operands.find(&:m64?)
+      if mem = operands.find(&:memory?)
         if mem.displacement != 0
-          if 0xFF == mem.displacement | 0xFF
+          if mem.displacement >= -0x7F - 1 && mem.displacement < 0x7F
             offset_bytes = 1
             mode |= 0x1
           else
@@ -19,7 +19,61 @@ class Fisk
       rm = rm & 0x7
       buffer.putc ((mode << 6) | (reg << 3) | rm)
       if mem && mem.displacement != 0
-        write_num buffer, mem.displacement, offset_bytes
+        1 + write_num(buffer, mem.displacement, offset_bytes)
+      else
+        1
+      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
+      offset_bytes = 0
+
+      if mem.rip?
+        buffer.putc 0x5 + ((reg_opnd.value % 8) * 8)
+        return 1 + write_num(buffer, mem.displacement, 4)
+      end
+
+      if mem.displacement != 0
+        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.displacement != 0
+        1 + write_num(buffer, mem.displacement, offset_bytes)
+      else
+        1
+      end
+    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 +90,7 @@ 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?)
 
       rex = 0b0100
       rex = (rex << 1) | w
@@ -44,11 +98,13 @@ class Fisk
       rex = (rex << 1) | x
       rex = (rex << 1) | b
       buffer.putc rex
+      1
     end
 
     def add_opcode buffer, byte, addend
       byte |= addend
       buffer.putc byte
+      1
     end
 
     def write_num buffer, num, size
@@ -56,6 +112,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

@@ -15,5 +15,10 @@ class Fisk
     # 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
   end
 end

data/lib/fisk/instructions/adc.rb

@@ -3,758 +3,724 @@
 class Fisk
   module Instructions
     # Instruction ADC
-    forms = []
-    operands = []
-    encodings = []
+    ADC = Instruction.new("ADC", [
     # adcb: al, imm8
-    operands << OPERAND_TYPES[0]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_opcode buffer, 0x14, 0
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+      Form.new([
+        OPERAND_TYPES[0],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_opcode(buffer, 0x14, 0) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcb: r8, imm8
-    operands << OPERAND_TYPES[2]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[2],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x80, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x80, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcb: r8, r8
-    operands << OPERAND_TYPES[2]
-    operands << OPERAND_TYPES[3]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[2],
+        OPERAND_TYPES[3],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x10, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x10, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               0,
-              operands[1].rex_value)
-        add_opcode buffer, 0x12, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x12, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcb: r8, m8
-    operands << OPERAND_TYPES[2]
-    operands << OPERAND_TYPES[4]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[2],
+        OPERAND_TYPES[4],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               operands[1].rex_value,
-              operands[1].rex_value)
-        add_opcode buffer, 0x12, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x12, 0) +
+            add_modrm_reg_mem(buffer,
               0,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: ax, imm16
-    operands << OPERAND_TYPES[5]
-    operands << OPERAND_TYPES[6]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_opcode buffer, 0x15, 0
-        add_immediate buffer, operands[1].op_value, 2
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+      Form.new([
+        OPERAND_TYPES[5],
+        OPERAND_TYPES[6],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_opcode(buffer, 0x15, 0) +
+            add_immediate(buffer, operands[1].op_value, 2) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: r16, imm8
-    operands << OPERAND_TYPES[7]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[7],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: r16, imm16
-    operands << OPERAND_TYPES[7]
-    operands << OPERAND_TYPES[6]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[7],
+        OPERAND_TYPES[6],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 2
-      end
-
-      def bytesize; 4; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 2) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: r16, r16
-    operands << OPERAND_TYPES[7]
-    operands << OPERAND_TYPES[8]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[7],
+        OPERAND_TYPES[8],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               0,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: r16, m16
-    operands << OPERAND_TYPES[7]
-    operands << OPERAND_TYPES[9]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[7],
+        OPERAND_TYPES[9],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               operands[1].rex_value,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_mem(buffer,
               0,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: eax, imm32
-    operands << OPERAND_TYPES[10]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_opcode buffer, 0x15, 0
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 5; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+      Form.new([
+        OPERAND_TYPES[10],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_opcode(buffer, 0x15, 0) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: r32, imm8
-    operands << OPERAND_TYPES[12]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[12],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: r32, imm32
-    operands << OPERAND_TYPES[12]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[12],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 6; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: r32, r32
-    operands << OPERAND_TYPES[12]
-    operands << OPERAND_TYPES[13]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[12],
+        OPERAND_TYPES[13],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               0,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: r32, m32
-    operands << OPERAND_TYPES[12]
-    operands << OPERAND_TYPES[14]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[12],
+        OPERAND_TYPES[14],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[0].rex_value,
               operands[1].rex_value,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_mem(buffer,
               0,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: rax, imm32
-    operands << OPERAND_TYPES[15]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[15],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               0,
               0,
-              0)
-        add_opcode buffer, 0x15, 0
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 6; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              0) +
+            add_opcode(buffer, 0x15, 0) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: r64, imm8
-    operands << OPERAND_TYPES[16]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[16],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 4; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: r64, imm32
-    operands << OPERAND_TYPES[16]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[16],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               0,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               3,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 7; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: r64, r64
-    operands << OPERAND_TYPES[16]
-    operands << OPERAND_TYPES[17]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[16],
+        OPERAND_TYPES[17],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               operands[1].rex_value,
               0,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 3; end
-    }.new
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               operands[0].rex_value,
               0,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_reg(buffer,
               3,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: r64, m64
-    operands << OPERAND_TYPES[16]
-    operands << OPERAND_TYPES[18]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[16],
+        OPERAND_TYPES[18],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               operands[0].rex_value,
               operands[1].rex_value,
-              operands[1].rex_value)
-        add_opcode buffer, 0x13, 0
-        add_modrm(buffer, operands,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x13, 0) +
+            add_modrm_reg_mem(buffer,
               0,
               operands[0].op_value,
-              operands[1].op_value)
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcb: m8, imm8
-    operands << OPERAND_TYPES[19]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[19],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x80, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x80, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcb: m8, r8
-    operands << OPERAND_TYPES[19]
-    operands << OPERAND_TYPES[3]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[19],
+        OPERAND_TYPES[3],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x10, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x10, 0) +
+            add_modrm_mem_reg(buffer,
               0,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: m16, imm8
-    operands << OPERAND_TYPES[20]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[20],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: m16, imm16
-    operands << OPERAND_TYPES[20]
-    operands << OPERAND_TYPES[6]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[20],
+        OPERAND_TYPES[6],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 2
-      end
-
-      def bytesize; 4; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 2) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcw: m16, r16
-    operands << OPERAND_TYPES[20]
-    operands << OPERAND_TYPES[8]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_prefix buffer, operands, 0x66, false
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[20],
+        OPERAND_TYPES[8],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, false) +
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_mem_reg(buffer,
               0,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: m32, imm8
-    operands << OPERAND_TYPES[21]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[21],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: m32, imm32
-    operands << OPERAND_TYPES[21]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[21],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 6; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcl: m32, r32
-    operands << OPERAND_TYPES[21]
-    operands << OPERAND_TYPES[13]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[21],
+        OPERAND_TYPES[13],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               false,
               0,
               operands[1].rex_value,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_mem_reg(buffer,
               0,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 2; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: m64, imm8
-    operands << OPERAND_TYPES[22]
-    operands << OPERAND_TYPES[1]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[22],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x83, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x83, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 1
-      end
-
-      def bytesize; 4; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: m64, imm32
-    operands << OPERAND_TYPES[22]
-    operands << OPERAND_TYPES[11]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[22],
+        OPERAND_TYPES[11],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               0,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x81, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x81, 0) +
+            add_modrm(buffer,
               0,
               2,
-              operands[0].op_value)
-        add_immediate buffer, operands[1].op_value, 4
-      end
-
-      def bytesize; 7; end
-    }.new
-    forms << Form.new(operands, encodings)
-    operands = []
-    encodings = []
+              operands[0].op_value, operands) +
+            add_immediate(buffer, operands[1].op_value, 4) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
     # adcq: m64, r64
-    operands << OPERAND_TYPES[22]
-    operands << OPERAND_TYPES[17]
-    encodings << Class.new(Fisk::Encoding) {
-      def encode buffer, operands
-        add_rex(buffer, operands,
+      Form.new([
+        OPERAND_TYPES[22],
+        OPERAND_TYPES[17],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
               true,
               1,
               operands[1].rex_value,
               operands[0].rex_value,
-              operands[0].rex_value)
-        add_opcode buffer, 0x11, 0
-        add_modrm(buffer, operands,
+              operands[0].rex_value) +
+            add_opcode(buffer, 0x11, 0) +
+            add_modrm_mem_reg(buffer,
               0,
               operands[1].op_value,
-              operands[0].op_value)
-      end
-
-      def bytesize; 3; end
-    }.new
-    forms << Form.new(operands, encodings)
-    ADC = Instruction.new("ADC", forms)
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
   end
 end