Checked in some necessary changes from the #1949

 - `cs_simple_types.h`
 - `MCInst.{c,h}`
 - `MCInstrDesc.{c,h}`
 - `utils.{c,h}`

Author: Rot127

CMakeLists.txt

@@ -106,6 +106,7 @@ set(SOURCES_ENGINE
 )
 set(HEADERS_ENGINE
     cs_priv.h
+    cs_simple_types.h
     LEB128.h
     MathExtras.h
     MCDisassembler.h

MCInst.c

@@ -9,6 +9,7 @@
 #include <stdlib.h>
 #endif
 #include <string.h>
+#include <assert.h>
 
 #include "MCInst.h"
 #include "utils.h"
@@ -32,16 +33,19 @@ void MCInst_Init(MCInst *inst)
 	inst->assembly[0] = '\0';
 	inst->wasm_data.type = WASM_OP_INVALID;
 	inst->xAcquireRelease = 0;
+	for (int i = 0; i < MAX_MC_OPS; ++i)
+		inst->tied_op_idx[i] = -1;
 }
 
 void MCInst_clear(MCInst *inst)
 {
 	inst->size = 0;
 }
 
-// do not free @Op
+// does not free @Op
 void MCInst_insert0(MCInst *inst, int index, MCOperand *Op)
 {
+	assert(index < MAX_MC_OPS);
 	int i;
 
 	for(i = inst->size; i > index; i--)
@@ -74,6 +78,7 @@ unsigned MCInst_getOpcodePub(const MCInst *inst)
 
 MCOperand *MCInst_getOperand(MCInst *inst, unsigned i)
 {
+	assert(i < MAX_MC_OPS);
 	return &inst->Operands[i];
 }
 
@@ -85,6 +90,7 @@ unsigned MCInst_getNumOperands(const MCInst *inst)
 // This addOperand2 function doesnt free Op
 void MCInst_addOperand2(MCInst *inst, MCOperand *Op)
 {
+	assert(inst->size < MAX_MC_OPS);
 	inst->Operands[inst->size] = *Op;
 
 	inst->size++;
@@ -110,6 +116,21 @@ bool MCOperand_isFPImm(const MCOperand *op)
 	return op->Kind == kFPImmediate;
 }
 
+bool MCOperand_isDFPImm(const MCOperand *op)
+{
+	return op->Kind == kDFPImmediate;
+}
+
+bool MCOperand_isExpr(const MCOperand *op)
+{
+	return op->Kind == kExpr;
+}
+
+bool MCOperand_isInst(const MCOperand *op)
+{
+	return op->Kind == kInst;
+}
+
 /// getReg - Returns the register number.
 unsigned MCOperand_getReg(const MCOperand *op)
 {
@@ -146,6 +167,7 @@ MCOperand *MCOperand_CreateReg1(MCInst *mcInst, unsigned Reg)
 {
 	MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
 
+	op->MachineOperandType = kRegister;
 	op->Kind = kRegister;
 	op->RegVal = Reg;
 
@@ -157,6 +179,7 @@ void MCOperand_CreateReg0(MCInst *mcInst, unsigned Reg)
 	MCOperand *op = &(mcInst->Operands[mcInst->size]);
 	mcInst->size++;
 
+	op->MachineOperandType = kRegister;
 	op->Kind = kRegister;
 	op->RegVal = Reg;
 }
@@ -165,6 +188,7 @@ MCOperand *MCOperand_CreateImm1(MCInst *mcInst, int64_t Val)
 {
 	MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
 
+	op->MachineOperandType = kImmediate;
 	op->Kind = kImmediate;
 	op->ImmVal = Val;
 
@@ -173,9 +197,69 @@ MCOperand *MCOperand_CreateImm1(MCInst *mcInst, int64_t Val)
 
 void MCOperand_CreateImm0(MCInst *mcInst, int64_t Val)
 {
+	assert(mcInst->size < MAX_MC_OPS);
 	MCOperand *op = &(mcInst->Operands[mcInst->size]);
 	mcInst->size++;
 
+	op->MachineOperandType = kImmediate;
 	op->Kind = kImmediate;
 	op->ImmVal = Val;
 }
+
+/// Check if any operand of the MCInstrDesc is predicable
+bool MCInst_isPredicable(const MCInstrDesc *MIDesc) {
+	const MCOperandInfo *OpInfo = MIDesc->OpInfo;
+	unsigned NumOps = MIDesc->NumOperands;
+	for (unsigned i = 0; i < NumOps; ++i) {
+		if (MCOperandInfo_isPredicate(&OpInfo[i])) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/// Checks if tied operands exist in the instruction and sets
+/// - The writeback flag in detail
+/// - Saves the indices of the tied destination operands.
+void MCInst_handleWriteback(MCInst *MI, const MCInstrDesc *InstDesc) {
+	const MCOperandInfo *OpInfo = InstDesc[MCInst_getOpcode(MI)].OpInfo;
+	unsigned short NumOps = InstDesc[MCInst_getOpcode(MI)].NumOperands;
+
+	unsigned i;
+	for (i = 0; i < NumOps; ++i) {
+		if (MCOperandInfo_isTiedToOp(&OpInfo[i])) {
+			int idx = MCOperandInfo_getOperandConstraint(
+				&InstDesc[MCInst_getOpcode(MI)], i, MCOI_TIED_TO);
+
+			if (idx == -1)
+				continue;
+
+			if(i >= MAX_MC_OPS) {
+				assert(0 && "Maximum number of MC operands reached.");
+			}
+			MI->tied_op_idx[i] = idx;
+
+			if (MI->flat_insn->detail)
+				MI->flat_insn->detail->writeback = true;
+		}
+	}
+}
+
+/// Check if operand with OpNum is tied by another operand
+/// (operand is tying destination).
+bool MCInst_opIsTied(const MCInst *MI, unsigned OpNum) {
+	assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
+	for (int i = 0; i < MAX_MC_OPS; ++i) {
+		if (MI->tied_op_idx[i] == OpNum)
+			return true;
+	}
+	return false;
+}
+
+/// Check if operand with OpNum is tying another operand
+/// (operand is tying src).
+bool MCInst_opIsTying(const MCInst *MI, unsigned OpNum) {
+	assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
+	return MI->tied_op_idx[OpNum] != -1;
+}
+

MCInst.h

@@ -20,6 +20,7 @@
 #define CS_MCINST_H
 
 #include "include/capstone/capstone.h"
+#include "MCInstrDesc.h"
 #include "MCRegisterInfo.h"
 
 typedef struct MCInst MCInst;
@@ -34,6 +35,10 @@ struct MCOperand {
 		kRegister,                ///< Register operand.
 		kImmediate,               ///< Immediate operand.
 		kFPImmediate,             ///< Floating-point immediate operand.
+		kDFPImmediate,            ///< Double-Floating-point immediate operand.
+		kExpr,                    ///< Relocatable immediate operand.
+		kInst                     ///< Sub-instruction operand.
+
 	} MachineOperandType;
 	unsigned char Kind;
 
@@ -52,6 +57,10 @@ bool MCOperand_isImm(const MCOperand *op);
 
 bool MCOperand_isFPImm(const MCOperand *op);
 
+bool MCOperand_isDFPImm(const MCOperand *op);
+
+bool MCOperand_isExpr(const MCOperand *op);
+
 bool MCOperand_isInst(const MCOperand *op);
 
 /// getReg - Returns the register number.
@@ -84,6 +93,8 @@ void MCOperand_CreateImm0(MCInst *inst, int64_t Val);
 // create Imm operand in the last-unused slot
 MCOperand *MCOperand_CreateImm1(MCInst *inst, int64_t Val);
 
+#define MAX_MC_OPS 48
+
 /// MCInst - Instances of this class represent a single low-level machine
 /// instruction.
 struct MCInst {
@@ -92,7 +103,7 @@ struct MCInst {
 	bool has_imm;	// indicate this instruction has an X86_OP_IMM operand - used for ATT syntax
 	uint8_t op1_size; // size of 1st operand - for X86 Intel syntax
 	unsigned Opcode;  // private opcode
-	MCOperand Operands[48];
+	MCOperand Operands[MAX_MC_OPS];
 	cs_insn *flat_insn;	// insn to be exposed to public
 	uint64_t address;	// address of this insn
 	cs_struct *csh;	// save the main csh
@@ -108,7 +119,8 @@ struct MCInst {
 	// This is copied from cs_x86 struct
 	uint8_t x86_prefix[4];
 	uint8_t imm_size;	// immediate size for X86_OP_IMM operand
-	bool writeback;	// writeback for ARM
+	bool writeback; // writeback for ARM
+	int8_t tied_op_idx[MAX_MC_OPS];	///< Tied operand indices. Index = Src op; Value: Dest op
 	// operand access index for list of registers sharing the same access right (for ARM)
 	uint8_t ac_idx;
 	uint8_t popcode_adjust;   // Pseudo X86 instruction adjust
@@ -141,4 +153,12 @@ unsigned MCInst_getNumOperands(const MCInst *inst);
 // This addOperand2 function doesnt free Op
 void MCInst_addOperand2(MCInst *inst, MCOperand *Op);
 
+bool MCInst_isPredicable(const MCInstrDesc *MIDesc);
+
+void MCInst_handleWriteback(MCInst *MI, const MCInstrDesc *InstDesc);
+
+bool MCInst_opIsTied(const MCInst *MI, unsigned OpNum);
+
+bool MCInst_opIsTying(const MCInst *MI, unsigned OpNum);
+
 #endif

MCInstrDesc.c

@@ -16,3 +16,23 @@ bool MCOperandInfo_isOptionalDef(const MCOperandInfo *m)
 {
 	return m->Flags & (1 << MCOI_OptionalDef);
 }
+
+/// Checks if operand is tied to another one.
+bool MCOperandInfo_isTiedToOp(const MCOperandInfo *m) {
+	if (m->Constraints & (1 << MCOI_TIED_TO))
+		return true;
+	return false;
+}
+
+/// Returns the value of the specified operand constraint if
+/// it is present. Returns -1 if it is not present.
+int MCOperandInfo_getOperandConstraint(const MCInstrDesc *InstrDesc, unsigned OpNum,
+						MCOI_OperandConstraint Constraint) {
+	const MCOperandInfo OpInfo = InstrDesc->OpInfo[OpNum];
+	if (OpNum < InstrDesc->NumOperands &&
+		(OpInfo.Constraints & (1 << Constraint))) {
+		unsigned ValuePos = 4 + Constraint * 4;
+		return (OpInfo.Constraints >> ValuePos) & 0xf;
+	}
+	return -1;
+}

MCInstrDesc.h

@@ -158,4 +158,9 @@ bool MCOperandInfo_isPredicate(const MCOperandInfo *m);
 
 bool MCOperandInfo_isOptionalDef(const MCOperandInfo *m);
 
+bool MCOperandInfo_isTiedToOp(const MCOperandInfo *m);
+
+int MCOperandInfo_getOperandConstraint(const MCInstrDesc *OpInfo, unsigned OpNum,
+						MCOI_OperandConstraint Constraint);
+
 #endif