correctly decode 12-byte extended FPU immediates

Author: jack68k

arch/M68K/M68KDisassembler.c

@@ -218,6 +218,18 @@ static uint64_t m68k_read_safe_64(const m68k_info *info, const uint64_t address)
 	return m68k_read_disassembler_64(info, addr);
 }
 
+static void m68k_read_safe_96(const m68k_info *info, const uint64_t address,
+			      uint8_t *dst)
+{
+	const uint64_t addr = (address - info->baseAddress) &
+			      info->address_mask;
+	if (info->code_len < addr + 12) {
+		memset(dst, 0xaa, 12);
+		return;
+	}
+	memcpy(dst, info->code + addr, 12);
+}
+
 /* ======================================================================== */
 /* =============================== PROTOTYPES ============================= */
 /* ======================================================================== */
@@ -306,6 +318,10 @@ static unsigned long long peek_imm_64(const m68k_info *info)
 {
 	return m68k_read_safe_64((info), (info)->pc);
 }
+static void peek_imm_96(const m68k_info *info, uint8_t *dst)
+{
+	m68k_read_safe_96(info, info->pc, dst);
+}
 
 static unsigned int read_imm_8(m68k_info *info)
 {
@@ -331,6 +347,11 @@ static unsigned long long read_imm_64(m68k_info *info)
 	(info)->pc += 8;
 	return value & 0xffffffffffffffff;
 }
+static void read_imm_96(m68k_info *info, uint8_t *dst)
+{
+	peek_imm_96(info, dst);
+	info->pc += 12;
+}
 
 /* Fake a split interface */
 #define get_ea_mode_str_8(instruction) get_ea_mode_str(instruction, 0)
