fisk 1.0.0 → 2.3.0

data/lib/fisk/instructions/cmppd.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPPD: Compare Packed Double-Precision Floating-Point Values
+    CMPPD = Instruction.new("CMPPD", [
+    # cmppd: xmm, xmm, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              0,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmppd: xmm, m128, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[25],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              operands[1].rex_value,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpps.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPPS: Compare Packed Single-Precision Floating-Point Values
+    CMPPS = Instruction.new("CMPPS", [
+    # cmpps: xmm, xmm, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[1],
+      ].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, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpps: xmm, m128, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[25],
+        OPERAND_TYPES[1],
+      ].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, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpsd.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPSD: Compare Scalar Double-Precision Floating-Point Values
+    CMPSD = Instruction.new("CMPSD", [
+    # cmpsd: xmm, xmm, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0xF2, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              0,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpsd: xmm, m64, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[18],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0xF2, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              operands[1].rex_value,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpss.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPSS: Compare Scalar Single-Precision Floating-Point Values
+    CMPSS = Instruction.new("CMPSS", [
+    # cmpss: xmm, xmm, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0xF3, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              0,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpss: xmm, m32, imm8
+      Form.new([
+        OPERAND_TYPES[23],
+        OPERAND_TYPES[14],
+        OPERAND_TYPES[1],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0xF3, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              operands[1].rex_value,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xC2, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            add_immediate(buffer, operands[2].op_value, 1) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpxchg.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPXCHG: Compare and Exchange
+    CMPXCHG = Instruction.new("CMPXCHG", [
+    # cmpxchgb: r8, r8
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB0, 0) +
+            add_modrm_reg_reg(buffer,
+              3,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgw: r16, r16
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_reg_reg(buffer,
+              3,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgl: r32, r32
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_reg_reg(buffer,
+              3,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgq: r64, r64
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_reg_reg(buffer,
+              3,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgb: m8, r8
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB0, 0) +
+            add_modrm_mem_reg(buffer,
+              0,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgw: m16, r16
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_mem_reg(buffer,
+              0,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgl: m32, r32
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_mem_reg(buffer,
+              0,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # cmpxchgq: m64, r64
+      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, 0x0F, 0) +
+            add_opcode(buffer, 0xB1, 0) +
+            add_modrm_mem_reg(buffer,
+              0,
+              operands[1].op_value,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpxchg16b.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPXCHG16B: Compare and Exchange 16 Bytes
+    CMPXCHG16B = Instruction.new("CMPXCHG16B", [
+    # cmpxchg16b: m128
+      Form.new([
+        OPERAND_TYPES[25],
+      ].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, 0x0F, 0) +
+            add_opcode(buffer, 0xC7, 0) +
+            add_modrm(buffer,
+              0,
+              1,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cmpxchg8b.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CMPXCHG8B: Compare and Exchange 8 Bytes
+    CMPXCHG8B = Instruction.new("CMPXCHG8B", [
+    # cmpxchg8b: m64
+      Form.new([
+        OPERAND_TYPES[18],
+      ].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, 0x0F, 0) +
+            add_opcode(buffer, 0xC7, 0) +
+            add_modrm(buffer,
+              0,
+              1,
+              operands[0].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/comisd.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction COMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
+    COMISD = Instruction.new("COMISD", [
+    # comisd: xmm, xmm
+      Form.new([
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[24],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              0,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0x2F, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # comisd: xmm, m64
+      Form.new([
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[18],
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_prefix(buffer, operands, 0x66, true) +
+            add_rex(buffer, operands,
+              false,
+              0,
+              operands[0].rex_value,
+              operands[1].rex_value,
+              operands[1].rex_value) +
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0x2F, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/comiss.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction COMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS
+    COMISS = Instruction.new("COMISS", [
+    # comiss: xmm, xmm
+      Form.new([
+        OPERAND_TYPES[24],
+        OPERAND_TYPES[24],
+      ].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, 0x0F, 0) +
+            add_opcode(buffer, 0x2F, 0) +
+            add_modrm(buffer,
+              3,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    # comiss: xmm, m32
+      Form.new([
+        OPERAND_TYPES[24],
+        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, 0x0F, 0) +
+            add_opcode(buffer, 0x2F, 0) +
+            add_modrm(buffer,
+              0,
+              operands[0].op_value,
+              operands[1].op_value, operands) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cpuid.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CPUID: CPU Identification
+    CPUID = Instruction.new("CPUID", [
+    # cpuid: 
+      Form.new([
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_opcode(buffer, 0x0F, 0) +
+            add_opcode(buffer, 0xA2, 0) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end

data/lib/fisk/instructions/cqo.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Fisk
+  module Instructions
+    # Instruction CQO: Convert Quadword to Octaword
+    CQO = Instruction.new("CQO", [
+    # cqto: 
+      Form.new([
+      ].freeze, [
+        Class.new(Fisk::Encoding) {
+          def encode buffer, operands
+            add_rex(buffer, operands,
+              true,
+              1,
+              0,
+              0,
+              0) +
+            add_opcode(buffer, 0x99, 0) +
+            0
+          end
+        }.new.freeze,
+      ].freeze).freeze,
+    ].freeze).freeze
+  end
+end