Add .clang-format and format

.clang-format

@@ -1,6 +1,120 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# clang-format configuration file. Intended for clang-format >= 11.
+#
+# For more information, see:
+#
+#   Documentation/process/clang-format.rst
+#   https://clang.llvm.org/docs/ClangFormat.html
+#   https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+#
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: DontAlign
+AlignOperands: true
+AlignTrailingComments:
+  Kind: Always
+  OverEmptyLines: 2
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
 BraceWrapping:
-  AfterClass:      true
+  AfterClass: false
   AfterControlStatement: false
-  AfterFunction:   true
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
-UseTab: Always
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '.*'
+    Priority: 1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentGotoLabels: false
+IndentPPDirectives: None
+IndentWidth: 8
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 8
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+
+# Taken from git's rules
+PenaltyBreakAssignment: 10
+PenaltyBreakBeforeFirstCallParameter: 30
+PenaltyBreakComment: 10
+PenaltyBreakFirstLessLess: 0
+PenaltyBreakString: 10
+PenaltyExcessCharacter: 100
+PenaltyReturnTypeOnItsOwnLine: 60
+
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: false
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatementsExceptForEachMacros
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp03
+TabWidth: 8
+UseTab: Always

MCInst.c

@@ -207,7 +207,8 @@ void MCOperand_CreateImm0(MCInst *mcInst, int64_t Val)
 }
 
 /// Check if any operand of the MCInstrDesc is predicable
-bool MCInst_isPredicable(const MCInstrDesc *MIDesc) {
+bool MCInst_isPredicable(const MCInstrDesc *MIDesc)
+{
 	const MCOperandInfo *OpInfo = MIDesc->OpInfo;
 	unsigned NumOps = MIDesc->NumOperands;
 	for (unsigned i = 0; i < NumOps; ++i) {
@@ -221,21 +222,24 @@ bool MCInst_isPredicable(const MCInstrDesc *MIDesc) {
 /// 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) {
+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);
+				&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.");
+			if (i >= MAX_MC_OPS) {
+				assert(0 &&
+				       "Maximum number of MC operands reached.");
 			}
 			MI->tied_op_idx[i] = idx;
 
@@ -247,7 +251,8 @@ void MCInst_handleWriteback(MCInst *MI, const MCInstrDesc *InstDesc) {
 
 /// Check if operand with OpNum is tied by another operand
 /// (operand is tying destination).
-bool MCInst_opIsTied(const MCInst *MI, unsigned OpNum) {
+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)
@@ -258,8 +263,8 @@ bool MCInst_opIsTied(const MCInst *MI, unsigned OpNum) {
 
 /// Check if operand with OpNum is tying another operand
 /// (operand is tying src).
-bool MCInst_opIsTying(const MCInst *MI, unsigned OpNum) {
+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

@@ -31,13 +31,13 @@ typedef struct MCOperand MCOperand;
 /// This is a simple discriminated union.
 struct MCOperand {
 	enum {
-		kInvalid = 0,                 ///< Uninitialized.
-		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.
+		kInvalid = 0,  ///< Uninitialized.
+		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;
@@ -119,8 +119,9 @@ 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
-	int8_t tied_op_idx[MAX_MC_OPS];	///< Tied operand indices. Index = Src op; Value: Dest op
+	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

MCInstrDesc.c

@@ -18,19 +18,22 @@ bool MCOperandInfo_isOptionalDef(const MCOperandInfo *m)
 }
 
 /// Checks if operand is tied to another one.
-bool MCOperandInfo_isTiedToOp(const MCOperandInfo *m) {
+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) {
+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))) {
+	    (OpInfo.Constraints & (1 << Constraint))) {
 		unsigned ValuePos = 4 + Constraint * 4;
 		return (OpInfo.Constraints >> ValuePos) & 0xf;
 	}

MCInstrDesc.h

@@ -160,7 +160,8 @@ bool MCOperandInfo_isOptionalDef(const MCOperandInfo *m);
 
 bool MCOperandInfo_isTiedToOp(const MCOperandInfo *m);
 
-int MCOperandInfo_getOperandConstraint(const MCInstrDesc *OpInfo, unsigned OpNum,
-						MCOI_OperandConstraint Constraint);
+int MCOperandInfo_getOperandConstraint(const MCInstrDesc *OpInfo,
+				       unsigned OpNum,
+				       MCOI_OperandConstraint Constraint);
 
 #endif

Mapping.c

@@ -23,7 +23,7 @@ static unsigned short *make_id2insn(const insn_map *insns, unsigned int size)
 // look for @id in @insns, given its size in @max. first time call will update
 // @cache. return 0 if not found
 unsigned short insn_find(const insn_map *insns, unsigned int max,
-						 unsigned int id, unsigned short **cache)
+			 unsigned int id, unsigned short **cache)
 {
 	if (id > insns[max - 1].id)
 		return 0;
@@ -99,9 +99,9 @@ void map_implicit_reads(MCInst *MI, const insn_map *imap)
 	uint16_t reg = imap[Opcode].regs_use[i];
 	while (reg != 0) {
 		if (i >= MAX_IMPL_R_REGS ||
-			detail->regs_read_count >= MAX_IMPL_R_REGS) {
+		    detail->regs_read_count >= MAX_IMPL_R_REGS) {
 			printf("ERROR: Too many implicit read register defined in "
-				   "instruction mapping.\n");
+			       "instruction mapping.\n");
 			return;
 		}
 		detail->regs_read[detail->regs_read_count++] = reg;
@@ -124,9 +124,9 @@ void map_implicit_writes(MCInst *MI, const insn_map *imap)
 	uint16_t reg = imap[Opcode].regs_mod[i];
 	while (reg != 0) {
 		if (i >= MAX_IMPL_W_REGS ||
-			detail->regs_write_count >= MAX_IMPL_W_REGS) {
+		    detail->regs_write_count >= MAX_IMPL_W_REGS) {
 			printf("ERROR: Too many implicit write register defined in "
-				   "instruction mapping.\n");
+			       "instruction mapping.\n");
 			return;
 		}
 		detail->regs_write[detail->regs_write_count++] = reg;
@@ -161,7 +161,7 @@ void map_groups(MCInst *MI, const insn_map *imap)
 // Search for the CS instruction id for the given @MC_Opcode in @imap.
 // return -1 if none is found.
 unsigned int find_cs_id(unsigned MC_Opcode, const insn_map *imap,
-						unsigned imap_size)
+			unsigned imap_size)
 {
 	// binary searching since the IDs are sorted in order
 	unsigned int left, right, m;
@@ -200,21 +200,21 @@ void map_cs_id(MCInst *MI, const insn_map *imap, unsigned int imap_size)
 		return;
 	}
 	printf("ERROR: Could not find CS id for MCInst opcode: %d\n",
-		   MCInst_getOpcode(MI));
+	       MCInst_getOpcode(MI));
 	return;
 }
 
 /// Returns the operand type information from the
 /// mapping table for instruction operands.
 /// Only usable by `auto-sync` archs!
 const cs_op_type mapping_get_op_type(MCInst *MI, unsigned OpNum,
-									 const map_insn_ops *insn_ops_map,
-									 size_t map_size)
+				     const map_insn_ops *insn_ops_map,
+				     size_t map_size)
 {
 	assert(MI);
 	assert(MI->Opcode < map_size);
 	assert(OpNum < sizeof(insn_ops_map[MI->Opcode].ops) /
-					   sizeof(insn_ops_map[MI->Opcode].ops[0]));
+			       sizeof(insn_ops_map[MI->Opcode].ops[0]));
 
 	return insn_ops_map[MI->Opcode].ops[OpNum].type;
 }