@@ -611,6 +632,8 @@ static void get_ea_mode_op(m68k_info *info, cs_m68k_op *op,
 			op->imm = read_imm_16(info);
 		else if (size == 4)
 			op->imm = read_imm_32(info);
+		else if (size == 12)
+			read_imm_96(info, op->fp_ext.ximm);
 		else
 			op->imm = read_imm_64(info);
 
@@ -2374,12 +2397,16 @@ static void d68020_fpu(m68k_info *info)
 			ext->op_size.type = M68K_SIZE_TYPE_FPU;
 			ext->op_size.fpu_size = M68K_FPU_SIZE_EXTENDED;
 			get_ea_mode_op(info, op0, info->ir, 12);
+			if (op0->type == M68K_OP_IMM)
+				op0->type = M68K_OP_FP_EXTENDED;
 			break;
 
 		case 0x03: // packed decimal
 			ext->op_size.type = M68K_SIZE_TYPE_FPU_PACKED;
 			ext->op_size.fpu_size = M68K_FPU_SIZE_PACKED;
 			get_ea_mode_op(info, op0, info->ir, 12);
+			if (op0->type == M68K_OP_IMM)
+				op0->type = M68K_OP_FP_EXTENDED;
 			break;
 
 		default:

arch/M68K/M68KInstPrinter.c

@@ -224,6 +224,13 @@ static void printAddressingMode(SStream *O, unsigned int pc,
 		SStream_concat(O, "$%" PRIx64 ".l", op->imm);
 		break;
 	case M68K_AM_IMMEDIATE:
+		if (op->type == M68K_OP_FP_EXTENDED) {
+			int i;
+			SStream_concat0(O, "#$");
+			for (i = 0; i < 12; i++)
+				SStream_concat(O, "%02x", op->fp_ext.ximm[i]);
+			break;
+		}
 		if (inst->op_size.type == M68K_SIZE_TYPE_FPU) {
 #if defined(_KERNEL_MODE)
 			// Issue #681: Windows kernel does not support formatting float point

include/capstone/m68k.h

@@ -126,6 +126,8 @@ typedef enum m68k_op_type {
 		CS_OP_SPECIAL +
 		3, ///< Register pair in the same op (upper 4 bits for first reg, lower for second)
 	M68K_OP_BR_DISP = CS_OP_SPECIAL + 4, ///< Branch displacement
+	M68K_OP_FP_EXTENDED =
+		CS_OP_SPECIAL + 5, ///< extended precision / packed decimal Floating-Point operand (ximm)
 	M68K_OP_MEM = CS_OP_MEM, ///< = CS_OP_MEM (Memory operand).
 } m68k_op_type;
 
@@ -167,6 +169,11 @@ typedef struct cs_m68k_op_reg_pair {
 	m68k_reg reg_1;
 } cs_m68k_op_reg_pair;
 
+/// 96-bit extended-precision / packed-decimal FPU immediate.
+typedef struct m68k_op_fp_ext {
+	uint8_t ximm[12]; ///< Raw big-endian M68K byte order.
+} m68k_op_fp_ext;
+
 /// Instruction operand
 typedef struct cs_m68k_op {
 	union {
@@ -187,6 +194,8 @@ typedef struct cs_m68k_op {
 			     ///< For branch displacement: target = instruction_addr + disp_offset + disp
 			     ///< Typically 2 (displacement follows opword), but 4 when an extension
 			     ///< word sits between the opword and the displacement.
+	m68k_op_fp_ext fp_ext; ///< 96-bit extended-precision / packed-decimal immediate.
+			       ///< Valid when type is M68K_OP_FP_EXTENDED.
 } cs_m68k_op;
 
 /// Operation size of the CPU instructions

suite/cstest/include/test_detail_m68k.h

@@ -80,6 +80,8 @@ typedef struct {
 	double dimm;
 	float simm;
 
+	char *ximm; ///< hex string for 96-bit extended/packed immediate
+
 	TestDetailM68KOpMem *mem;
 } TestDetailM68KOp;
 
@@ -112,6 +114,8 @@ static const cyaml_schema_field_t test_detail_m68k_op_mapping_schema[] = {
 			 register_bits),
 	CYAML_FIELD_FLOAT("dimm", CYAML_FLAG_OPTIONAL, TestDetailM68KOp, dimm),
 	CYAML_FIELD_FLOAT("simm", CYAML_FLAG_OPTIONAL, TestDetailM68KOp, simm),
+	CYAML_FIELD_STRING_PTR("ximm", CYAML_FLAG_POINTER | CYAML_FLAG_OPTIONAL,
+			       TestDetailM68KOp, ximm, 0, CYAML_UNLIMITED),
 	CYAML_FIELD_MAPPING_PTR("mem", CYAML_FLAG_OPTIONAL, TestDetailM68KOp,
 				mem, test_detail_m68k_op_mem_mapping_schema),
 	CYAML_FIELD_END

suite/cstest/include/test_mapping.h

@@ -902,6 +902,7 @@ static const cs_enum_id_map cs_enum_map[] = {
 	{ .str = "M68K_FPU_SIZE_DOUBLE", .val = M68K_FPU_SIZE_DOUBLE },
 	{ .str = "M68K_FPU_SIZE_EXTENDED", .val = M68K_FPU_SIZE_EXTENDED },
 	{ .str = "M68K_FPU_SIZE_NONE", .val = M68K_FPU_SIZE_NONE },
+	{ .str = "M68K_FPU_SIZE_PACKED", .val = M68K_FPU_SIZE_PACKED },
 	{ .str = "M68K_FPU_SIZE_SINGLE", .val = M68K_FPU_SIZE_SINGLE },
 	{ .str = "M68K_GRP_BRANCH_RELATIVE", .val = M68K_GRP_BRANCH_RELATIVE },
 	{ .str = "M68K_GRP_IRET", .val = M68K_GRP_IRET },
@@ -915,6 +916,7 @@ static const cs_enum_id_map cs_enum_map[] = {
 	{ .str = "M68K_OP_BR_DISP_SIZE_WORD",
 	  .val = M68K_OP_BR_DISP_SIZE_WORD },
 	{ .str = "M68K_OP_FP_DOUBLE", .val = M68K_OP_FP_DOUBLE },
+	{ .str = "M68K_OP_FP_EXTENDED", .val = M68K_OP_FP_EXTENDED },
 	{ .str = "M68K_OP_FP_SINGLE", .val = M68K_OP_FP_SINGLE },
 	{ .str = "M68K_OP_IMM", .val = M68K_OP_IMM },
 	{ .str = "M68K_OP_MEM", .val = M68K_OP_MEM },

suite/cstest/src/test_detail_m68k.c

@@ -109,6 +109,7 @@ TestDetailM68KOp *test_detail_m68k_op_clone(TestDetailM68KOp *op)
 	clone->imm = op->imm;
 	clone->dimm = op->dimm;
 	clone->simm = op->simm;
+	clone->ximm = op->ximm ? strdup(op->ximm) : NULL;
 	clone->br_disp = op->br_disp;
 	clone->br_disp_size = op->br_disp_size;
 	clone->disp_offset = op->disp_offset;
@@ -128,6 +129,7 @@ void test_detail_m68k_op_free(TestDetailM68KOp *op)
 	cs_mem_free(op->reg_pair_0);
 	cs_mem_free(op->reg_pair_1);
 	cs_mem_free(op->address_mode);
+	cs_mem_free(op->ximm);
 	test_detail_m68k_op_mem_free(op->mem);
 	cs_mem_free(op);
 }
@@ -176,6 +178,21 @@ bool test_expected_m68k(csh *handle, cs_m68k *actual, TestDetailM68K *expected)
 		case M68K_OP_FP_DOUBLE:
 			compare_fp_ret(op->dimm, eop->dimm, false);
 			break;
+		case M68K_OP_FP_EXTENDED:
+			if (eop->ximm) {
+				char actual_hex[25];  // 12*2 chars + \0
+				for (int j = 0; j < 12; j++)
+					snprintf(actual_hex + j * 2, 3,
+						 "%02x", op->fp_ext.ximm[j]);
+				actual_hex[24] = '\0';
+				if (strcmp(actual_hex, eop->ximm) != 0) {
+					fprintf(stderr,
+						"ximm mismatch: got %s, expected %s\n",
+						actual_hex, eop->ximm);
+					return false;
+				}
+			}
+			break;
 		case M68K_OP_REG_BITS:
 			compare_uint32_ret(op->register_bits,
 					   eop->register_bits, false);

tests/details/m68k.yaml

@@ -1386,3 +1386,64 @@ test_cases:
               -
                 type: M68K_OP_REG
                 reg: fp1
+  -
+    input:
+      bytes: [ 0xf2, 0x3c, 0x48, 0x00, 0x3f, 0xff, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x3c, 0x48, 0x80, 0xc0, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
+      arch: "m68k"
+      options: [ CS_OPT_DETAIL, CS_MODE_BIG_ENDIAN, CS_MODE_M68K_040 ]
+      address: 0x3000
+    expected:
+      insns:
+      -
+        asm_text: "fmove.x #$3fff00008000000000000000, fp0"
+        details:
+          regs_write: [ fp0 ]
+          m68k:
+            op_size_type: M68K_SIZE_TYPE_FPU
+            op_size_fpu: M68K_FPU_SIZE_EXTENDED
+            operands:
+              -
+                type: M68K_OP_FP_EXTENDED
+                address_mode: M68K_AM_IMMEDIATE
+                ximm: "3fff00008000000000000000"
+              -
+                type: M68K_OP_REG
+                reg: fp0
+      -
+        asm_text: "fmove.x #$c0000000a000000000000000, fp1"
+        details:
+          regs_write: [ fp1 ]
+          m68k:
+            op_size_type: M68K_SIZE_TYPE_FPU
+            op_size_fpu: M68K_FPU_SIZE_EXTENDED
+            operands:
+              -
+                type: M68K_OP_FP_EXTENDED
+                address_mode: M68K_AM_IMMEDIATE
+                ximm: "c0000000a000000000000000"
+              -
+                type: M68K_OP_REG
+                reg: fp1
+  -
+    input:
+      bytes: [ 0xf2, 0x3c, 0x4c, 0x00, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
+      arch: "m68k"
+      options: [ CS_OPT_DETAIL, CS_MODE_BIG_ENDIAN, CS_MODE_M68K_040 ]
+      address: 0x4000
+    expected:
+      insns:
+      -
+        asm_text: "fmove.p #$000100001000000000000000, fp0"
+        details:
+          regs_write: [ fp0 ]
+          m68k:
+            op_size_type: M68K_SIZE_TYPE_FPU_PACKED
+            op_size_fpu: M68K_FPU_SIZE_PACKED
+            operands:
+              -
+                type: M68K_OP_FP_EXTENDED
+                address_mode: M68K_AM_IMMEDIATE
+                ximm: "000100001000000000000000"
+              -
+                type: M68K_OP_REG
+                reg: fp0