@@ -223,13 +223,13 @@ const cs_op_type mapping_get_op_type(MCInst *MI, unsigned OpNum,
 /// mapping table for instruction operands.
 /// Only usable by `auto-sync` archs!
 const cs_ac_type mapping_get_op_access(MCInst *MI, unsigned OpNum,
-									   const map_insn_ops *insn_ops_map,
-									   size_t map_size)
+				       const map_insn_ops *insn_ops_map,
+				       size_t map_size)
 {
 	assert(MI);
 	assert(MI->Opcode < map_size);
 	assert(OpNum < sizeof(insn_ops_map[MI->Opcode].ops) /
-					   sizeof(insn_ops_map[MI->Opcode].ops[0]));
+			       sizeof(insn_ops_map[MI->Opcode].ops[0]));
 
 	cs_ac_type access = insn_ops_map[MI->Opcode].ops[OpNum].access;
 	if (MCInst_opIsTied(MI, OpNum) || MCInst_opIsTying(MI, OpNum))
@@ -239,14 +239,14 @@ const cs_ac_type mapping_get_op_access(MCInst *MI, unsigned OpNum,
 
 /// Returns the operand at detail->arch.operands[op_count + offset]
 /// Or NULL if detail is not set.
-#define DEFINE_get_detail_op(arch, ARCH)                                       \
-	cs_##arch##_op *ARCH##_get_detail_op(MCInst *MI, int offset)               \
-	{                                                                          \
-		if (!MI->flat_insn->detail)                                            \
-			return NULL;                                                       \
-		int OpIdx = MI->flat_insn->detail->arch.op_count + offset;             \
-		assert(OpIdx >= 0 && OpIdx < MAX_MC_OPS);                              \
-		return &MI->flat_insn->detail->arch.operands[OpIdx];                   \
+#define DEFINE_get_detail_op(arch, ARCH) \
+	cs_##arch##_op *ARCH##_get_detail_op(MCInst *MI, int offset) \
+	{ \
+		if (!MI->flat_insn->detail) \
+			return NULL; \
+		int OpIdx = MI->flat_insn->detail->arch.op_count + offset; \
+		assert(OpIdx >= 0 && OpIdx < MAX_MC_OPS); \
+		return &MI->flat_insn->detail->arch.operands[OpIdx]; \
 	}
 
 DEFINE_get_detail_op(arm, ARM);