Add missing thirdparty files

.gitignore

@@ -396,4 +396,4 @@ FodyWeavers.xsd
 *.msp
 
 # JetBrains Rider
-*.sln.iml
+*.sln.iml

thirdparty/.gitignore

@@ -0,0 +1,8 @@
+!*
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/

thirdparty/capstone/arch/ARM/ARMAddressingModes.h

@@ -0,0 +1,784 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically translated source file from LLVM. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Only small edits allowed. */
+/* For multiple similar edits, please create a Patch for the translator. */
+
+/* Capstone's C++ file translator: */
+/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */
+
+//===-- ARMAddressingModes.h - ARM Addressing Modes -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the ARM addressing mode implementation stuff.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CS_ARM_ADDRESSINGMODES_H
+#define CS_ARM_ADDRESSINGMODES_H
+
+#include <capstone/platform.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../MathExtras.h"
+#include <assert.h>
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+/// ARM_AM - ARM Addressing Mode Stuff
+typedef enum ShiftOpc {
+	ARM_AM_no_shift = 0,
+	ARM_AM_asr,
+	ARM_AM_lsl,
+	ARM_AM_lsr,
+	ARM_AM_ror,
+	ARM_AM_rrx,
+	ARM_AM_uxtw
+} ARM_AM_ShiftOpc;
+
+typedef enum AddrOpc { ARM_AM_sub = 0, ARM_AM_add } ARM_AM_AddrOpc;
+
+static inline const char *ARM_AM_getAddrOpcStr(ARM_AM_AddrOpc Op)
+{
+	return Op == ARM_AM_sub ? "-" : "";
+}
+
+static inline const char *ARM_AM_getShiftOpcStr(ARM_AM_ShiftOpc Op)
+{
+	switch (Op) {
+	default:
+		assert(0 && "Unknown shift opc!");
+	case ARM_AM_asr:
+		return "asr";
+	case ARM_AM_lsl:
+		return "lsl";
+	case ARM_AM_lsr:
+		return "lsr";
+	case ARM_AM_ror:
+		return "ror";
+	case ARM_AM_rrx:
+		return "rrx";
+	case ARM_AM_uxtw:
+		return "uxtw";
+	}
+}
+
+static inline unsigned ARM_AM_getShiftOpcEncoding(ARM_AM_ShiftOpc Op)
+{
+	switch (Op) {
+	default:
+		assert(0 && "Unknown shift opc!");
+	case ARM_AM_asr:
+		return 2;
+	case ARM_AM_lsl:
+		return 0;
+	case ARM_AM_lsr:
+		return 1;
+	case ARM_AM_ror:
+		return 3;
+	}
+}
+
+typedef enum AMSubMode {
+	ARM_AM_bad_am_submode = 0,
+	ARM_AM_ia,
+	ARM_AM_ib,
+	ARM_AM_da,
+	ARM_AM_db
+} ARM_AM_SubMode;
+
+static inline const char *ARM_AM_getAMSubModeStr(ARM_AM_SubMode Mode)
+{
+	switch (Mode) {
+	default:
+		assert(0 && "Unknown addressing sub-mode!");
+	case ARM_AM_ia:
+		return "ia";
+	case ARM_AM_ib:
+		return "ib";
+	case ARM_AM_da:
+		return "da";
+	case ARM_AM_db:
+		return "db";
+	}
+}
+
+/// rotr32 - Rotate a 32-bit unsigned value right by a specified # bits.
+///
+static inline unsigned ARM_AM_rotr32(unsigned Val, unsigned Amt)
+{
+	return (Val >> Amt) | (Val << ((32 - Amt) & 31));
+}
+
+/// rotl32 - Rotate a 32-bit unsigned value left by a specified # bits.
+///
+static inline unsigned ARM_AM_rotl32(unsigned Val, unsigned Amt)
+{
+	return (Val << Amt) | (Val >> ((32 - Amt) & 31));
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #1: shift_operand with registers
+//===--------------------------------------------------------------------===//
+//
+// This 'addressing mode' is used for arithmetic instructions.  It can
+// represent things like:
+//   reg
+//   reg [asr|lsl|lsr|ror|rrx] reg
+//   reg [asr|lsl|lsr|ror|rrx] imm
+//
+// This is stored three operands [rega, regb, opc].  The first is the base
+// reg, the second is the shift amount (or reg0 if not present or imm).  The
+// third operand encodes the shift opcode and the imm if a reg isn't present.
+//
+static inline unsigned ARM_AM_getSORegOpc(ARM_AM_ShiftOpc ShOp, unsigned Imm)
+{
+	return ShOp | (Imm << 3);
+}
+
+static inline unsigned ARM_AM_getSORegOffset(unsigned Op)
+{
+	return Op >> 3;
+}
+
+static inline ARM_AM_ShiftOpc ARM_AM_getSORegShOp(unsigned Op)
+{
+	return (ARM_AM_ShiftOpc)(Op & 7);
+}
+
+/// getSOImmValImm - Given an encoded imm field for the reg/imm form, return
+/// the 8-bit imm value.
+static inline unsigned ARM_AM_getSOImmValImm(unsigned Imm)
+{
+	return Imm & 0xFF;
+}
+
+/// getSOImmValRot - Given an encoded imm field for the reg/imm form, return
+/// the rotate amount.
+static inline unsigned ARM_AM_getSOImmValRot(unsigned Imm)
+{
+	return (Imm >> 8) * 2;
+}
+
+/// getSOImmValRotate - Try to handle Imm with an immediate shifter operand,
+/// computing the rotate amount to use.  If this immediate value cannot be
+/// handled with a single shifter-op, determine a good rotate amount that will
+/// take a maximal chunk of bits out of the immediate.
+static inline unsigned ARM_AM_getSOImmValRotate(unsigned Imm)
+{
+	// 8-bit (or less) immediates are trivially shifter_operands with a rotate
+	// of zero.
+	if ((Imm & ~255U) == 0)
+		return 0;
+
+	// Use CTZ to compute the rotate amount.
+	unsigned TZ = CountTrailingZeros_32(Imm);
+
+	// Rotate amount must be even.  Something like 0x200 must be rotated 8 bits,
+	// not 9.
+	unsigned RotAmt = TZ & ~1;
+
+	// If we can handle this spread, return it.
+	if ((ARM_AM_rotr32(Imm, RotAmt) & ~255U) == 0)
+		return (32 - RotAmt) & 31; // HW rotates right, not left.
+
+	// For values like 0xF000000F, we should ignore the low 6 bits, then
+	// retry the hunt.
+	if (Imm & 63U) {
+		unsigned TZ2 = CountTrailingZeros_32(Imm & ~63U);
+		unsigned RotAmt2 = TZ2 & ~1;
+		if ((ARM_AM_rotr32(Imm, RotAmt2) & ~255U) == 0)
+			return (32 - RotAmt2) &
+			       31; // HW rotates right, not left.
+	}
+
+	// Otherwise, we have no way to cover this span of bits with a single
+	// shifter_op immediate.  Return a chunk of bits that will be useful to
+	// handle.
+	return (32 - RotAmt) & 31; // HW rotates right, not left.
+}
+
+/// getSOImmVal - Given a 32-bit immediate, if it is something that can fit
+/// into an shifter_operand immediate operand, return the 12-bit encoding for
+/// it.  If not, return -1.
+static inline int ARM_AM_getSOImmVal(unsigned Arg)
+{
+	// 8-bit (or less) immediates are trivially shifter_operands with a rotate
+	// of zero.
+	if ((Arg & ~255U) == 0)
+		return Arg;
+
+	unsigned RotAmt = ARM_AM_getSOImmValRotate(Arg);
+
+	// If this cannot be handled with a single shifter_op, bail out.
+	if (ARM_AM_rotr32(~255U, RotAmt) & Arg)
+		return -1;
+
+	// Encode this correctly.
+	return ARM_AM_rotl32(Arg, RotAmt) | ((RotAmt >> 1) << 8);
+}
+
+/// isSOImmTwoPartVal - Return true if the specified value can be obtained by
+/// or'ing together two SOImmVal's.
+static inline bool ARM_AM_isSOImmTwoPartVal(unsigned V)
+{
+	// If this can be handled with a single shifter_op, bail out.
+	V = ARM_AM_rotr32(~255U, ARM_AM_getSOImmValRotate(V)) & V;
+	if (V == 0)
+		return false;
+
+	// If this can be handled with two shifter_op's, accept.
+	V = ARM_AM_rotr32(~255U, ARM_AM_getSOImmValRotate(V)) & V;
+	return V == 0;
+}
+
+/// getSOImmTwoPartFirst - If V is a value that satisfies isSOImmTwoPartVal,
+/// return the first chunk of it.
+static inline unsigned ARM_AM_getSOImmTwoPartFirst(unsigned V)
+{
+	return ARM_AM_rotr32(255U, ARM_AM_getSOImmValRotate(V)) & V;
+}
+
+/// getSOImmTwoPartSecond - If V is a value that satisfies isSOImmTwoPartVal,
+/// return the second chunk of it.
+static inline unsigned ARM_AM_getSOImmTwoPartSecond(unsigned V)
+{
+	// Mask out the first hunk.
+	V = ARM_AM_rotr32(~255U, ARM_AM_getSOImmValRotate(V)) & V;
+
+	// Take what's left.
+
+	return V;
+}
+
+/// isSOImmTwoPartValNeg - Return true if the specified value can be obtained
+/// by two SOImmVal, that -V = First + Second.
+/// "R+V" can be optimized to (sub (sub R, First), Second).
+/// "R=V" can be optimized to (sub (mvn R, ~(-First)), Second).
+static inline bool ARM_AM_isSOImmTwoPartValNeg(unsigned V)
+{
+	unsigned First;
+	if (!ARM_AM_isSOImmTwoPartVal(-V))
+		return false;
+	// Return false if ~(-First) is not a SoImmval.
+	First = ARM_AM_getSOImmTwoPartFirst(-V);
+	First = ~(-First);
+	return !(ARM_AM_rotr32(~255U, ARM_AM_getSOImmValRotate(First)) & First);
+}
+
+/// getThumbImmValShift - Try to handle Imm with a 8-bit immediate followed
+/// by a left shift. Returns the shift amount to use.
+static inline unsigned ARM_AM_getThumbImmValShift(unsigned Imm)
+{
+	// 8-bit (or less) immediates are trivially immediate operand with a shift
+	// of zero.
+	if ((Imm & ~255U) == 0)
+		return 0;
+
+	// Use CTZ to compute the shift amount.
+	return CountTrailingZeros_32(Imm);
+}
+
+/// isThumbImmShiftedVal - Return true if the specified value can be obtained
+/// by left shifting a 8-bit immediate.
+static inline bool ARM_AM_isThumbImmShiftedVal(unsigned V)
+{
+	// If this can be handled with
+	V = (~255U << ARM_AM_getThumbImmValShift(V)) & V;
+	return V == 0;
+}
+
+/// getThumbImm16ValShift - Try to handle Imm with a 16-bit immediate followed
+/// by a left shift. Returns the shift amount to use.
+static inline unsigned ARM_AM_getThumbImm16ValShift(unsigned Imm)
+{
+	// 16-bit (or less) immediates are trivially immediate operand with a shift
+	// of zero.
+	if ((Imm & ~65535U) == 0)
+		return 0;
+
+	// Use CTZ to compute the shift amount.
+	return CountTrailingZeros_32(Imm);
+}
+
+/// isThumbImm16ShiftedVal - Return true if the specified value can be
+/// obtained by left shifting a 16-bit immediate.
+static inline bool ARM_AM_isThumbImm16ShiftedVal(unsigned V)
+{
+	// If this can be handled with
+	V = (~65535U << ARM_AM_getThumbImm16ValShift(V)) & V;
+	return V == 0;
+}
+
+/// getThumbImmNonShiftedVal - If V is a value that satisfies
+/// isThumbImmShiftedVal, return the non-shiftd value.
+static inline unsigned ARM_AM_getThumbImmNonShiftedVal(unsigned V)
+{
+	return V >> ARM_AM_getThumbImmValShift(V);
+}
+
+/// getT2SOImmValSplat - Return the 12-bit encoded representation
+/// if the specified value can be obtained by splatting the low 8 bits
+/// into every other byte or every byte of a 32-bit value. i.e.,
+///     00000000 00000000 00000000 abcdefgh    control = 0
+///     00000000 abcdefgh 00000000 abcdefgh    control = 1
+///     abcdefgh 00000000 abcdefgh 00000000    control = 2
+///     abcdefgh abcdefgh abcdefgh abcdefgh    control = 3
+/// Return -1 if none of the above apply.
+/// See ARM Reference Manual A6.3.2.
+static inline int ARM_AM_getT2SOImmValSplatVal(unsigned V)
+{
+	unsigned u, Vs, Imm;
+	// control = 0
+	if ((V & 0xffffff00) == 0)
+		return V;
+
+	// If the value is zeroes in the first byte, just shift those off
+	Vs = ((V & 0xff) == 0) ? V >> 8 : V;
+	// Any passing value only has 8 bits of payload, splatted across the word
+	Imm = Vs & 0xff;
+	// Likewise, any passing values have the payload splatted into the 3rd byte
+	u = Imm | (Imm << 16);
+
+	// control = 1 or 2
+	if (Vs == u)
+		return (((Vs == V) ? 1 : 2) << 8) | Imm;
+
+	// control = 3
+	if (Vs == (u | (u << 8)))
+		return (3 << 8) | Imm;
+
+	return -1;
+}
+
+/// getT2SOImmValRotateVal - Return the 12-bit encoded representation if the
+/// specified value is a rotated 8-bit value. Return -1 if no rotation
+/// encoding is possible.
+/// See ARM Reference Manual A6.3.2.
+static inline int ARM_AM_getT2SOImmValRotateVal(unsigned V)
+{
+	unsigned RotAmt = CountLeadingZeros_32(V);
+	if (RotAmt >= 24)
+		return -1;
+
+	// If 'Arg' can be handled with a single shifter_op return the value.
+	if ((ARM_AM_rotr32(0xff000000U, RotAmt) & V) == V)
+		return (ARM_AM_rotr32(V, 24 - RotAmt) & 0x7f) |
+		       ((RotAmt + 8) << 7);
+
+	return -1;
+}
+
+/// getT2SOImmVal - Given a 32-bit immediate, if it is something that can fit
+/// into a Thumb-2 shifter_operand immediate operand, return the 12-bit
+/// encoding for it.  If not, return -1.
+/// See ARM Reference Manual A6.3.2.
+static inline int ARM_AM_getT2SOImmVal(unsigned Arg)
+{
+	// If 'Arg' is an 8-bit splat, then get the encoded value.
+	int Splat = ARM_AM_getT2SOImmValSplatVal(Arg);
+	if (Splat != -1)
+		return Splat;
+
+	// If 'Arg' can be handled with a single shifter_op return the value.
+	int Rot = ARM_AM_getT2SOImmValRotateVal(Arg);
+	if (Rot != -1)
+		return Rot;
+
+	return -1;
+}
+
+static inline unsigned ARM_AM_getT2SOImmValRotate(unsigned V)
+{
+	if ((V & ~255U) == 0)
+		return 0;
+	// Use CTZ to compute the rotate amount.
+	unsigned RotAmt = CountTrailingZeros_32(V);
+	return (32 - RotAmt) & 31;
+}
+
+static inline bool ARM_AM_isT2SOImmTwoPartVal(unsigned Imm)
+{
+	unsigned V = Imm;
+	// Passing values can be any combination of splat values and shifter
+	// values. If this can be handled with a single shifter or splat, bail
+	// out. Those should be handled directly, not with a two-part val.
+	if (ARM_AM_getT2SOImmValSplatVal(V) != -1)
+		return false;
+	V = ARM_AM_rotr32(~255U, ARM_AM_getT2SOImmValRotate(V)) & V;
+	if (V == 0)
+		return false;
+
+	// If this can be handled as an immediate, accept.
+	if (ARM_AM_getT2SOImmVal(V) != -1)
+		return true;
+
+	// Likewise, try masking out a splat value first.
+	V = Imm;
+	if (ARM_AM_getT2SOImmValSplatVal(V & 0xff00ff00U) != -1)
+		V &= ~0xff00ff00U;
+	else if (ARM_AM_getT2SOImmValSplatVal(V & 0x00ff00ffU) != -1)
+		V &= ~0x00ff00ffU;
+	// If what's left can be handled as an immediate, accept.
+	if (ARM_AM_getT2SOImmVal(V) != -1)
+		return true;
+
+	// Otherwise, do not accept.
+	return false;
+}
+
+static inline unsigned ARM_AM_getT2SOImmTwoPartFirst(unsigned Imm)
+{
+	// Try a shifter operand as one part
+	unsigned V = ARM_AM_rotr32(~255, ARM_AM_getT2SOImmValRotate(Imm)) & Imm;
+	// If the rest is encodable as an immediate, then return it.
+	if (ARM_AM_getT2SOImmVal(V) != -1)
+		return V;
+
+	// Try masking out a splat value first.
+	if (ARM_AM_getT2SOImmValSplatVal(Imm & 0xff00ff00U) != -1)
+		return Imm & 0xff00ff00U;
+
+	// The other splat is all that's left as an option.
+
+	return Imm & 0x00ff00ffU;
+}
+
+static inline unsigned ARM_AM_getT2SOImmTwoPartSecond(unsigned Imm)
+{
+	// Mask out the first hunk
+	Imm ^= ARM_AM_getT2SOImmTwoPartFirst(Imm);
+	// Return what's left
+
+	return Imm;
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #2
+//===--------------------------------------------------------------------===//
+//
+// This is used for most simple load/store instructions.
+//
+// addrmode2 := reg +/- reg shop imm
+// addrmode2 := reg +/- imm12
+//
+// The first operand is always a Reg.  The second operand is a reg if in
+// reg/reg form, otherwise it's reg#0.  The third field encodes the operation
+// in bit 12, the immediate in bits 0-11, and the shift op in 13-15. The
+// fourth operand 16-17 encodes the index mode.
+//
+// If this addressing mode is a frame index (before prolog/epilog insertion
+// and code rewriting), this operand will have the form:  FI#, reg0, <offs>
+// with no shift amount for the frame offset.
+//
+static inline unsigned ARM_AM_getAM2Opc(ARM_AM_AddrOpc Opc, unsigned Imm12,
+					ARM_AM_ShiftOpc SO, unsigned IdxMode)
+{
+	bool isSub = Opc == ARM_AM_sub;
+	return Imm12 | ((int)isSub << 12) | (SO << 13) | (IdxMode << 16);
+}
+
+static inline unsigned ARM_AM_getAM2Offset(unsigned AM2Opc)
+{
+	return AM2Opc & ((1 << 12) - 1);
+}
+
+static inline ARM_AM_AddrOpc ARM_AM_getAM2Op(unsigned AM2Opc)
+{
+	return ((AM2Opc >> 12) & 1) ? ARM_AM_sub : ARM_AM_add;
+}
+
+static inline ARM_AM_ShiftOpc ARM_AM_getAM2ShiftOpc(unsigned AM2Opc)
+{
+	return (ARM_AM_ShiftOpc)((AM2Opc >> 13) & 7);
+}
+
+static inline unsigned ARM_AM_getAM2IdxMode(unsigned AM2Opc)
+{
+	return (AM2Opc >> 16);
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #3
+//===--------------------------------------------------------------------===//
+//
+// This is used for sign-extending loads, and load/store-pair instructions.
+//
+// addrmode3 := reg +/- reg
+// addrmode3 := reg +/- imm8
+//
+// The first operand is always a Reg.  The second operand is a reg if in
+// reg/reg form, otherwise it's reg#0.  The third field encodes the operation
+// in bit 8, the immediate in bits 0-7. The fourth operand 9-10 encodes the
+// index mode.
+/// getAM3Opc - This function encodes the addrmode3 opc field.
+static inline unsigned ARM_AM_getAM3Opc(ARM_AM_AddrOpc Opc,
+					unsigned char Offset, unsigned IdxMode)
+{
+	bool isSub = Opc == ARM_AM_sub;
+	return ((int)isSub << 8) | Offset | (IdxMode << 9);
+}
+
+static inline unsigned char ARM_AM_getAM3Offset(unsigned AM3Opc)
+{
+	return AM3Opc & 0xFF;
+}
+
+static inline ARM_AM_AddrOpc ARM_AM_getAM3Op(unsigned AM3Opc)
+{
+	return ((AM3Opc >> 8) & 1) ? ARM_AM_sub : ARM_AM_add;
+}
+
+static inline unsigned ARM_AM_getAM3IdxMode(unsigned AM3Opc)
+{
+	return (AM3Opc >> 9);
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #4
+//===--------------------------------------------------------------------===//
+//
+// This is used for load / store multiple instructions.
+//
+// addrmode4 := reg, <mode>
+//
+// The four modes are:
+//    IA - Increment after
+//    IB - Increment before
+//    DA - Decrement after
+//    DB - Decrement before
+// For VFP instructions, only the IA and DB modes are valid.
+static inline ARM_AM_SubMode ARM_AM_getAM4SubMode(unsigned Mode)
+{
+	return (ARM_AM_SubMode)(Mode & 0x7);
+}
+
+static inline unsigned ARM_AM_getAM4ModeImm(ARM_AM_SubMode SubMode)
+{
+	return (int)SubMode;
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #5
+//===--------------------------------------------------------------------===//
+//
+// This is used for coprocessor instructions, such as FP load/stores.
+//
+// addrmode5 := reg +/- imm8*4
+//
+// The first operand is always a Reg.  The second operand encodes the
+// operation (add or subtract) in bit 8 and the immediate in bits 0-7.
+/// getAM5Opc - This function encodes the addrmode5 opc field.
+static inline unsigned ARM_AM_getAM5Opc(ARM_AM_AddrOpc Opc,
+					unsigned char Offset)
+{
+	bool isSub = Opc == ARM_AM_sub;
+	return ((int)isSub << 8) | Offset;
+}
+
+static inline unsigned char ARM_AM_getAM5Offset(unsigned AM5Opc)
+{
+	return AM5Opc & 0xFF;
+}
+
+static inline ARM_AM_AddrOpc ARM_AM_getAM5Op(unsigned AM5Opc)
+{
+	return ((AM5Opc >> 8) & 1) ? ARM_AM_sub : ARM_AM_add;
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #5 FP16
+//===--------------------------------------------------------------------===//
+//
+// This is used for coprocessor instructions, such as 16-bit FP load/stores.
+//
+// addrmode5fp16 := reg +/- imm8*2
+//
+// The first operand is always a Reg.  The second operand encodes the
+// operation (add or subtract) in bit 8 and the immediate in bits 0-7.
+/// getAM5FP16Opc - This function encodes the addrmode5fp16 opc field.
+static inline unsigned ARM_AM_getAM5FP16Opc(ARM_AM_AddrOpc Opc,
+					    unsigned char Offset)
+{
+	bool isSub = Opc == ARM_AM_sub;
+	return ((int)isSub << 8) | Offset;
+}
+
+static inline unsigned char ARM_AM_getAM5FP16Offset(unsigned AM5Opc)
+{
+	return AM5Opc & 0xFF;
+}
+
+static inline ARM_AM_AddrOpc ARM_AM_getAM5FP16Op(unsigned AM5Opc)
+{
+	return ((AM5Opc >> 8) & 1) ? ARM_AM_sub : ARM_AM_add;
+}
+
+//===--------------------------------------------------------------------===//
+// Addressing Mode #6
+//===--------------------------------------------------------------------===//
+//
+// This is used for NEON load / store instructions.
+//
+// addrmode6 := reg with optional alignment
+//
+// This is stored in two operands [regaddr, align].  The first is the
+// address register.  The second operand is the value of the alignment
+// specifier in bytes or zero if no explicit alignment.
+// Valid alignments depend on the specific instruction.
+//===--------------------------------------------------------------------===//
+// NEON/MVE Modified Immediates
+//===--------------------------------------------------------------------===//
+//
+// Several NEON and MVE instructions (e.g., VMOV) take a "modified immediate"
+// vector operand, where a small immediate encoded in the instruction
+// specifies a full NEON vector value.  These modified immediates are
+// represented here as encoded integers.  The low 8 bits hold the immediate
+// value; bit 12 holds the "Op" field of the instruction, and bits 11-8 hold
+// the "Cmode" field of the instruction.  The interfaces below treat the
+// Op and Cmode values as a single 5-bit value.
+static inline unsigned ARM_AM_createVMOVModImm(unsigned OpCmode, unsigned Val)
+{
+	return (OpCmode << 8) | Val;
+}
+
+static inline unsigned ARM_AM_getVMOVModImmOpCmode(unsigned ModImm)
+{
+	return (ModImm >> 8) & 0x1f;
+}
+
+static inline unsigned ARM_AM_getVMOVModImmVal(unsigned ModImm)
+{
+	return ModImm & 0xff;
+}
+
+/// decodeVMOVModImm - Decode a NEON/MVE modified immediate value into the
+/// element value and the element size in bits.  (If the element size is
+/// smaller than the vector, it is splatted into all the elements.)
+static inline uint64_t ARM_AM_decodeVMOVModImm(unsigned ModImm,
+					       unsigned *EltBits)
+{
+	unsigned OpCmode = ARM_AM_getVMOVModImmOpCmode(ModImm);
+	unsigned Imm8 = ARM_AM_getVMOVModImmVal(ModImm);
+	uint64_t Val = 0;
+
+	if (OpCmode == 0xe) {
+		// 8-bit vector elements
+		Val = Imm8;
+		*EltBits = 8;
+	} else if ((OpCmode & 0xc) == 0x8) {
+		// 16-bit vector elements
+		unsigned ByteNum = (OpCmode & 0x6) >> 1;
+		Val = Imm8 << (8 * ByteNum);
+		*EltBits = 16;
+	} else if ((OpCmode & 0x8) == 0) {
+		// 32-bit vector elements, zero with one byte set
+		unsigned ByteNum = (OpCmode & 0x6) >> 1;
+		Val = Imm8 << (8 * ByteNum);
+		*EltBits = 32;
+	} else if ((OpCmode & 0xe) == 0xc) {
+		// 32-bit vector elements, one byte with low bits set
+		unsigned ByteNum = 1 + (OpCmode & 0x1);
+		Val = (Imm8 << (8 * ByteNum)) | (0xffff >> (8 * (2 - ByteNum)));
+		*EltBits = 32;
+	} else if (OpCmode == 0x1e) {
+		// 64-bit vector elements
+		for (unsigned ByteNum = 0; ByteNum < 8; ++ByteNum) {
+			if ((ModImm >> ByteNum) & 1)
+				Val |= (uint64_t)0xff << (8 * ByteNum);
+		}
+		*EltBits = 64;
+	} else {
+		assert(0 && "Unsupported VMOV immediate");
+	}
+	return Val;
+}
+
+// Generic validation for single-byte immediate (0X00, 00X0, etc).
+static inline bool ARM_AM_isNEONBytesplat(unsigned Value, unsigned Size)
+{
+	unsigned count = 0;
+	for (unsigned i = 0; i < Size; ++i) {
+		if (Value & 0xff)
+			count++;
+		Value >>= 8;
+	}
+	return count == 1;
+}
+
+/// Checks if Value is a correct immediate for instructions like VBIC/VORR.
+static inline bool ARM_AM_isNEONi16splat(unsigned Value)
+{
+	if (Value > 0xffff)
+		return false;
+	// i16 value with set bits only in one byte X0 or 0X.
+	return Value == 0 || ARM_AM_isNEONBytesplat(Value, 2);
+}
+
+// Encode NEON 16 bits Splat immediate for instructions like VBIC/VORR
+static inline unsigned ARM_AM_encodeNEONi16splat(unsigned Value)
+{
+	if (Value >= 0x100)
+		Value = (Value >> 8) | 0xa00;
+	else
+		Value |= 0x800;
+	return Value;
+}
+
+/// Checks if Value is a correct immediate for instructions like VBIC/VORR.
+static inline bool ARM_AM_isNEONi32splat(unsigned Value)
+{
+	// i32 value with set bits only in one byte X000, 0X00, 00X0, or 000X.
+	return Value == 0 || ARM_AM_isNEONBytesplat(Value, 4);
+}
+
+/// Encode NEON 32 bits Splat immediate for instructions like VBIC/VORR.
+static inline unsigned ARM_AM_encodeNEONi32splat(unsigned Value)
+{
+	if (Value >= 0x100 && Value <= 0xff00)
+		Value = (Value >> 8) | 0x200;
+	else if (Value > 0xffff && Value <= 0xff0000)
+		Value = (Value >> 16) | 0x400;
+	else if (Value > 0xffffff)
+		Value = (Value >> 24) | 0x600;
+	return Value;
+}
+
+//===--------------------------------------------------------------------===//
+// Floating-point Immediates
+//
+static inline float ARM_AM_getFPImmFloat(unsigned Imm)
+{
+	// We expect an 8-bit binary encoding of a floating-point number here.
+
+	uint8_t Sign = (Imm >> 7) & 0x1;
+	uint8_t Exp = (Imm >> 4) & 0x7;
+	uint8_t Mantissa = Imm & 0xf;
+
+	//   8-bit FP    IEEE Float Encoding
+	//   abcd efgh   aBbbbbbc defgh000 00000000 00000000
+	//
+	// where B = NOT(b);
+	uint32_t I = 0;
+	I |= Sign << 31;
+	I |= ((Exp & 0x4) != 0 ? 0 : 1) << 30;
+	I |= ((Exp & 0x4) != 0 ? 0x1f : 0) << 25;
+	I |= (Exp & 0x3) << 23;
+	I |= Mantissa << 19;
+	return BitsToFloat(I);
+}
+
+#endif // CS_ARM_ADDRESSINGMODES_H

thirdparty/capstone/arch/ARM/ARMBaseInfo.c

@@ -0,0 +1,101 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically translated source file from LLVM. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Only small edits allowed. */
+/* For multiple similar edits, please create a Patch for the translator. */
+
+/* Capstone's C++ file translator: */
+/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */
+
+//===-- ARMBaseInfo.cpp - ARM Base encoding information------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides basic encoding and assembly information for ARM.
+//
+//===----------------------------------------------------------------------===//
+#include <capstone/platform.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ARMBaseInfo.h"
+#include "ARMMapping.h"
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+const char *get_pred_mask(ARM_PredBlockMask pred_mask)
+{
+	switch (pred_mask) {
+	default:
+		assert(0 && "pred_mask not handled.");
+	case ARM_T:
+		return "T";
+	case ARM_TT:
+		return "TT";
+	case ARM_TE:
+		return "TE";
+	case ARM_TTT:
+		return "TTT";
+	case ARM_TTE:
+		return "TTE";
+	case ARM_TEE:
+		return "TEE";
+	case ARM_TET:
+		return "TET";
+	case ARM_TTTT:
+		return "TTTT";
+	case ARM_TTTE:
+		return "TTTE";
+	case ARM_TTEE:
+		return "TTEE";
+	case ARM_TTET:
+		return "TTET";
+	case ARM_TEEE:
+		return "TEEE";
+	case ARM_TEET:
+		return "TEET";
+	case ARM_TETT:
+		return "TETT";
+	case ARM_TETE:
+		return "TETE";
+	}
+}
+
+#define GET_MCLASSSYSREG_IMPL
+#include "ARMGenSystemRegister.inc"
+
+// lookup system register using 12-bit SYSm value.
+// Note: the search is uniqued using M1 mask
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegBy12bitSYSmValue(unsigned SYSm)
+{
+	return ARMSysReg_lookupMClassSysRegByM1Encoding12(SYSm);
+}
+
+// returns APSR with _<bits> qualifier.
+// Note: ARMv7-M deprecates using MSR APSR without a _<bits> qualifier
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegAPSRNonDeprecated(unsigned SYSm)
+{
+	return ARMSysReg_lookupMClassSysRegByM2M3Encoding8((1 << 9) |
+							   (SYSm & 0xFF));
+}
+
+// lookup system registers using 8-bit SYSm value
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegBy8bitSYSmValue(unsigned SYSm)
+{
+	return ARMSysReg_lookupMClassSysRegByM2M3Encoding8((1 << 8) |
+							   (SYSm & 0xFF));
+}

thirdparty/capstone/arch/ARM/ARMBaseInfo.h

@@ -0,0 +1,573 @@
+//===-- ARMBaseInfo.h - Top level definitions for ARM ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains small standalone helper functions and enum definitions for
+// the ARM target useful for the compiler back-end and the MC libraries.
+// As such, it deliberately does not include references to LLVM core
+// code gen types, passes, etc..
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CS_ARM_BASEINFO_H
+#define CS_ARM_BASEINFO_H
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../MCInstPrinter.h"
+#include "capstone/arm.h"
+
+#define GET_INSTRINFO_ENUM
+#include "ARMGenInstrInfo.inc"
+
+// System Registers
+typedef struct MClassSysReg {
+	const char *Name;
+	arm_sysop_reg sysreg;
+	uint16_t M1Encoding12;
+	uint16_t M2M3Encoding8;
+	uint16_t Encoding;
+	int FeaturesRequired[2];
+} ARMSysReg_MClassSysReg;
+
+// return true if FeaturesRequired are all present in ActiveFeatures
+static inline bool hasRequiredFeatures(const ARMSysReg_MClassSysReg *TheReg,
+				       int ActiveFeatures)
+{
+	return (TheReg->FeaturesRequired[0] == ActiveFeatures ||
+		TheReg->FeaturesRequired[1] == ActiveFeatures);
+}
+
+// returns true if TestFeatures are all present in FeaturesRequired
+static inline bool
+MClassSysReg_isInRequiredFeatures(const ARMSysReg_MClassSysReg *TheReg,
+				  int TestFeatures)
+{
+	return (TheReg->FeaturesRequired[0] == TestFeatures ||
+		TheReg->FeaturesRequired[1] == TestFeatures);
+}
+
+#define GET_SUBTARGETINFO_ENUM
+#include "ARMGenSubtargetInfo.inc"
+
+// lookup system register using 12-bit SYSm value.
+// Note: the search is uniqued using M1 mask
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegBy12bitSYSmValue(unsigned SYSm);
+// returns APSR with _<bits> qualifier.
+// Note: ARMv7-M deprecates using MSR APSR without a _<bits> qualifier
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegAPSRNonDeprecated(unsigned SYSm);
+// lookup system registers using 8-bit SYSm value
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegBy8bitSYSmValue(unsigned SYSm);
+// end namespace ARMSysReg
+
+// Banked Registers
+typedef struct BankedReg {
+	const char *Name;
+	arm_sysop_reg sysreg;
+	uint16_t Encoding;
+} ARMBankedReg_BankedReg;
+
+#define GET_BANKEDREG_DECL
+#define GET_MCLASSSYSREG_DECL
+#include "ARMGenSystemRegister.inc"
+
+typedef enum IMod { ARM_PROC_IE = 2, ARM_PROC_ID = 3 } ARM_PROC_IMod;
+
+typedef enum IFlags {
+	ARM_PROC_F = 1,
+	ARM_PROC_I = 2,
+	ARM_PROC_A = 4
+} ARM_PROC_IFlags;
+
+inline static const char *ARM_PROC_IFlagsToString(unsigned val)
+{
+	switch (val) {
+	default:
+		// llvm_unreachable("Unknown iflags operand");
+	case ARM_PROC_F:
+		return "f";
+	case ARM_PROC_I:
+		return "i";
+	case ARM_PROC_A:
+		return "a";
+	}
+}
+
+inline static const char *ARM_PROC_IModToString(unsigned val)
+{
+	switch (val) {
+	default:
+		// llvm_unreachable("Unknown imod operand");
+		assert(0);
+	case ARM_PROC_IE:
+		return "ie";
+	case ARM_PROC_ID:
+		return "id";
+	}
+}
+
+inline static const char *ARM_MB_MemBOptToString(unsigned val, bool HasV8)
+{
+	switch (val) {
+	default:
+		// llvm_unreachable("Unknown memory operation");
+		assert(0);
+	case ARM_MB_SY:
+		return "sy";
+	case ARM_MB_ST:
+		return "st";
+	case ARM_MB_LD:
+		return HasV8 ? "ld" : "#0xd";
+	case ARM_MB_RESERVED_12:
+		return "#0xc";
+	case ARM_MB_ISH:
+		return "ish";
+	case ARM_MB_ISHST:
+		return "ishst";
+	case ARM_MB_ISHLD:
+		return HasV8 ? "ishld" : "#0x9";
+	case ARM_MB_RESERVED_8:
+		return "#0x8";
+	case ARM_MB_NSH:
+		return "nsh";
+	case ARM_MB_NSHST:
+		return "nshst";
+	case ARM_MB_NSHLD:
+		return HasV8 ? "nshld" : "#0x5";
+	case ARM_MB_RESERVED_4:
+		return "#0x4";
+	case ARM_MB_OSH:
+		return "osh";
+	case ARM_MB_OSHST:
+		return "oshst";
+	case ARM_MB_OSHLD:
+		return HasV8 ? "oshld" : "#0x1";
+	case ARM_MB_RESERVED_0:
+		return "#0x0";
+	}
+}
+
+typedef enum TraceSyncBOpt { ARM_TSB_CSYNC = 0 } ARM_TSB_TraceSyncBOpt;
+
+inline static const char *ARM_TSB_TraceSyncBOptToString(unsigned val)
+{
+	switch (val) {
+	default:
+		// llvm_unreachable("Unknown trace synchronization barrier operation");
+		assert(0);
+	case ARM_TSB_CSYNC:
+		return "csync";
+	}
+}
+
+typedef enum InstSyncBOpt {
+	ARM_ISB_RESERVED_0 = 0,
+	ARM_ISB_RESERVED_1 = 1,
+	ARM_ISB_RESERVED_2 = 2,
+	ARM_ISB_RESERVED_3 = 3,
+	ARM_ISB_RESERVED_4 = 4,
+	ARM_ISB_RESERVED_5 = 5,
+	ARM_ISB_RESERVED_6 = 6,
+	ARM_ISB_RESERVED_7 = 7,
+	ARM_ISB_RESERVED_8 = 8,
+	ARM_ISB_RESERVED_9 = 9,
+	ARM_ISB_RESERVED_10 = 10,
+	ARM_ISB_RESERVED_11 = 11,
+	ARM_ISB_RESERVED_12 = 12,
+	ARM_ISB_RESERVED_13 = 13,
+	ARM_ISB_RESERVED_14 = 14,
+	ARM_ISB_SY = 15
+} ARM_ISB_InstSyncBOpt;
+
+inline static const char *ARM_ISB_InstSyncBOptToString(unsigned val)
+{
+	switch (val) {
+	default:
+		// llvm_unreachable("Unknown memory operation");
+		assert(0);
+	case ARM_ISB_RESERVED_0:
+		return "#0x0";
+	case ARM_ISB_RESERVED_1:
+		return "#0x1";
+	case ARM_ISB_RESERVED_2:
+		return "#0x2";
+	case ARM_ISB_RESERVED_3:
+		return "#0x3";
+	case ARM_ISB_RESERVED_4:
+		return "#0x4";
+	case ARM_ISB_RESERVED_5:
+		return "#0x5";
+	case ARM_ISB_RESERVED_6:
+		return "#0x6";
+	case ARM_ISB_RESERVED_7:
+		return "#0x7";
+	case ARM_ISB_RESERVED_8:
+		return "#0x8";
+	case ARM_ISB_RESERVED_9:
+		return "#0x9";
+	case ARM_ISB_RESERVED_10:
+		return "#0xa";
+	case ARM_ISB_RESERVED_11:
+		return "#0xb";
+	case ARM_ISB_RESERVED_12:
+		return "#0xc";
+	case ARM_ISB_RESERVED_13:
+		return "#0xd";
+	case ARM_ISB_RESERVED_14:
+		return "#0xe";
+	case ARM_ISB_SY:
+		return "sy";
+	}
+}
+
+#define GET_REGINFO_ENUM
+#include "ARMGenRegisterInfo.inc"
+
+/// isARMLowRegister - Returns true if the register is a low register (r0-r7).
+///
+static inline bool isARMLowRegister(unsigned Reg)
+{
+	switch (Reg) {
+	case ARM_R0:
+	case ARM_R1:
+	case ARM_R2:
+	case ARM_R3:
+	case ARM_R4:
+	case ARM_R5:
+	case ARM_R6:
+	case ARM_R7:
+		return true;
+	default:
+		return false;
+	}
+}
+
+/// ARMII - This namespace holds all of the target specific flags that
+/// instruction info tracks.
+///
+/// ARM Index Modes
+typedef enum IndexMode {
+	ARMII_IndexModeNone = 0,
+	ARMII_IndexModePre = 1,
+	ARMII_IndexModePost = 2,
+	ARMII_IndexModeUpd = 3
+} ARMII_IndexMode;
+
+/// ARM Addressing Modes
+typedef enum AddrMode {
+	ARMII_AddrModeNone = 0,
+	ARMII_AddrMode1 = 1,
+	ARMII_AddrMode2 = 2,
+	ARMII_AddrMode3 = 3,
+	ARMII_AddrMode4 = 4,
+	ARMII_AddrMode5 = 5,
+	ARMII_AddrMode6 = 6,
+	ARMII_AddrModeT1_1 = 7,
+	ARMII_AddrModeT1_2 = 8,
+	ARMII_AddrModeT1_4 = 9,
+	ARMII_AddrModeT1_s = 10,     // i8 * 4 for pc and sp relative data
+	ARMII_AddrModeT2_i12 = 11,
+	ARMII_AddrModeT2_i8 = 12,    // +/- i8
+	ARMII_AddrModeT2_i8pos = 13, // + i8
+	ARMII_AddrModeT2_i8neg = 14, // - i8
+	ARMII_AddrModeT2_so = 15,
+	ARMII_AddrModeT2_pc = 16,    // +/- i12 for pc relative data
+	ARMII_AddrModeT2_i8s4 = 17,  // i8 * 4
+	ARMII_AddrMode_i12 = 18,
+	ARMII_AddrMode5FP16 = 19,    // i8 * 2
+	ARMII_AddrModeT2_ldrex = 20, // i8 * 4, with unscaled offset in MCInst
+	ARMII_AddrModeT2_i7s4 = 21,  // i7 * 4
+	ARMII_AddrModeT2_i7s2 = 22,  // i7 * 2
+	ARMII_AddrModeT2_i7 = 23,    // i7 * 1
+} ARMII_AddrMode;
+
+inline static const char *ARMII_AddrModeToString(ARMII_AddrMode addrmode)
+{
+	switch (addrmode) {
+	case ARMII_AddrModeNone:
+		return "AddrModeNone";
+	case ARMII_AddrMode1:
+		return "AddrMode1";
+	case ARMII_AddrMode2:
+		return "AddrMode2";
+	case ARMII_AddrMode3:
+		return "AddrMode3";
+	case ARMII_AddrMode4:
+		return "AddrMode4";
+	case ARMII_AddrMode5:
+		return "AddrMode5";
+	case ARMII_AddrMode5FP16:
+		return "AddrMode5FP16";
+	case ARMII_AddrMode6:
+		return "AddrMode6";
+	case ARMII_AddrModeT1_1:
+		return "AddrModeT1_1";
+	case ARMII_AddrModeT1_2:
+		return "AddrModeT1_2";
+	case ARMII_AddrModeT1_4:
+		return "AddrModeT1_4";
+	case ARMII_AddrModeT1_s:
+		return "AddrModeT1_s";
+	case ARMII_AddrModeT2_i12:
+		return "AddrModeT2_i12";
+	case ARMII_AddrModeT2_i8:
+		return "AddrModeT2_i8";
+	case ARMII_AddrModeT2_i8pos:
+		return "AddrModeT2_i8pos";
+	case ARMII_AddrModeT2_i8neg:
+		return "AddrModeT2_i8neg";
+	case ARMII_AddrModeT2_so:
+		return "AddrModeT2_so";
+	case ARMII_AddrModeT2_pc:
+		return "AddrModeT2_pc";
+	case ARMII_AddrModeT2_i8s4:
+		return "AddrModeT2_i8s4";
+	case ARMII_AddrMode_i12:
+		return "AddrMode_i12";
+	case ARMII_AddrModeT2_ldrex:
+		return "AddrModeT2_ldrex";
+	case ARMII_AddrModeT2_i7s4:
+		return "AddrModeT2_i7s4";
+	case ARMII_AddrModeT2_i7s2:
+		return "AddrModeT2_i7s2";
+	case ARMII_AddrModeT2_i7:
+		return "AddrModeT2_i7";
+	}
+}
+
+/// Target Operand Flag enum.
+typedef enum TOF {
+	//===------------------------------------------------------------------===//
+	// ARM Specific MachineOperand flags.
+
+	ARMII_MO_NO_FLAG = 0,
+
+	/// MO_LO16 - On a symbol operand, this represents a relocation containing
+	/// lower 16 bit of the address. Used only via movw instruction.
+	ARMII_MO_LO16 = 0x1,
+
+	/// MO_HI16 - On a symbol operand, this represents a relocation containing
+	/// higher 16 bit of the address. Used only via movt instruction.
+	ARMII_MO_HI16 = 0x2,
+
+	/// MO_OPTION_MASK - Most flags are mutually exclusive; this mask selects
+	/// just that part of the flag set.
+	ARMII_MO_OPTION_MASK = 0x3,
+
+	/// MO_COFFSTUB - On a symbol operand "FOO", this indicates that the
+	/// reference is actually to the ".refptr.FOO" symbol.  This is used for
+	/// stub symbols on windows.
+	ARMII_MO_COFFSTUB = 0x4,
+
+	/// MO_GOT - On a symbol operand, this represents a GOT relative relocation.
+	ARMII_MO_GOT = 0x8,
+
+	/// MO_SBREL - On a symbol operand, this represents a static base relative
+	/// relocation. Used in movw and movt instructions.
+	ARMII_MO_SBREL = 0x10,
+
+	/// MO_DLLIMPORT - On a symbol operand, this represents that the reference
+	/// to the symbol is for an import stub.  This is used for DLL import
+	/// storage class indication on Windows.
+	ARMII_MO_DLLIMPORT = 0x20,
+
+	/// MO_SECREL - On a symbol operand this indicates that the immediate is
+	/// the offset from beginning of section.
+	///
+	/// This is the TLS offset for the COFF/Windows TLS mechanism.
+	ARMII_MO_SECREL = 0x40,
+
+	/// MO_NONLAZY - This is an independent flag, on a symbol operand "FOO" it
+	/// represents a symbol which, if indirect, will get special Darwin mangling
+	/// as a non-lazy-ptr indirect symbol (i.e. "L_FOO$non_lazy_ptr"). Can be
+	/// combined with MO_LO16, MO_HI16 or MO_NO_FLAG (in a constant-pool, for
+	/// example).
+	ARMII_MO_NONLAZY = 0x80,
+
+	// It's undefined behaviour if an enum overflows the range between its
+	// smallest and largest values, but since these are |ed together, it can
+	// happen. Put a sentinel in (values of this enum are stored as "unsigned
+	// char").
+	ARMII_MO_UNUSED_MAXIMUM = 0xff
+} ARMII_TOF;
+
+enum {
+	//===------------------------------------------------------------------===//
+	// Instruction Flags.
+
+	//===------------------------------------------------------------------===//
+	// This four-bit field describes the addressing mode used.
+	ARMII_AddrModeMask =
+		0x1f, // The AddrMode enums are declared in ARMBaseInfo.h
+
+	// IndexMode - Unindex, pre-indexed, or post-indexed are valid for load
+	// and store ops only.  Generic "updating" flag is used for ld/st multiple.
+	// The index mode enums are declared in ARMBaseInfo.h
+	ARMII_IndexModeShift = 5,
+	ARMII_IndexModeMask = 3 << ARMII_IndexModeShift,
+
+	//===------------------------------------------------------------------===//
+	// Instruction encoding formats.
+	//
+	ARMII_FormShift = 7,
+	ARMII_FormMask = 0x3f << ARMII_FormShift,
+
+	// Pseudo instructions
+	ARMII_Pseudo = 0 << ARMII_FormShift,
+
+	// Multiply instructions
+	ARMII_MulFrm = 1 << ARMII_FormShift,
+
+	// Branch instructions
+	ARMII_BrFrm = 2 << ARMII_FormShift,
+	ARMII_BrMiscFrm = 3 << ARMII_FormShift,
+
+	// Data Processing instructions
+	ARMII_DPFrm = 4 << ARMII_FormShift,
+	ARMII_DPSoRegFrm = 5 << ARMII_FormShift,
+
+	// Load and Store
+	ARMII_LdFrm = 6 << ARMII_FormShift,
+	ARMII_StFrm = 7 << ARMII_FormShift,
+	ARMII_LdMiscFrm = 8 << ARMII_FormShift,
+	ARMII_StMiscFrm = 9 << ARMII_FormShift,
+	ARMII_LdStMulFrm = 10 << ARMII_FormShift,
+
+	ARMII_LdStExFrm = 11 << ARMII_FormShift,
+
+	// Miscellaneous arithmetic instructions
+	ARMII_ArithMiscFrm = 12 << ARMII_FormShift,
+	ARMII_SatFrm = 13 << ARMII_FormShift,
+
+	// Extend instructions
+	ARMII_ExtFrm = 14 << ARMII_FormShift,
+
+	// VFP formats
+	ARMII_VFPUnaryFrm = 15 << ARMII_FormShift,
+	ARMII_VFPBinaryFrm = 16 << ARMII_FormShift,
+	ARMII_VFPConv1Frm = 17 << ARMII_FormShift,
+	ARMII_VFPConv2Frm = 18 << ARMII_FormShift,
+	ARMII_VFPConv3Frm = 19 << ARMII_FormShift,
+	ARMII_VFPConv4Frm = 20 << ARMII_FormShift,
+	ARMII_VFPConv5Frm = 21 << ARMII_FormShift,
+	ARMII_VFPLdStFrm = 22 << ARMII_FormShift,
+	ARMII_VFPLdStMulFrm = 23 << ARMII_FormShift,
+	ARMII_VFPMiscFrm = 24 << ARMII_FormShift,
+
+	// Thumb format
+	ARMII_ThumbFrm = 25 << ARMII_FormShift,
+
+	// Miscelleaneous format
+	ARMII_MiscFrm = 26 << ARMII_FormShift,
+
+	// NEON formats
+	ARMII_NGetLnFrm = 27 << ARMII_FormShift,
+	ARMII_NSetLnFrm = 28 << ARMII_FormShift,
+	ARMII_NDupFrm = 29 << ARMII_FormShift,
+	ARMII_NLdStFrm = 30 << ARMII_FormShift,
+	ARMII_N1RegModImmFrm = 31 << ARMII_FormShift,
+	ARMII_N2RegFrm = 32 << ARMII_FormShift,
+	ARMII_NVCVTFrm = 33 << ARMII_FormShift,
+	ARMII_NVDupLnFrm = 34 << ARMII_FormShift,
+	ARMII_N2RegVShLFrm = 35 << ARMII_FormShift,
+	ARMII_N2RegVShRFrm = 36 << ARMII_FormShift,
+	ARMII_N3RegFrm = 37 << ARMII_FormShift,
+	ARMII_N3RegVShFrm = 38 << ARMII_FormShift,
+	ARMII_NVExtFrm = 39 << ARMII_FormShift,
+	ARMII_NVMulSLFrm = 40 << ARMII_FormShift,
+	ARMII_NVTBLFrm = 41 << ARMII_FormShift,
+	ARMII_N3RegCplxFrm = 43 << ARMII_FormShift,
+
+	//===------------------------------------------------------------------===//
+	// Misc flags.
+
+	// UnaryDP - Indicates this is a unary data processing instruction, i.e.
+	// it doesn't have a Rn operand.
+	ARMII_UnaryDP = 1 << 13,
+
+	// Xform16Bit - Indicates this Thumb2 instruction may be transformed into
+	// a 16-bit Thumb instruction if certain conditions are met.
+	ARMII_Xform16Bit = 1 << 14,
+
+	// ThumbArithFlagSetting - The instruction is a 16-bit flag setting Thumb
+	// instruction. Used by the parser to determine whether to require the 'S'
+	// suffix on the mnemonic (when not in an IT block) or preclude it (when
+	// in an IT block).
+	ARMII_ThumbArithFlagSetting = 1 << 19,
+
+	// Whether an instruction can be included in an MVE tail-predicated loop,
+	// though extra validity checks may need to be performed too.
+	ARMII_ValidForTailPredication = 1 << 20,
+
+	// Whether an instruction writes to the top/bottom half of a vector element
+	// and leaves the other half untouched.
+	ARMII_RetainsPreviousHalfElement = 1 << 21,
+
+	// Whether the instruction produces a scalar result from vector operands.
+	ARMII_HorizontalReduction = 1 << 22,
+
+	// Whether this instruction produces a vector result that is larger than
+	// its input, typically reading from the top/bottom halves of the input(s).
+	ARMII_DoubleWidthResult = 1 << 23,
+
+	// The vector element size for MVE instructions. 00 = i8, 01 = i16, 10 = i32
+	// and 11 = i64. This is the largest type if multiple are present, so a
+	// MVE_VMOVLs8bh is ize 01=i16, as it extends from a i8 to a i16. There are
+	// some caveats so cannot be used blindly, such as exchanging VMLADAVA's and
+	// complex instructions, which may use different input lanes.
+	ARMII_VecSizeShift = 24,
+	ARMII_VecSize = 3 << ARMII_VecSizeShift,
+
+	//===------------------------------------------------------------------===//
+	// Code domain.
+	ARMII_DomainShift = 15,
+	ARMII_DomainMask = 15 << ARMII_DomainShift,
+	ARMII_DomainGeneral = 0 << ARMII_DomainShift,
+	ARMII_DomainVFP = 1 << ARMII_DomainShift,
+	ARMII_DomainNEON = 2 << ARMII_DomainShift,
+	ARMII_DomainNEONA8 = 4 << ARMII_DomainShift,
+	ARMII_DomainMVE = 8 << ARMII_DomainShift,
+
+	//===------------------------------------------------------------------===//
+	// Field shifts - such shifts are used to set field while generating
+	// machine instructions.
+	//
+	// FIXME: This list will need adjusting/fixing as the MC code emitter
+	// takes shape and the ARMCodeEmitter.cpp bits go away.
+	ARMII_ShiftTypeShift = 4,
+
+	ARMII_M_BitShift = 5,
+	ARMII_ShiftImmShift = 5,
+	ARMII_ShiftShift = 7,
+	ARMII_N_BitShift = 7,
+	ARMII_ImmHiShift = 8,
+	ARMII_SoRotImmShift = 8,
+	ARMII_RegRsShift = 8,
+	ARMII_ExtRotImmShift = 10,
+	ARMII_RegRdLoShift = 12,
+	ARMII_RegRdShift = 12,
+	ARMII_RegRdHiShift = 16,
+	ARMII_RegRnShift = 16,
+	ARMII_S_BitShift = 20,
+	ARMII_W_BitShift = 21,
+	ARMII_AM3_I_BitShift = 22,
+	ARMII_D_BitShift = 22,
+	ARMII_U_BitShift = 23,
+	ARMII_P_BitShift = 24,
+	ARMII_I_BitShift = 25,
+	ARMII_CondShift = 28
+};
+
+const char *get_pred_mask(ARM_PredBlockMask pred_mask);
+
+#endif // CS_ARM_BASEINFO_H

thirdparty/capstone/arch/ARM/ARMDisassemblerExtension.c

@@ -0,0 +1,238 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+/*    Rot127 <unisono@quyllur.org>, 2022-2023 */
+
+#include "ARMDisassemblerExtension.h"
+#include "ARMBaseInfo.h"
+
+bool ITBlock_push_back(ARM_ITBlock *it, char v)
+{
+	if (it->size >= sizeof(it->ITStates)) {
+		// TODO: consider warning user.
+		it->size = 0;
+	}
+	it->ITStates[it->size] = v;
+	it->size++;
+
+	return true;
+}
+
+// Returns true if the current instruction is in an IT block
+bool ITBlock_instrInITBlock(ARM_ITBlock *it)
+{
+	return (it->size > 0);
+}
+
+// Returns true if current instruction is the last instruction in an IT block
+bool ITBlock_instrLastInITBlock(ARM_ITBlock *it)
+{
+	return (it->size == 1);
+}
+
+// Returns the condition code for instruction in IT block
+unsigned ITBlock_getITCC(ARM_ITBlock *it)
+{
+	unsigned CC = ARMCC_AL;
+
+	if (ITBlock_instrInITBlock(it))
+		CC = it->ITStates[it->size - 1];
+
+	return CC;
+}
+
+// Advances the IT block state to the next T or E
+void ITBlock_advanceITState(ARM_ITBlock *it)
+{
+	it->size--;
+}
+
+// Called when decoding an IT instruction. Sets the IT state for the following
+// instructions that for the IT block. Firstcond and Mask correspond to the
+// fields in the IT instruction encoding.
+void ITBlock_setITState(ARM_ITBlock *it, char Firstcond, char Mask)
+{
+	// (3 - the number of trailing zeros) is the number of then / else.
+	unsigned NumTZ = CountTrailingZeros_8(Mask);
+	unsigned char CCBits = (unsigned char)(Firstcond & 0xf);
+	assert(NumTZ <= 3 && "Invalid IT mask!");
+	// push condition codes onto the stack the correct order for the pops
+	for (unsigned Pos = NumTZ + 1; Pos <= 3; ++Pos) {
+		unsigned Else = (Mask >> Pos) & 1;
+		ITBlock_push_back(it, CCBits ^ Else);
+	}
+	ITBlock_push_back(it, CCBits);
+}
+
+bool VPTBlock_push_back(ARM_VPTBlock *it, char v)
+{
+	if (it->size >= sizeof(it->VPTStates)) {
+		// TODO: consider warning user.
+		it->size = 0;
+	}
+	it->VPTStates[it->size] = v;
+	it->size++;
+
+	return true;
+}
+
+bool VPTBlock_instrInVPTBlock(ARM_VPTBlock *VPT)
+{
+	return VPT->size > 0;
+}
+
+unsigned VPTBlock_getVPTPred(ARM_VPTBlock *VPT)
+{
+	unsigned Pred = ARMVCC_None;
+	if (VPTBlock_instrInVPTBlock(VPT))
+		Pred = VPT->VPTStates[VPT->size - 1];
+	return Pred;
+}
+
+void VPTBlock_advanceVPTState(ARM_VPTBlock *VPT)
+{
+	VPT->size--;
+}
+
+void VPTBlock_setVPTState(ARM_VPTBlock *VPT, char Mask)
+{
+	// (3 - the number of trailing zeros) is the number of then / else.
+	unsigned NumTZ = CountTrailingZeros_8(Mask);
+	assert(NumTZ <= 3 && "Invalid VPT mask!");
+	// push predicates onto the stack the correct order for the pops
+	for (unsigned Pos = NumTZ + 1; Pos <= 3; ++Pos) {
+		bool T = ((Mask >> Pos) & 1) == 0;
+		if (T)
+			VPTBlock_push_back(VPT, ARMVCC_Then);
+		else
+			VPTBlock_push_back(VPT, ARMVCC_Else);
+	}
+	VPTBlock_push_back(VPT, ARMVCC_Then);
+}
+
+/// ThumbDisassembler - Thumb disassembler for all Thumb platforms.
+
+bool Check(DecodeStatus *Out, DecodeStatus In)
+{
+	switch (In) {
+	case MCDisassembler_Success:
+		// Out stays the same.
+		return true;
+	case MCDisassembler_SoftFail:
+		*Out = In;
+		return true;
+	case MCDisassembler_Fail:
+		*Out = In;
+		return false;
+	default: // never reached
+		return false;
+	}
+}
+
+// Imported from ARMBaseInstrInfo.h
+//
+/// isValidCoprocessorNumber - decide whether an explicit coprocessor
+/// number is legal in generic instructions like CDP. The answer can
+/// vary with the subtarget.
+bool isValidCoprocessorNumber(MCInst *Inst, unsigned Num)
+{
+	// In Armv7 and Armv8-M CP10 and CP11 clash with VFP/NEON, however, the
+	// coprocessor is still valid for CDP/MCR/MRC and friends. Allowing it is
+	// useful for code which is shared with older architectures which do not
+	// know the new VFP/NEON mnemonics.
+
+	// Armv8-A disallows everything *other* than 111x (CP14 and CP15).
+	if (ARM_getFeatureBits(Inst->csh->mode, ARM_HasV8Ops) &&
+	    (Num & 0xE) != 0xE)
+		return false;
+
+	// Armv8.1-M disallows 100x (CP8,CP9) and 111x (CP14,CP15)
+	// which clash with MVE.
+	if (ARM_getFeatureBits(Inst->csh->mode, ARM_HasV8_1MMainlineOps) &&
+	    ((Num & 0xE) == 0x8 || (Num & 0xE) == 0xE))
+		return false;
+
+	return true;
+}
+
+// Imported from ARMMCTargetDesc.h
+bool ARM_isVpred(arm_op_type op)
+{
+	return op == ARM_OP_VPRED_R || op == ARM_OP_VPRED_N;
+}
+
+// Imported from ARMBaseInstrInfo.h
+//
+// This table shows the VPT instruction variants, i.e. the different
+// mask field encodings, see also B5.6. Predication/conditional execution in
+// the ArmARM.
+bool isVPTOpcode(int Opc)
+{
+	return Opc == ARM_MVE_VPTv16i8 || Opc == ARM_MVE_VPTv16u8 ||
+	       Opc == ARM_MVE_VPTv16s8 || Opc == ARM_MVE_VPTv8i16 ||
+	       Opc == ARM_MVE_VPTv8u16 || Opc == ARM_MVE_VPTv8s16 ||
+	       Opc == ARM_MVE_VPTv4i32 || Opc == ARM_MVE_VPTv4u32 ||
+	       Opc == ARM_MVE_VPTv4s32 || Opc == ARM_MVE_VPTv4f32 ||
+	       Opc == ARM_MVE_VPTv8f16 || Opc == ARM_MVE_VPTv16i8r ||
+	       Opc == ARM_MVE_VPTv16u8r || Opc == ARM_MVE_VPTv16s8r ||
+	       Opc == ARM_MVE_VPTv8i16r || Opc == ARM_MVE_VPTv8u16r ||
+	       Opc == ARM_MVE_VPTv8s16r || Opc == ARM_MVE_VPTv4i32r ||
+	       Opc == ARM_MVE_VPTv4u32r || Opc == ARM_MVE_VPTv4s32r ||
+	       Opc == ARM_MVE_VPTv4f32r || Opc == ARM_MVE_VPTv8f16r ||
+	       Opc == ARM_MVE_VPST;
+}
+
+// Imported from ARMMCTargetDesc.cpp
+bool ARM_isCDECoproc(size_t Coproc, const MCInst *MI)
+{
+	// Unfortunately we don't have ARMTargetInfo in the disassembler, so we have
+	// to rely on feature bits.
+	if (Coproc >= 8)
+		return false;
+
+	return ARM_getFeatureBits(MI->csh->mode,
+				  ARM_FeatureCoprocCDE0 + Coproc);
+}
+
+// Hacky: enable all features for disassembler
+bool ARM_getFeatureBits(unsigned int mode, unsigned int feature)
+{
+	if (feature == ARM_ModeThumb) {
+		if (mode & CS_MODE_THUMB)
+			return true;
+		return false;
+	}
+
+	if (feature == ARM_FeatureDFB)
+		return false;
+
+	if (feature == ARM_FeatureRAS)
+		return false;
+
+	if (feature == ARM_FeatureMClass && (mode & CS_MODE_MCLASS) == 0)
+		return false;
+
+	if ((feature == ARM_HasMVEIntegerOps || feature == ARM_HasMVEFloatOps ||
+	     feature == ARM_FeatureMVEVectorCostFactor1 ||
+	     feature == ARM_FeatureMVEVectorCostFactor2 ||
+	     feature == ARM_FeatureMVEVectorCostFactor4) &&
+	    (mode & CS_MODE_MCLASS) == 0)
+		return false;
+
+	if ((feature == ARM_HasV8Ops || feature == ARM_HasV8_1MMainlineOps ||
+	     feature == ARM_HasV8_1aOps || feature == ARM_HasV8_2aOps ||
+	     feature == ARM_HasV8_3aOps || feature == ARM_HasV8_4aOps ||
+	     feature == ARM_HasV8_5aOps || feature == ARM_HasV8_6aOps ||
+	     feature == ARM_HasV8_7aOps || feature == ARM_HasV8_8aOps ||
+	     feature == ARM_HasV8_9aOps) &&
+	    (mode & CS_MODE_V8) == 0)
+		return false;
+
+	if (feature >= ARM_FeatureCoprocCDE0 &&
+	    feature <= ARM_FeatureCoprocCDE7)
+		// We currently have no way to detect CDE (Custom-Datapath-Extension)
+		// coprocessors.
+		return false;
+
+	// we support everything
+	return true;
+}

thirdparty/capstone/arch/ARM/ARMDisassemblerExtension.h

@@ -0,0 +1,51 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+/*    Rot127 <unisono@quyllur.org>, 2022-2023 */
+
+#ifndef CS_ARM_DISASSEMBLER_EXTENSION_H
+#define CS_ARM_DISASSEMBLER_EXTENSION_H
+
+#include "../../MCDisassembler.h"
+#include "../../MCRegisterInfo.h"
+#include "../../MathExtras.h"
+#include "../../cs_priv.h"
+#include "ARMAddressingModes.h"
+#include "capstone/capstone.h"
+
+unsigned ARM_AM_getAM5FP16Opc(ARM_AM_AddrOpc Opc, unsigned char Offset);
+
+bool ITBlock_push_back(ARM_ITBlock *it, char v);
+
+bool ITBlock_instrInITBlock(ARM_ITBlock *it);
+
+bool ITBlock_instrLastInITBlock(ARM_ITBlock *it);
+
+unsigned ITBlock_getITCC(ARM_ITBlock *it);
+
+void ITBlock_advanceITState(ARM_ITBlock *it);
+
+void ITBlock_setITState(ARM_ITBlock *it, char Firstcond, char Mask);
+
+bool Check(DecodeStatus *Out, DecodeStatus In);
+
+bool isValidCoprocessorNumber(MCInst *Inst, unsigned Num);
+
+bool ARM_isVpred(arm_op_type op);
+
+bool isVPTOpcode(int Opc);
+
+bool ARM_isCDECoproc(size_t Coproc, const MCInst *MI);
+
+bool VPTBlock_push_back(ARM_VPTBlock *it, char v);
+
+bool VPTBlock_instrInVPTBlock(ARM_VPTBlock *VPT);
+
+unsigned VPTBlock_getVPTPred(ARM_VPTBlock *VPT);
+
+void VPTBlock_advanceVPTState(ARM_VPTBlock *VPT);
+
+void VPTBlock_setVPTState(ARM_VPTBlock *VPT, char Mask);
+
+bool ARM_getFeatureBits(unsigned int mode, unsigned int feature);
+
+#endif // CS_ARM_DISASSEMBLER_EXTENSION_H

thirdparty/capstone/arch/ARM/ARMFeatureEnum.inc

@@ -0,0 +1,22 @@
+ARM_FEATURE_IsThumb = 128, ARM_FEATURE_IsARM, ARM_FEATURE_UseNegativeImmediates,
+	ARM_FEATURE_IsThumb2, ARM_FEATURE_HasV8, ARM_FEATURE_HasAES,
+	ARM_FEATURE_HasV8_1MMainline, ARM_FEATURE_HasMVEInt, ARM_FEATURE_HasV7,
+	ARM_FEATURE_IsMClass, ARM_FEATURE_HasPACBTI, ARM_FEATURE_HasV8MBaseline,
+	ARM_FEATURE_HasLOB, ARM_FEATURE_HasV6T2, ARM_FEATURE_HasV5T,
+	ARM_FEATURE_IsNotMClass, ARM_FEATURE_Has8MSecExt, ARM_FEATURE_HasV4T,
+	ARM_FEATURE_PreV8, ARM_FEATURE_HasCLRBHB, ARM_FEATURE_HasV6K,
+	ARM_FEATURE_HasV7Clrex, ARM_FEATURE_HasCRC, ARM_FEATURE_HasCDE,
+	ARM_FEATURE_HasDFB, ARM_FEATURE_HasDB, ARM_FEATURE_HasVirtualization,
+	ARM_FEATURE_HasRAS, ARM_FEATURE_HasVFP2, ARM_FEATURE_HasDPVFP,
+	ARM_FEATURE_HasVFP3, ARM_FEATURE_HasFPRegs, ARM_FEATURE_HasV6M,
+	ARM_FEATURE_HasV6, ARM_FEATURE_HasAcquireRelease, ARM_FEATURE_HasV5TE,
+	ARM_FEATURE_HasDSP, ARM_FEATURE_HasMP, ARM_FEATURE_HasSB,
+	ARM_FEATURE_HasDivideInThumb, ARM_FEATURE_HasDivideInARM,
+	ARM_FEATURE_HasV8_1a, ARM_FEATURE_HasSHA2, ARM_FEATURE_HasTrustZone,
+	ARM_FEATURE_UseNaClTrap, ARM_FEATURE_HasV8_4a, ARM_FEATURE_HasNEON,
+	ARM_FEATURE_HasFullFP16, ARM_FEATURE_HasMVEFloat, ARM_FEATURE_HasV8_3a,
+	ARM_FEATURE_HasFP16, ARM_FEATURE_HasBF16, ARM_FEATURE_HasFPARMv8,
+	ARM_FEATURE_HasVFP4, ARM_FEATURE_HasFP16FML, ARM_FEATURE_HasFPRegs16,
+	ARM_FEATURE_HasV8MMainline, ARM_FEATURE_HasFPRegs64,
+	ARM_FEATURE_HasFPRegsV8_1M, ARM_FEATURE_HasDotProd,
+	ARM_FEATURE_HasMatMulInt8,

thirdparty/capstone/arch/ARM/ARMGenCSAliasMnemMap.inc

@@ -0,0 +1,48 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: <commit> */
+/* LLVM-tag: <tag> */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+	{ ARM_INS_ALIAS_VMOV, "vmov" },
+	{ ARM_INS_ALIAS_NOP, "nop" },
+	{ ARM_INS_ALIAS_YIELD, "yield" },
+	{ ARM_INS_ALIAS_WFE, "wfe" },
+	{ ARM_INS_ALIAS_WFI, "wfi" },
+	{ ARM_INS_ALIAS_SEV, "sev" },
+	{ ARM_INS_ALIAS_SEVL, "sevl" },
+	{ ARM_INS_ALIAS_ESB, "esb" },
+	{ ARM_INS_ALIAS_CSDB, "csdb" },
+	{ ARM_INS_ALIAS_CLRBHB, "clrbhb" },
+	{ ARM_INS_ALIAS_PACBTI, "pacbti" },
+	{ ARM_INS_ALIAS_BTI, "bti" },
+	{ ARM_INS_ALIAS_PAC, "pac" },
+	{ ARM_INS_ALIAS_AUT, "aut" },
+	{ ARM_INS_ALIAS_SSBB, "ssbb" },
+	{ ARM_INS_ALIAS_PSSBB, "pssbb" },
+	{ ARM_INS_ALIAS_DFB, "dfb" },
+	{ ARM_INS_ALIAS_CSETM, "csetm" },
+	{ ARM_INS_ALIAS_CSET, "cset" },
+	{ ARM_INS_ALIAS_CINC, "cinc" },
+	{ ARM_INS_ALIAS_CINV, "cinv" },
+	{ ARM_INS_ALIAS_CNEG, "cneg" },
+	{ ARM_INS_ALIAS_VMLAV, "vmlav" },
+	{ ARM_INS_ALIAS_VMLAVA, "vmlava" },
+	{ ARM_INS_ALIAS_VRMLALVH, "vrmlalvh" },
+	{ ARM_INS_ALIAS_VRMLALVHA, "vrmlalvha" },
+	{ ARM_INS_ALIAS_VMLALV, "vmlalv" },
+	{ ARM_INS_ALIAS_VMLALVA, "vmlalva" },
+	{ ARM_INS_ALIAS_VBIC, "vbic" },
+	{ ARM_INS_ALIAS_VEOR, "veor" },
+	{ ARM_INS_ALIAS_VORN, "vorn" },
+	{ ARM_INS_ALIAS_VORR, "vorr" },
+	{ ARM_INS_ALIAS_VAND, "vand" },
+	{ ARM_INS_ALIAS_VPSEL, "vpsel" },
+	{ ARM_INS_ALIAS_ERET, "eret" },

thirdparty/capstone/arch/ARM/ARMGenCSFeatureName.inc

@@ -0,0 +1,60 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+{ ARM_FEATURE_IsARM, "IsARM" }, { ARM_FEATURE_HasV5T, "HasV5T" },
+	{ ARM_FEATURE_HasV4T, "HasV4T" }, { ARM_FEATURE_HasVFP2, "HasVFP2" },
+	{ ARM_FEATURE_HasV5TE, "HasV5TE" }, { ARM_FEATURE_HasV6T2, "HasV6T2" },
+	{ ARM_FEATURE_HasMVEInt, "HasMVEInt" },
+	{ ARM_FEATURE_HasNEON, "HasNEON" },
+	{ ARM_FEATURE_HasFPRegs64, "HasFPRegs64" },
+	{ ARM_FEATURE_HasFPRegs, "HasFPRegs" },
+	{ ARM_FEATURE_IsThumb2, "IsThumb2" },
+	{ ARM_FEATURE_HasV8_1MMainline, "HasV8_1MMainline" },
+	{ ARM_FEATURE_HasLOB, "HasLOB" }, { ARM_FEATURE_IsThumb, "IsThumb" },
+	{ ARM_FEATURE_HasV8MBaseline, "HasV8MBaseline" },
+	{ ARM_FEATURE_Has8MSecExt, "Has8MSecExt" },
+	{ ARM_FEATURE_HasV8, "HasV8" }, { ARM_FEATURE_HasAES, "HasAES" },
+	{ ARM_FEATURE_HasBF16, "HasBF16" }, { ARM_FEATURE_HasCDE, "HasCDE" },
+	{ ARM_FEATURE_PreV8, "PreV8" }, { ARM_FEATURE_HasV6K, "HasV6K" },
+	{ ARM_FEATURE_HasCRC, "HasCRC" }, { ARM_FEATURE_HasV7, "HasV7" },
+	{ ARM_FEATURE_HasDB, "HasDB" },
+	{ ARM_FEATURE_HasVirtualization, "HasVirtualization" },
+	{ ARM_FEATURE_HasVFP3, "HasVFP3" },
+	{ ARM_FEATURE_HasDPVFP, "HasDPVFP" },
+	{ ARM_FEATURE_HasFullFP16, "HasFullFP16" },
+	{ ARM_FEATURE_HasV6, "HasV6" },
+	{ ARM_FEATURE_HasAcquireRelease, "HasAcquireRelease" },
+	{ ARM_FEATURE_HasV7Clrex, "HasV7Clrex" },
+	{ ARM_FEATURE_HasMVEFloat, "HasMVEFloat" },
+	{ ARM_FEATURE_HasFPRegsV8_1M, "HasFPRegsV8_1M" },
+	{ ARM_FEATURE_HasMP, "HasMP" }, { ARM_FEATURE_HasSB, "HasSB" },
+	{ ARM_FEATURE_HasDivideInARM, "HasDivideInARM" },
+	{ ARM_FEATURE_HasV8_1a, "HasV8_1a" },
+	{ ARM_FEATURE_HasSHA2, "HasSHA2" },
+	{ ARM_FEATURE_HasTrustZone, "HasTrustZone" },
+	{ ARM_FEATURE_UseNaClTrap, "UseNaClTrap" },
+	{ ARM_FEATURE_HasV8_4a, "HasV8_4a" },
+	{ ARM_FEATURE_HasV8_3a, "HasV8_3a" },
+	{ ARM_FEATURE_HasFPARMv8, "HasFPARMv8" },
+	{ ARM_FEATURE_HasFP16, "HasFP16" }, { ARM_FEATURE_HasVFP4, "HasVFP4" },
+	{ ARM_FEATURE_HasFP16FML, "HasFP16FML" },
+	{ ARM_FEATURE_HasFPRegs16, "HasFPRegs16" },
+	{ ARM_FEATURE_HasV8MMainline, "HasV8MMainline" },
+	{ ARM_FEATURE_HasDotProd, "HasDotProd" },
+	{ ARM_FEATURE_HasMatMulInt8, "HasMatMulInt8" },
+	{ ARM_FEATURE_IsMClass, "IsMClass" },
+	{ ARM_FEATURE_HasPACBTI, "HasPACBTI" },
+	{ ARM_FEATURE_IsNotMClass, "IsNotMClass" },
+	{ ARM_FEATURE_HasDSP, "HasDSP" },
+	{ ARM_FEATURE_HasDivideInThumb, "HasDivideInThumb" },
+	{ ARM_FEATURE_HasV6M, "HasV6M" },

thirdparty/capstone/arch/ARM/ARMGenCSMappingInsnName.inc

@@ -0,0 +1,650 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+"invalid",		// ARM_INS_INVALID
+	"asr",		// ARM_INS_ASR
+	"it",		// ARM_INS_IT
+	"ldrbt",	// ARM_INS_LDRBT
+	"ldr",		// ARM_INS_LDR
+	"ldrht",	// ARM_INS_LDRHT
+	"ldrsbt",	// ARM_INS_LDRSBT
+	"ldrsht",	// ARM_INS_LDRSHT
+	"ldrt",		// ARM_INS_LDRT
+	"lsl",		// ARM_INS_LSL
+	"lsr",		// ARM_INS_LSR
+	"ror",		// ARM_INS_ROR
+	"rrx",		// ARM_INS_RRX
+	"strbt",	// ARM_INS_STRBT
+	"strt",		// ARM_INS_STRT
+	"vld1",		// ARM_INS_VLD1
+	"vld2",		// ARM_INS_VLD2
+	"vld3",		// ARM_INS_VLD3
+	"vld4",		// ARM_INS_VLD4
+	"vst1",		// ARM_INS_VST1
+	"vst2",		// ARM_INS_VST2
+	"vst3",		// ARM_INS_VST3
+	"vst4",		// ARM_INS_VST4
+	"ldrb",		// ARM_INS_LDRB
+	"ldrh",		// ARM_INS_LDRH
+	"ldrsb",	// ARM_INS_LDRSB
+	"ldrsh",	// ARM_INS_LDRSH
+	"movs",		// ARM_INS_MOVS
+	"mov",		// ARM_INS_MOV
+	"str",		// ARM_INS_STR
+	"adc",		// ARM_INS_ADC
+	"add",		// ARM_INS_ADD
+	"adr",		// ARM_INS_ADR
+	"aesd",		// ARM_INS_AESD
+	"aese",		// ARM_INS_AESE
+	"aesimc",	// ARM_INS_AESIMC
+	"aesmc",	// ARM_INS_AESMC
+	"and",		// ARM_INS_AND
+	"vdot",		// ARM_INS_VDOT
+	"vcvt",		// ARM_INS_VCVT
+	"vcvtb",	// ARM_INS_VCVTB
+	"vcvtt",	// ARM_INS_VCVTT
+	"bfc",		// ARM_INS_BFC
+	"bfi",		// ARM_INS_BFI
+	"bic",		// ARM_INS_BIC
+	"bkpt",		// ARM_INS_BKPT
+	"bl",		// ARM_INS_BL
+	"blx",		// ARM_INS_BLX
+	"bx",		// ARM_INS_BX
+	"bxj",		// ARM_INS_BXJ
+	"b",		// ARM_INS_B
+	"cx1",		// ARM_INS_CX1
+	"cx1a",		// ARM_INS_CX1A
+	"cx1d",		// ARM_INS_CX1D
+	"cx1da",	// ARM_INS_CX1DA
+	"cx2",		// ARM_INS_CX2
+	"cx2a",		// ARM_INS_CX2A
+	"cx2d",		// ARM_INS_CX2D
+	"cx2da",	// ARM_INS_CX2DA
+	"cx3",		// ARM_INS_CX3
+	"cx3a",		// ARM_INS_CX3A
+	"cx3d",		// ARM_INS_CX3D
+	"cx3da",	// ARM_INS_CX3DA
+	"vcx1a",	// ARM_INS_VCX1A
+	"vcx1",		// ARM_INS_VCX1
+	"vcx2a",	// ARM_INS_VCX2A
+	"vcx2",		// ARM_INS_VCX2
+	"vcx3a",	// ARM_INS_VCX3A
+	"vcx3",		// ARM_INS_VCX3
+	"cdp",		// ARM_INS_CDP
+	"cdp2",		// ARM_INS_CDP2
+	"clrex",	// ARM_INS_CLREX
+	"clz",		// ARM_INS_CLZ
+	"cmn",		// ARM_INS_CMN
+	"cmp",		// ARM_INS_CMP
+	"cps",		// ARM_INS_CPS
+	"crc32b",	// ARM_INS_CRC32B
+	"crc32cb",	// ARM_INS_CRC32CB
+	"crc32ch",	// ARM_INS_CRC32CH
+	"crc32cw",	// ARM_INS_CRC32CW
+	"crc32h",	// ARM_INS_CRC32H
+	"crc32w",	// ARM_INS_CRC32W
+	"dbg",		// ARM_INS_DBG
+	"dmb",		// ARM_INS_DMB
+	"dsb",		// ARM_INS_DSB
+	"eor",		// ARM_INS_EOR
+	"eret",		// ARM_INS_ERET
+	"vmov",		// ARM_INS_VMOV
+	"fldmdbx",	// ARM_INS_FLDMDBX
+	"fldmiax",	// ARM_INS_FLDMIAX
+	"vmrs",		// ARM_INS_VMRS
+	"fstmdbx",	// ARM_INS_FSTMDBX
+	"fstmiax",	// ARM_INS_FSTMIAX
+	"hint",		// ARM_INS_HINT
+	"hlt",		// ARM_INS_HLT
+	"hvc",		// ARM_INS_HVC
+	"isb",		// ARM_INS_ISB
+	"lda",		// ARM_INS_LDA
+	"ldab",		// ARM_INS_LDAB
+	"ldaex",	// ARM_INS_LDAEX
+	"ldaexb",	// ARM_INS_LDAEXB
+	"ldaexd",	// ARM_INS_LDAEXD
+	"ldaexh",	// ARM_INS_LDAEXH
+	"ldah",		// ARM_INS_LDAH
+	"ldc2l",	// ARM_INS_LDC2L
+	"ldc2",		// ARM_INS_LDC2
+	"ldcl",		// ARM_INS_LDCL
+	"ldc",		// ARM_INS_LDC
+	"ldmda",	// ARM_INS_LDMDA
+	"ldmdb",	// ARM_INS_LDMDB
+	"ldm",		// ARM_INS_LDM
+	"ldmib",	// ARM_INS_LDMIB
+	"ldrd",		// ARM_INS_LDRD
+	"ldrex",	// ARM_INS_LDREX
+	"ldrexb",	// ARM_INS_LDREXB
+	"ldrexd",	// ARM_INS_LDREXD
+	"ldrexh",	// ARM_INS_LDREXH
+	"mcr",		// ARM_INS_MCR
+	"mcr2",		// ARM_INS_MCR2
+	"mcrr",		// ARM_INS_MCRR
+	"mcrr2",	// ARM_INS_MCRR2
+	"mla",		// ARM_INS_MLA
+	"mls",		// ARM_INS_MLS
+	"movt",		// ARM_INS_MOVT
+	"movw",		// ARM_INS_MOVW
+	"mrc",		// ARM_INS_MRC
+	"mrc2",		// ARM_INS_MRC2
+	"mrrc",		// ARM_INS_MRRC
+	"mrrc2",	// ARM_INS_MRRC2
+	"mrs",		// ARM_INS_MRS
+	"msr",		// ARM_INS_MSR
+	"mul",		// ARM_INS_MUL
+	"asrl",		// ARM_INS_ASRL
+	"dlstp",	// ARM_INS_DLSTP
+	"lctp",		// ARM_INS_LCTP
+	"letp",		// ARM_INS_LETP
+	"lsll",		// ARM_INS_LSLL
+	"lsrl",		// ARM_INS_LSRL
+	"sqrshr",	// ARM_INS_SQRSHR
+	"sqrshrl",	// ARM_INS_SQRSHRL
+	"sqshl",	// ARM_INS_SQSHL
+	"sqshll",	// ARM_INS_SQSHLL
+	"srshr",	// ARM_INS_SRSHR
+	"srshrl",	// ARM_INS_SRSHRL
+	"uqrshl",	// ARM_INS_UQRSHL
+	"uqrshll",	// ARM_INS_UQRSHLL
+	"uqshl",	// ARM_INS_UQSHL
+	"uqshll",	// ARM_INS_UQSHLL
+	"urshr",	// ARM_INS_URSHR
+	"urshrl",	// ARM_INS_URSHRL
+	"vabav",	// ARM_INS_VABAV
+	"vabd",		// ARM_INS_VABD
+	"vabs",		// ARM_INS_VABS
+	"vadc",		// ARM_INS_VADC
+	"vadci",	// ARM_INS_VADCI
+	"vaddlva",	// ARM_INS_VADDLVA
+	"vaddlv",	// ARM_INS_VADDLV
+	"vaddva",	// ARM_INS_VADDVA
+	"vaddv",	// ARM_INS_VADDV
+	"vadd",		// ARM_INS_VADD
+	"vand",		// ARM_INS_VAND
+	"vbic",		// ARM_INS_VBIC
+	"vbrsr",	// ARM_INS_VBRSR
+	"vcadd",	// ARM_INS_VCADD
+	"vcls",		// ARM_INS_VCLS
+	"vclz",		// ARM_INS_VCLZ
+	"vcmla",	// ARM_INS_VCMLA
+	"vcmp",		// ARM_INS_VCMP
+	"vcmul",	// ARM_INS_VCMUL
+	"vctp",		// ARM_INS_VCTP
+	"vcvta",	// ARM_INS_VCVTA
+	"vcvtm",	// ARM_INS_VCVTM
+	"vcvtn",	// ARM_INS_VCVTN
+	"vcvtp",	// ARM_INS_VCVTP
+	"vddup",	// ARM_INS_VDDUP
+	"vdup",		// ARM_INS_VDUP
+	"vdwdup",	// ARM_INS_VDWDUP
+	"veor",		// ARM_INS_VEOR
+	"vfmas",	// ARM_INS_VFMAS
+	"vfma",		// ARM_INS_VFMA
+	"vfms",		// ARM_INS_VFMS
+	"vhadd",	// ARM_INS_VHADD
+	"vhcadd",	// ARM_INS_VHCADD
+	"vhsub",	// ARM_INS_VHSUB
+	"vidup",	// ARM_INS_VIDUP
+	"viwdup",	// ARM_INS_VIWDUP
+	"vld20",	// ARM_INS_VLD20
+	"vld21",	// ARM_INS_VLD21
+	"vld40",	// ARM_INS_VLD40
+	"vld41",	// ARM_INS_VLD41
+	"vld42",	// ARM_INS_VLD42
+	"vld43",	// ARM_INS_VLD43
+	"vldrb",	// ARM_INS_VLDRB
+	"vldrd",	// ARM_INS_VLDRD
+	"vldrh",	// ARM_INS_VLDRH
+	"vldrw",	// ARM_INS_VLDRW
+	"vmaxav",	// ARM_INS_VMAXAV
+	"vmaxa",	// ARM_INS_VMAXA
+	"vmaxnmav",	// ARM_INS_VMAXNMAV
+	"vmaxnma",	// ARM_INS_VMAXNMA
+	"vmaxnmv",	// ARM_INS_VMAXNMV
+	"vmaxnm",	// ARM_INS_VMAXNM
+	"vmaxv",	// ARM_INS_VMAXV
+	"vmax",		// ARM_INS_VMAX
+	"vminav",	// ARM_INS_VMINAV
+	"vmina",	// ARM_INS_VMINA
+	"vminnmav",	// ARM_INS_VMINNMAV
+	"vminnma",	// ARM_INS_VMINNMA
+	"vminnmv",	// ARM_INS_VMINNMV
+	"vminnm",	// ARM_INS_VMINNM
+	"vminv",	// ARM_INS_VMINV
+	"vmin",		// ARM_INS_VMIN
+	"vmladava",	// ARM_INS_VMLADAVA
+	"vmladavax",	// ARM_INS_VMLADAVAX
+	"vmladav",	// ARM_INS_VMLADAV
+	"vmladavx",	// ARM_INS_VMLADAVX
+	"vmlaldava",	// ARM_INS_VMLALDAVA
+	"vmlaldavax",	// ARM_INS_VMLALDAVAX
+	"vmlaldav",	// ARM_INS_VMLALDAV
+	"vmlaldavx",	// ARM_INS_VMLALDAVX
+	"vmlas",	// ARM_INS_VMLAS
+	"vmla",		// ARM_INS_VMLA
+	"vmlsdava",	// ARM_INS_VMLSDAVA
+	"vmlsdavax",	// ARM_INS_VMLSDAVAX
+	"vmlsdav",	// ARM_INS_VMLSDAV
+	"vmlsdavx",	// ARM_INS_VMLSDAVX
+	"vmlsldava",	// ARM_INS_VMLSLDAVA
+	"vmlsldavax",	// ARM_INS_VMLSLDAVAX
+	"vmlsldav",	// ARM_INS_VMLSLDAV
+	"vmlsldavx",	// ARM_INS_VMLSLDAVX
+	"vmovlb",	// ARM_INS_VMOVLB
+	"vmovlt",	// ARM_INS_VMOVLT
+	"vmovnb",	// ARM_INS_VMOVNB
+	"vmovnt",	// ARM_INS_VMOVNT
+	"vmulh",	// ARM_INS_VMULH
+	"vmullb",	// ARM_INS_VMULLB
+	"vmullt",	// ARM_INS_VMULLT
+	"vmul",		// ARM_INS_VMUL
+	"vmvn",		// ARM_INS_VMVN
+	"vneg",		// ARM_INS_VNEG
+	"vorn",		// ARM_INS_VORN
+	"vorr",		// ARM_INS_VORR
+	"vpnot",	// ARM_INS_VPNOT
+	"vpsel",	// ARM_INS_VPSEL
+	"vpst",		// ARM_INS_VPST
+	"vpt",		// ARM_INS_VPT
+	"vqabs",	// ARM_INS_VQABS
+	"vqadd",	// ARM_INS_VQADD
+	"vqdmladhx",	// ARM_INS_VQDMLADHX
+	"vqdmladh",	// ARM_INS_VQDMLADH
+	"vqdmlah",	// ARM_INS_VQDMLAH
+	"vqdmlash",	// ARM_INS_VQDMLASH
+	"vqdmlsdhx",	// ARM_INS_VQDMLSDHX
+	"vqdmlsdh",	// ARM_INS_VQDMLSDH
+	"vqdmulh",	// ARM_INS_VQDMULH
+	"vqdmullb",	// ARM_INS_VQDMULLB
+	"vqdmullt",	// ARM_INS_VQDMULLT
+	"vqmovnb",	// ARM_INS_VQMOVNB
+	"vqmovnt",	// ARM_INS_VQMOVNT
+	"vqmovunb",	// ARM_INS_VQMOVUNB
+	"vqmovunt",	// ARM_INS_VQMOVUNT
+	"vqneg",	// ARM_INS_VQNEG
+	"vqrdmladhx",	// ARM_INS_VQRDMLADHX
+	"vqrdmladh",	// ARM_INS_VQRDMLADH
+	"vqrdmlah",	// ARM_INS_VQRDMLAH
+	"vqrdmlash",	// ARM_INS_VQRDMLASH
+	"vqrdmlsdhx",	// ARM_INS_VQRDMLSDHX
+	"vqrdmlsdh",	// ARM_INS_VQRDMLSDH
+	"vqrdmulh",	// ARM_INS_VQRDMULH
+	"vqrshl",	// ARM_INS_VQRSHL
+	"vqrshrnb",	// ARM_INS_VQRSHRNB
+	"vqrshrnt",	// ARM_INS_VQRSHRNT
+	"vqrshrunb",	// ARM_INS_VQRSHRUNB
+	"vqrshrunt",	// ARM_INS_VQRSHRUNT
+	"vqshlu",	// ARM_INS_VQSHLU
+	"vqshl",	// ARM_INS_VQSHL
+	"vqshrnb",	// ARM_INS_VQSHRNB
+	"vqshrnt",	// ARM_INS_VQSHRNT
+	"vqshrunb",	// ARM_INS_VQSHRUNB
+	"vqshrunt",	// ARM_INS_VQSHRUNT
+	"vqsub",	// ARM_INS_VQSUB
+	"vrev16",	// ARM_INS_VREV16
+	"vrev32",	// ARM_INS_VREV32
+	"vrev64",	// ARM_INS_VREV64
+	"vrhadd",	// ARM_INS_VRHADD
+	"vrinta",	// ARM_INS_VRINTA
+	"vrintm",	// ARM_INS_VRINTM
+	"vrintn",	// ARM_INS_VRINTN
+	"vrintp",	// ARM_INS_VRINTP
+	"vrintx",	// ARM_INS_VRINTX
+	"vrintz",	// ARM_INS_VRINTZ
+	"vrmlaldavha",	// ARM_INS_VRMLALDAVHA
+	"vrmlaldavhax", // ARM_INS_VRMLALDAVHAX
+	"vrmlaldavh",	// ARM_INS_VRMLALDAVH
+	"vrmlaldavhx",	// ARM_INS_VRMLALDAVHX
+	"vrmlsldavha",	// ARM_INS_VRMLSLDAVHA
+	"vrmlsldavhax", // ARM_INS_VRMLSLDAVHAX
+	"vrmlsldavh",	// ARM_INS_VRMLSLDAVH
+	"vrmlsldavhx",	// ARM_INS_VRMLSLDAVHX
+	"vrmulh",	// ARM_INS_VRMULH
+	"vrshl",	// ARM_INS_VRSHL
+	"vrshrnb",	// ARM_INS_VRSHRNB
+	"vrshrnt",	// ARM_INS_VRSHRNT
+	"vrshr",	// ARM_INS_VRSHR
+	"vsbc",		// ARM_INS_VSBC
+	"vsbci",	// ARM_INS_VSBCI
+	"vshlc",	// ARM_INS_VSHLC
+	"vshllb",	// ARM_INS_VSHLLB
+	"vshllt",	// ARM_INS_VSHLLT
+	"vshl",		// ARM_INS_VSHL
+	"vshrnb",	// ARM_INS_VSHRNB
+	"vshrnt",	// ARM_INS_VSHRNT
+	"vshr",		// ARM_INS_VSHR
+	"vsli",		// ARM_INS_VSLI
+	"vsri",		// ARM_INS_VSRI
+	"vst20",	// ARM_INS_VST20
+	"vst21",	// ARM_INS_VST21
+	"vst40",	// ARM_INS_VST40
+	"vst41",	// ARM_INS_VST41
+	"vst42",	// ARM_INS_VST42
+	"vst43",	// ARM_INS_VST43
+	"vstrb",	// ARM_INS_VSTRB
+	"vstrd",	// ARM_INS_VSTRD
+	"vstrh",	// ARM_INS_VSTRH
+	"vstrw",	// ARM_INS_VSTRW
+	"vsub",		// ARM_INS_VSUB
+	"wlstp",	// ARM_INS_WLSTP
+	"mvn",		// ARM_INS_MVN
+	"orr",		// ARM_INS_ORR
+	"pkhbt",	// ARM_INS_PKHBT
+	"pkhtb",	// ARM_INS_PKHTB
+	"pldw",		// ARM_INS_PLDW
+	"pld",		// ARM_INS_PLD
+	"pli",		// ARM_INS_PLI
+	"qadd",		// ARM_INS_QADD
+	"qadd16",	// ARM_INS_QADD16
+	"qadd8",	// ARM_INS_QADD8
+	"qasx",		// ARM_INS_QASX
+	"qdadd",	// ARM_INS_QDADD
+	"qdsub",	// ARM_INS_QDSUB
+	"qsax",		// ARM_INS_QSAX
+	"qsub",		// ARM_INS_QSUB
+	"qsub16",	// ARM_INS_QSUB16
+	"qsub8",	// ARM_INS_QSUB8
+	"rbit",		// ARM_INS_RBIT
+	"rev",		// ARM_INS_REV
+	"rev16",	// ARM_INS_REV16
+	"revsh",	// ARM_INS_REVSH
+	"rfeda",	// ARM_INS_RFEDA
+	"rfedb",	// ARM_INS_RFEDB
+	"rfeia",	// ARM_INS_RFEIA
+	"rfeib",	// ARM_INS_RFEIB
+	"rsb",		// ARM_INS_RSB
+	"rsc",		// ARM_INS_RSC
+	"sadd16",	// ARM_INS_SADD16
+	"sadd8",	// ARM_INS_SADD8
+	"sasx",		// ARM_INS_SASX
+	"sb",		// ARM_INS_SB
+	"sbc",		// ARM_INS_SBC
+	"sbfx",		// ARM_INS_SBFX
+	"sdiv",		// ARM_INS_SDIV
+	"sel",		// ARM_INS_SEL
+	"setend",	// ARM_INS_SETEND
+	"setpan",	// ARM_INS_SETPAN
+	"sha1c",	// ARM_INS_SHA1C
+	"sha1h",	// ARM_INS_SHA1H
+	"sha1m",	// ARM_INS_SHA1M
+	"sha1p",	// ARM_INS_SHA1P
+	"sha1su0",	// ARM_INS_SHA1SU0
+	"sha1su1",	// ARM_INS_SHA1SU1
+	"sha256h",	// ARM_INS_SHA256H
+	"sha256h2",	// ARM_INS_SHA256H2
+	"sha256su0",	// ARM_INS_SHA256SU0
+	"sha256su1",	// ARM_INS_SHA256SU1
+	"shadd16",	// ARM_INS_SHADD16
+	"shadd8",	// ARM_INS_SHADD8
+	"shasx",	// ARM_INS_SHASX
+	"shsax",	// ARM_INS_SHSAX
+	"shsub16",	// ARM_INS_SHSUB16
+	"shsub8",	// ARM_INS_SHSUB8
+	"smc",		// ARM_INS_SMC
+	"smlabb",	// ARM_INS_SMLABB
+	"smlabt",	// ARM_INS_SMLABT
+	"smlad",	// ARM_INS_SMLAD
+	"smladx",	// ARM_INS_SMLADX
+	"smlal",	// ARM_INS_SMLAL
+	"smlalbb",	// ARM_INS_SMLALBB
+	"smlalbt",	// ARM_INS_SMLALBT
+	"smlald",	// ARM_INS_SMLALD
+	"smlaldx",	// ARM_INS_SMLALDX
+	"smlaltb",	// ARM_INS_SMLALTB
+	"smlaltt",	// ARM_INS_SMLALTT
+	"smlatb",	// ARM_INS_SMLATB
+	"smlatt",	// ARM_INS_SMLATT
+	"smlawb",	// ARM_INS_SMLAWB
+	"smlawt",	// ARM_INS_SMLAWT
+	"smlsd",	// ARM_INS_SMLSD
+	"smlsdx",	// ARM_INS_SMLSDX
+	"smlsld",	// ARM_INS_SMLSLD
+	"smlsldx",	// ARM_INS_SMLSLDX
+	"smmla",	// ARM_INS_SMMLA
+	"smmlar",	// ARM_INS_SMMLAR
+	"smmls",	// ARM_INS_SMMLS
+	"smmlsr",	// ARM_INS_SMMLSR
+	"smmul",	// ARM_INS_SMMUL
+	"smmulr",	// ARM_INS_SMMULR
+	"smuad",	// ARM_INS_SMUAD
+	"smuadx",	// ARM_INS_SMUADX
+	"smulbb",	// ARM_INS_SMULBB
+	"smulbt",	// ARM_INS_SMULBT
+	"smull",	// ARM_INS_SMULL
+	"smultb",	// ARM_INS_SMULTB
+	"smultt",	// ARM_INS_SMULTT
+	"smulwb",	// ARM_INS_SMULWB
+	"smulwt",	// ARM_INS_SMULWT
+	"smusd",	// ARM_INS_SMUSD
+	"smusdx",	// ARM_INS_SMUSDX
+	"srsda",	// ARM_INS_SRSDA
+	"srsdb",	// ARM_INS_SRSDB
+	"srsia",	// ARM_INS_SRSIA
+	"srsib",	// ARM_INS_SRSIB
+	"ssat",		// ARM_INS_SSAT
+	"ssat16",	// ARM_INS_SSAT16
+	"ssax",		// ARM_INS_SSAX
+	"ssub16",	// ARM_INS_SSUB16
+	"ssub8",	// ARM_INS_SSUB8
+	"stc2l",	// ARM_INS_STC2L
+	"stc2",		// ARM_INS_STC2
+	"stcl",		// ARM_INS_STCL
+	"stc",		// ARM_INS_STC
+	"stl",		// ARM_INS_STL
+	"stlb",		// ARM_INS_STLB
+	"stlex",	// ARM_INS_STLEX
+	"stlexb",	// ARM_INS_STLEXB
+	"stlexd",	// ARM_INS_STLEXD
+	"stlexh",	// ARM_INS_STLEXH
+	"stlh",		// ARM_INS_STLH
+	"stmda",	// ARM_INS_STMDA
+	"stmdb",	// ARM_INS_STMDB
+	"stm",		// ARM_INS_STM
+	"stmib",	// ARM_INS_STMIB
+	"strb",		// ARM_INS_STRB
+	"strd",		// ARM_INS_STRD
+	"strex",	// ARM_INS_STREX
+	"strexb",	// ARM_INS_STREXB
+	"strexd",	// ARM_INS_STREXD
+	"strexh",	// ARM_INS_STREXH
+	"strh",		// ARM_INS_STRH
+	"strht",	// ARM_INS_STRHT
+	"sub",		// ARM_INS_SUB
+	"svc",		// ARM_INS_SVC
+	"swp",		// ARM_INS_SWP
+	"swpb",		// ARM_INS_SWPB
+	"sxtab",	// ARM_INS_SXTAB
+	"sxtab16",	// ARM_INS_SXTAB16
+	"sxtah",	// ARM_INS_SXTAH
+	"sxtb",		// ARM_INS_SXTB
+	"sxtb16",	// ARM_INS_SXTB16
+	"sxth",		// ARM_INS_SXTH
+	"teq",		// ARM_INS_TEQ
+	"trap",		// ARM_INS_TRAP
+	"tsb",		// ARM_INS_TSB
+	"tst",		// ARM_INS_TST
+	"uadd16",	// ARM_INS_UADD16
+	"uadd8",	// ARM_INS_UADD8
+	"uasx",		// ARM_INS_UASX
+	"ubfx",		// ARM_INS_UBFX
+	"udf",		// ARM_INS_UDF
+	"udiv",		// ARM_INS_UDIV
+	"uhadd16",	// ARM_INS_UHADD16
+	"uhadd8",	// ARM_INS_UHADD8
+	"uhasx",	// ARM_INS_UHASX
+	"uhsax",	// ARM_INS_UHSAX
+	"uhsub16",	// ARM_INS_UHSUB16
+	"uhsub8",	// ARM_INS_UHSUB8
+	"umaal",	// ARM_INS_UMAAL
+	"umlal",	// ARM_INS_UMLAL
+	"umull",	// ARM_INS_UMULL
+	"uqadd16",	// ARM_INS_UQADD16
+	"uqadd8",	// ARM_INS_UQADD8
+	"uqasx",	// ARM_INS_UQASX
+	"uqsax",	// ARM_INS_UQSAX
+	"uqsub16",	// ARM_INS_UQSUB16
+	"uqsub8",	// ARM_INS_UQSUB8
+	"usad8",	// ARM_INS_USAD8
+	"usada8",	// ARM_INS_USADA8
+	"usat",		// ARM_INS_USAT
+	"usat16",	// ARM_INS_USAT16
+	"usax",		// ARM_INS_USAX
+	"usub16",	// ARM_INS_USUB16
+	"usub8",	// ARM_INS_USUB8
+	"uxtab",	// ARM_INS_UXTAB
+	"uxtab16",	// ARM_INS_UXTAB16
+	"uxtah",	// ARM_INS_UXTAH
+	"uxtb",		// ARM_INS_UXTB
+	"uxtb16",	// ARM_INS_UXTB16
+	"uxth",		// ARM_INS_UXTH
+	"vabal",	// ARM_INS_VABAL
+	"vaba",		// ARM_INS_VABA
+	"vabdl",	// ARM_INS_VABDL
+	"vacge",	// ARM_INS_VACGE
+	"vacgt",	// ARM_INS_VACGT
+	"vaddhn",	// ARM_INS_VADDHN
+	"vaddl",	// ARM_INS_VADDL
+	"vaddw",	// ARM_INS_VADDW
+	"vfmab",	// ARM_INS_VFMAB
+	"vfmat",	// ARM_INS_VFMAT
+	"vbif",		// ARM_INS_VBIF
+	"vbit",		// ARM_INS_VBIT
+	"vbsl",		// ARM_INS_VBSL
+	"vceq",		// ARM_INS_VCEQ
+	"vcge",		// ARM_INS_VCGE
+	"vcgt",		// ARM_INS_VCGT
+	"vcle",		// ARM_INS_VCLE
+	"vclt",		// ARM_INS_VCLT
+	"vcmpe",	// ARM_INS_VCMPE
+	"vcnt",		// ARM_INS_VCNT
+	"vdiv",		// ARM_INS_VDIV
+	"vext",		// ARM_INS_VEXT
+	"vfmal",	// ARM_INS_VFMAL
+	"vfmsl",	// ARM_INS_VFMSL
+	"vfnma",	// ARM_INS_VFNMA
+	"vfnms",	// ARM_INS_VFNMS
+	"vins",		// ARM_INS_VINS
+	"vjcvt",	// ARM_INS_VJCVT
+	"vldmdb",	// ARM_INS_VLDMDB
+	"vldmia",	// ARM_INS_VLDMIA
+	"vldr",		// ARM_INS_VLDR
+	"vlldm",	// ARM_INS_VLLDM
+	"vlstm",	// ARM_INS_VLSTM
+	"vmlal",	// ARM_INS_VMLAL
+	"vmls",		// ARM_INS_VMLS
+	"vmlsl",	// ARM_INS_VMLSL
+	"vmmla",	// ARM_INS_VMMLA
+	"vmovx",	// ARM_INS_VMOVX
+	"vmovl",	// ARM_INS_VMOVL
+	"vmovn",	// ARM_INS_VMOVN
+	"vmsr",		// ARM_INS_VMSR
+	"vmull",	// ARM_INS_VMULL
+	"vnmla",	// ARM_INS_VNMLA
+	"vnmls",	// ARM_INS_VNMLS
+	"vnmul",	// ARM_INS_VNMUL
+	"vpadal",	// ARM_INS_VPADAL
+	"vpaddl",	// ARM_INS_VPADDL
+	"vpadd",	// ARM_INS_VPADD
+	"vpmax",	// ARM_INS_VPMAX
+	"vpmin",	// ARM_INS_VPMIN
+	"vqdmlal",	// ARM_INS_VQDMLAL
+	"vqdmlsl",	// ARM_INS_VQDMLSL
+	"vqdmull",	// ARM_INS_VQDMULL
+	"vqmovun",	// ARM_INS_VQMOVUN
+	"vqmovn",	// ARM_INS_VQMOVN
+	"vqrdmlsh",	// ARM_INS_VQRDMLSH
+	"vqrshrn",	// ARM_INS_VQRSHRN
+	"vqrshrun",	// ARM_INS_VQRSHRUN
+	"vqshrn",	// ARM_INS_VQSHRN
+	"vqshrun",	// ARM_INS_VQSHRUN
+	"vraddhn",	// ARM_INS_VRADDHN
+	"vrecpe",	// ARM_INS_VRECPE
+	"vrecps",	// ARM_INS_VRECPS
+	"vrintr",	// ARM_INS_VRINTR
+	"vrshrn",	// ARM_INS_VRSHRN
+	"vrsqrte",	// ARM_INS_VRSQRTE
+	"vrsqrts",	// ARM_INS_VRSQRTS
+	"vrsra",	// ARM_INS_VRSRA
+	"vrsubhn",	// ARM_INS_VRSUBHN
+	"vscclrm",	// ARM_INS_VSCCLRM
+	"vsdot",	// ARM_INS_VSDOT
+	"vseleq",	// ARM_INS_VSELEQ
+	"vselge",	// ARM_INS_VSELGE
+	"vselgt",	// ARM_INS_VSELGT
+	"vselvs",	// ARM_INS_VSELVS
+	"vshll",	// ARM_INS_VSHLL
+	"vshrn",	// ARM_INS_VSHRN
+	"vsmmla",	// ARM_INS_VSMMLA
+	"vsqrt",	// ARM_INS_VSQRT
+	"vsra",		// ARM_INS_VSRA
+	"vstmdb",	// ARM_INS_VSTMDB
+	"vstmia",	// ARM_INS_VSTMIA
+	"vstr",		// ARM_INS_VSTR
+	"vsubhn",	// ARM_INS_VSUBHN
+	"vsubl",	// ARM_INS_VSUBL
+	"vsubw",	// ARM_INS_VSUBW
+	"vsudot",	// ARM_INS_VSUDOT
+	"vswp",		// ARM_INS_VSWP
+	"vtbl",		// ARM_INS_VTBL
+	"vtbx",		// ARM_INS_VTBX
+	"vcvtr",	// ARM_INS_VCVTR
+	"vtrn",		// ARM_INS_VTRN
+	"vtst",		// ARM_INS_VTST
+	"vudot",	// ARM_INS_VUDOT
+	"vummla",	// ARM_INS_VUMMLA
+	"vusdot",	// ARM_INS_VUSDOT
+	"vusmmla",	// ARM_INS_VUSMMLA
+	"vuzp",		// ARM_INS_VUZP
+	"vzip",		// ARM_INS_VZIP
+	"addw",		// ARM_INS_ADDW
+	"aut",		// ARM_INS_AUT
+	"autg",		// ARM_INS_AUTG
+	"bfl",		// ARM_INS_BFL
+	"bflx",		// ARM_INS_BFLX
+	"bf",		// ARM_INS_BF
+	"bfcsel",	// ARM_INS_BFCSEL
+	"bfx",		// ARM_INS_BFX
+	"bti",		// ARM_INS_BTI
+	"bxaut",	// ARM_INS_BXAUT
+	"clrm",		// ARM_INS_CLRM
+	"csel",		// ARM_INS_CSEL
+	"csinc",	// ARM_INS_CSINC
+	"csinv",	// ARM_INS_CSINV
+	"csneg",	// ARM_INS_CSNEG
+	"dcps1",	// ARM_INS_DCPS1
+	"dcps2",	// ARM_INS_DCPS2
+	"dcps3",	// ARM_INS_DCPS3
+	"dls",		// ARM_INS_DLS
+	"le",		// ARM_INS_LE
+	"orn",		// ARM_INS_ORN
+	"pac",		// ARM_INS_PAC
+	"pacbti",	// ARM_INS_PACBTI
+	"pacg",		// ARM_INS_PACG
+	"sg",		// ARM_INS_SG
+	"subs",		// ARM_INS_SUBS
+	"subw",		// ARM_INS_SUBW
+	"tbb",		// ARM_INS_TBB
+	"tbh",		// ARM_INS_TBH
+	"tt",		// ARM_INS_TT
+	"tta",		// ARM_INS_TTA
+	"ttat",		// ARM_INS_TTAT
+	"ttt",		// ARM_INS_TTT
+	"wls",		// ARM_INS_WLS
+	"blxns",	// ARM_INS_BLXNS
+	"bxns",		// ARM_INS_BXNS
+	"cbnz",		// ARM_INS_CBNZ
+	"cbz",		// ARM_INS_CBZ
+	"pop",		// ARM_INS_POP
+	"push",		// ARM_INS_PUSH
+	"__brkdiv0",	// ARM_INS___BRKDIV0

thirdparty/capstone/arch/ARM/ARMGenCSOpGroup.inc

@@ -0,0 +1,90 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+ARM_OP_GROUP_RegImmShift = 0,
+	ARM_OP_GROUP_LdStmModeOperand = 1,
+	ARM_OP_GROUP_MandatoryInvertedPredicateOperand = 2,
+	ARM_OP_GROUP_Operand = 3, ARM_OP_GROUP_ModImmOperand = 4,
+	ARM_OP_GROUP_PredicateOperand = 5, ARM_OP_GROUP_SORegImmOperand = 6,
+	ARM_OP_GROUP_SORegRegOperand = 7, ARM_OP_GROUP_SBitModifierOperand = 8,
+	ARM_OP_GROUP_AddrModeImm12Operand_0 = 9,
+	ARM_OP_GROUP_AddrMode2Operand = 10, ARM_OP_GROUP_CPInstOperand = 11,
+	ARM_OP_GROUP_MandatoryPredicateOperand = 12,
+	ARM_OP_GROUP_ThumbITMask = 13, ARM_OP_GROUP_RegisterList = 14,
+	ARM_OP_GROUP_AddrMode7Operand = 15, ARM_OP_GROUP_GPRPairOperand = 16,
+	ARM_OP_GROUP_AddrMode3Operand_0 = 17, ARM_OP_GROUP_PCLabel = 18,
+	ARM_OP_GROUP_AddrModePCOperand = 19,
+	ARM_OP_GROUP_AddrMode2OffsetOperand = 20,
+	ARM_OP_GROUP_AddrMode3OffsetOperand = 21,
+	ARM_OP_GROUP_AddrMode6Operand = 22,
+	ARM_OP_GROUP_VectorListThreeAllLanes = 23,
+	ARM_OP_GROUP_VectorListThreeSpacedAllLanes = 24,
+	ARM_OP_GROUP_VectorListThree = 25,
+	ARM_OP_GROUP_VectorListThreeSpaced = 26,
+	ARM_OP_GROUP_VectorListFourAllLanes = 27,
+	ARM_OP_GROUP_VectorListFourSpacedAllLanes = 28,
+	ARM_OP_GROUP_VectorListFour = 29,
+	ARM_OP_GROUP_VectorListFourSpaced = 30, ARM_OP_GROUP_T2SOOperand = 31,
+	ARM_OP_GROUP_T2AddrModeImm8OffsetOperand = 32,
+	ARM_OP_GROUP_T2AddrModeImm8Operand_1 = 33,
+	ARM_OP_GROUP_AdrLabelOperand_0 = 34, ARM_OP_GROUP_VectorIndex = 35,
+	ARM_OP_GROUP_BitfieldInvMaskImmOperand = 36,
+	ARM_OP_GROUP_PImmediate = 37, ARM_OP_GROUP_VPTPredicateOperand = 38,
+	ARM_OP_GROUP_CImmediate = 39, ARM_OP_GROUP_CPSIMod = 40,
+	ARM_OP_GROUP_CPSIFlag = 41, ARM_OP_GROUP_MemBOption = 42,
+	ARM_OP_GROUP_FPImmOperand = 43, ARM_OP_GROUP_InstSyncBOption = 44,
+	ARM_OP_GROUP_AddrMode5Operand_0 = 45, ARM_OP_GROUP_CoprocOptionImm = 46,
+	ARM_OP_GROUP_PostIdxImm8s4Operand = 47,
+	ARM_OP_GROUP_AddrMode5Operand_1 = 48,
+	ARM_OP_GROUP_AddrModeImm12Operand_1 = 49,
+	ARM_OP_GROUP_AddrMode3Operand_1 = 50,
+	ARM_OP_GROUP_PostIdxImm8Operand = 51,
+	ARM_OP_GROUP_PostIdxRegOperand = 52, ARM_OP_GROUP_BankedRegOperand = 53,
+	ARM_OP_GROUP_MSRMaskOperand = 54, ARM_OP_GROUP_MveSaturateOp = 55,
+	ARM_OP_GROUP_VMOVModImmOperand = 56,
+	ARM_OP_GROUP_ComplexRotationOp_180_90 = 57,
+	ARM_OP_GROUP_ComplexRotationOp_90_0 = 58,
+	ARM_OP_GROUP_MandatoryRestrictedPredicateOperand = 59,
+	ARM_OP_GROUP_MVEVectorList_2 = 60, ARM_OP_GROUP_MVEVectorList_4 = 61,
+	ARM_OP_GROUP_T2AddrModeImm8Operand_0 = 62,
+	ARM_OP_GROUP_MveAddrModeRQOperand_0 = 63,
+	ARM_OP_GROUP_MveAddrModeRQOperand_3 = 64,
+	ARM_OP_GROUP_MveAddrModeRQOperand_1 = 65,
+	ARM_OP_GROUP_MveAddrModeRQOperand_2 = 66, ARM_OP_GROUP_VPTMask = 67,
+	ARM_OP_GROUP_PKHLSLShiftImm = 68, ARM_OP_GROUP_PKHASRShiftImm = 69,
+	ARM_OP_GROUP_ImmPlusOneOperand = 70, ARM_OP_GROUP_SetendOperand = 71,
+	ARM_OP_GROUP_ShiftImmOperand = 72, ARM_OP_GROUP_RotImmOperand = 73,
+	ARM_OP_GROUP_TraceSyncBOption = 74,
+	ARM_OP_GROUP_VectorListOneAllLanes = 75,
+	ARM_OP_GROUP_VectorListTwoAllLanes = 76,
+	ARM_OP_GROUP_NoHashImmediate = 77,
+	ARM_OP_GROUP_AddrMode6OffsetOperand = 78,
+	ARM_OP_GROUP_VectorListOne = 79, ARM_OP_GROUP_VectorListTwo = 80,
+	ARM_OP_GROUP_VectorListTwoSpacedAllLanes = 81,
+	ARM_OP_GROUP_VectorListTwoSpaced = 82,
+	ARM_OP_GROUP_AddrMode5FP16Operand_0 = 83,
+	ARM_OP_GROUP_T2AddrModeImm8s4Operand_0 = 84,
+	ARM_OP_GROUP_T2AddrModeImm8s4OffsetOperand = 85,
+	ARM_OP_GROUP_T2AddrModeImm8s4Operand_1 = 86, ARM_OP_GROUP_FBits16 = 87,
+	ARM_OP_GROUP_FBits32 = 88, ARM_OP_GROUP_ThumbSRImm = 89,
+	ARM_OP_GROUP_ThumbLdrLabelOperand = 90,
+	ARM_OP_GROUP_T2AddrModeSoRegOperand = 91,
+	ARM_OP_GROUP_T2AddrModeImm0_1020s4Operand = 92,
+	ARM_OP_GROUP_AddrModeTBB = 93, ARM_OP_GROUP_AddrModeTBH = 94,
+	ARM_OP_GROUP_ThumbS4ImmOperand = 95,
+	ARM_OP_GROUP_AdrLabelOperand_2 = 96,
+	ARM_OP_GROUP_ThumbAddrModeImm5S1Operand = 97,
+	ARM_OP_GROUP_ThumbAddrModeRROperand = 98,
+	ARM_OP_GROUP_ThumbAddrModeImm5S2Operand = 99,
+	ARM_OP_GROUP_ThumbAddrModeImm5S4Operand = 100,
+	ARM_OP_GROUP_ThumbAddrModeSPOperand = 101,

thirdparty/capstone/arch/ARM/ARMGenSubtargetInfo.inc

@@ -0,0 +1,241 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+#ifdef GET_SUBTARGETINFO_ENUM
+#undef GET_SUBTARGETINFO_ENUM
+
+enum {
+	ARM_ARMv4 = 0,
+	ARM_ARMv4t = 1,
+	ARM_ARMv5t = 2,
+	ARM_ARMv5te = 3,
+	ARM_ARMv5tej = 4,
+	ARM_ARMv6 = 5,
+	ARM_ARMv6j = 6,
+	ARM_ARMv6k = 7,
+	ARM_ARMv6kz = 8,
+	ARM_ARMv6m = 9,
+	ARM_ARMv6sm = 10,
+	ARM_ARMv6t2 = 11,
+	ARM_ARMv7a = 12,
+	ARM_ARMv7em = 13,
+	ARM_ARMv7k = 14,
+	ARM_ARMv7m = 15,
+	ARM_ARMv7r = 16,
+	ARM_ARMv7s = 17,
+	ARM_ARMv7ve = 18,
+	ARM_ARMv8a = 19,
+	ARM_ARMv8mBaseline = 20,
+	ARM_ARMv8mMainline = 21,
+	ARM_ARMv8r = 22,
+	ARM_ARMv9a = 23,
+	ARM_ARMv81a = 24,
+	ARM_ARMv81mMainline = 25,
+	ARM_ARMv82a = 26,
+	ARM_ARMv83a = 27,
+	ARM_ARMv84a = 28,
+	ARM_ARMv85a = 29,
+	ARM_ARMv86a = 30,
+	ARM_ARMv87a = 31,
+	ARM_ARMv88a = 32,
+	ARM_ARMv89a = 33,
+	ARM_ARMv91a = 34,
+	ARM_ARMv92a = 35,
+	ARM_ARMv93a = 36,
+	ARM_ARMv94a = 37,
+	ARM_Feature8MSecExt = 38,
+	ARM_FeatureAAPCSFrameChain = 39,
+	ARM_FeatureAAPCSFrameChainLeaf = 40,
+	ARM_FeatureAClass = 41,
+	ARM_FeatureAES = 42,
+	ARM_FeatureAcquireRelease = 43,
+	ARM_FeatureAtomics32 = 44,
+	ARM_FeatureAvoidMOVsShOp = 45,
+	ARM_FeatureAvoidPartialCPSR = 46,
+	ARM_FeatureBF16 = 47,
+	ARM_FeatureCLRBHB = 48,
+	ARM_FeatureCRC = 49,
+	ARM_FeatureCheapPredicableCPSR = 50,
+	ARM_FeatureCheckVLDnAlign = 51,
+	ARM_FeatureCoprocCDE0 = 52,
+	ARM_FeatureCoprocCDE1 = 53,
+	ARM_FeatureCoprocCDE2 = 54,
+	ARM_FeatureCoprocCDE3 = 55,
+	ARM_FeatureCoprocCDE4 = 56,
+	ARM_FeatureCoprocCDE5 = 57,
+	ARM_FeatureCoprocCDE6 = 58,
+	ARM_FeatureCoprocCDE7 = 59,
+	ARM_FeatureCrypto = 60,
+	ARM_FeatureD32 = 61,
+	ARM_FeatureDB = 62,
+	ARM_FeatureDFB = 63,
+	ARM_FeatureDSP = 64,
+	ARM_FeatureDontWidenVMOVS = 65,
+	ARM_FeatureDotProd = 66,
+	ARM_FeatureExecuteOnly = 67,
+	ARM_FeatureExpandMLx = 68,
+	ARM_FeatureFP16 = 69,
+	ARM_FeatureFP16FML = 70,
+	ARM_FeatureFP64 = 71,
+	ARM_FeatureFPAO = 72,
+	ARM_FeatureFPARMv8 = 73,
+	ARM_FeatureFPARMv8_D16 = 74,
+	ARM_FeatureFPARMv8_D16_SP = 75,
+	ARM_FeatureFPARMv8_SP = 76,
+	ARM_FeatureFPRegs = 77,
+	ARM_FeatureFPRegs16 = 78,
+	ARM_FeatureFPRegs64 = 79,
+	ARM_FeatureFixCMSE_CVE_2021_35465 = 80,
+	ARM_FeatureFixCortexA57AES1742098 = 81,
+	ARM_FeatureFullFP16 = 82,
+	ARM_FeatureFuseAES = 83,
+	ARM_FeatureFuseLiterals = 84,
+	ARM_FeatureHWDivARM = 85,
+	ARM_FeatureHWDivThumb = 86,
+	ARM_FeatureHardenSlsBlr = 87,
+	ARM_FeatureHardenSlsNoComdat = 88,
+	ARM_FeatureHardenSlsRetBr = 89,
+	ARM_FeatureHasNoBranchPredictor = 90,
+	ARM_FeatureHasRetAddrStack = 91,
+	ARM_FeatureHasSlowFPVFMx = 92,
+	ARM_FeatureHasSlowFPVMLx = 93,
+	ARM_FeatureHasVMLxHazards = 94,
+	ARM_FeatureLOB = 95,
+	ARM_FeatureLongCalls = 96,
+	ARM_FeatureMClass = 97,
+	ARM_FeatureMP = 98,
+	ARM_FeatureMVEVectorCostFactor1 = 99,
+	ARM_FeatureMVEVectorCostFactor2 = 100,
+	ARM_FeatureMVEVectorCostFactor4 = 101,
+	ARM_FeatureMatMulInt8 = 102,
+	ARM_FeatureMuxedUnits = 103,
+	ARM_FeatureNEON = 104,
+	ARM_FeatureNEONForFP = 105,
+	ARM_FeatureNEONForFPMovs = 106,
+	ARM_FeatureNaClTrap = 107,
+	ARM_FeatureNoARM = 108,
+	ARM_FeatureNoBTIAtReturnTwice = 109,
+	ARM_FeatureNoMovt = 110,
+	ARM_FeatureNoNegativeImmediates = 111,
+	ARM_FeatureNoPostRASched = 112,
+	ARM_FeatureNonpipelinedVFP = 113,
+	ARM_FeaturePACBTI = 114,
+	ARM_FeaturePerfMon = 115,
+	ARM_FeaturePref32BitThumb = 116,
+	ARM_FeaturePrefISHSTBarrier = 117,
+	ARM_FeaturePrefLoopAlign32 = 118,
+	ARM_FeaturePreferVMOVSR = 119,
+	ARM_FeatureProfUnpredicate = 120,
+	ARM_FeatureRAS = 121,
+	ARM_FeatureRClass = 122,
+	ARM_FeatureReadTp = 123,
+	ARM_FeatureReserveR9 = 124,
+	ARM_FeatureSB = 125,
+	ARM_FeatureSHA2 = 126,
+	ARM_FeatureSlowFPBrcc = 127,
+	ARM_FeatureSlowLoadDSubreg = 128,
+	ARM_FeatureSlowOddRegister = 129,
+	ARM_FeatureSlowVDUP32 = 130,
+	ARM_FeatureSlowVGETLNi32 = 131,
+	ARM_FeatureSplatVFPToNeon = 132,
+	ARM_FeatureStrictAlign = 133,
+	ARM_FeatureThumb2 = 134,
+	ARM_FeatureTrustZone = 135,
+	ARM_FeatureUseMIPipeliner = 136,
+	ARM_FeatureUseMISched = 137,
+	ARM_FeatureUseWideStrideVFP = 138,
+	ARM_FeatureV7Clrex = 139,
+	ARM_FeatureVFP2 = 140,
+	ARM_FeatureVFP2_SP = 141,
+	ARM_FeatureVFP3 = 142,
+	ARM_FeatureVFP3_D16 = 143,
+	ARM_FeatureVFP3_D16_SP = 144,
+	ARM_FeatureVFP3_SP = 145,
+	ARM_FeatureVFP4 = 146,
+	ARM_FeatureVFP4_D16 = 147,
+	ARM_FeatureVFP4_D16_SP = 148,
+	ARM_FeatureVFP4_SP = 149,
+	ARM_FeatureVMLxForwarding = 150,
+	ARM_FeatureVirtualization = 151,
+	ARM_FeatureZCZeroing = 152,
+	ARM_HasCDEOps = 153,
+	ARM_HasMVEFloatOps = 154,
+	ARM_HasMVEIntegerOps = 155,
+	ARM_HasV4TOps = 156,
+	ARM_HasV5TEOps = 157,
+	ARM_HasV5TOps = 158,
+	ARM_HasV6KOps = 159,
+	ARM_HasV6MOps = 160,
+	ARM_HasV6Ops = 161,
+	ARM_HasV6T2Ops = 162,
+	ARM_HasV7Ops = 163,
+	ARM_HasV8MBaselineOps = 164,
+	ARM_HasV8MMainlineOps = 165,
+	ARM_HasV8Ops = 166,
+	ARM_HasV8_1MMainlineOps = 167,
+	ARM_HasV8_1aOps = 168,
+	ARM_HasV8_2aOps = 169,
+	ARM_HasV8_3aOps = 170,
+	ARM_HasV8_4aOps = 171,
+	ARM_HasV8_5aOps = 172,
+	ARM_HasV8_6aOps = 173,
+	ARM_HasV8_7aOps = 174,
+	ARM_HasV8_8aOps = 175,
+	ARM_HasV8_9aOps = 176,
+	ARM_HasV9_0aOps = 177,
+	ARM_HasV9_1aOps = 178,
+	ARM_HasV9_2aOps = 179,
+	ARM_HasV9_3aOps = 180,
+	ARM_HasV9_4aOps = 181,
+	ARM_IWMMXT = 182,
+	ARM_IWMMXT2 = 183,
+	ARM_ModeBigEndianInstructions = 184,
+	ARM_ModeSoftFloat = 185,
+	ARM_ModeThumb = 186,
+	ARM_ProcA5 = 187,
+	ARM_ProcA7 = 188,
+	ARM_ProcA8 = 189,
+	ARM_ProcA9 = 190,
+	ARM_ProcA12 = 191,
+	ARM_ProcA15 = 192,
+	ARM_ProcA17 = 193,
+	ARM_ProcA32 = 194,
+	ARM_ProcA35 = 195,
+	ARM_ProcA53 = 196,
+	ARM_ProcA55 = 197,
+	ARM_ProcA57 = 198,
+	ARM_ProcA72 = 199,
+	ARM_ProcA73 = 200,
+	ARM_ProcA75 = 201,
+	ARM_ProcA76 = 202,
+	ARM_ProcA77 = 203,
+	ARM_ProcA78 = 204,
+	ARM_ProcA78C = 205,
+	ARM_ProcA710 = 206,
+	ARM_ProcExynos = 207,
+	ARM_ProcKrait = 208,
+	ARM_ProcKryo = 209,
+	ARM_ProcM3 = 210,
+	ARM_ProcM7 = 211,
+	ARM_ProcR4 = 212,
+	ARM_ProcR5 = 213,
+	ARM_ProcR7 = 214,
+	ARM_ProcR52 = 215,
+	ARM_ProcSwift = 216,
+	ARM_ProcV1 = 217,
+	ARM_ProcX1 = 218,
+	ARM_ProcX1C = 219,
+	ARM_XScale = 220,
+	ARM_NumSubtargetFeatures = 221
+};
+#endif // GET_SUBTARGETINFO_ENUM

thirdparty/capstone/arch/ARM/ARMGenSystemRegister.inc

@@ -0,0 +1,575 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically generated file by Capstone's LLVM TableGen Disassembler Backend. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Do not edit. */
+
+/* Capstone's LLVM TableGen Backends: */
+/* https://github.com/capstone-engine/llvm-capstone */
+
+#ifdef GET_BANKEDREG_DECL
+#endif
+
+#ifdef GET_MCLASSSYSREG_DECL
+#endif
+
+#ifdef GET_BANKEDREG_DECL
+const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByName(const char *Name);
+const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByEncoding(uint8_t Encoding);
+#endif
+
+#ifdef GET_MCLASSSYSREG_DECL
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByName(const char *Name);
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByM1Encoding12(uint16_t M1Encoding12);
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByM2M3Encoding8(uint16_t M2M3Encoding8);
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByEncoding(uint16_t Encoding);
+#endif
+
+#ifdef GET_BANKEDREG_IMPL
+static const ARMBankedReg_BankedReg BankedRegsList[] = {
+	{ "elr_hyp", { .bankedreg = ARM_BANKEDREG_ELR_HYP }, 0x1E },   // 0
+	{ "lr_abt", { .bankedreg = ARM_BANKEDREG_LR_ABT }, 0x14 },     // 1
+	{ "lr_fiq", { .bankedreg = ARM_BANKEDREG_LR_FIQ }, 0xE },      // 2
+	{ "lr_irq", { .bankedreg = ARM_BANKEDREG_LR_IRQ }, 0x10 },     // 3
+	{ "lr_mon", { .bankedreg = ARM_BANKEDREG_LR_MON }, 0x1C },     // 4
+	{ "lr_svc", { .bankedreg = ARM_BANKEDREG_LR_SVC }, 0x12 },     // 5
+	{ "lr_und", { .bankedreg = ARM_BANKEDREG_LR_UND }, 0x16 },     // 6
+	{ "lr_usr", { .bankedreg = ARM_BANKEDREG_LR_USR }, 0x6 },      // 7
+	{ "r10_fiq", { .bankedreg = ARM_BANKEDREG_R10_FIQ }, 0xA },    // 8
+	{ "r10_usr", { .bankedreg = ARM_BANKEDREG_R10_USR }, 0x2 },    // 9
+	{ "r11_fiq", { .bankedreg = ARM_BANKEDREG_R11_FIQ }, 0xB },    // 10
+	{ "r11_usr", { .bankedreg = ARM_BANKEDREG_R11_USR }, 0x3 },    // 11
+	{ "r12_fiq", { .bankedreg = ARM_BANKEDREG_R12_FIQ }, 0xC },    // 12
+	{ "r12_usr", { .bankedreg = ARM_BANKEDREG_R12_USR }, 0x4 },    // 13
+	{ "r8_fiq", { .bankedreg = ARM_BANKEDREG_R8_FIQ }, 0x8 },      // 14
+	{ "r8_usr", { .bankedreg = ARM_BANKEDREG_R8_USR }, 0x0 },      // 15
+	{ "r9_fiq", { .bankedreg = ARM_BANKEDREG_R9_FIQ }, 0x9 },      // 16
+	{ "r9_usr", { .bankedreg = ARM_BANKEDREG_R9_USR }, 0x1 },      // 17
+	{ "spsr_abt", { .bankedreg = ARM_BANKEDREG_SPSR_ABT }, 0x34 }, // 18
+	{ "spsr_fiq", { .bankedreg = ARM_BANKEDREG_SPSR_FIQ }, 0x2E }, // 19
+	{ "spsr_hyp", { .bankedreg = ARM_BANKEDREG_SPSR_HYP }, 0x3E }, // 20
+	{ "spsr_irq", { .bankedreg = ARM_BANKEDREG_SPSR_IRQ }, 0x30 }, // 21
+	{ "spsr_mon", { .bankedreg = ARM_BANKEDREG_SPSR_MON }, 0x3C }, // 22
+	{ "spsr_svc", { .bankedreg = ARM_BANKEDREG_SPSR_SVC }, 0x32 }, // 23
+	{ "spsr_und", { .bankedreg = ARM_BANKEDREG_SPSR_UND }, 0x36 }, // 24
+	{ "sp_abt", { .bankedreg = ARM_BANKEDREG_SP_ABT }, 0x15 },     // 25
+	{ "sp_fiq", { .bankedreg = ARM_BANKEDREG_SP_FIQ }, 0xD },      // 26
+	{ "sp_hyp", { .bankedreg = ARM_BANKEDREG_SP_HYP }, 0x1F },     // 27
+	{ "sp_irq", { .bankedreg = ARM_BANKEDREG_SP_IRQ }, 0x11 },     // 28
+	{ "sp_mon", { .bankedreg = ARM_BANKEDREG_SP_MON }, 0x1D },     // 29
+	{ "sp_svc", { .bankedreg = ARM_BANKEDREG_SP_SVC }, 0x13 },     // 30
+	{ "sp_und", { .bankedreg = ARM_BANKEDREG_SP_UND }, 0x17 },     // 31
+	{ "sp_usr", { .bankedreg = ARM_BANKEDREG_SP_USR }, 0x5 },      // 32
+};
+
+const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByName(const char *Name)
+{
+	static const struct IndexTypeStr Index[] = {
+		{ "ELR_HYP", 0 },   { "LR_ABT", 1 },	{ "LR_FIQ", 2 },
+		{ "LR_IRQ", 3 },    { "LR_MON", 4 },	{ "LR_SVC", 5 },
+		{ "LR_UND", 6 },    { "LR_USR", 7 },	{ "R10_FIQ", 8 },
+		{ "R10_USR", 9 },   { "R11_FIQ", 10 },	{ "R11_USR", 11 },
+		{ "R12_FIQ", 12 },  { "R12_USR", 13 },	{ "R8_FIQ", 14 },
+		{ "R8_USR", 15 },   { "R9_FIQ", 16 },	{ "R9_USR", 17 },
+		{ "SPSR_ABT", 18 }, { "SPSR_FIQ", 19 }, { "SPSR_HYP", 20 },
+		{ "SPSR_IRQ", 21 }, { "SPSR_MON", 22 }, { "SPSR_SVC", 23 },
+		{ "SPSR_UND", 24 }, { "SP_ABT", 25 },	{ "SP_FIQ", 26 },
+		{ "SP_HYP", 27 },   { "SP_IRQ", 28 },	{ "SP_MON", 29 },
+		{ "SP_SVC", 30 },   { "SP_UND", 31 },	{ "SP_USR", 32 },
+	};
+
+	unsigned i =
+		binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), Name);
+	if (i == -1)
+		return NULL;
+	else
+		return &BankedRegsList[Index[i].index];
+}
+
+const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByEncoding(uint8_t Encoding)
+{
+	static const struct IndexType Index[] = {
+		{ 0x0, 15 },  { 0x1, 17 },  { 0x2, 9 },	  { 0x3, 11 },
+		{ 0x4, 13 },  { 0x5, 32 },  { 0x6, 7 },	  { 0x8, 14 },
+		{ 0x9, 16 },  { 0xA, 8 },   { 0xB, 10 },  { 0xC, 12 },
+		{ 0xD, 26 },  { 0xE, 2 },   { 0x10, 3 },  { 0x11, 28 },
+		{ 0x12, 5 },  { 0x13, 30 }, { 0x14, 1 },  { 0x15, 25 },
+		{ 0x16, 6 },  { 0x17, 31 }, { 0x1C, 4 },  { 0x1D, 29 },
+		{ 0x1E, 0 },  { 0x1F, 27 }, { 0x2E, 19 }, { 0x30, 21 },
+		{ 0x32, 23 }, { 0x34, 18 }, { 0x36, 24 }, { 0x3C, 22 },
+		{ 0x3E, 20 },
+	};
+
+	unsigned i =
+		binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
+	if (i == -1)
+		return NULL;
+	else
+		return &BankedRegsList[Index[i].index];
+}
+
+#endif
+
+#ifdef GET_MCLASSSYSREG_IMPL
+static const ARMSysReg_MClassSysReg MClassSysRegsList[] = {
+	{ "apsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_APSR },
+	  0x800,
+	  0x100,
+	  0x800,
+	  { 0 } }, // 0
+	{ "apsr_g",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_APSR_G },
+	  0x400,
+	  0x0,
+	  0x400,
+	  { ARM_FeatureDSP } }, // 1
+	{ "apsr_nzcvq",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_APSR_NZCVQ },
+	  0x1800,
+	  0x200,
+	  0x800,
+	  { 0 } }, // 2
+	{ "apsr_nzcvqg",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_APSR_NZCVQG },
+	  0xC00,
+	  0x300,
+	  0xC00,
+	  { ARM_FeatureDSP } }, // 3
+	{ "basepri",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_BASEPRI },
+	  0x811,
+	  0x111,
+	  0x811,
+	  { ARM_HasV7Ops } }, // 4
+	{ "basepri_max",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_BASEPRI_MAX },
+	  0x812,
+	  0x112,
+	  0x812,
+	  { ARM_HasV7Ops } }, // 5
+	{ "basepri_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_BASEPRI_NS },
+	  0x891,
+	  0x191,
+	  0x891,
+	  { ARM_Feature8MSecExt, ARM_HasV7Ops } }, // 6
+	{ "control",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_CONTROL },
+	  0x814,
+	  0x114,
+	  0x814,
+	  { 0 } }, // 7
+	{ "control_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_CONTROL_NS },
+	  0x894,
+	  0x194,
+	  0x894,
+	  { ARM_Feature8MSecExt } }, // 8
+	{ "eapsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_EAPSR },
+	  0x802,
+	  0x102,
+	  0x802,
+	  { 0 } }, // 9
+	{ "eapsr_g",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_EAPSR_G },
+	  0x402,
+	  0x2,
+	  0x402,
+	  { ARM_FeatureDSP } }, // 10
+	{ "eapsr_nzcvq",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_EAPSR_NZCVQ },
+	  0x1802,
+	  0x202,
+	  0x802,
+	  { 0 } }, // 11
+	{ "eapsr_nzcvqg",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_EAPSR_NZCVQG },
+	  0xC02,
+	  0x302,
+	  0xC02,
+	  { ARM_FeatureDSP } }, // 12
+	{ "epsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_EPSR },
+	  0x806,
+	  0x106,
+	  0x806,
+	  { 0 } }, // 13
+	{ "faultmask",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_FAULTMASK },
+	  0x813,
+	  0x113,
+	  0x813,
+	  { ARM_HasV7Ops } }, // 14
+	{ "faultmask_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_FAULTMASK_NS },
+	  0x893,
+	  0x193,
+	  0x893,
+	  { ARM_Feature8MSecExt, ARM_HasV7Ops } }, // 15
+	{ "iapsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IAPSR },
+	  0x801,
+	  0x101,
+	  0x801,
+	  { 0 } }, // 16
+	{ "iapsr_g",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IAPSR_G },
+	  0x401,
+	  0x1,
+	  0x401,
+	  { ARM_FeatureDSP } }, // 17
+	{ "iapsr_nzcvq",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IAPSR_NZCVQ },
+	  0x1801,
+	  0x201,
+	  0x801,
+	  { 0 } }, // 18
+	{ "iapsr_nzcvqg",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IAPSR_NZCVQG },
+	  0xC01,
+	  0x301,
+	  0xC01,
+	  { ARM_FeatureDSP } }, // 19
+	{ "iepsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IEPSR },
+	  0x807,
+	  0x107,
+	  0x807,
+	  { 0 } }, // 20
+	{ "ipsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_IPSR },
+	  0x805,
+	  0x105,
+	  0x805,
+	  { 0 } }, // 21
+	{ "msp",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_MSP },
+	  0x808,
+	  0x108,
+	  0x808,
+	  { 0 } }, // 22
+	{ "msplim",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_MSPLIM },
+	  0x80A,
+	  0x10A,
+	  0x80A,
+	  { ARM_HasV8MBaselineOps } }, // 23
+	{ "msplim_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_MSPLIM_NS },
+	  0x88A,
+	  0x18A,
+	  0x88A,
+	  { ARM_Feature8MSecExt, ARM_HasV8MBaselineOps } }, // 24
+	{ "msp_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_MSP_NS },
+	  0x888,
+	  0x188,
+	  0x888,
+	  { ARM_Feature8MSecExt } }, // 25
+	{ "pac_key_p_0",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_0 },
+	  0x820,
+	  0x120,
+	  0x820,
+	  { ARM_FeaturePACBTI } }, // 26
+	{ "pac_key_p_0_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_0_NS },
+	  0x8A0,
+	  0x1A0,
+	  0x8A0,
+	  { ARM_FeaturePACBTI } }, // 27
+	{ "pac_key_p_1",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_1 },
+	  0x821,
+	  0x121,
+	  0x821,
+	  { ARM_FeaturePACBTI } }, // 28
+	{ "pac_key_p_1_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_1_NS },
+	  0x8A1,
+	  0x1A1,
+	  0x8A1,
+	  { ARM_FeaturePACBTI } }, // 29
+	{ "pac_key_p_2",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_2 },
+	  0x822,
+	  0x122,
+	  0x822,
+	  { ARM_FeaturePACBTI } }, // 30
+	{ "pac_key_p_2_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_2_NS },
+	  0x8A2,
+	  0x1A2,
+	  0x8A2,
+	  { ARM_FeaturePACBTI } }, // 31
+	{ "pac_key_p_3",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_3 },
+	  0x823,
+	  0x123,
+	  0x823,
+	  { ARM_FeaturePACBTI } }, // 32
+	{ "pac_key_p_3_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_P_3_NS },
+	  0x8A3,
+	  0x1A3,
+	  0x8A3,
+	  { ARM_FeaturePACBTI } }, // 33
+	{ "pac_key_u_0",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_0 },
+	  0x824,
+	  0x124,
+	  0x824,
+	  { ARM_FeaturePACBTI } }, // 34
+	{ "pac_key_u_0_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_0_NS },
+	  0x8A4,
+	  0x1A4,
+	  0x8A4,
+	  { ARM_FeaturePACBTI } }, // 35
+	{ "pac_key_u_1",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_1 },
+	  0x825,
+	  0x125,
+	  0x825,
+	  { ARM_FeaturePACBTI } }, // 36
+	{ "pac_key_u_1_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_1_NS },
+	  0x8A5,
+	  0x1A5,
+	  0x8A5,
+	  { ARM_FeaturePACBTI } }, // 37
+	{ "pac_key_u_2",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_2 },
+	  0x826,
+	  0x126,
+	  0x826,
+	  { ARM_FeaturePACBTI } }, // 38
+	{ "pac_key_u_2_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_2_NS },
+	  0x8A6,
+	  0x1A6,
+	  0x8A6,
+	  { ARM_FeaturePACBTI } }, // 39
+	{ "pac_key_u_3",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_3 },
+	  0x827,
+	  0x127,
+	  0x827,
+	  { ARM_FeaturePACBTI } }, // 40
+	{ "pac_key_u_3_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PAC_KEY_U_3_NS },
+	  0x8A7,
+	  0x1A7,
+	  0x8A7,
+	  { ARM_FeaturePACBTI } }, // 41
+	{ "primask",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PRIMASK },
+	  0x810,
+	  0x110,
+	  0x810,
+	  { 0 } }, // 42
+	{ "primask_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PRIMASK_NS },
+	  0x890,
+	  0x190,
+	  0x890,
+	  { 0 } }, // 43
+	{ "psp",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PSP },
+	  0x809,
+	  0x109,
+	  0x809,
+	  { 0 } }, // 44
+	{ "psplim",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PSPLIM },
+	  0x80B,
+	  0x10B,
+	  0x80B,
+	  { ARM_HasV8MBaselineOps } }, // 45
+	{ "psplim_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PSPLIM_NS },
+	  0x88B,
+	  0x18B,
+	  0x88B,
+	  { ARM_Feature8MSecExt, ARM_HasV8MBaselineOps } }, // 46
+	{ "psp_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_PSP_NS },
+	  0x889,
+	  0x189,
+	  0x889,
+	  { ARM_Feature8MSecExt } }, // 47
+	{ "sp_ns",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_SP_NS },
+	  0x898,
+	  0x198,
+	  0x898,
+	  { ARM_Feature8MSecExt } }, // 48
+	{ "xpsr",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_XPSR },
+	  0x803,
+	  0x103,
+	  0x803,
+	  { 0 } }, // 49
+	{ "xpsr_g",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_XPSR_G },
+	  0x403,
+	  0x3,
+	  0x403,
+	  { ARM_FeatureDSP } }, // 50
+	{ "xpsr_nzcvq",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_XPSR_NZCVQ },
+	  0x1803,
+	  0x203,
+	  0x803,
+	  { 0 } }, // 51
+	{ "xpsr_nzcvqg",
+	  { .mclasssysreg = ARM_MCLASSSYSREG_XPSR_NZCVQG },
+	  0xC03,
+	  0x303,
+	  0xC03,
+	  { ARM_FeatureDSP } }, // 52
+};
+
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByName(const char *Name)
+{
+	static const struct IndexTypeStr Index[] = {
+		{ "APSR", 0 },		{ "APSR_G", 1 },
+		{ "APSR_NZCVQ", 2 },	{ "APSR_NZCVQG", 3 },
+		{ "BASEPRI", 4 },	{ "BASEPRI_MAX", 5 },
+		{ "BASEPRI_NS", 6 },	{ "CONTROL", 7 },
+		{ "CONTROL_NS", 8 },	{ "EAPSR", 9 },
+		{ "EAPSR_G", 10 },	{ "EAPSR_NZCVQ", 11 },
+		{ "EAPSR_NZCVQG", 12 }, { "EPSR", 13 },
+		{ "FAULTMASK", 14 },	{ "FAULTMASK_NS", 15 },
+		{ "IAPSR", 16 },	{ "IAPSR_G", 17 },
+		{ "IAPSR_NZCVQ", 18 },	{ "IAPSR_NZCVQG", 19 },
+		{ "IEPSR", 20 },	{ "IPSR", 21 },
+		{ "MSP", 22 },		{ "MSPLIM", 23 },
+		{ "MSPLIM_NS", 24 },	{ "MSP_NS", 25 },
+		{ "PAC_KEY_P_0", 26 },	{ "PAC_KEY_P_0_NS", 27 },
+		{ "PAC_KEY_P_1", 28 },	{ "PAC_KEY_P_1_NS", 29 },
+		{ "PAC_KEY_P_2", 30 },	{ "PAC_KEY_P_2_NS", 31 },
+		{ "PAC_KEY_P_3", 32 },	{ "PAC_KEY_P_3_NS", 33 },
+		{ "PAC_KEY_U_0", 34 },	{ "PAC_KEY_U_0_NS", 35 },
+		{ "PAC_KEY_U_1", 36 },	{ "PAC_KEY_U_1_NS", 37 },
+		{ "PAC_KEY_U_2", 38 },	{ "PAC_KEY_U_2_NS", 39 },
+		{ "PAC_KEY_U_3", 40 },	{ "PAC_KEY_U_3_NS", 41 },
+		{ "PRIMASK", 42 },	{ "PRIMASK_NS", 43 },
+		{ "PSP", 44 },		{ "PSPLIM", 45 },
+		{ "PSPLIM_NS", 46 },	{ "PSP_NS", 47 },
+		{ "SP_NS", 48 },	{ "XPSR", 49 },
+		{ "XPSR_G", 50 },	{ "XPSR_NZCVQ", 51 },
+		{ "XPSR_NZCVQG", 52 },
+	};
+
+	unsigned i =
+		binsearch_IndexTypeStrEncoding(Index, ARR_SIZE(Index), Name);
+	if (i == -1)
+		return NULL;
+	else
+		return &MClassSysRegsList[Index[i].index];
+}
+
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByM1Encoding12(uint16_t M1Encoding12)
+{
+	static const struct IndexType Index[] = {
+		{ 0x400, 1 },	{ 0x401, 17 }, { 0x402, 10 },  { 0x403, 50 },
+		{ 0x800, 0 },	{ 0x801, 16 }, { 0x802, 9 },   { 0x803, 49 },
+		{ 0x805, 21 },	{ 0x806, 13 }, { 0x807, 20 },  { 0x808, 22 },
+		{ 0x809, 44 },	{ 0x80A, 23 }, { 0x80B, 45 },  { 0x810, 42 },
+		{ 0x811, 4 },	{ 0x812, 5 },  { 0x813, 14 },  { 0x814, 7 },
+		{ 0x820, 26 },	{ 0x821, 28 }, { 0x822, 30 },  { 0x823, 32 },
+		{ 0x824, 34 },	{ 0x825, 36 }, { 0x826, 38 },  { 0x827, 40 },
+		{ 0x888, 25 },	{ 0x889, 47 }, { 0x88A, 24 },  { 0x88B, 46 },
+		{ 0x890, 43 },	{ 0x891, 6 },  { 0x893, 15 },  { 0x894, 8 },
+		{ 0x898, 48 },	{ 0x8A0, 27 }, { 0x8A1, 29 },  { 0x8A2, 31 },
+		{ 0x8A3, 33 },	{ 0x8A4, 35 }, { 0x8A5, 37 },  { 0x8A6, 39 },
+		{ 0x8A7, 41 },	{ 0xC00, 3 },  { 0xC01, 19 },  { 0xC02, 12 },
+		{ 0xC03, 52 },	{ 0x1800, 2 }, { 0x1801, 18 }, { 0x1802, 11 },
+		{ 0x1803, 51 },
+	};
+
+	unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index),
+						 M1Encoding12);
+	if (i == -1)
+		return NULL;
+	else
+		return &MClassSysRegsList[Index[i].index];
+}
+
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByM2M3Encoding8(uint16_t M2M3Encoding8)
+{
+	static const struct IndexType Index[] = {
+		{ 0x0, 1 },    { 0x1, 17 },   { 0x2, 10 },   { 0x3, 50 },
+		{ 0x100, 0 },  { 0x101, 16 }, { 0x102, 9 },  { 0x103, 49 },
+		{ 0x105, 21 }, { 0x106, 13 }, { 0x107, 20 }, { 0x108, 22 },
+		{ 0x109, 44 }, { 0x10A, 23 }, { 0x10B, 45 }, { 0x110, 42 },
+		{ 0x111, 4 },  { 0x112, 5 },  { 0x113, 14 }, { 0x114, 7 },
+		{ 0x120, 26 }, { 0x121, 28 }, { 0x122, 30 }, { 0x123, 32 },
+		{ 0x124, 34 }, { 0x125, 36 }, { 0x126, 38 }, { 0x127, 40 },
+		{ 0x188, 25 }, { 0x189, 47 }, { 0x18A, 24 }, { 0x18B, 46 },
+		{ 0x190, 43 }, { 0x191, 6 },  { 0x193, 15 }, { 0x194, 8 },
+		{ 0x198, 48 }, { 0x1A0, 27 }, { 0x1A1, 29 }, { 0x1A2, 31 },
+		{ 0x1A3, 33 }, { 0x1A4, 35 }, { 0x1A5, 37 }, { 0x1A6, 39 },
+		{ 0x1A7, 41 }, { 0x200, 2 },  { 0x201, 18 }, { 0x202, 11 },
+		{ 0x203, 51 }, { 0x300, 3 },  { 0x301, 19 }, { 0x302, 12 },
+		{ 0x303, 52 },
+	};
+
+	unsigned i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index),
+						 M2M3Encoding8);
+	if (i == -1)
+		return NULL;
+	else
+		return &MClassSysRegsList[Index[i].index];
+}
+
+const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByEncoding(uint16_t Encoding)
+{
+	static const struct IndexType Index[] = {
+		{ 0x400, 1 },  { 0x401, 17 }, { 0x402, 10 }, { 0x403, 50 },
+		{ 0x800, 0 },  { 0x800, 2 },  { 0x801, 16 }, { 0x801, 18 },
+		{ 0x802, 9 },  { 0x802, 11 }, { 0x803, 49 }, { 0x803, 51 },
+		{ 0x805, 21 }, { 0x806, 13 }, { 0x807, 20 }, { 0x808, 22 },
+		{ 0x809, 44 }, { 0x80A, 23 }, { 0x80B, 45 }, { 0x810, 42 },
+		{ 0x811, 4 },  { 0x812, 5 },  { 0x813, 14 }, { 0x814, 7 },
+		{ 0x820, 26 }, { 0x821, 28 }, { 0x822, 30 }, { 0x823, 32 },
+		{ 0x824, 34 }, { 0x825, 36 }, { 0x826, 38 }, { 0x827, 40 },
+		{ 0x888, 25 }, { 0x889, 47 }, { 0x88A, 24 }, { 0x88B, 46 },
+		{ 0x890, 43 }, { 0x891, 6 },  { 0x893, 15 }, { 0x894, 8 },
+		{ 0x898, 48 }, { 0x8A0, 27 }, { 0x8A1, 29 }, { 0x8A2, 31 },
+		{ 0x8A3, 33 }, { 0x8A4, 35 }, { 0x8A5, 37 }, { 0x8A6, 39 },
+		{ 0x8A7, 41 }, { 0xC00, 3 },  { 0xC01, 19 }, { 0xC02, 12 },
+		{ 0xC03, 52 },
+	};
+
+	unsigned i =
+		binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
+	if (i == -1)
+		return NULL;
+	else
+		return &MClassSysRegsList[Index[i].index];
+}
+
+#endif
+
+#undef GET_BANKEDREG_DECL
+#undef GET_MCLASSSYSREG_DECL

thirdparty/capstone/arch/ARM/ARMInsnEnum.inc

@@ -0,0 +1,162 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+/* By Rot127 <unisono@quyllur.org>, 2023 */
+
+/* Auto generated file. Do not edit. */
+/* Code generator: https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */
+
+ARM_INS___BRKDIV0, ARM_INS_ADC, ARM_INS_ADD, ARM_INS_ADDW, ARM_INS_ADR,
+	ARM_INS_AESD, ARM_INS_AESE, ARM_INS_AESIMC, ARM_INS_AESMC, ARM_INS_AND,
+	ARM_INS_ASR, ARM_INS_ASRL, ARM_INS_AUT, ARM_INS_AUTG, ARM_INS_B,
+	ARM_INS_BF, ARM_INS_BFC, ARM_INS_BFCSEL, ARM_INS_BFI, ARM_INS_BFL,
+	ARM_INS_BFLX, ARM_INS_BFX, ARM_INS_BIC, ARM_INS_BKPT, ARM_INS_BL,
+	ARM_INS_BLX, ARM_INS_BLXNS, ARM_INS_BTI, ARM_INS_BX, ARM_INS_BXAUT,
+	ARM_INS_BXJ, ARM_INS_BXNS, ARM_INS_CBNZ, ARM_INS_CBZ, ARM_INS_CDP,
+	ARM_INS_CDP2, ARM_INS_CINC, ARM_INS_CINV, ARM_INS_CLRBHB, ARM_INS_CLREX,
+	ARM_INS_CLRM, ARM_INS_CLZ, ARM_INS_CMN, ARM_INS_CMP, ARM_INS_CNEG,
+	ARM_INS_CPS, ARM_INS_CRC32B, ARM_INS_CRC32CB, ARM_INS_CRC32CH,
+	ARM_INS_CRC32CW, ARM_INS_CRC32H, ARM_INS_CRC32W, ARM_INS_CSDB,
+	ARM_INS_CSEL, ARM_INS_CSET, ARM_INS_CSETM, ARM_INS_CSINC, ARM_INS_CSINV,
+	ARM_INS_CSNEG, ARM_INS_CX1, ARM_INS_CX1A, ARM_INS_CX1D, ARM_INS_CX1DA,
+	ARM_INS_CX2, ARM_INS_CX2A, ARM_INS_CX2D, ARM_INS_CX2DA, ARM_INS_CX3,
+	ARM_INS_CX3A, ARM_INS_CX3D, ARM_INS_CX3DA, ARM_INS_DBG, ARM_INS_DCPS1,
+	ARM_INS_DCPS2, ARM_INS_DCPS3, ARM_INS_DFB, ARM_INS_DLS, ARM_INS_DLSTP,
+	ARM_INS_DMB, ARM_INS_DSB, ARM_INS_EOR, ARM_INS_ERET, ARM_INS_ESB,
+	ARM_INS_FADDD, ARM_INS_FADDS, ARM_INS_FCMPZD, ARM_INS_FCMPZS,
+	ARM_INS_FCONSTD, ARM_INS_FCONSTS, ARM_INS_FLDMDBX, ARM_INS_FLDMIAX,
+	ARM_INS_FMDHR, ARM_INS_FMDLR, ARM_INS_FMSTAT, ARM_INS_FSTMDBX,
+	ARM_INS_FSTMIAX, ARM_INS_FSUBD, ARM_INS_FSUBS, ARM_INS_HINT,
+	ARM_INS_HLT, ARM_INS_HVC, ARM_INS_ISB, ARM_INS_IT, ARM_INS_LCTP,
+	ARM_INS_LDA, ARM_INS_LDAB, ARM_INS_LDAEX, ARM_INS_LDAEXB,
+	ARM_INS_LDAEXD, ARM_INS_LDAEXH, ARM_INS_LDAH, ARM_INS_LDC, ARM_INS_LDC2,
+	ARM_INS_LDC2L, ARM_INS_LDCL, ARM_INS_LDM, ARM_INS_LDMDA, ARM_INS_LDMDB,
+	ARM_INS_LDMIB, ARM_INS_LDR, ARM_INS_LDRB, ARM_INS_LDRBT, ARM_INS_LDRD,
+	ARM_INS_LDREX, ARM_INS_LDREXB, ARM_INS_LDREXD, ARM_INS_LDREXH,
+	ARM_INS_LDRH, ARM_INS_LDRHT, ARM_INS_LDRSB, ARM_INS_LDRSBT,
+	ARM_INS_LDRSH, ARM_INS_LDRSHT, ARM_INS_LDRT, ARM_INS_LE, ARM_INS_LETP,
+	ARM_INS_LSL, ARM_INS_LSLL, ARM_INS_LSR, ARM_INS_LSRL, ARM_INS_MCR,
+	ARM_INS_MCR2, ARM_INS_MCRR, ARM_INS_MCRR2, ARM_INS_MLA, ARM_INS_MLS,
+	ARM_INS_MOV, ARM_INS_MOVS, ARM_INS_MOVT, ARM_INS_MOVW, ARM_INS_MRC,
+	ARM_INS_MRC2, ARM_INS_MRRC, ARM_INS_MRRC2, ARM_INS_MRS, ARM_INS_MSR,
+	ARM_INS_MUL, ARM_INS_MVN, ARM_INS_NEG, ARM_INS_NOP, ARM_INS_ORN,
+	ARM_INS_ORR, ARM_INS_PAC, ARM_INS_PACBTI, ARM_INS_PACG, ARM_INS_PKHBT,
+	ARM_INS_PKHTB, ARM_INS_PLD, ARM_INS_PLDW, ARM_INS_PLI, ARM_INS_POP,
+	ARM_INS_PSSBB, ARM_INS_PUSH, ARM_INS_QADD, ARM_INS_QADD16,
+	ARM_INS_QADD8, ARM_INS_QASX, ARM_INS_QDADD, ARM_INS_QDSUB, ARM_INS_QSAX,
+	ARM_INS_QSUB, ARM_INS_QSUB16, ARM_INS_QSUB8, ARM_INS_RBIT, ARM_INS_REV,
+	ARM_INS_REV16, ARM_INS_REVSH, ARM_INS_RFEDA, ARM_INS_RFEDB,
+	ARM_INS_RFEIA, ARM_INS_RFEIB, ARM_INS_ROR, ARM_INS_RRX, ARM_INS_RSB,
+	ARM_INS_RSC, ARM_INS_SADD16, ARM_INS_SADD8, ARM_INS_SASX, ARM_INS_SB,
+	ARM_INS_SBC, ARM_INS_SBFX, ARM_INS_SDIV, ARM_INS_SEL, ARM_INS_SETEND,
+	ARM_INS_SETPAN, ARM_INS_SEV, ARM_INS_SEVL, ARM_INS_SG, ARM_INS_SHA1C,
+	ARM_INS_SHA1H, ARM_INS_SHA1M, ARM_INS_SHA1P, ARM_INS_SHA1SU0,
+	ARM_INS_SHA1SU1, ARM_INS_SHA256H, ARM_INS_SHA256H2, ARM_INS_SHA256SU0,
+	ARM_INS_SHA256SU1, ARM_INS_SHADD16, ARM_INS_SHADD8, ARM_INS_SHASX,
+	ARM_INS_SHSAX, ARM_INS_SHSUB16, ARM_INS_SHSUB8, ARM_INS_SMC,
+	ARM_INS_SMLABB, ARM_INS_SMLABT, ARM_INS_SMLAD, ARM_INS_SMLADX,
+	ARM_INS_SMLAL, ARM_INS_SMLALBB, ARM_INS_SMLALBT, ARM_INS_SMLALD,
+	ARM_INS_SMLALDX, ARM_INS_SMLALTB, ARM_INS_SMLALTT, ARM_INS_SMLATB,
+	ARM_INS_SMLATT, ARM_INS_SMLAWB, ARM_INS_SMLAWT, ARM_INS_SMLSD,
+	ARM_INS_SMLSDX, ARM_INS_SMLSLD, ARM_INS_SMLSLDX, ARM_INS_SMMLA,
+	ARM_INS_SMMLAR, ARM_INS_SMMLS, ARM_INS_SMMLSR, ARM_INS_SMMUL,
+	ARM_INS_SMMULR, ARM_INS_SMUAD, ARM_INS_SMUADX, ARM_INS_SMULBB,
+	ARM_INS_SMULBT, ARM_INS_SMULL, ARM_INS_SMULTB, ARM_INS_SMULTT,
+	ARM_INS_SMULWB, ARM_INS_SMULWT, ARM_INS_SMUSD, ARM_INS_SMUSDX,
+	ARM_INS_SQRSHR, ARM_INS_SQRSHRL, ARM_INS_SQSHL, ARM_INS_SQSHLL,
+	ARM_INS_SRSDA, ARM_INS_SRSDB, ARM_INS_SRSHR, ARM_INS_SRSHRL,
+	ARM_INS_SRSIA, ARM_INS_SRSIB, ARM_INS_SSAT, ARM_INS_SSAT16,
+	ARM_INS_SSAX, ARM_INS_SSBB, ARM_INS_SSUB16, ARM_INS_SSUB8, ARM_INS_STC,
+	ARM_INS_STC2, ARM_INS_STC2L, ARM_INS_STCL, ARM_INS_STL, ARM_INS_STLB,
+	ARM_INS_STLEX, ARM_INS_STLEXB, ARM_INS_STLEXD, ARM_INS_STLEXH,
+	ARM_INS_STLH, ARM_INS_STM, ARM_INS_STMDA, ARM_INS_STMDB, ARM_INS_STMIB,
+	ARM_INS_STR, ARM_INS_STRB, ARM_INS_STRBT, ARM_INS_STRD, ARM_INS_STREX,
+	ARM_INS_STREXB, ARM_INS_STREXD, ARM_INS_STREXH, ARM_INS_STRH,
+	ARM_INS_STRHT, ARM_INS_STRT, ARM_INS_SUB, ARM_INS_SUBS, ARM_INS_SUBW,
+	ARM_INS_SVC, ARM_INS_SWP, ARM_INS_SWPB, ARM_INS_SXTAB, ARM_INS_SXTAB16,
+	ARM_INS_SXTAH, ARM_INS_SXTB, ARM_INS_SXTB16, ARM_INS_SXTH, ARM_INS_TBB,
+	ARM_INS_TBH, ARM_INS_TEQ, ARM_INS_TRAP, ARM_INS_TSB, ARM_INS_TST,
+	ARM_INS_TT, ARM_INS_TTA, ARM_INS_TTAT, ARM_INS_TTT, ARM_INS_UADD16,
+	ARM_INS_UADD8, ARM_INS_UASX, ARM_INS_UBFX, ARM_INS_UDF, ARM_INS_UDIV,
+	ARM_INS_UHADD16, ARM_INS_UHADD8, ARM_INS_UHASX, ARM_INS_UHSAX,
+	ARM_INS_UHSUB16, ARM_INS_UHSUB8, ARM_INS_UMAAL, ARM_INS_UMLAL,
+	ARM_INS_UMULL, ARM_INS_UQADD16, ARM_INS_UQADD8, ARM_INS_UQASX,
+	ARM_INS_UQRSHL, ARM_INS_UQRSHLL, ARM_INS_UQSAX, ARM_INS_UQSHL,
+	ARM_INS_UQSHLL, ARM_INS_UQSUB16, ARM_INS_UQSUB8, ARM_INS_URSHR,
+	ARM_INS_URSHRL, ARM_INS_USAD8, ARM_INS_USADA8, ARM_INS_USAT,
+	ARM_INS_USAT16, ARM_INS_USAX, ARM_INS_USUB16, ARM_INS_USUB8,
+	ARM_INS_UXTAB, ARM_INS_UXTAB16, ARM_INS_UXTAH, ARM_INS_UXTB,
+	ARM_INS_UXTB16, ARM_INS_UXTH, ARM_INS_VABA, ARM_INS_VABAL,
+	ARM_INS_VABAV, ARM_INS_VABD, ARM_INS_VABDL, ARM_INS_VABS, ARM_INS_VACGE,
+	ARM_INS_VACGT, ARM_INS_VACLE, ARM_INS_VACLT, ARM_INS_VADC,
+	ARM_INS_VADCI, ARM_INS_VADD, ARM_INS_VADDHN, ARM_INS_VADDL,
+	ARM_INS_VADDLV, ARM_INS_VADDLVA, ARM_INS_VADDV, ARM_INS_VADDVA,
+	ARM_INS_VADDW, ARM_INS_VAND, ARM_INS_VBIC, ARM_INS_VBIF, ARM_INS_VBIT,
+	ARM_INS_VBRSR, ARM_INS_VBSL, ARM_INS_VCADD, ARM_INS_VCEQ, ARM_INS_VCGE,
+	ARM_INS_VCGT, ARM_INS_VCLE, ARM_INS_VCLS, ARM_INS_VCLT, ARM_INS_VCLZ,
+	ARM_INS_VCMLA, ARM_INS_VCMP, ARM_INS_VCMPE, ARM_INS_VCMUL, ARM_INS_VCNT,
+	ARM_INS_VCTP, ARM_INS_VCVT, ARM_INS_VCVTA, ARM_INS_VCVTB, ARM_INS_VCVTM,
+	ARM_INS_VCVTN, ARM_INS_VCVTP, ARM_INS_VCVTR, ARM_INS_VCVTT,
+	ARM_INS_VCX1, ARM_INS_VCX1A, ARM_INS_VCX2, ARM_INS_VCX2A, ARM_INS_VCX3,
+	ARM_INS_VCX3A, ARM_INS_VDDUP, ARM_INS_VDIV, ARM_INS_VDOT, ARM_INS_VDUP,
+	ARM_INS_VDWDUP, ARM_INS_VEOR, ARM_INS_VEXT, ARM_INS_VFMA, ARM_INS_VFMAB,
+	ARM_INS_VFMAL, ARM_INS_VFMAS, ARM_INS_VFMAT, ARM_INS_VFMS,
+	ARM_INS_VFMSL, ARM_INS_VFNMA, ARM_INS_VFNMS, ARM_INS_VHADD,
+	ARM_INS_VHCADD, ARM_INS_VHSUB, ARM_INS_VIDUP, ARM_INS_VINS,
+	ARM_INS_VIWDUP, ARM_INS_VJCVT, ARM_INS_VLD1, ARM_INS_VLD2,
+	ARM_INS_VLD20, ARM_INS_VLD21, ARM_INS_VLD3, ARM_INS_VLD4, ARM_INS_VLD40,
+	ARM_INS_VLD41, ARM_INS_VLD42, ARM_INS_VLD43, ARM_INS_VLDMDB,
+	ARM_INS_VLDMIA, ARM_INS_VLDR, ARM_INS_VLDRB, ARM_INS_VLDRD,
+	ARM_INS_VLDRH, ARM_INS_VLDRW, ARM_INS_VLLDM, ARM_INS_VLSTM,
+	ARM_INS_VMAX, ARM_INS_VMAXA, ARM_INS_VMAXAV, ARM_INS_VMAXNM,
+	ARM_INS_VMAXNMA, ARM_INS_VMAXNMAV, ARM_INS_VMAXNMV, ARM_INS_VMAXV,
+	ARM_INS_VMIN, ARM_INS_VMINA, ARM_INS_VMINAV, ARM_INS_VMINNM,
+	ARM_INS_VMINNMA, ARM_INS_VMINNMAV, ARM_INS_VMINNMV, ARM_INS_VMINV,
+	ARM_INS_VMLA, ARM_INS_VMLADAV, ARM_INS_VMLADAVA, ARM_INS_VMLADAVAX,
+	ARM_INS_VMLADAVX, ARM_INS_VMLAL, ARM_INS_VMLALDAV, ARM_INS_VMLALDAVA,
+	ARM_INS_VMLALDAVAX, ARM_INS_VMLALDAVX, ARM_INS_VMLALV, ARM_INS_VMLALVA,
+	ARM_INS_VMLAS, ARM_INS_VMLAV, ARM_INS_VMLAVA, ARM_INS_VMLS,
+	ARM_INS_VMLSDAV, ARM_INS_VMLSDAVA, ARM_INS_VMLSDAVAX, ARM_INS_VMLSDAVX,
+	ARM_INS_VMLSL, ARM_INS_VMLSLDAV, ARM_INS_VMLSLDAVA, ARM_INS_VMLSLDAVAX,
+	ARM_INS_VMLSLDAVX, ARM_INS_VMMLA, ARM_INS_VMOV, ARM_INS_VMOVL,
+	ARM_INS_VMOVLB, ARM_INS_VMOVLT, ARM_INS_VMOVN, ARM_INS_VMOVNB,
+	ARM_INS_VMOVNT, ARM_INS_VMOVX, ARM_INS_VMRS, ARM_INS_VMSR, ARM_INS_VMUL,
+	ARM_INS_VMULH, ARM_INS_VMULL, ARM_INS_VMULLB, ARM_INS_VMULLT,
+	ARM_INS_VMVN, ARM_INS_VNEG, ARM_INS_VNMLA, ARM_INS_VNMLS, ARM_INS_VNMUL,
+	ARM_INS_VORN, ARM_INS_VORR, ARM_INS_VPADAL, ARM_INS_VPADD,
+	ARM_INS_VPADDL, ARM_INS_VPMAX, ARM_INS_VPMIN, ARM_INS_VPNOT,
+	ARM_INS_VPOP, ARM_INS_VPSEL, ARM_INS_VPST, ARM_INS_VPT, ARM_INS_VPUSH,
+	ARM_INS_VQABS, ARM_INS_VQADD, ARM_INS_VQDMLADH, ARM_INS_VQDMLADHX,
+	ARM_INS_VQDMLAH, ARM_INS_VQDMLAL, ARM_INS_VQDMLASH, ARM_INS_VQDMLSDH,
+	ARM_INS_VQDMLSDHX, ARM_INS_VQDMLSL, ARM_INS_VQDMULH, ARM_INS_VQDMULL,
+	ARM_INS_VQDMULLB, ARM_INS_VQDMULLT, ARM_INS_VQMOVN, ARM_INS_VQMOVNB,
+	ARM_INS_VQMOVNT, ARM_INS_VQMOVUN, ARM_INS_VQMOVUNB, ARM_INS_VQMOVUNT,
+	ARM_INS_VQNEG, ARM_INS_VQRDMLADH, ARM_INS_VQRDMLADHX, ARM_INS_VQRDMLAH,
+	ARM_INS_VQRDMLASH, ARM_INS_VQRDMLSDH, ARM_INS_VQRDMLSDHX,
+	ARM_INS_VQRDMLSH, ARM_INS_VQRDMULH, ARM_INS_VQRSHL, ARM_INS_VQRSHRN,
+	ARM_INS_VQRSHRNB, ARM_INS_VQRSHRNT, ARM_INS_VQRSHRUN, ARM_INS_VQRSHRUNB,
+	ARM_INS_VQRSHRUNT, ARM_INS_VQSHL, ARM_INS_VQSHLU, ARM_INS_VQSHRN,
+	ARM_INS_VQSHRNB, ARM_INS_VQSHRNT, ARM_INS_VQSHRUN, ARM_INS_VQSHRUNB,
+	ARM_INS_VQSHRUNT, ARM_INS_VQSUB, ARM_INS_VRADDHN, ARM_INS_VRECPE,
+	ARM_INS_VRECPS, ARM_INS_VREV16, ARM_INS_VREV32, ARM_INS_VREV64,
+	ARM_INS_VRHADD, ARM_INS_VRINTA, ARM_INS_VRINTM, ARM_INS_VRINTN,
+	ARM_INS_VRINTP, ARM_INS_VRINTR, ARM_INS_VRINTX, ARM_INS_VRINTZ,
+	ARM_INS_VRMLALDAVH, ARM_INS_VRMLALDAVHA, ARM_INS_VRMLALDAVHAX,
+	ARM_INS_VRMLALDAVHX, ARM_INS_VRMLALVH, ARM_INS_VRMLALVHA,
+	ARM_INS_VRMLSLDAVH, ARM_INS_VRMLSLDAVHA, ARM_INS_VRMLSLDAVHAX,
+	ARM_INS_VRMLSLDAVHX, ARM_INS_VRMULH, ARM_INS_VRSHL, ARM_INS_VRSHR,
+	ARM_INS_VRSHRN, ARM_INS_VRSHRNB, ARM_INS_VRSHRNT, ARM_INS_VRSQRTE,
+	ARM_INS_VRSQRTS, ARM_INS_VRSRA, ARM_INS_VRSUBHN, ARM_INS_VSBC,
+	ARM_INS_VSBCI, ARM_INS_VSCCLRM, ARM_INS_VSDOT, ARM_INS_VSELEQ,
+	ARM_INS_VSELGE, ARM_INS_VSELGT, ARM_INS_VSELVS, ARM_INS_VSHL,
+	ARM_INS_VSHLC, ARM_INS_VSHLL, ARM_INS_VSHLLB, ARM_INS_VSHLLT,
+	ARM_INS_VSHR, ARM_INS_VSHRN, ARM_INS_VSHRNB, ARM_INS_VSHRNT,
+	ARM_INS_VSLI, ARM_INS_VSMMLA, ARM_INS_VSQRT, ARM_INS_VSRA, ARM_INS_VSRI,
+	ARM_INS_VST1, ARM_INS_VST2, ARM_INS_VST20, ARM_INS_VST21, ARM_INS_VST3,
+	ARM_INS_VST4, ARM_INS_VST40, ARM_INS_VST41, ARM_INS_VST42,
+	ARM_INS_VST43, ARM_INS_VSTMDB, ARM_INS_VSTMIA, ARM_INS_VSTR,
+	ARM_INS_VSTRB, ARM_INS_VSTRD, ARM_INS_VSTRH, ARM_INS_VSTRW,
+	ARM_INS_VSUB, ARM_INS_VSUBHN, ARM_INS_VSUBL, ARM_INS_VSUBW,
+	ARM_INS_VSUDOT, ARM_INS_VSWP, ARM_INS_VTBL, ARM_INS_VTBX, ARM_INS_VTRN,
+	ARM_INS_VTST, ARM_INS_VUDOT, ARM_INS_VUMMLA, ARM_INS_VUSDOT,
+	ARM_INS_VUSMMLA, ARM_INS_VUZP, ARM_INS_VZIP, ARM_INS_WFE, ARM_INS_WFI,
+	ARM_INS_WLS, ARM_INS_WLSTP, ARM_INS_YIELD,

thirdparty/capstone/arch/ARM/ARMInstPrinter.h

@@ -0,0 +1,203 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2023 */
+/* Automatically translated source file from LLVM. */
+
+/* LLVM-commit: 464bda7750a3ba9e23823fc707d7e7b6fc38438d */
+/* LLVM-tag: llvmorg-16.0.2-5-g464bda7750a3 */
+
+/* Only small edits allowed. */
+/* For multiple similar edits, please create a Patch for the translator. */
+
+/* Capstone's C++ file translator: */
+/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */
+
+//===- ARMInstPrinter.h - Convert ARM MCInst to assembly syntax -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This class prints an ARM MCInst to a .s file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CS_ARM_INSTPRINTER_H
+#define CS_ARM_INSTPRINTER_H
+
+#include <capstone/platform.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../MCInst.h"
+#include "../../MCInstPrinter.h"
+#include "../../MCRegisterInfo.h"
+#include "../../SStream.h"
+#include "../../utils.h"
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+bool applyTargetSpecificCLOption(const char *Opt);
+// Autogenerated by tblgen.
+void printOperandAddr(MCInst *MI, uint64_t Address, unsigned OpNum, SStream *O);
+void printSORegRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printSORegImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printAddrModeTBB(MCInst *MI, unsigned OpNum, SStream *O);
+void printAddrModeTBH(MCInst *MI, unsigned OpNum, SStream *O);
+void printAddrMode2Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printAM2PostIndexOp(MCInst *MI, unsigned OpNum, SStream *O);
+void printAM2PreOrOffsetIndexOp(MCInst *MI, unsigned OpNum, SStream *O);
+void printAddrMode2OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printAddrMode3Operand(AlwaysPrintImm0) \
+	void CONCAT(printAddrMode3Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printAddrMode3Operand(false) DECLARE_printAddrMode3Operand(true)
+
+	void printAddrMode3OffsetOperand(MCInst *MI, unsigned OpNum,
+					 SStream *O);
+void printAM3PreOrOffsetIndexOp(MCInst *MI, unsigned Op, SStream *O,
+				bool AlwaysPrintImm0);
+void printPostIdxImm8Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printPostIdxRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printPostIdxImm8s4Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printLdStmModeOperand(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printAddrMode5Operand(AlwaysPrintImm0) \
+	void CONCAT(printAddrMode5Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printAddrMode5Operand(false) DECLARE_printAddrMode5Operand(true)
+
+#define DECLARE_printAddrMode5FP16Operand(AlwaysPrintImm0) \
+	void CONCAT(printAddrMode5FP16Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+	DECLARE_printAddrMode5FP16Operand(false)
+
+		void printAddrMode6Operand(MCInst *MI, unsigned OpNum,
+					   SStream *O);
+void printAddrMode7Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printAddrMode6OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printBitfieldInvMaskImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printMemBOption(MCInst *MI, unsigned OpNum, SStream *O);
+void printInstSyncBOption(MCInst *MI, unsigned OpNum, SStream *O);
+void printTraceSyncBOption(MCInst *MI, unsigned OpNum, SStream *O);
+void printShiftImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printPKHLSLShiftImm(MCInst *MI, unsigned OpNum, SStream *O);
+void printPKHASRShiftImm(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printAdrLabelOperand(scale) \
+	void CONCAT(printAdrLabelOperand, scale)(MCInst * MI, unsigned OpNum, \
+						 SStream *O);
+DECLARE_printAdrLabelOperand(0) DECLARE_printAdrLabelOperand(2)
+
+#define DEFINE_printAdrLabelOperandAddr(scale) \
+	static inline void CONCAT(printAdrLabelOperandAddr, scale)( \
+		MCInst * MI, uint64_t Address, unsigned OpNum, SStream *O) \
+	{ \
+		CONCAT(printAdrLabelOperand, scale)(MI, OpNum, O); \
+	}
+	DEFINE_printAdrLabelOperandAddr(0) DEFINE_printAdrLabelOperandAddr(2)
+
+		void printThumbS4ImmOperand(MCInst *MI, unsigned OpNum,
+					    SStream *O);
+void printThumbSRImm(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbITMask(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbAddrModeRROperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbAddrModeImm5SOperand(MCInst *MI, unsigned OpNum, SStream *O,
+				    unsigned Scale);
+void printThumbAddrModeImm5S1Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbAddrModeImm5S2Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbAddrModeImm5S4Operand(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbAddrModeSPOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printT2SOOperand(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printAddrModeImm12Operand(AlwaysPrintImm0) \
+	void CONCAT(printAddrModeImm12Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printAddrModeImm12Operand(false) DECLARE_printAddrModeImm12Operand(true)
+
+#define DECLARE_printT2AddrModeImm8Operand(AlwaysPrintImm0) \
+	void CONCAT(printT2AddrModeImm8Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+	DECLARE_printT2AddrModeImm8Operand(true)
+		DECLARE_printT2AddrModeImm8Operand(false)
+
+#define DECLARE_printT2AddrModeImm8s4Operand(AlwaysPrintImm0) \
+	void CONCAT(printT2AddrModeImm8s4Operand, \
+		    AlwaysPrintImm0)(MCInst * MI, unsigned OpNum, SStream *O);
+			DECLARE_printT2AddrModeImm8s4Operand(false)
+				DECLARE_printT2AddrModeImm8s4Operand(true)
+
+					void printT2AddrModeImm0_1020s4Operand(
+						MCInst *MI, unsigned OpNum,
+						SStream *O);
+void printT2AddrModeImm8OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printT2AddrModeImm8s4OffsetOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printT2AddrModeSoRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printSetendOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printCPSIMod(MCInst *MI, unsigned OpNum, SStream *O);
+void printCPSIFlag(MCInst *MI, unsigned OpNum, SStream *O);
+void printMSRMaskOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printBankedRegOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printMandatoryPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printMandatoryRestrictedPredicateOperand(MCInst *MI, unsigned OpNum,
+					      SStream *O);
+void printMandatoryInvertedPredicateOperand(MCInst *MI, unsigned OpNum,
+					    SStream *O);
+void printSBitModifierOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printRegisterList(MCInst *MI, unsigned OpNum, SStream *O);
+void printNoHashImmediate(MCInst *MI, unsigned OpNum, SStream *O);
+void printPImmediate(MCInst *MI, unsigned OpNum, SStream *O);
+void printCImmediate(MCInst *MI, unsigned OpNum, SStream *O);
+void printCoprocOptionImm(MCInst *MI, unsigned OpNum, SStream *O);
+void printFPImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printVMOVModImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printImmPlusOneOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printRotImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printModImmOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printGPRPairOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printPCLabel(MCInst *MI, unsigned OpNum, SStream *O);
+void printThumbLdrLabelOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printFBits16(MCInst *MI, unsigned OpNum, SStream *O);
+void printFBits32(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorIndex(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListOne(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListTwo(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListTwoSpaced(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListThree(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListFour(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListOneAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListTwoAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListThreeAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListFourAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListTwoSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListThreeSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListFourSpacedAllLanes(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListThreeSpaced(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorListFourSpaced(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printMVEVectorList(NumRegs) \
+	void CONCAT(printMVEVectorList, NumRegs)(MCInst * MI, unsigned OpNum, \
+						 SStream *O);
+DECLARE_printMVEVectorList(2) DECLARE_printMVEVectorList(4)
+
+#define DECLARE_printComplexRotationOp(Angle, Remainder) \
+	void CONCAT(printComplexRotationOp, CONCAT(Angle, Remainder))( \
+		MCInst * MI, unsigned OpNum, SStream *O);
+	DECLARE_printComplexRotationOp(90, 0)
+		DECLARE_printComplexRotationOp(180, 90)
+
+	// MVE
+	void printVPTPredicateOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printVPTMask(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printMveAddrModeRQOperand(shift) \
+	void CONCAT(printMveAddrModeRQOperand, \
+		    shift)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printMveAddrModeRQOperand(0) DECLARE_printMveAddrModeRQOperand(3)
+	DECLARE_printMveAddrModeRQOperand(1)
+		DECLARE_printMveAddrModeRQOperand(2)
+
+			void printMveSaturateOp(MCInst *MI, unsigned OpNum,
+						SStream *O);
+
+unsigned translateShiftImm(unsigned imm);
+
+#endif // CS_ARM_INSTPRINTER_H

thirdparty/capstone/arch/ARM/ARMLinkage.h

@@ -0,0 +1,22 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_ARM_LINKAGE_H
+#define CS_ARM_LINKAGE_H
+
+// Function definitions to call static LLVM functions.
+
+#include "../../MCDisassembler.h"
+#include "../../MCInst.h"
+#include "../../MCRegisterInfo.h"
+#include "../../SStream.h"
+#include "capstone/capstone.h"
+
+DecodeStatus ARM_LLVM_getInstruction(csh handle, const uint8_t *Bytes,
+				     size_t ByteLen, MCInst *MI, uint16_t *Size,
+				     uint64_t Address, void *Info);
+const char *ARM_LLVM_getRegisterName(unsigned RegNo, unsigned AltIdx);
+void ARM_LLVM_printInstruction(MCInst *MI, SStream *O,
+			       void * /* MCRegisterInfo* */ info);
+
+#endif // CS_ARM_LINKAGE_H

thirdparty/capstone/arch/ARM/ARMMapping.h

@@ -0,0 +1,88 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_ARM_MAPPING_H
+#define CS_ARM_MAPPING_H
+
+#include "../../include/capstone/capstone.h"
+#include "../../utils.h"
+#include "ARMBaseInfo.h"
+
+typedef enum {
+#include "ARMGenCSOpGroup.inc"
+} arm_op_group;
+
+extern const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByEncoding(uint8_t Encoding);
+extern const ARMSysReg_MClassSysReg *
+ARMSysReg_lookupMClassSysRegByEncoding(uint16_t Encoding);
+
+// return name of register in friendly string
+const char *ARM_reg_name(csh handle, unsigned int reg);
+
+void ARM_printer(MCInst *MI, SStream *O, void * /* MCRegisterInfo* */ info);
+
+// given internal insn id, return public instruction ID
+void ARM_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
+
+const char *ARM_insn_name(csh handle, unsigned int id);
+
+const char *ARM_group_name(csh handle, unsigned int id);
+
+// check if this insn is relative branch
+bool ARM_rel_branch(cs_struct *h, unsigned int insn_id);
+
+bool ARM_blx_to_arm_mode(cs_struct *h, unsigned int insn_id);
+
+void ARM_reg_access(const cs_insn *insn, cs_regs regs_read,
+		    uint8_t *regs_read_count, cs_regs regs_write,
+		    uint8_t *regs_write_count);
+
+const ARMBankedReg_BankedReg *
+ARMBankedReg_lookupBankedRegByEncoding(uint8_t encoding);
+
+bool ARM_getInstruction(csh handle, const uint8_t *code, size_t code_len,
+			MCInst *instr, uint16_t *size, uint64_t address,
+			void *info);
+void ARM_set_instr_map_data(MCInst *MI);
+
+void ARM_init_mri(MCRegisterInfo *MRI);
+
+// cs_detail related functions
+void ARM_init_cs_detail(MCInst *MI);
+void ARM_add_cs_detail(MCInst *MI, int /* arm_op_group */ op_group,
+		       va_list args);
+static inline void add_cs_detail(MCInst *MI, int /* arm_op_group */ op_group,
+				 ...)
+{
+	if (!MI->flat_insn->detail)
+		return;
+	va_list args;
+	va_start(args, op_group);
+	ARM_add_cs_detail(MI, op_group, args);
+	va_end(args);
+}
+
+void ARM_insert_detail_op_reg_at(MCInst *MI, unsigned index, arm_reg Reg,
+				 cs_ac_type access);
+void ARM_insert_detail_op_imm_at(MCInst *MI, unsigned index, int64_t Val,
+				 cs_ac_type access);
+void ARM_set_detail_op_reg(MCInst *MI, unsigned OpNum, arm_reg Reg);
+void ARM_set_detail_op_sysop(MCInst *MI, int SysReg, arm_op_type type,
+			     bool IsOutReg, uint8_t Mask, uint16_t Sysm);
+void ARM_set_detail_op_imm(MCInst *MI, unsigned OpNum, arm_op_type ImmType,
+			   int64_t Imm);
+void ARM_set_detail_op_float(MCInst *MI, unsigned OpNum, uint64_t Imm);
+void ARM_set_detail_op_mem(MCInst *MI, unsigned OpNum, bool is_index_reg,
+			   int scale, int lshift, uint64_t Val);
+void ARM_set_detail_op_mem_offset(MCInst *MI, unsigned OpNum, uint64_t Val,
+				  bool subtracted);
+void ARM_set_detail_op_neon_lane(MCInst *MI, unsigned OpNum);
+
+void ARM_check_updates_flags(MCInst *MI);
+
+void ARM_setup_op(cs_arm_op *op);
+void ARM_add_vector_data(MCInst *MI, arm_vectordata_type data_type);
+void ARM_add_vector_size(MCInst *MI, unsigned size);
+
+#endif // CS_ARM_MAPPING_H

thirdparty/capstone/arch/ARM/ARMMappingInsnName.inc

@@ -0,0 +1,475 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+"adc",		     // ARM_INS_ADC,
+	"add",	     // ARM_INS_ADD,
+	"addw",	     // ARM_INS_ADDW,
+	"adr",	     // ARM_INS_ADR,
+	"aesd",	     // ARM_INS_AESD,
+	"aese",	     // ARM_INS_AESE,
+	"aesimc",    // ARM_INS_AESIMC,
+	"aesmc",     // ARM_INS_AESMC,
+	"and",	     // ARM_INS_AND,
+	"asr",	     // ARM_INS_ASR,
+	"b",	     // ARM_INS_B,
+	"bfc",	     // ARM_INS_BFC,
+	"bfi",	     // ARM_INS_BFI,
+	"bic",	     // ARM_INS_BIC,
+	"bkpt",	     // ARM_INS_BKPT,
+	"bl",	     // ARM_INS_BL,
+	"blx",	     // ARM_INS_BLX,
+	"blxns",     // ARM_INS_BLXNS,
+	"bx",	     // ARM_INS_BX,
+	"bxj",	     // ARM_INS_BXJ,
+	"bxns",	     // ARM_INS_BXNS,
+	"cbnz",	     // ARM_INS_CBNZ,
+	"cbz",	     // ARM_INS_CBZ,
+	"cdp",	     // ARM_INS_CDP,
+	"cdp2",	     // ARM_INS_CDP2,
+	"clrex",     // ARM_INS_CLREX,
+	"clz",	     // ARM_INS_CLZ,
+	"cmn",	     // ARM_INS_CMN,
+	"cmp",	     // ARM_INS_CMP,
+	"cps",	     // ARM_INS_CPS,
+	"crc32b",    // ARM_INS_CRC32B,
+	"crc32cb",   // ARM_INS_CRC32CB,
+	"crc32ch",   // ARM_INS_CRC32CH,
+	"crc32cw",   // ARM_INS_CRC32CW,
+	"crc32h",    // ARM_INS_CRC32H,
+	"crc32w",    // ARM_INS_CRC32W,
+	"csdb",	     // ARM_INS_CSDB,
+	"dbg",	     // ARM_INS_DBG,
+	"dcps1",     // ARM_INS_DCPS1,
+	"dcps2",     // ARM_INS_DCPS2,
+	"dcps3",     // ARM_INS_DCPS3,
+	"dfb",	     // ARM_INS_DFB,
+	"dmb",	     // ARM_INS_DMB,
+	"dsb",	     // ARM_INS_DSB,
+	"eor",	     // ARM_INS_EOR,
+	"eret",	     // ARM_INS_ERET,
+	"esb",	     // ARM_INS_ESB,
+	"faddd",     // ARM_INS_FADDD,
+	"fadds",     // ARM_INS_FADDS,
+	"fcmpzd",    // ARM_INS_FCMPZD,
+	"fcmpzs",    // ARM_INS_FCMPZS,
+	"fconstd",   // ARM_INS_FCONSTD,
+	"fconsts",   // ARM_INS_FCONSTS,
+	"fldmdbx",   // ARM_INS_FLDMDBX,
+	"fldmiax",   // ARM_INS_FLDMIAX,
+	"fmdhr",     // ARM_INS_FMDHR,
+	"fmdlr",     // ARM_INS_FMDLR,
+	"fmstat",    // ARM_INS_FMSTAT,
+	"fstmdbx",   // ARM_INS_FSTMDBX,
+	"fstmiax",   // ARM_INS_FSTMIAX,
+	"fsubd",     // ARM_INS_FSUBD,
+	"fsubs",     // ARM_INS_FSUBS,
+	"hint",	     // ARM_INS_HINT,
+	"hlt",	     // ARM_INS_HLT,
+	"hvc",	     // ARM_INS_HVC,
+	"isb",	     // ARM_INS_ISB,
+	"it",	     // ARM_INS_IT,
+	"lda",	     // ARM_INS_LDA,
+	"ldab",	     // ARM_INS_LDAB,
+	"ldaex",     // ARM_INS_LDAEX,
+	"ldaexb",    // ARM_INS_LDAEXB,
+	"ldaexd",    // ARM_INS_LDAEXD,
+	"ldaexh",    // ARM_INS_LDAEXH,
+	"ldah",	     // ARM_INS_LDAH,
+	"ldc",	     // ARM_INS_LDC,
+	"ldc2",	     // ARM_INS_LDC2,
+	"ldc2l",     // ARM_INS_LDC2L,
+	"ldcl",	     // ARM_INS_LDCL,
+	"ldm",	     // ARM_INS_LDM,
+	"ldmda",     // ARM_INS_LDMDA,
+	"ldmdb",     // ARM_INS_LDMDB,
+	"ldmib",     // ARM_INS_LDMIB,
+	"ldr",	     // ARM_INS_LDR,
+	"ldrb",	     // ARM_INS_LDRB,
+	"ldrbt",     // ARM_INS_LDRBT,
+	"ldrd",	     // ARM_INS_LDRD,
+	"ldrex",     // ARM_INS_LDREX,
+	"ldrexb",    // ARM_INS_LDREXB,
+	"ldrexd",    // ARM_INS_LDREXD,
+	"ldrexh",    // ARM_INS_LDREXH,
+	"ldrh",	     // ARM_INS_LDRH,
+	"ldrht",     // ARM_INS_LDRHT,
+	"ldrsb",     // ARM_INS_LDRSB,
+	"ldrsbt",    // ARM_INS_LDRSBT,
+	"ldrsh",     // ARM_INS_LDRSH,
+	"ldrsht",    // ARM_INS_LDRSHT,
+	"ldrt",	     // ARM_INS_LDRT,
+	"lsl",	     // ARM_INS_LSL,
+	"lsr",	     // ARM_INS_LSR,
+	"mcr",	     // ARM_INS_MCR,
+	"mcr2",	     // ARM_INS_MCR2,
+	"mcrr",	     // ARM_INS_MCRR,
+	"mcrr2",     // ARM_INS_MCRR2,
+	"mla",	     // ARM_INS_MLA,
+	"mls",	     // ARM_INS_MLS,
+	"mov",	     // ARM_INS_MOV,
+	"movs",	     // ARM_INS_MOVS,
+	"movt",	     // ARM_INS_MOVT,
+	"movw",	     // ARM_INS_MOVW,
+	"mrc",	     // ARM_INS_MRC,
+	"mrc2",	     // ARM_INS_MRC2,
+	"mrrc",	     // ARM_INS_MRRC,
+	"mrrc2",     // ARM_INS_MRRC2,
+	"mrs",	     // ARM_INS_MRS,
+	"msr",	     // ARM_INS_MSR,
+	"mul",	     // ARM_INS_MUL,
+	"mvn",	     // ARM_INS_MVN,
+	"neg",	     // ARM_INS_NEG,
+	"nop",	     // ARM_INS_NOP,
+	"orn",	     // ARM_INS_ORN,
+	"orr",	     // ARM_INS_ORR,
+	"pkhbt",     // ARM_INS_PKHBT,
+	"pkhtb",     // ARM_INS_PKHTB,
+	"pld",	     // ARM_INS_PLD,
+	"pldw",	     // ARM_INS_PLDW,
+	"pli",	     // ARM_INS_PLI,
+	"pop",	     // ARM_INS_POP,
+	"push",	     // ARM_INS_PUSH,
+	"qadd",	     // ARM_INS_QADD,
+	"qadd16",    // ARM_INS_QADD16,
+	"qadd8",     // ARM_INS_QADD8,
+	"qasx",	     // ARM_INS_QASX,
+	"qdadd",     // ARM_INS_QDADD,
+	"qdsub",     // ARM_INS_QDSUB,
+	"qsax",	     // ARM_INS_QSAX,
+	"qsub",	     // ARM_INS_QSUB,
+	"qsub16",    // ARM_INS_QSUB16,
+	"qsub8",     // ARM_INS_QSUB8,
+	"rbit",	     // ARM_INS_RBIT,
+	"rev",	     // ARM_INS_REV,
+	"rev16",     // ARM_INS_REV16,
+	"revsh",     // ARM_INS_REVSH,
+	"rfeda",     // ARM_INS_RFEDA,
+	"rfedb",     // ARM_INS_RFEDB,
+	"rfeia",     // ARM_INS_RFEIA,
+	"rfeib",     // ARM_INS_RFEIB,
+	"ror",	     // ARM_INS_ROR,
+	"rrx",	     // ARM_INS_RRX,
+	"rsb",	     // ARM_INS_RSB,
+	"rsc",	     // ARM_INS_RSC,
+	"sadd16",    // ARM_INS_SADD16,
+	"sadd8",     // ARM_INS_SADD8,
+	"sasx",	     // ARM_INS_SASX,
+	"sbc",	     // ARM_INS_SBC,
+	"sbfx",	     // ARM_INS_SBFX,
+	"sdiv",	     // ARM_INS_SDIV,
+	"sel",	     // ARM_INS_SEL,
+	"setend",    // ARM_INS_SETEND,
+	"setpan",    // ARM_INS_SETPAN,
+	"sev",	     // ARM_INS_SEV,
+	"sevl",	     // ARM_INS_SEVL,
+	"sg",	     // ARM_INS_SG,
+	"sha1c",     // ARM_INS_SHA1C,
+	"sha1h",     // ARM_INS_SHA1H,
+	"sha1m",     // ARM_INS_SHA1M,
+	"sha1p",     // ARM_INS_SHA1P,
+	"sha1su0",   // ARM_INS_SHA1SU0,
+	"sha1su1",   // ARM_INS_SHA1SU1,
+	"sha256h",   // ARM_INS_SHA256H,
+	"sha256h2",  // ARM_INS_SHA256H2,
+	"sha256su0", // ARM_INS_SHA256SU0,
+	"sha256su1", // ARM_INS_SHA256SU1,
+	"shadd16",   // ARM_INS_SHADD16,
+	"shadd8",    // ARM_INS_SHADD8,
+	"shasx",     // ARM_INS_SHASX,
+	"shsax",     // ARM_INS_SHSAX,
+	"shsub16",   // ARM_INS_SHSUB16,
+	"shsub8",    // ARM_INS_SHSUB8,
+	"smc",	     // ARM_INS_SMC,
+	"smlabb",    // ARM_INS_SMLABB,
+	"smlabt",    // ARM_INS_SMLABT,
+	"smlad",     // ARM_INS_SMLAD,
+	"smladx",    // ARM_INS_SMLADX,
+	"smlal",     // ARM_INS_SMLAL,
+	"smlalbb",   // ARM_INS_SMLALBB,
+	"smlalbt",   // ARM_INS_SMLALBT,
+	"smlald",    // ARM_INS_SMLALD,
+	"smlaldx",   // ARM_INS_SMLALDX,
+	"smlaltb",   // ARM_INS_SMLALTB,
+	"smlaltt",   // ARM_INS_SMLALTT,
+	"smlatb",    // ARM_INS_SMLATB,
+	"smlatt",    // ARM_INS_SMLATT,
+	"smlawb",    // ARM_INS_SMLAWB,
+	"smlawt",    // ARM_INS_SMLAWT,
+	"smlsd",     // ARM_INS_SMLSD,
+	"smlsdx",    // ARM_INS_SMLSDX,
+	"smlsld",    // ARM_INS_SMLSLD,
+	"smlsldx",   // ARM_INS_SMLSLDX,
+	"smmla",     // ARM_INS_SMMLA,
+	"smmlar",    // ARM_INS_SMMLAR,
+	"smmls",     // ARM_INS_SMMLS,
+	"smmlsr",    // ARM_INS_SMMLSR,
+	"smmul",     // ARM_INS_SMMUL,
+	"smmulr",    // ARM_INS_SMMULR,
+	"smuad",     // ARM_INS_SMUAD,
+	"smuadx",    // ARM_INS_SMUADX,
+	"smulbb",    // ARM_INS_SMULBB,
+	"smulbt",    // ARM_INS_SMULBT,
+	"smull",     // ARM_INS_SMULL,
+	"smultb",    // ARM_INS_SMULTB,
+	"smultt",    // ARM_INS_SMULTT,
+	"smulwb",    // ARM_INS_SMULWB,
+	"smulwt",    // ARM_INS_SMULWT,
+	"smusd",     // ARM_INS_SMUSD,
+	"smusdx",    // ARM_INS_SMUSDX,
+	"srsda",     // ARM_INS_SRSDA,
+	"srsdb",     // ARM_INS_SRSDB,
+	"srsia",     // ARM_INS_SRSIA,
+	"srsib",     // ARM_INS_SRSIB,
+	"ssat",	     // ARM_INS_SSAT,
+	"ssat16",    // ARM_INS_SSAT16,
+	"ssax",	     // ARM_INS_SSAX,
+	"ssub16",    // ARM_INS_SSUB16,
+	"ssub8",     // ARM_INS_SSUB8,
+	"stc",	     // ARM_INS_STC,
+	"stc2",	     // ARM_INS_STC2,
+	"stc2l",     // ARM_INS_STC2L,
+	"stcl",	     // ARM_INS_STCL,
+	"stl",	     // ARM_INS_STL,
+	"stlb",	     // ARM_INS_STLB,
+	"stlex",     // ARM_INS_STLEX,
+	"stlexb",    // ARM_INS_STLEXB,
+	"stlexd",    // ARM_INS_STLEXD,
+	"stlexh",    // ARM_INS_STLEXH,
+	"stlh",	     // ARM_INS_STLH,
+	"stm",	     // ARM_INS_STM,
+	"stmda",     // ARM_INS_STMDA,
+	"stmdb",     // ARM_INS_STMDB,
+	"stmib",     // ARM_INS_STMIB,
+	"str",	     // ARM_INS_STR,
+	"strb",	     // ARM_INS_STRB,
+	"strbt",     // ARM_INS_STRBT,
+	"strd",	     // ARM_INS_STRD,
+	"strex",     // ARM_INS_STREX,
+	"strexb",    // ARM_INS_STREXB,
+	"strexd",    // ARM_INS_STREXD,
+	"strexh",    // ARM_INS_STREXH,
+	"strh",	     // ARM_INS_STRH,
+	"strht",     // ARM_INS_STRHT,
+	"strt",	     // ARM_INS_STRT,
+	"sub",	     // ARM_INS_SUB,
+	"subs",	     // ARM_INS_SUBS,
+	"subw",	     // ARM_INS_SUBW,
+	"svc",	     // ARM_INS_SVC,
+	"swp",	     // ARM_INS_SWP,
+	"swpb",	     // ARM_INS_SWPB,
+	"sxtab",     // ARM_INS_SXTAB,
+	"sxtab16",   // ARM_INS_SXTAB16,
+	"sxtah",     // ARM_INS_SXTAH,
+	"sxtb",	     // ARM_INS_SXTB,
+	"sxtb16",    // ARM_INS_SXTB16,
+	"sxth",	     // ARM_INS_SXTH,
+	"tbb",	     // ARM_INS_TBB,
+	"tbh",	     // ARM_INS_TBH,
+	"teq",	     // ARM_INS_TEQ,
+	"trap",	     // ARM_INS_TRAP,
+	"tsb",	     // ARM_INS_TSB,
+	"tst",	     // ARM_INS_TST,
+	"tt",	     // ARM_INS_TT,
+	"tta",	     // ARM_INS_TTA,
+	"ttat",	     // ARM_INS_TTAT,
+	"ttt",	     // ARM_INS_TTT,
+	"uadd16",    // ARM_INS_UADD16,
+	"uadd8",     // ARM_INS_UADD8,
+	"uasx",	     // ARM_INS_UASX,
+	"ubfx",	     // ARM_INS_UBFX,
+	"udf",	     // ARM_INS_UDF,
+	"udiv",	     // ARM_INS_UDIV,
+	"uhadd16",   // ARM_INS_UHADD16,
+	"uhadd8",    // ARM_INS_UHADD8,
+	"uhasx",     // ARM_INS_UHASX,
+	"uhsax",     // ARM_INS_UHSAX,
+	"uhsub16",   // ARM_INS_UHSUB16,
+	"uhsub8",    // ARM_INS_UHSUB8,
+	"umaal",     // ARM_INS_UMAAL,
+	"umlal",     // ARM_INS_UMLAL,
+	"umull",     // ARM_INS_UMULL,
+	"uqadd16",   // ARM_INS_UQADD16,
+	"uqadd8",    // ARM_INS_UQADD8,
+	"uqasx",     // ARM_INS_UQASX,
+	"uqsax",     // ARM_INS_UQSAX,
+	"uqsub16",   // ARM_INS_UQSUB16,
+	"uqsub8",    // ARM_INS_UQSUB8,
+	"usad8",     // ARM_INS_USAD8,
+	"usada8",    // ARM_INS_USADA8,
+	"usat",	     // ARM_INS_USAT,
+	"usat16",    // ARM_INS_USAT16,
+	"usax",	     // ARM_INS_USAX,
+	"usub16",    // ARM_INS_USUB16,
+	"usub8",     // ARM_INS_USUB8,
+	"uxtab",     // ARM_INS_UXTAB,
+	"uxtab16",   // ARM_INS_UXTAB16,
+	"uxtah",     // ARM_INS_UXTAH,
+	"uxtb",	     // ARM_INS_UXTB,
+	"uxtb16",    // ARM_INS_UXTB16,
+	"uxth",	     // ARM_INS_UXTH,
+	"vaba",	     // ARM_INS_VABA,
+	"vabal",     // ARM_INS_VABAL,
+	"vabd",	     // ARM_INS_VABD,
+	"vabdl",     // ARM_INS_VABDL,
+	"vabs",	     // ARM_INS_VABS,
+	"vacge",     // ARM_INS_VACGE,
+	"vacgt",     // ARM_INS_VACGT,
+	"vacle",     // ARM_INS_VACLE,
+	"vaclt",     // ARM_INS_VACLT,
+	"vadd",	     // ARM_INS_VADD,
+	"vaddhn",    // ARM_INS_VADDHN,
+	"vaddl",     // ARM_INS_VADDL,
+	"vaddw",     // ARM_INS_VADDW,
+	"vand",	     // ARM_INS_VAND,
+	"vbic",	     // ARM_INS_VBIC,
+	"vbif",	     // ARM_INS_VBIF,
+	"vbit",	     // ARM_INS_VBIT,
+	"vbsl",	     // ARM_INS_VBSL,
+	"vcadd",     // ARM_INS_VCADD,
+	"vceq",	     // ARM_INS_VCEQ,
+	"vcge",	     // ARM_INS_VCGE,
+	"vcgt",	     // ARM_INS_VCGT,
+	"vcle",	     // ARM_INS_VCLE,
+	"vcls",	     // ARM_INS_VCLS,
+	"vclt",	     // ARM_INS_VCLT,
+	"vclz",	     // ARM_INS_VCLZ,
+	"vcmla",     // ARM_INS_VCMLA,
+	"vcmp",	     // ARM_INS_VCMP,
+	"vcmpe",     // ARM_INS_VCMPE,
+	"vcnt",	     // ARM_INS_VCNT,
+	"vcvt",	     // ARM_INS_VCVT,
+	"vcvta",     // ARM_INS_VCVTA,
+	"vcvtb",     // ARM_INS_VCVTB,
+	"vcvtm",     // ARM_INS_VCVTM,
+	"vcvtn",     // ARM_INS_VCVTN,
+	"vcvtp",     // ARM_INS_VCVTP,
+	"vcvtr",     // ARM_INS_VCVTR,
+	"vcvtt",     // ARM_INS_VCVTT,
+	"vdiv",	     // ARM_INS_VDIV,
+	"vdup",	     // ARM_INS_VDUP,
+	"veor",	     // ARM_INS_VEOR,
+	"vext",	     // ARM_INS_VEXT,
+	"vfma",	     // ARM_INS_VFMA,
+	"vfms",	     // ARM_INS_VFMS,
+	"vfnma",     // ARM_INS_VFNMA,
+	"vfnms",     // ARM_INS_VFNMS,
+	"vhadd",     // ARM_INS_VHADD,
+	"vhsub",     // ARM_INS_VHSUB,
+	"vins",	     // ARM_INS_VINS,
+	"vjcvt",     // ARM_INS_VJCVT,
+	"vld1",	     // ARM_INS_VLD1,
+	"vld2",	     // ARM_INS_VLD2,
+	"vld3",	     // ARM_INS_VLD3,
+	"vld4",	     // ARM_INS_VLD4,
+	"vldmdb",    // ARM_INS_VLDMDB,
+	"vldmia",    // ARM_INS_VLDMIA,
+	"vldr",	     // ARM_INS_VLDR,
+	"vlldm",     // ARM_INS_VLLDM,
+	"vlstm",     // ARM_INS_VLSTM,
+	"vmax",	     // ARM_INS_VMAX,
+	"vmaxnm",    // ARM_INS_VMAXNM,
+	"vmin",	     // ARM_INS_VMIN,
+	"vminnm",    // ARM_INS_VMINNM,
+	"vmla",	     // ARM_INS_VMLA,
+	"vmlal",     // ARM_INS_VMLAL,
+	"vmls",	     // ARM_INS_VMLS,
+	"vmlsl",     // ARM_INS_VMLSL,
+	"vmov",	     // ARM_INS_VMOV,
+	"vmovl",     // ARM_INS_VMOVL,
+	"vmovn",     // ARM_INS_VMOVN,
+	"vmovx",     // ARM_INS_VMOVX,
+	"vmrs",	     // ARM_INS_VMRS,
+	"vmsr",	     // ARM_INS_VMSR,
+	"vmul",	     // ARM_INS_VMUL,
+	"vmull",     // ARM_INS_VMULL,
+	"vmvn",	     // ARM_INS_VMVN,
+	"vneg",	     // ARM_INS_VNEG,
+	"vnmla",     // ARM_INS_VNMLA,
+	"vnmls",     // ARM_INS_VNMLS,
+	"vnmul",     // ARM_INS_VNMUL,
+	"vorn",	     // ARM_INS_VORN,
+	"vorr",	     // ARM_INS_VORR,
+	"vpadal",    // ARM_INS_VPADAL,
+	"vpadd",     // ARM_INS_VPADD,
+	"vpaddl",    // ARM_INS_VPADDL,
+	"vpmax",     // ARM_INS_VPMAX,
+	"vpmin",     // ARM_INS_VPMIN,
+	"vpop",	     // ARM_INS_VPOP,
+	"vpush",     // ARM_INS_VPUSH,
+	"vqabs",     // ARM_INS_VQABS,
+	"vqadd",     // ARM_INS_VQADD,
+	"vqdmlal",   // ARM_INS_VQDMLAL,
+	"vqdmlsl",   // ARM_INS_VQDMLSL,
+	"vqdmulh",   // ARM_INS_VQDMULH,
+	"vqdmull",   // ARM_INS_VQDMULL,
+	"vqmovn",    // ARM_INS_VQMOVN,
+	"vqmovun",   // ARM_INS_VQMOVUN,
+	"vqneg",     // ARM_INS_VQNEG,
+	"vqrdmlah",  // ARM_INS_VQRDMLAH,
+	"vqrdmlsh",  // ARM_INS_VQRDMLSH,
+	"vqrdmulh",  // ARM_INS_VQRDMULH,
+	"vqrshl",    // ARM_INS_VQRSHL,
+	"vqrshrn",   // ARM_INS_VQRSHRN,
+	"vqrshrun",  // ARM_INS_VQRSHRUN,
+	"vqshl",     // ARM_INS_VQSHL,
+	"vqshlu",    // ARM_INS_VQSHLU,
+	"vqshrn",    // ARM_INS_VQSHRN,
+	"vqshrun",   // ARM_INS_VQSHRUN,
+	"vqsub",     // ARM_INS_VQSUB,
+	"vraddhn",   // ARM_INS_VRADDHN,
+	"vrecpe",    // ARM_INS_VRECPE,
+	"vrecps",    // ARM_INS_VRECPS,
+	"vrev16",    // ARM_INS_VREV16,
+	"vrev32",    // ARM_INS_VREV32,
+	"vrev64",    // ARM_INS_VREV64,
+	"vrhadd",    // ARM_INS_VRHADD,
+	"vrinta",    // ARM_INS_VRINTA,
+	"vrintm",    // ARM_INS_VRINTM,
+	"vrintn",    // ARM_INS_VRINTN,
+	"vrintp",    // ARM_INS_VRINTP,
+	"vrintr",    // ARM_INS_VRINTR,
+	"vrintx",    // ARM_INS_VRINTX,
+	"vrintz",    // ARM_INS_VRINTZ,
+	"vrshl",     // ARM_INS_VRSHL,
+	"vrshr",     // ARM_INS_VRSHR,
+	"vrshrn",    // ARM_INS_VRSHRN,
+	"vrsqrte",   // ARM_INS_VRSQRTE,
+	"vrsqrts",   // ARM_INS_VRSQRTS,
+	"vrsra",     // ARM_INS_VRSRA,
+	"vrsubhn",   // ARM_INS_VRSUBHN,
+	"vsdot",     // ARM_INS_VSDOT,
+	"vseleq",    // ARM_INS_VSELEQ,
+	"vselge",    // ARM_INS_VSELGE,
+	"vselgt",    // ARM_INS_VSELGT,
+	"vselvs",    // ARM_INS_VSELVS,
+	"vshl",	     // ARM_INS_VSHL,
+	"vshll",     // ARM_INS_VSHLL,
+	"vshr",	     // ARM_INS_VSHR,
+	"vshrn",     // ARM_INS_VSHRN,
+	"vsli",	     // ARM_INS_VSLI,
+	"vsqrt",     // ARM_INS_VSQRT,
+	"vsra",	     // ARM_INS_VSRA,
+	"vsri",	     // ARM_INS_VSRI,
+	"vst1",	     // ARM_INS_VST1,
+	"vst2",	     // ARM_INS_VST2,
+	"vst3",	     // ARM_INS_VST3,
+	"vst4",	     // ARM_INS_VST4,
+	"vstmdb",    // ARM_INS_VSTMDB,
+	"vstmia",    // ARM_INS_VSTMIA,
+	"vstr",	     // ARM_INS_VSTR,
+	"vsub",	     // ARM_INS_VSUB,
+	"vsubhn",    // ARM_INS_VSUBHN,
+	"vsubl",     // ARM_INS_VSUBL,
+	"vsubw",     // ARM_INS_VSUBW,
+	"vswp",	     // ARM_INS_VSWP,
+	"vtbl",	     // ARM_INS_VTBL,
+	"vtbx",	     // ARM_INS_VTBX,
+	"vtrn",	     // ARM_INS_VTRN,
+	"vtst",	     // ARM_INS_VTST,
+	"vudot",     // ARM_INS_VUDOT,
+	"vuzp",	     // ARM_INS_VUZP,
+	"vzip",	     // ARM_INS_VZIP,
+	"wfe",	     // ARM_INS_WFE,
+	"wfi",	     // ARM_INS_WFI,
+	"yield",     // ARM_INS_YIELD,

thirdparty/capstone/arch/ARM/ARMModule.c

@@ -0,0 +1,52 @@
+/* Capstone Disassembly Engine */
+/* By Dang Hoang Vu <danghvu@gmail.com> 2013 */
+
+#include "capstone/capstone.h"
+#ifdef CAPSTONE_HAS_ARM
+
+#include "ARMModule.h"
+#include "../../MCRegisterInfo.h"
+#include "../../cs_priv.h"
+#include "ARMInstPrinter.h"
+#include "ARMMapping.h"
+
+cs_err ARM_global_init(cs_struct *ud)
+{
+	MCRegisterInfo *mri;
+	mri = cs_mem_malloc(sizeof(*mri));
+
+	ARM_init_mri(mri);
+
+	ud->printer = ARM_printer;
+	ud->printer_info = mri;
+	ud->reg_name = ARM_reg_name;
+	ud->insn_id = ARM_get_insn_id;
+	ud->insn_name = ARM_insn_name;
+	ud->group_name = ARM_group_name;
+	ud->post_printer = NULL;
+#ifndef CAPSTONE_DIET
+	ud->reg_access = ARM_reg_access;
+#endif
+
+	ud->disasm = ARM_getInstruction;
+
+	return CS_ERR_OK;
+}
+
+cs_err ARM_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+	switch (type) {
+	case CS_OPT_MODE:
+		handle->mode = (cs_mode)value;
+		break;
+	case CS_OPT_SYNTAX:
+		handle->syntax |= (int)value;
+		break;
+	default:
+		break;
+	}
+
+	return CS_ERR_OK;
+}
+
+#endif

thirdparty/capstone/arch/ARM/ARMModule.h

@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Travis Finkenauer <tmfinken@gmail.com>, 2018 */
+
+#ifndef CS_ARM_MODULE_H
+#define CS_ARM_MODULE_H
+
+#include "../../utils.h"
+
+cs_err ARM_global_init(cs_struct *ud);
+cs_err ARM_option(cs_struct *handle, cs_opt_type type, size_t value);
+
+#endif

thirdparty/capstone/arch/X86/X86BaseInfo.h

@@ -0,0 +1,50 @@
+//===-- X86BaseInfo.h - Top level definitions for X86 -------- --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains small standalone helper functions and enum definitions for
+// the X86 target useful for the compiler back-end and the MC libraries.
+// As such, it deliberately does not include references to LLVM core
+// code gen types, passes, etc..
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CS_X86_BASEINFO_H
+#define CS_X86_BASEINFO_H
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+// Enums for memory operand decoding.  Each memory operand is represented with
+// a 5 operand sequence in the form:
+//   [BaseReg, ScaleAmt, IndexReg, Disp, Segment]
+// These enums help decode this.
+enum {
+	X86_AddrBaseReg = 0,
+	X86_AddrScaleAmt = 1,
+	X86_AddrIndexReg = 2,
+	X86_AddrDisp = 3,
+
+	/// AddrSegmentReg - The operand # of the segment in the memory operand.
+	X86_AddrSegmentReg = 4,
+
+	/// AddrNumOperands - Total number of operands in a memory reference.
+	X86_AddrNumOperands = 5
+};
+
+enum IPREFIXES {
+	X86_IP_NO_PREFIX = 0,
+	X86_IP_HAS_OP_SIZE = 1,
+	X86_IP_HAS_AD_SIZE = 2,
+	X86_IP_HAS_REPEAT_NE = 4,
+	X86_IP_HAS_REPEAT = 8,
+	X86_IP_HAS_LOCK = 16,
+	X86_IP_HAS_NOTRACK = 64
+};
+
+#endif

thirdparty/capstone/arch/X86/X86Disassembler.h

@@ -0,0 +1,28 @@
+//===-- X86Disassembler.h - Disassembler for x86 and x86_64 -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_X86_DISASSEMBLER_H
+#define CS_X86_DISASSEMBLER_H
+
+#include "capstone/capstone.h"
+
+#include "../../MCInst.h"
+
+#include "../../MCRegisterInfo.h"
+#include "X86DisassemblerDecoderCommon.h"
+
+bool X86_getInstruction(csh handle, const uint8_t *code, size_t code_len,
+		MCInst *instr, uint16_t *size, uint64_t address, void *info);
+
+void X86_init(MCRegisterInfo *MRI);
+
+#endif

thirdparty/capstone/arch/X86/X86DisassemblerDecoder.h

@@ -0,0 +1,725 @@
+/*===-- X86DisassemblerDecoderInternal.h - Disassembler decoder ---*- C -*-===*
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===*
+ *
+ * This file is part of the X86 Disassembler.
+ * It contains the public interface of the instruction decoder.
+ * Documentation for the disassembler can be found in X86Disassembler.h.
+ *
+ *===----------------------------------------------------------------------===*/
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_X86_DISASSEMBLERDECODER_H
+#define CS_X86_DISASSEMBLERDECODER_H
+
+#if defined(CAPSTONE_HAS_OSXKERNEL)
+#include <libkern/libkern.h>
+#else
+#include <stdio.h>
+#endif
+
+#include "X86DisassemblerDecoderCommon.h"
+
+/*
+ * Accessor functions for various fields of an Intel instruction
+ */
+#define modFromModRM(modRM)  (((modRM) & 0xc0) >> 6)
+#define regFromModRM(modRM)  (((modRM) & 0x38) >> 3)
+#define rmFromModRM(modRM)   ((modRM) & 0x7)
+#define scaleFromSIB(sib)    (((sib) & 0xc0) >> 6)
+#define indexFromSIB(sib)    (((sib) & 0x38) >> 3)
+#define baseFromSIB(sib)     ((sib) & 0x7)
+#define wFromREX(rex)        (((rex) & 0x8) >> 3)
+#define rFromREX(rex)        (((rex) & 0x4) >> 2)
+#define xFromREX(rex)        (((rex) & 0x2) >> 1)
+#define bFromREX(rex)        ((rex) & 0x1)
+
+#define rFromEVEX2of4(evex)     (((~(evex)) & 0x80) >> 7)
+#define xFromEVEX2of4(evex)     (((~(evex)) & 0x40) >> 6)
+#define bFromEVEX2of4(evex)     (((~(evex)) & 0x20) >> 5)
+#define r2FromEVEX2of4(evex)    (((~(evex)) & 0x10) >> 4)
+#define mmFromEVEX2of4(evex)    ((evex) & 0x3)
+#define wFromEVEX3of4(evex)     (((evex) & 0x80) >> 7)
+#define vvvvFromEVEX3of4(evex)  (((~(evex)) & 0x78) >> 3)
+#define ppFromEVEX3of4(evex)    ((evex) & 0x3)
+#define zFromEVEX4of4(evex)     (((evex) & 0x80) >> 7)
+#define l2FromEVEX4of4(evex)    (((evex) & 0x40) >> 6)
+#define lFromEVEX4of4(evex)     (((evex) & 0x20) >> 5)
+#define bFromEVEX4of4(evex)     (((evex) & 0x10) >> 4)
+#define v2FromEVEX4of4(evex)    (((~evex) & 0x8) >> 3)
+#define aaaFromEVEX4of4(evex)   ((evex) & 0x7)
+
+#define rFromVEX2of3(vex)       (((~(vex)) & 0x80) >> 7)
+#define xFromVEX2of3(vex)       (((~(vex)) & 0x40) >> 6)
+#define bFromVEX2of3(vex)       (((~(vex)) & 0x20) >> 5)
+#define mmmmmFromVEX2of3(vex)   ((vex) & 0x1f)
+#define wFromVEX3of3(vex)       (((vex) & 0x80) >> 7)
+#define vvvvFromVEX3of3(vex)    (((~(vex)) & 0x78) >> 3)
+#define lFromVEX3of3(vex)       (((vex) & 0x4) >> 2)
+#define ppFromVEX3of3(vex)      ((vex) & 0x3)
+
+#define rFromVEX2of2(vex)       (((~(vex)) & 0x80) >> 7)
+#define vvvvFromVEX2of2(vex)    (((~(vex)) & 0x78) >> 3)
+#define lFromVEX2of2(vex)       (((vex) & 0x4) >> 2)
+#define ppFromVEX2of2(vex)      ((vex) & 0x3)
+
+#define rFromXOP2of3(xop)       (((~(xop)) & 0x80) >> 7)
+#define xFromXOP2of3(xop)       (((~(xop)) & 0x40) >> 6)
+#define bFromXOP2of3(xop)       (((~(xop)) & 0x20) >> 5)
+#define mmmmmFromXOP2of3(xop)   ((xop) & 0x1f)
+#define wFromXOP3of3(xop)       (((xop) & 0x80) >> 7)
+#define vvvvFromXOP3of3(vex)    (((~(vex)) & 0x78) >> 3)
+#define lFromXOP3of3(xop)       (((xop) & 0x4) >> 2)
+#define ppFromXOP3of3(xop)      ((xop) & 0x3)
+
+/*
+ * These enums represent Intel registers for use by the decoder.
+ */
+
+#define REGS_8BIT     \
+  ENTRY(AL)           \
+  ENTRY(CL)           \
+  ENTRY(DL)           \
+  ENTRY(BL)           \
+  ENTRY(AH)           \
+  ENTRY(CH)           \
+  ENTRY(DH)           \
+  ENTRY(BH)           \
+  ENTRY(R8B)          \
+  ENTRY(R9B)          \
+  ENTRY(R10B)         \
+  ENTRY(R11B)         \
+  ENTRY(R12B)         \
+  ENTRY(R13B)         \
+  ENTRY(R14B)         \
+  ENTRY(R15B)         \
+  ENTRY(SPL)          \
+  ENTRY(BPL)          \
+  ENTRY(SIL)          \
+  ENTRY(DIL)
+
+#define EA_BASES_16BIT  \
+  ENTRY(BX_SI)          \
+  ENTRY(BX_DI)          \
+  ENTRY(BP_SI)          \
+  ENTRY(BP_DI)          \
+  ENTRY(SI)             \
+  ENTRY(DI)             \
+  ENTRY(BP)             \
+  ENTRY(BX)             \
+  ENTRY(R8W)            \
+  ENTRY(R9W)            \
+  ENTRY(R10W)           \
+  ENTRY(R11W)           \
+  ENTRY(R12W)           \
+  ENTRY(R13W)           \
+  ENTRY(R14W)           \
+  ENTRY(R15W)
+
+#define REGS_16BIT    \
+  ENTRY(AX)           \
+  ENTRY(CX)           \
+  ENTRY(DX)           \
+  ENTRY(BX)           \
+  ENTRY(SP)           \
+  ENTRY(BP)           \
+  ENTRY(SI)           \
+  ENTRY(DI)           \
+  ENTRY(R8W)          \
+  ENTRY(R9W)          \
+  ENTRY(R10W)         \
+  ENTRY(R11W)         \
+  ENTRY(R12W)         \
+  ENTRY(R13W)         \
+  ENTRY(R14W)         \
+  ENTRY(R15W)
+
+#define EA_BASES_32BIT  \
+  ENTRY(EAX)            \
+  ENTRY(ECX)            \
+  ENTRY(EDX)            \
+  ENTRY(EBX)            \
+  ENTRY(sib)            \
+  ENTRY(EBP)            \
+  ENTRY(ESI)            \
+  ENTRY(EDI)            \
+  ENTRY(R8D)            \
+  ENTRY(R9D)            \
+  ENTRY(R10D)           \
+  ENTRY(R11D)           \
+  ENTRY(R12D)           \
+  ENTRY(R13D)           \
+  ENTRY(R14D)           \
+  ENTRY(R15D)
+
+#define REGS_32BIT  \
+  ENTRY(EAX)        \
+  ENTRY(ECX)        \
+  ENTRY(EDX)        \
+  ENTRY(EBX)        \
+  ENTRY(ESP)        \
+  ENTRY(EBP)        \
+  ENTRY(ESI)        \
+  ENTRY(EDI)        \
+  ENTRY(R8D)        \
+  ENTRY(R9D)        \
+  ENTRY(R10D)       \
+  ENTRY(R11D)       \
+  ENTRY(R12D)       \
+  ENTRY(R13D)       \
+  ENTRY(R14D)       \
+  ENTRY(R15D)
+
+#define EA_BASES_64BIT  \
+  ENTRY(RAX)            \
+  ENTRY(RCX)            \
+  ENTRY(RDX)            \
+  ENTRY(RBX)            \
+  ENTRY(sib64)          \
+  ENTRY(RBP)            \
+  ENTRY(RSI)            \
+  ENTRY(RDI)            \
+  ENTRY(R8)             \
+  ENTRY(R9)             \
+  ENTRY(R10)            \
+  ENTRY(R11)            \
+  ENTRY(R12)            \
+  ENTRY(R13)            \
+  ENTRY(R14)            \
+  ENTRY(R15)
+
+#define REGS_64BIT  \
+  ENTRY(RAX)        \
+  ENTRY(RCX)        \
+  ENTRY(RDX)        \
+  ENTRY(RBX)        \
+  ENTRY(RSP)        \
+  ENTRY(RBP)        \
+  ENTRY(RSI)        \
+  ENTRY(RDI)        \
+  ENTRY(R8)         \
+  ENTRY(R9)         \
+  ENTRY(R10)        \
+  ENTRY(R11)        \
+  ENTRY(R12)        \
+  ENTRY(R13)        \
+  ENTRY(R14)        \
+  ENTRY(R15)
+
+#define REGS_MMX  \
+  ENTRY(MM0)      \
+  ENTRY(MM1)      \
+  ENTRY(MM2)      \
+  ENTRY(MM3)      \
+  ENTRY(MM4)      \
+  ENTRY(MM5)      \
+  ENTRY(MM6)      \
+  ENTRY(MM7)
+
+#define REGS_XMM  \
+  ENTRY(XMM0)     \
+  ENTRY(XMM1)     \
+  ENTRY(XMM2)     \
+  ENTRY(XMM3)     \
+  ENTRY(XMM4)     \
+  ENTRY(XMM5)     \
+  ENTRY(XMM6)     \
+  ENTRY(XMM7)     \
+  ENTRY(XMM8)     \
+  ENTRY(XMM9)     \
+  ENTRY(XMM10)    \
+  ENTRY(XMM11)    \
+  ENTRY(XMM12)    \
+  ENTRY(XMM13)    \
+  ENTRY(XMM14)    \
+  ENTRY(XMM15)    \
+  ENTRY(XMM16)    \
+  ENTRY(XMM17)    \
+  ENTRY(XMM18)    \
+  ENTRY(XMM19)    \
+  ENTRY(XMM20)    \
+  ENTRY(XMM21)    \
+  ENTRY(XMM22)    \
+  ENTRY(XMM23)    \
+  ENTRY(XMM24)    \
+  ENTRY(XMM25)    \
+  ENTRY(XMM26)    \
+  ENTRY(XMM27)    \
+  ENTRY(XMM28)    \
+  ENTRY(XMM29)    \
+  ENTRY(XMM30)    \
+  ENTRY(XMM31)
+
+
+#define REGS_YMM  \
+  ENTRY(YMM0)     \
+  ENTRY(YMM1)     \
+  ENTRY(YMM2)     \
+  ENTRY(YMM3)     \
+  ENTRY(YMM4)     \
+  ENTRY(YMM5)     \
+  ENTRY(YMM6)     \
+  ENTRY(YMM7)     \
+  ENTRY(YMM8)     \
+  ENTRY(YMM9)     \
+  ENTRY(YMM10)    \
+  ENTRY(YMM11)    \
+  ENTRY(YMM12)    \
+  ENTRY(YMM13)    \
+  ENTRY(YMM14)    \
+  ENTRY(YMM15)    \
+  ENTRY(YMM16)    \
+  ENTRY(YMM17)    \
+  ENTRY(YMM18)    \
+  ENTRY(YMM19)    \
+  ENTRY(YMM20)    \
+  ENTRY(YMM21)    \
+  ENTRY(YMM22)    \
+  ENTRY(YMM23)    \
+  ENTRY(YMM24)    \
+  ENTRY(YMM25)    \
+  ENTRY(YMM26)    \
+  ENTRY(YMM27)    \
+  ENTRY(YMM28)    \
+  ENTRY(YMM29)    \
+  ENTRY(YMM30)    \
+  ENTRY(YMM31)
+
+#define REGS_ZMM  \
+  ENTRY(ZMM0)     \
+  ENTRY(ZMM1)     \
+  ENTRY(ZMM2)     \
+  ENTRY(ZMM3)     \
+  ENTRY(ZMM4)     \
+  ENTRY(ZMM5)     \
+  ENTRY(ZMM6)     \
+  ENTRY(ZMM7)     \
+  ENTRY(ZMM8)     \
+  ENTRY(ZMM9)     \
+  ENTRY(ZMM10)    \
+  ENTRY(ZMM11)    \
+  ENTRY(ZMM12)    \
+  ENTRY(ZMM13)    \
+  ENTRY(ZMM14)    \
+  ENTRY(ZMM15)    \
+  ENTRY(ZMM16)    \
+  ENTRY(ZMM17)    \
+  ENTRY(ZMM18)    \
+  ENTRY(ZMM19)    \
+  ENTRY(ZMM20)    \
+  ENTRY(ZMM21)    \
+  ENTRY(ZMM22)    \
+  ENTRY(ZMM23)    \
+  ENTRY(ZMM24)    \
+  ENTRY(ZMM25)    \
+  ENTRY(ZMM26)    \
+  ENTRY(ZMM27)    \
+  ENTRY(ZMM28)    \
+  ENTRY(ZMM29)    \
+  ENTRY(ZMM30)    \
+  ENTRY(ZMM31)
+
+#define REGS_MASKS \
+  ENTRY(K0)        \
+  ENTRY(K1)        \
+  ENTRY(K2)        \
+  ENTRY(K3)        \
+  ENTRY(K4)        \
+  ENTRY(K5)        \
+  ENTRY(K6)        \
+  ENTRY(K7)
+
+#define REGS_SEGMENT \
+  ENTRY(ES)          \
+  ENTRY(CS)          \
+  ENTRY(SS)          \
+  ENTRY(DS)          \
+  ENTRY(FS)          \
+  ENTRY(GS)
+
+#define REGS_DEBUG  \
+  ENTRY(DR0)        \
+  ENTRY(DR1)        \
+  ENTRY(DR2)        \
+  ENTRY(DR3)        \
+  ENTRY(DR4)        \
+  ENTRY(DR5)        \
+  ENTRY(DR6)        \
+  ENTRY(DR7)        \
+  ENTRY(DR8)        \
+  ENTRY(DR9)        \
+  ENTRY(DR10)        \
+  ENTRY(DR11)        \
+  ENTRY(DR12)        \
+  ENTRY(DR13)        \
+  ENTRY(DR14)        \
+  ENTRY(DR15)
+
+#define REGS_CONTROL  \
+  ENTRY(CR0)          \
+  ENTRY(CR1)          \
+  ENTRY(CR2)          \
+  ENTRY(CR3)          \
+  ENTRY(CR4)          \
+  ENTRY(CR5)          \
+  ENTRY(CR6)          \
+  ENTRY(CR7)          \
+  ENTRY(CR8)          \
+  ENTRY(CR9)          \
+  ENTRY(CR10)          \
+  ENTRY(CR11)          \
+  ENTRY(CR12)          \
+  ENTRY(CR13)          \
+  ENTRY(CR14)          \
+  ENTRY(CR15)
+
+#define REGS_BOUND    \
+  ENTRY(BND0)         \
+  ENTRY(BND1)         \
+  ENTRY(BND2)         \
+  ENTRY(BND3)
+ 
+#define ALL_EA_BASES  \
+  EA_BASES_16BIT      \
+  EA_BASES_32BIT      \
+  EA_BASES_64BIT
+
+#define ALL_SIB_BASES \
+  REGS_32BIT          \
+  REGS_64BIT
+
+#define ALL_REGS      \
+  REGS_8BIT           \
+  REGS_16BIT          \
+  REGS_32BIT          \
+  REGS_64BIT          \
+  REGS_MMX            \
+  REGS_XMM            \
+  REGS_YMM            \
+  REGS_ZMM            \
+  REGS_MASKS          \
+  REGS_SEGMENT        \
+  REGS_DEBUG          \
+  REGS_CONTROL        \
+  REGS_BOUND          \
+  ENTRY(RIP)
+
+/*
+ * EABase - All possible values of the base field for effective-address
+ *   computations, a.k.a. the Mod and R/M fields of the ModR/M byte.  We
+ *   distinguish between bases (EA_BASE_*) and registers that just happen to be
+ *   referred to when Mod == 0b11 (EA_REG_*).
+ */
+typedef enum {
+  EA_BASE_NONE,
+#define ENTRY(x) EA_BASE_##x,
+  ALL_EA_BASES
+#undef ENTRY
+#define ENTRY(x) EA_REG_##x,
+  ALL_REGS
+#undef ENTRY
+  EA_max
+} EABase;
+
+/*
+ * SIBIndex - All possible values of the SIB index field.
+ *   Borrows entries from ALL_EA_BASES with the special case that
+ *   sib is synonymous with NONE.
+ * Vector SIB: index can be XMM or YMM.
+ */
+typedef enum {
+  SIB_INDEX_NONE,
+#define ENTRY(x) SIB_INDEX_##x,
+  ALL_EA_BASES
+  REGS_XMM
+  REGS_YMM
+  REGS_ZMM
+#undef ENTRY
+  SIB_INDEX_max
+} SIBIndex;
+
+/*
+ * SIBBase - All possible values of the SIB base field.
+ */
+typedef enum {
+  SIB_BASE_NONE,
+#define ENTRY(x) SIB_BASE_##x,
+  ALL_SIB_BASES
+#undef ENTRY
+  SIB_BASE_max
+} SIBBase;
+
+/*
+ * EADisplacement - Possible displacement types for effective-address
+ *   computations.
+ */
+typedef enum {
+  EA_DISP_NONE,
+  EA_DISP_8,
+  EA_DISP_16,
+  EA_DISP_32
+} EADisplacement;
+
+/*
+ * Reg - All possible values of the reg field in the ModR/M byte.
+ */
+typedef enum {
+#define ENTRY(x) MODRM_REG_##x,
+  ALL_REGS
+#undef ENTRY
+  MODRM_REG_max
+} Reg;
+
+/*
+ * SegmentOverride - All possible segment overrides.
+ */
+typedef enum {
+  SEG_OVERRIDE_NONE,
+  SEG_OVERRIDE_CS,
+  SEG_OVERRIDE_SS,
+  SEG_OVERRIDE_DS,
+  SEG_OVERRIDE_ES,
+  SEG_OVERRIDE_FS,
+  SEG_OVERRIDE_GS,
+  SEG_OVERRIDE_max
+} SegmentOverride;
+
+/*
+ * VEXLeadingOpcodeByte - Possible values for the VEX.m-mmmm field
+ */
+typedef enum {
+  VEX_LOB_0F = 0x1,
+  VEX_LOB_0F38 = 0x2,
+  VEX_LOB_0F3A = 0x3
+} VEXLeadingOpcodeByte;
+
+typedef enum {
+  XOP_MAP_SELECT_8 = 0x8,
+  XOP_MAP_SELECT_9 = 0x9,
+  XOP_MAP_SELECT_A = 0xA
+} XOPMapSelect;
+
+/*
+ * VEXPrefixCode - Possible values for the VEX.pp/EVEX.pp field
+ */
+typedef enum {
+  VEX_PREFIX_NONE = 0x0,
+  VEX_PREFIX_66 = 0x1,
+  VEX_PREFIX_F3 = 0x2,
+  VEX_PREFIX_F2 = 0x3
+} VEXPrefixCode;
+
+typedef enum {
+	TYPE_NO_VEX_XOP   = 0x0,
+	TYPE_VEX_2B       = 0x1,
+	TYPE_VEX_3B       = 0x2,
+	TYPE_EVEX         = 0x3,
+	TYPE_XOP          = 0x4
+} VectorExtensionType;
+
+struct reader_info {
+	const uint8_t *code;
+	uint64_t size;
+	uint64_t offset;
+};
+
+/*
+ * byteReader_t - Type for the byte reader that the consumer must provide to
+ *   the decoder.  Reads a single byte from the instruction's address space.
+ * @param arg     - A baton that the consumer can associate with any internal
+ *                  state that it needs.
+ * @param byte    - A pointer to a single byte in memory that should be set to
+ *                  contain the value at address.
+ * @param address - The address in the instruction's address space that should
+ *                  be read from.
+ * @return        - -1 if the byte cannot be read for any reason; 0 otherwise.
+ */
+typedef int (*byteReader_t)(const struct reader_info *arg, uint8_t* byte, uint64_t address);
+
+/// The specification for how to extract and interpret a full instruction and
+/// its operands.
+struct InstructionSpecifier {
+#ifdef CAPSTONE_X86_REDUCE
+	uint8_t operands;
+#else
+	uint16_t operands;
+#endif
+};
+
+/*
+ * The x86 internal instruction, which is produced by the decoder.
+ */
+typedef struct InternalInstruction {
+  // from here, all members must be initialized to ZERO to work properly
+  uint8_t operandSize;
+  uint8_t prefix0, prefix1, prefix2, prefix3;
+  /* The value of the REX prefix, if present */
+  uint8_t rexPrefix;
+  /* The segment override type */
+  SegmentOverride segmentOverride;
+  bool                          consumedModRM;
+  uint8_t                       orgModRM;  // save original modRM because we will modify modRM
+  /* The SIB byte, used for more complex 32- or 64-bit memory operands */
+  bool                          consumedSIB;
+  uint8_t                       sib;
+  /* The displacement, used for memory operands */
+  bool                          consumedDisplacement;
+  int64_t                       displacement;
+  /* The value of the two-byte escape prefix (usually 0x0f) */
+  uint8_t twoByteEscape;
+  /* The value of the three-byte escape prefix (usually 0x38 or 0x3a) */
+  uint8_t threeByteEscape;
+  /* SIB state */
+  SIBIndex                      sibIndexBase;
+  SIBIndex                      sibIndex;
+  uint8_t                       sibScale;
+  SIBBase                       sibBase;
+
+  // Embedded rounding control.
+  uint8_t                       RC;
+
+  uint8_t                       numImmediatesConsumed;
+  /* 0xf2 or 0xf3 is xacquire or xrelease */
+  uint8_t xAcquireRelease;
+
+  // Address-size override
+  bool hasAdSize;
+  // Operand-size override
+  bool hasOpSize;
+  // Lock prefix
+  bool hasLockPrefix;
+  // The repeat prefix if any
+  uint8_t repeatPrefix;
+
+  // The possible mandatory prefix
+  uint8_t mandatoryPrefix;
+
+  /* The value of the vector extension prefix(EVEX/VEX/XOP), if present */
+  uint8_t vectorExtensionPrefix[4];
+
+  /* Offsets from the start of the instruction to the pieces of data, which is
+     needed to find relocation entries for adding symbolic operands */
+  uint8_t displacementOffset;
+  uint8_t immediateOffset;
+  uint8_t modRMOffset;
+
+  // end-of-zero-members
+
+  /* Reader interface (C) */
+  byteReader_t reader;
+
+  /* Opaque value passed to the reader */
+  const void* readerArg;
+  /* The address of the next byte to read via the reader */
+  uint64_t readerCursor;
+
+  /* General instruction information */
+
+  /* The mode to disassemble for (64-bit, protected, real) */
+  DisassemblerMode mode;
+  /* The start of the instruction, usable with the reader */
+  uint64_t startLocation;
+  /* The length of the instruction, in bytes */
+  size_t length;
+
+  /* Prefix state */
+
+  /* The type of the vector extension prefix */
+  VectorExtensionType vectorExtensionType;
+
+  /* Sizes of various critical pieces of data, in bytes */
+  uint8_t registerSize;
+  uint8_t addressSize;
+  uint8_t displacementSize;
+  uint8_t immediateSize;
+
+  uint8_t immSize;	// immediate size for X86_OP_IMM operand
+
+  /* opcode state */
+
+  /* The last byte of the opcode, not counting any ModR/M extension */
+  uint8_t opcode;
+
+  /* decode state */
+
+  /* The type of opcode, used for indexing into the array of decode tables */
+  OpcodeType opcodeType;
+  /* The instruction ID, extracted from the decode table */
+  uint16_t instructionID;
+  /* The specifier for the instruction, from the instruction info table */
+  const struct InstructionSpecifier *spec;
+
+  /* state for additional bytes, consumed during operand decode.  Pattern:
+     consumed___ indicates that the byte was already consumed and does not
+     need to be consumed again */
+
+  /* The VEX.vvvv field, which contains a third register operand for some AVX
+     instructions */
+  Reg                           vvvv;
+
+  /* The writemask for AVX-512 instructions which is contained in EVEX.aaa */
+  Reg                           writemask;
+
+  /* The ModR/M byte, which contains most register operands and some portion of
+     all memory operands */
+  uint8_t                       modRM;
+
+  // special data to handle MOVcr, MOVdr, MOVrc, MOVrd
+  uint8_t                       firstByte;     // save the first byte in stream
+
+  /* Immediates.  There can be two in some cases */
+  uint8_t                       numImmediatesTranslated;
+  uint64_t                      immediates[2];
+
+  /* A register or immediate operand encoded into the opcode */
+  Reg                           opcodeRegister;
+
+  /* Portions of the ModR/M byte */
+
+  /* These fields determine the allowable values for the ModR/M fields, which
+     depend on operand and address widths */
+  EABase                        eaRegBase;
+  Reg                           regBase;
+
+  /* The Mod and R/M fields can encode a base for an effective address, or a
+     register.  These are separated into two fields here */
+  EABase                        eaBase;
+  EADisplacement                eaDisplacement;
+  /* The reg field always encodes a register */
+  Reg                           reg;
+
+  const struct OperandSpecifier *operands;
+} InternalInstruction;
+
+/* decodeInstruction - Decode one instruction and store the decoding results in
+ *   a buffer provided by the consumer.
+ * @param insn      - The buffer to store the instruction in.  Allocated by the
+ *                    consumer.
+ * @param reader    - The byteReader_t for the bytes to be read.
+ * @param readerArg - An argument to pass to the reader for storing context
+ *                    specific to the consumer.  May be NULL.
+ * @param logger    - The dlog_t to be used in printing status messages from the
+ *                    disassembler.  May be NULL.
+ * @param loggerArg - An argument to pass to the logger for storing context
+ *                    specific to the logger.  May be NULL.
+ * @param startLoc  - The address (in the reader's address space) of the first
+ *                    byte in the instruction.
+ * @param mode      - The mode (16-bit, 32-bit, 64-bit) to decode in.
+ * @return          - Nonzero if there was an error during decode, 0 otherwise.
+ */
+int decodeInstruction(struct InternalInstruction* insn,
+                      byteReader_t reader,
+                      const void* readerArg,
+                      uint64_t startLoc,
+                      DisassemblerMode mode);
+
+//const char *x86DisassemblerGetInstrName(unsigned Opcode, const void *mii);
+
+#endif

thirdparty/capstone/arch/X86/X86DisassemblerDecoderCommon.h

@@ -0,0 +1,483 @@
+/*===-- X86DisassemblerDecoderCommon.h - Disassembler decoder -----*- C -*-===*
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is distributed under the University of Illinois Open Source
+ * License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===*
+ *
+ * This file is part of the X86 Disassembler.
+ * It contains common definitions used by both the disassembler and the table
+ *  generator.
+ * Documentation for the disassembler can be found in X86Disassembler.h.
+ *
+ *===----------------------------------------------------------------------===*/
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+/*
+ * This header file provides those definitions that need to be shared between
+ * the decoder and the table generator in a C-friendly manner.
+ */
+
+#ifndef CS_X86_DISASSEMBLERDECODERCOMMON_H
+#define CS_X86_DISASSEMBLERDECODERCOMMON_H
+
+#define INSTRUCTIONS_SYM  x86DisassemblerInstrSpecifiers
+#define CONTEXTS_SYM      x86DisassemblerContexts
+#define ONEBYTE_SYM       x86DisassemblerOneByteOpcodes
+#define TWOBYTE_SYM       x86DisassemblerTwoByteOpcodes
+#define THREEBYTE38_SYM   x86DisassemblerThreeByte38Opcodes
+#define THREEBYTE3A_SYM   x86DisassemblerThreeByte3AOpcodes
+#define XOP8_MAP_SYM      x86DisassemblerXOP8Opcodes
+#define XOP9_MAP_SYM      x86DisassemblerXOP9Opcodes
+#define XOPA_MAP_SYM      x86DisassemblerXOPAOpcodes
+#define THREEDNOW_MAP_SYM x86Disassembler3DNowOpcodes
+
+
+/*
+ * Attributes of an instruction that must be known before the opcode can be
+ * processed correctly.  Most of these indicate the presence of particular
+ * prefixes, but ATTR_64BIT is simply an attribute of the decoding context.
+ */
+#define ATTRIBUTE_BITS                  \
+  ENUM_ENTRY(ATTR_NONE,   0x00)         \
+  ENUM_ENTRY(ATTR_64BIT,  (0x1 << 0))   \
+  ENUM_ENTRY(ATTR_XS,     (0x1 << 1))   \
+  ENUM_ENTRY(ATTR_XD,     (0x1 << 2))   \
+  ENUM_ENTRY(ATTR_REXW,   (0x1 << 3))   \
+  ENUM_ENTRY(ATTR_OPSIZE, (0x1 << 4))   \
+  ENUM_ENTRY(ATTR_ADSIZE, (0x1 << 5))   \
+  ENUM_ENTRY(ATTR_VEX,    (0x1 << 6))   \
+  ENUM_ENTRY(ATTR_VEXL,   (0x1 << 7))   \
+  ENUM_ENTRY(ATTR_EVEX,   (0x1 << 8))   \
+  ENUM_ENTRY(ATTR_EVEXL,  (0x1 << 9))   \
+  ENUM_ENTRY(ATTR_EVEXL2, (0x1 << 10))  \
+  ENUM_ENTRY(ATTR_EVEXK,  (0x1 << 11))  \
+  ENUM_ENTRY(ATTR_EVEXKZ, (0x1 << 12))  \
+  ENUM_ENTRY(ATTR_EVEXB,  (0x1 << 13))
+
+#define ENUM_ENTRY(n, v) n = v,
+enum attributeBits {
+	ATTRIBUTE_BITS
+	ATTR_max
+};
+#undef ENUM_ENTRY
+
+/*
+ * Combinations of the above attributes that are relevant to instruction
+ * decode. Although other combinations are possible, they can be reduced to
+ * these without affecting the ultimately decoded instruction.
+ */
+
+//           Class name           Rank  Rationale for rank assignment
+#define INSTRUCTION_CONTEXTS                                                   \
+  ENUM_ENTRY(IC,                    0,  "says nothing about the instruction")  \
+  ENUM_ENTRY(IC_64BIT,              1,  "says the instruction applies in "     \
+                                        "64-bit mode but no more")             \
+  ENUM_ENTRY(IC_OPSIZE,             3,  "requires an OPSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_ADSIZE,             3,  "requires an ADSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_OPSIZE_ADSIZE,      4,  "requires ADSIZE and OPSIZE prefixes") \
+  ENUM_ENTRY(IC_XD,                 2,  "may say something about the opcode "  \
+                                        "but not the operands")                \
+  ENUM_ENTRY(IC_XS,                 2,  "may say something about the opcode "  \
+                                        "but not the operands")                \
+  ENUM_ENTRY(IC_XD_OPSIZE,          3,  "requires an OPSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_XS_OPSIZE,          3,  "requires an OPSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_XD_ADSIZE,          3,  "requires an ADSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_XS_ADSIZE,          3,  "requires an ADSIZE prefix, so "       \
+                                        "operands change width")               \
+  ENUM_ENTRY(IC_64BIT_REXW,         5,  "requires a REX.W prefix, so operands "\
+                                        "change width; overrides IC_OPSIZE")   \
+  ENUM_ENTRY(IC_64BIT_REXW_ADSIZE,  6,  "requires a REX.W prefix and 0x67 "    \
+                                        "prefix")                              \
+  ENUM_ENTRY(IC_64BIT_OPSIZE,       3,  "Just as meaningful as IC_OPSIZE")     \
+  ENUM_ENTRY(IC_64BIT_ADSIZE,       3,  "Just as meaningful as IC_ADSIZE")     \
+  ENUM_ENTRY(IC_64BIT_OPSIZE_ADSIZE, 4, "Just as meaningful as IC_OPSIZE/"     \
+                                        "IC_ADSIZE")                           \
+  ENUM_ENTRY(IC_64BIT_XD,           6,  "XD instructions are SSE; REX.W is "   \
+                                        "secondary")                           \
+  ENUM_ENTRY(IC_64BIT_XS,           6,  "Just as meaningful as IC_64BIT_XD")   \
+  ENUM_ENTRY(IC_64BIT_XD_OPSIZE,    3,  "Just as meaningful as IC_XD_OPSIZE")  \
+  ENUM_ENTRY(IC_64BIT_XS_OPSIZE,    3,  "Just as meaningful as IC_XS_OPSIZE")  \
+  ENUM_ENTRY(IC_64BIT_XD_ADSIZE,    3,  "Just as meaningful as IC_XD_ADSIZE")  \
+  ENUM_ENTRY(IC_64BIT_XS_ADSIZE,    3,  "Just as meaningful as IC_XS_ADSIZE")  \
+  ENUM_ENTRY(IC_64BIT_REXW_XS,      7,  "OPSIZE could mean a different "       \
+                                        "opcode")                              \
+  ENUM_ENTRY(IC_64BIT_REXW_XD,      7,  "Just as meaningful as "               \
+                                        "IC_64BIT_REXW_XS")                    \
+  ENUM_ENTRY(IC_64BIT_REXW_OPSIZE,  8,  "The Dynamic Duo!  Prefer over all "   \
+                                        "else because this changes most "      \
+                                        "operands' meaning")                   \
+  ENUM_ENTRY(IC_VEX,                1,  "requires a VEX prefix")               \
+  ENUM_ENTRY(IC_VEX_XS,             2,  "requires VEX and the XS prefix")      \
+  ENUM_ENTRY(IC_VEX_XD,             2,  "requires VEX and the XD prefix")      \
+  ENUM_ENTRY(IC_VEX_OPSIZE,         2,  "requires VEX and the OpSize prefix")  \
+  ENUM_ENTRY(IC_VEX_W,              3,  "requires VEX and the W prefix")       \
+  ENUM_ENTRY(IC_VEX_W_XS,           4,  "requires VEX, W, and XS prefix")      \
+  ENUM_ENTRY(IC_VEX_W_XD,           4,  "requires VEX, W, and XD prefix")      \
+  ENUM_ENTRY(IC_VEX_W_OPSIZE,       4,  "requires VEX, W, and OpSize")         \
+  ENUM_ENTRY(IC_VEX_L,              3,  "requires VEX and the L prefix")       \
+  ENUM_ENTRY(IC_VEX_L_XS,           4,  "requires VEX and the L and XS prefix")\
+  ENUM_ENTRY(IC_VEX_L_XD,           4,  "requires VEX and the L and XD prefix")\
+  ENUM_ENTRY(IC_VEX_L_OPSIZE,       4,  "requires VEX, L, and OpSize")         \
+  ENUM_ENTRY(IC_VEX_L_W,            4,  "requires VEX, L and W")               \
+  ENUM_ENTRY(IC_VEX_L_W_XS,         5,  "requires VEX, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_VEX_L_W_XD,         5,  "requires VEX, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_VEX_L_W_OPSIZE,     5,  "requires VEX, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX,               1,  "requires an EVEX prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS,            2,  "requires EVEX and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD,            2,  "requires EVEX and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE,        2,  "requires EVEX and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W,             3,  "requires EVEX and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS,          4,  "requires EVEX, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD,          4,  "requires EVEX, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE,      4,  "requires EVEX, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L,             3,  "requires EVEX and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS,          4,  "requires EVEX and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD,          4,  "requires EVEX and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE,      4,  "requires EVEX, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W,           3,  "requires EVEX, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS,        4,  "requires EVEX, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD,        4,  "requires EVEX, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE,    4,  "requires EVEX, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2,            3,  "requires EVEX and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS,         4,  "requires EVEX and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD,         4,  "requires EVEX and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE,     4,  "requires EVEX, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W,          3,  "requires EVEX, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS,       4,  "requires EVEX, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD,       4,  "requires EVEX, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE,   4,  "requires EVEX, L2, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_K,             1,  "requires an EVEX_K prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS_K,          2,  "requires EVEX_K and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD_K,          2,  "requires EVEX_K and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE_K,      2,  "requires EVEX_K and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W_K,           3,  "requires EVEX_K and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS_K,        4,  "requires EVEX_K, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD_K,        4,  "requires EVEX_K, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE_K,    4,  "requires EVEX_K, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L_K,           3,  "requires EVEX_K and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS_K,        4,  "requires EVEX_K and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD_K,        4,  "requires EVEX_K and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE_K,    4,  "requires EVEX_K, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W_K,         3,  "requires EVEX_K, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS_K,      4,  "requires EVEX_K, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD_K,      4,  "requires EVEX_K, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE_K,  4,  "requires EVEX_K, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2_K,          3,  "requires EVEX_K and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS_K,       4,  "requires EVEX_K and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD_K,       4,  "requires EVEX_K and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE_K,   4,  "requires EVEX_K, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W_K,        3,  "requires EVEX_K, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS_K,     4,  "requires EVEX_K, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD_K,     4,  "requires EVEX_K, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE_K, 4,  "requires EVEX_K, L2, W and OpSize")     \
+  ENUM_ENTRY(IC_EVEX_B,             1,  "requires an EVEX_B prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS_B,          2,  "requires EVEX_B and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD_B,          2,  "requires EVEX_B and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE_B,      2,  "requires EVEX_B and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W_B,           3,  "requires EVEX_B and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS_B,        4,  "requires EVEX_B, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD_B,        4,  "requires EVEX_B, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE_B,    4,  "requires EVEX_B, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L_B,           3,  "requires EVEX_B and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS_B,        4,  "requires EVEX_B and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD_B,        4,  "requires EVEX_B and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE_B,    4,  "requires EVEX_B, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W_B,         3,  "requires EVEX_B, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS_B,      4,  "requires EVEX_B, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD_B,      4,  "requires EVEX_B, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE_B,  4,  "requires EVEX_B, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2_B,          3,  "requires EVEX_B and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS_B,       4,  "requires EVEX_B and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD_B,       4,  "requires EVEX_B and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE_B,   4,  "requires EVEX_B, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W_B,        3,  "requires EVEX_B, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS_B,     4,  "requires EVEX_B, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD_B,     4,  "requires EVEX_B, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE_B, 4,  "requires EVEX_B, L2, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_K_B,           1,  "requires EVEX_B and EVEX_K prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS_K_B,        2,  "requires EVEX_B, EVEX_K and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD_K_B,        2,  "requires EVEX_B, EVEX_K and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE_K_B,    2,  "requires EVEX_B, EVEX_K and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W_K_B,         3,  "requires EVEX_B, EVEX_K and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS_K_B,      4,  "requires EVEX_B, EVEX_K, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD_K_B,      4,  "requires EVEX_B, EVEX_K, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE_K_B,  4,  "requires EVEX_B, EVEX_K, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L_K_B,         3,  "requires EVEX_B, EVEX_K and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS_K_B,      4,  "requires EVEX_B, EVEX_K and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD_K_B,      4,  "requires EVEX_B, EVEX_K and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE_K_B,  4,  "requires EVEX_B, EVEX_K, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W_K_B,       3,  "requires EVEX_B, EVEX_K, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS_K_B,    4,  "requires EVEX_B, EVEX_K, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD_K_B,    4,  "requires EVEX_B, EVEX_K, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE_K_B,4,  "requires EVEX_B, EVEX_K, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2_K_B,        3,  "requires EVEX_B, EVEX_K and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS_K_B,     4,  "requires EVEX_B, EVEX_K and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD_K_B,     4,  "requires EVEX_B, EVEX_K and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE_K_B, 4,  "requires EVEX_B, EVEX_K, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W_K_B,      3,  "requires EVEX_B, EVEX_K, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS_K_B,   4,  "requires EVEX_B, EVEX_K, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD_K_B,   4,  "requires EVEX_B, EVEX_K, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE_K_B,4,  "requires EVEX_B, EVEX_K, L2, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_KZ_B,           1,  "requires EVEX_B and EVEX_KZ prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS_KZ_B,        2,  "requires EVEX_B, EVEX_KZ and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD_KZ_B,        2,  "requires EVEX_B, EVEX_KZ and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE_KZ_B,    2,  "requires EVEX_B, EVEX_KZ and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W_KZ_B,         3,  "requires EVEX_B, EVEX_KZ and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS_KZ_B,      4,  "requires EVEX_B, EVEX_KZ, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD_KZ_B,      4,  "requires EVEX_B, EVEX_KZ, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE_KZ_B,  4,  "requires EVEX_B, EVEX_KZ, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L_KZ_B,           3,  "requires EVEX_B, EVEX_KZ and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS_KZ_B,        4,  "requires EVEX_B, EVEX_KZ and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD_KZ_B,        4,  "requires EVEX_B, EVEX_KZ and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE_KZ_B,    4,  "requires EVEX_B, EVEX_KZ, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W_KZ_B,         3,  "requires EVEX_B, EVEX_KZ, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS_KZ_B,      4,  "requires EVEX_B, EVEX_KZ, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD_KZ_B,      4,  "requires EVEX_B, EVEX_KZ, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE_KZ_B,  4,  "requires EVEX_B, EVEX_KZ, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2_KZ_B,          3,  "requires EVEX_B, EVEX_KZ and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS_KZ_B,       4,  "requires EVEX_B, EVEX_KZ and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD_KZ_B,       4,  "requires EVEX_B, EVEX_KZ and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE_KZ_B,   4,  "requires EVEX_B, EVEX_KZ, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W_KZ_B,        3,  "requires EVEX_B, EVEX_KZ, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS_KZ_B,     4,  "requires EVEX_B, EVEX_KZ, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD_KZ_B,     4,  "requires EVEX_B, EVEX_KZ, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE_KZ_B, 4,  "requires EVEX_B, EVEX_KZ, L2, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_KZ,             1,  "requires an EVEX_KZ prefix")             \
+  ENUM_ENTRY(IC_EVEX_XS_KZ,          2,  "requires EVEX_KZ and the XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_XD_KZ,          2,  "requires EVEX_KZ and the XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_OPSIZE_KZ,      2,  "requires EVEX_KZ and the OpSize prefix") \
+  ENUM_ENTRY(IC_EVEX_W_KZ,           3,  "requires EVEX_KZ and the W prefix")      \
+  ENUM_ENTRY(IC_EVEX_W_XS_KZ,        4,  "requires EVEX_KZ, W, and XS prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_XD_KZ,        4,  "requires EVEX_KZ, W, and XD prefix")     \
+  ENUM_ENTRY(IC_EVEX_W_OPSIZE_KZ,    4,  "requires EVEX_KZ, W, and OpSize")        \
+  ENUM_ENTRY(IC_EVEX_L_KZ,           3,  "requires EVEX_KZ and the L prefix")       \
+  ENUM_ENTRY(IC_EVEX_L_XS_KZ,        4,  "requires EVEX_KZ and the L and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L_XD_KZ,        4,  "requires EVEX_KZ and the L and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L_OPSIZE_KZ,    4,  "requires EVEX_KZ, L, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L_W_KZ,         3,  "requires EVEX_KZ, L and W")               \
+  ENUM_ENTRY(IC_EVEX_L_W_XS_KZ,      4,  "requires EVEX_KZ, L, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_XD_KZ,      4,  "requires EVEX_KZ, L, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L_W_OPSIZE_KZ,  4,  "requires EVEX_KZ, L, W and OpSize")       \
+  ENUM_ENTRY(IC_EVEX_L2_KZ,          3,  "requires EVEX_KZ and the L2 prefix")       \
+  ENUM_ENTRY(IC_EVEX_L2_XS_KZ,       4,  "requires EVEX_KZ and the L2 and XS prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_XD_KZ,       4,  "requires EVEX_KZ and the L2 and XD prefix")\
+  ENUM_ENTRY(IC_EVEX_L2_OPSIZE_KZ,   4,  "requires EVEX_KZ, L2, and OpSize")         \
+  ENUM_ENTRY(IC_EVEX_L2_W_KZ,        3,  "requires EVEX_KZ, L2 and W")               \
+  ENUM_ENTRY(IC_EVEX_L2_W_XS_KZ,     4,  "requires EVEX_KZ, L2, W and XS prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_XD_KZ,     4,  "requires EVEX_KZ, L2, W and XD prefix")    \
+  ENUM_ENTRY(IC_EVEX_L2_W_OPSIZE_KZ, 4,  "requires EVEX_KZ, L2, W and OpSize")
+
+#define ENUM_ENTRY(n, r, d) n,
+typedef enum {
+	INSTRUCTION_CONTEXTS
+	IC_max
+} InstructionContext;
+#undef ENUM_ENTRY
+
+/*
+ * Opcode types, which determine which decode table to use, both in the Intel
+ * manual and also for the decoder.
+ */
+typedef enum {
+	ONEBYTE       = 0,
+	TWOBYTE       = 1,
+	THREEBYTE_38  = 2,
+	THREEBYTE_3A  = 3,
+	XOP8_MAP      = 4,
+	XOP9_MAP      = 5,
+	XOPA_MAP      = 6,
+	THREEDNOW_MAP = 7
+} OpcodeType;
+
+/*
+ * The following structs are used for the hierarchical decode table.  After
+ * determining the instruction's class (i.e., which IC_* constant applies to
+ * it), the decoder reads the opcode.  Some instructions require specific
+ * values of the ModR/M byte, so the ModR/M byte indexes into the final table.
+ *
+ * If a ModR/M byte is not required, "required" is left unset, and the values
+ * for each instructionID are identical.
+ */
+
+typedef uint16_t InstrUID;
+
+/*
+ * ModRMDecisionType - describes the type of ModR/M decision, allowing the
+ * consumer to determine the number of entries in it.
+ *
+ * MODRM_ONEENTRY - No matter what the value of the ModR/M byte is, the decoded
+ *                  instruction is the same.
+ * MODRM_SPLITRM  - If the ModR/M byte is between 0x00 and 0xbf, the opcode
+ *                  corresponds to one instruction; otherwise, it corresponds to
+ *                  a different instruction.
+ * MODRM_SPLITMISC- If the ModR/M byte is between 0x00 and 0xbf, ModR/M byte
+ *                  divided by 8 is used to select instruction; otherwise, each
+ *                  value of the ModR/M byte could correspond to a different
+ *                  instruction.
+ * MODRM_SPLITREG - ModR/M byte divided by 8 is used to select instruction. This
+ corresponds to instructions that use reg field as opcode
+ * MODRM_FULL     - Potentially, each value of the ModR/M byte could correspond
+ *                  to a different instruction.
+ */
+
+#define MODRMTYPES            \
+	ENUM_ENTRY(MODRM_ONEENTRY)  \
+ENUM_ENTRY(MODRM_SPLITRM)   \
+ENUM_ENTRY(MODRM_SPLITMISC)  \
+ENUM_ENTRY(MODRM_SPLITREG)  \
+ENUM_ENTRY(MODRM_FULL)
+
+#define ENUM_ENTRY(n) n,
+typedef enum {
+	MODRMTYPES
+	MODRM_max
+} ModRMDecisionType;
+#undef ENUM_ENTRY
+
+#define CASE_ENCODING_RM     \
+    case ENCODING_RM:        \
+    case ENCODING_RM_CD2:    \
+    case ENCODING_RM_CD4:    \
+    case ENCODING_RM_CD8:    \
+    case ENCODING_RM_CD16:   \
+    case ENCODING_RM_CD32:   \
+    case ENCODING_RM_CD64
+ 
+#define CASE_ENCODING_VSIB   \
+    case ENCODING_VSIB:      \
+    case ENCODING_VSIB_CD2:  \
+    case ENCODING_VSIB_CD4:  \
+    case ENCODING_VSIB_CD8:  \
+    case ENCODING_VSIB_CD16: \
+    case ENCODING_VSIB_CD32: \
+    case ENCODING_VSIB_CD64
+
+// Physical encodings of instruction operands.
+
+#define ENCODINGS                                                            \
+ENUM_ENTRY(ENCODING_NONE,   "")                                              \
+ENUM_ENTRY(ENCODING_REG,    "Register operand in ModR/M byte.")              \
+ENUM_ENTRY(ENCODING_RM,     "R/M operand in ModR/M byte.")                   \
+ENUM_ENTRY(ENCODING_RM_CD2, "R/M operand with CDisp scaling of 2")           \
+ENUM_ENTRY(ENCODING_RM_CD4, "R/M operand with CDisp scaling of 4")           \
+ENUM_ENTRY(ENCODING_RM_CD8, "R/M operand with CDisp scaling of 8")           \
+ENUM_ENTRY(ENCODING_RM_CD16,"R/M operand with CDisp scaling of 16")          \
+ENUM_ENTRY(ENCODING_RM_CD32,"R/M operand with CDisp scaling of 32")          \
+ENUM_ENTRY(ENCODING_RM_CD64,"R/M operand with CDisp scaling of 64")          \
+ENUM_ENTRY(ENCODING_VSIB,     "VSIB operand in ModR/M byte.")                \
+ENUM_ENTRY(ENCODING_VSIB_CD2, "VSIB operand with CDisp scaling of 2")        \
+ENUM_ENTRY(ENCODING_VSIB_CD4, "VSIB operand with CDisp scaling of 4")        \
+ENUM_ENTRY(ENCODING_VSIB_CD8, "VSIB operand with CDisp scaling of 8")        \
+ENUM_ENTRY(ENCODING_VSIB_CD16,"VSIB operand with CDisp scaling of 16")       \
+ENUM_ENTRY(ENCODING_VSIB_CD32,"VSIB operand with CDisp scaling of 32")       \
+ENUM_ENTRY(ENCODING_VSIB_CD64,"VSIB operand with CDisp scaling of 64")       \
+ENUM_ENTRY(ENCODING_VVVV,   "Register operand in VEX.vvvv byte.")            \
+ENUM_ENTRY(ENCODING_WRITEMASK, "Register operand in EVEX.aaa byte.")         \
+ENUM_ENTRY(ENCODING_IB,     "1-byte immediate")                              \
+ENUM_ENTRY(ENCODING_IW,     "2-byte")                                        \
+ENUM_ENTRY(ENCODING_ID,     "4-byte")                                        \
+ENUM_ENTRY(ENCODING_IO,     "8-byte")                                        \
+ENUM_ENTRY(ENCODING_RB,     "(AL..DIL, R8L..R15L) Register code added to "   \
+                            "the opcode byte")                               \
+ENUM_ENTRY(ENCODING_RW,     "(AX..DI, R8W..R15W)")                           \
+ENUM_ENTRY(ENCODING_RD,     "(EAX..EDI, R8D..R15D)")                         \
+ENUM_ENTRY(ENCODING_RO,     "(RAX..RDI, R8..R15)")                           \
+ENUM_ENTRY(ENCODING_FP,     "Position on floating-point stack in ModR/M "    \
+                            "byte.")                                         \
+ENUM_ENTRY(ENCODING_Iv,     "Immediate of operand size")                     \
+ENUM_ENTRY(ENCODING_Ia,     "Immediate of address size")                     \
+ENUM_ENTRY(ENCODING_IRC,    "Immediate for static rounding control")         \
+ENUM_ENTRY(ENCODING_Rv,     "Register code of operand size added to the "    \
+                            "opcode byte")                                   \
+ENUM_ENTRY(ENCODING_DUP,    "Duplicate of another operand; ID is encoded "   \
+                            "in type")                                       \
+ENUM_ENTRY(ENCODING_SI,     "Source index; encoded in OpSize/Adsize prefix") \
+ENUM_ENTRY(ENCODING_DI,     "Destination index; encoded in prefixes")
+
+#define ENUM_ENTRY(n, d) n,
+typedef enum {
+	ENCODINGS
+	ENCODING_max
+} OperandEncoding;
+#undef ENUM_ENTRY
+
+/*
+ * Semantic interpretations of instruction operands.
+ */
+#define TYPES                                                                  \
+  ENUM_ENTRY(TYPE_NONE,       "")                                              \
+  ENUM_ENTRY(TYPE_REL,        "immediate address")                             \
+  ENUM_ENTRY(TYPE_R8,         "1-byte register operand")                       \
+  ENUM_ENTRY(TYPE_R16,        "2-byte")                                        \
+  ENUM_ENTRY(TYPE_R32,        "4-byte")                                        \
+  ENUM_ENTRY(TYPE_R64,        "8-byte")                                        \
+  ENUM_ENTRY(TYPE_IMM,        "immediate operand")                      \
+  ENUM_ENTRY(TYPE_IMM3,       "1-byte immediate operand between 0 and 7")      \
+  ENUM_ENTRY(TYPE_IMM5,       "1-byte immediate operand between 0 and 31")     \
+  ENUM_ENTRY(TYPE_AVX512ICC,  "1-byte immediate operand for AVX512 icmp")      \
+  ENUM_ENTRY(TYPE_UIMM8,      "1-byte unsigned immediate operand")             \
+  ENUM_ENTRY(TYPE_M,          "Memory operand")                                \
+  ENUM_ENTRY(TYPE_MVSIBX,     "Memory operand using XMM index")                \
+  ENUM_ENTRY(TYPE_MVSIBY,     "Memory operand using YMM index")                \
+  ENUM_ENTRY(TYPE_MVSIBZ,     "Memory operand using ZMM index")                \
+  ENUM_ENTRY(TYPE_SRCIDX,     "memory at source index")                        \
+  ENUM_ENTRY(TYPE_DSTIDX,     "memory at destination index")                   \
+  ENUM_ENTRY(TYPE_MOFFS,      "memory offset (relative to segment base)")      \
+  ENUM_ENTRY(TYPE_ST,         "Position on the floating-point stack")          \
+  ENUM_ENTRY(TYPE_MM64,       "8-byte MMX register")                           \
+  ENUM_ENTRY(TYPE_XMM,        "16-byte")                                       \
+  ENUM_ENTRY(TYPE_YMM,        "32-byte")                                       \
+  ENUM_ENTRY(TYPE_ZMM,        "64-byte")                                       \
+  ENUM_ENTRY(TYPE_VK,         "mask register")                                 \
+  ENUM_ENTRY(TYPE_SEGMENTREG, "Segment register operand")                      \
+  ENUM_ENTRY(TYPE_DEBUGREG,   "Debug register operand")                        \
+  ENUM_ENTRY(TYPE_CONTROLREG, "Control register operand")                      \
+  ENUM_ENTRY(TYPE_BNDR,       "MPX bounds register")                           \
+                                                                               \
+  ENUM_ENTRY(TYPE_Rv,         "Register operand of operand size")              \
+  ENUM_ENTRY(TYPE_RELv,       "Immediate address of operand size")             \
+  ENUM_ENTRY(TYPE_DUP0,       "Duplicate of operand 0")                        \
+  ENUM_ENTRY(TYPE_DUP1,       "operand 1")                                     \
+  ENUM_ENTRY(TYPE_DUP2,       "operand 2")                                     \
+  ENUM_ENTRY(TYPE_DUP3,       "operand 3")                                     \
+  ENUM_ENTRY(TYPE_DUP4,       "operand 4")                                     \
+
+#define ENUM_ENTRY(n, d) n,
+typedef enum {
+	TYPES
+	TYPE_max
+} OperandType;
+#undef ENUM_ENTRY
+
+/*
+ * The specification for how to extract and interpret one operand.
+ */
+typedef struct OperandSpecifier {
+	uint8_t encoding;
+	uint8_t type;
+} OperandSpecifier;
+
+#define X86_MAX_OPERANDS 6
+
+/*
+ * Decoding mode for the Intel disassembler.  16-bit, 32-bit, and 64-bit mode
+ * are supported, and represent real mode, IA-32e, and IA-32e in 64-bit mode,
+ * respectively.
+ */
+typedef enum {
+	MODE_16BIT,
+	MODE_32BIT,
+	MODE_64BIT
+} DisassemblerMode;
+
+#endif

thirdparty/capstone/arch/X86/X86GenRegisterName.inc

@@ -0,0 +1,292 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+/// getRegisterName - This method is automatically generated by tblgen
+/// from the register set description.  This returns the assembler name
+/// for the specified register.
+static const char *getRegisterName(unsigned RegNo)
+{
+
+#ifndef CAPSTONE_DIET
+  static const char AsmStrs[] = {
+  /* 0 */ 's', 't', '(', '0', ')', 0,
+  /* 6 */ 's', 't', '(', '1', ')', 0,
+  /* 12 */ 's', 't', '(', '2', ')', 0,
+  /* 18 */ 's', 't', '(', '3', ')', 0,
+  /* 24 */ 's', 't', '(', '4', ')', 0,
+  /* 30 */ 's', 't', '(', '5', ')', 0,
+  /* 36 */ 's', 't', '(', '6', ')', 0,
+  /* 42 */ 's', 't', '(', '7', ')', 0,
+  /* 48 */ 'x', 'm', 'm', '1', '0', 0,
+  /* 54 */ 'y', 'm', 'm', '1', '0', 0,
+  /* 60 */ 'z', 'm', 'm', '1', '0', 0,
+  /* 66 */ 'c', 'r', '1', '0', 0,
+  /* 71 */ 'd', 'r', '1', '0', 0,
+  /* 76 */ 'x', 'm', 'm', '2', '0', 0,
+  /* 82 */ 'y', 'm', 'm', '2', '0', 0,
+  /* 88 */ 'z', 'm', 'm', '2', '0', 0,
+  /* 94 */ 'x', 'm', 'm', '3', '0', 0,
+  /* 100 */ 'y', 'm', 'm', '3', '0', 0,
+  /* 106 */ 'z', 'm', 'm', '3', '0', 0,
+  /* 112 */ 'b', 'n', 'd', '0', 0,
+  /* 117 */ 'k', '0', 0,
+  /* 120 */ 'x', 'm', 'm', '0', 0,
+  /* 125 */ 'y', 'm', 'm', '0', 0,
+  /* 130 */ 'z', 'm', 'm', '0', 0,
+  /* 135 */ 'f', 'p', '0', 0,
+  /* 139 */ 'c', 'r', '0', 0,
+  /* 143 */ 'd', 'r', '0', 0,
+  /* 147 */ 'x', 'm', 'm', '1', '1', 0,
+  /* 153 */ 'y', 'm', 'm', '1', '1', 0,
+  /* 159 */ 'z', 'm', 'm', '1', '1', 0,
+  /* 165 */ 'c', 'r', '1', '1', 0,
+  /* 170 */ 'd', 'r', '1', '1', 0,
+  /* 175 */ 'x', 'm', 'm', '2', '1', 0,
+  /* 181 */ 'y', 'm', 'm', '2', '1', 0,
+  /* 187 */ 'z', 'm', 'm', '2', '1', 0,
+  /* 193 */ 'x', 'm', 'm', '3', '1', 0,
+  /* 199 */ 'y', 'm', 'm', '3', '1', 0,
+  /* 205 */ 'z', 'm', 'm', '3', '1', 0,
+  /* 211 */ 'b', 'n', 'd', '1', 0,
+  /* 216 */ 'k', '1', 0,
+  /* 219 */ 'x', 'm', 'm', '1', 0,
+  /* 224 */ 'y', 'm', 'm', '1', 0,
+  /* 229 */ 'z', 'm', 'm', '1', 0,
+  /* 234 */ 'f', 'p', '1', 0,
+  /* 238 */ 'c', 'r', '1', 0,
+  /* 242 */ 'd', 'r', '1', 0,
+  /* 246 */ 'x', 'm', 'm', '1', '2', 0,
+  /* 252 */ 'y', 'm', 'm', '1', '2', 0,
+  /* 258 */ 'z', 'm', 'm', '1', '2', 0,
+  /* 264 */ 'c', 'r', '1', '2', 0,
+  /* 269 */ 'd', 'r', '1', '2', 0,
+  /* 274 */ 'x', 'm', 'm', '2', '2', 0,
+  /* 280 */ 'y', 'm', 'm', '2', '2', 0,
+  /* 286 */ 'z', 'm', 'm', '2', '2', 0,
+  /* 292 */ 'b', 'n', 'd', '2', 0,
+  /* 297 */ 'k', '2', 0,
+  /* 300 */ 'x', 'm', 'm', '2', 0,
+  /* 305 */ 'y', 'm', 'm', '2', 0,
+  /* 310 */ 'z', 'm', 'm', '2', 0,
+  /* 315 */ 'f', 'p', '2', 0,
+  /* 319 */ 'c', 'r', '2', 0,
+  /* 323 */ 'd', 'r', '2', 0,
+  /* 327 */ 'x', 'm', 'm', '1', '3', 0,
+  /* 333 */ 'y', 'm', 'm', '1', '3', 0,
+  /* 339 */ 'z', 'm', 'm', '1', '3', 0,
+  /* 345 */ 'c', 'r', '1', '3', 0,
+  /* 350 */ 'd', 'r', '1', '3', 0,
+  /* 355 */ 'x', 'm', 'm', '2', '3', 0,
+  /* 361 */ 'y', 'm', 'm', '2', '3', 0,
+  /* 367 */ 'z', 'm', 'm', '2', '3', 0,
+  /* 373 */ 'b', 'n', 'd', '3', 0,
+  /* 378 */ 'k', '3', 0,
+  /* 381 */ 'x', 'm', 'm', '3', 0,
+  /* 386 */ 'y', 'm', 'm', '3', 0,
+  /* 391 */ 'z', 'm', 'm', '3', 0,
+  /* 396 */ 'f', 'p', '3', 0,
+  /* 400 */ 'c', 'r', '3', 0,
+  /* 404 */ 'd', 'r', '3', 0,
+  /* 408 */ 'x', 'm', 'm', '1', '4', 0,
+  /* 414 */ 'y', 'm', 'm', '1', '4', 0,
+  /* 420 */ 'z', 'm', 'm', '1', '4', 0,
+  /* 426 */ 'c', 'r', '1', '4', 0,
+  /* 431 */ 'd', 'r', '1', '4', 0,
+  /* 436 */ 'x', 'm', 'm', '2', '4', 0,
+  /* 442 */ 'y', 'm', 'm', '2', '4', 0,
+  /* 448 */ 'z', 'm', 'm', '2', '4', 0,
+  /* 454 */ 'k', '4', 0,
+  /* 457 */ 'x', 'm', 'm', '4', 0,
+  /* 462 */ 'y', 'm', 'm', '4', 0,
+  /* 467 */ 'z', 'm', 'm', '4', 0,
+  /* 472 */ 'f', 'p', '4', 0,
+  /* 476 */ 'c', 'r', '4', 0,
+  /* 480 */ 'd', 'r', '4', 0,
+  /* 484 */ 'x', 'm', 'm', '1', '5', 0,
+  /* 490 */ 'y', 'm', 'm', '1', '5', 0,
+  /* 496 */ 'z', 'm', 'm', '1', '5', 0,
+  /* 502 */ 'c', 'r', '1', '5', 0,
+  /* 507 */ 'd', 'r', '1', '5', 0,
+  /* 512 */ 'x', 'm', 'm', '2', '5', 0,
+  /* 518 */ 'y', 'm', 'm', '2', '5', 0,
+  /* 524 */ 'z', 'm', 'm', '2', '5', 0,
+  /* 530 */ 'k', '5', 0,
+  /* 533 */ 'x', 'm', 'm', '5', 0,
+  /* 538 */ 'y', 'm', 'm', '5', 0,
+  /* 543 */ 'z', 'm', 'm', '5', 0,
+  /* 548 */ 'f', 'p', '5', 0,
+  /* 552 */ 'c', 'r', '5', 0,
+  /* 556 */ 'd', 'r', '5', 0,
+  /* 560 */ 'x', 'm', 'm', '1', '6', 0,
+  /* 566 */ 'y', 'm', 'm', '1', '6', 0,
+  /* 572 */ 'z', 'm', 'm', '1', '6', 0,
+  /* 578 */ 'x', 'm', 'm', '2', '6', 0,
+  /* 584 */ 'y', 'm', 'm', '2', '6', 0,
+  /* 590 */ 'z', 'm', 'm', '2', '6', 0,
+  /* 596 */ 'k', '6', 0,
+  /* 599 */ 'x', 'm', 'm', '6', 0,
+  /* 604 */ 'y', 'm', 'm', '6', 0,
+  /* 609 */ 'z', 'm', 'm', '6', 0,
+  /* 614 */ 'f', 'p', '6', 0,
+  /* 618 */ 'c', 'r', '6', 0,
+  /* 622 */ 'd', 'r', '6', 0,
+  /* 626 */ 'x', 'm', 'm', '1', '7', 0,
+  /* 632 */ 'y', 'm', 'm', '1', '7', 0,
+  /* 638 */ 'z', 'm', 'm', '1', '7', 0,
+  /* 644 */ 'x', 'm', 'm', '2', '7', 0,
+  /* 650 */ 'y', 'm', 'm', '2', '7', 0,
+  /* 656 */ 'z', 'm', 'm', '2', '7', 0,
+  /* 662 */ 'k', '7', 0,
+  /* 665 */ 'x', 'm', 'm', '7', 0,
+  /* 670 */ 'y', 'm', 'm', '7', 0,
+  /* 675 */ 'z', 'm', 'm', '7', 0,
+  /* 680 */ 'f', 'p', '7', 0,
+  /* 684 */ 'c', 'r', '7', 0,
+  /* 688 */ 'd', 'r', '7', 0,
+  /* 692 */ 'x', 'm', 'm', '1', '8', 0,
+  /* 698 */ 'y', 'm', 'm', '1', '8', 0,
+  /* 704 */ 'z', 'm', 'm', '1', '8', 0,
+  /* 710 */ 'x', 'm', 'm', '2', '8', 0,
+  /* 716 */ 'y', 'm', 'm', '2', '8', 0,
+  /* 722 */ 'z', 'm', 'm', '2', '8', 0,
+  /* 728 */ 'x', 'm', 'm', '8', 0,
+  /* 733 */ 'y', 'm', 'm', '8', 0,
+  /* 738 */ 'z', 'm', 'm', '8', 0,
+  /* 743 */ 'c', 'r', '8', 0,
+  /* 747 */ 'd', 'r', '8', 0,
+  /* 751 */ 'x', 'm', 'm', '1', '9', 0,
+  /* 757 */ 'y', 'm', 'm', '1', '9', 0,
+  /* 763 */ 'z', 'm', 'm', '1', '9', 0,
+  /* 769 */ 'x', 'm', 'm', '2', '9', 0,
+  /* 775 */ 'y', 'm', 'm', '2', '9', 0,
+  /* 781 */ 'z', 'm', 'm', '2', '9', 0,
+  /* 787 */ 'x', 'm', 'm', '9', 0,
+  /* 792 */ 'y', 'm', 'm', '9', 0,
+  /* 797 */ 'z', 'm', 'm', '9', 0,
+  /* 802 */ 'c', 'r', '9', 0,
+  /* 806 */ 'd', 'r', '9', 0,
+  /* 810 */ 'R', '1', '0', 'B', 'H', 0,
+  /* 816 */ 'R', '1', '1', 'B', 'H', 0,
+  /* 822 */ 'R', '1', '2', 'B', 'H', 0,
+  /* 828 */ 'R', '1', '3', 'B', 'H', 0,
+  /* 834 */ 'R', '1', '4', 'B', 'H', 0,
+  /* 840 */ 'R', '1', '5', 'B', 'H', 0,
+  /* 846 */ 'R', '8', 'B', 'H', 0,
+  /* 851 */ 'R', '9', 'B', 'H', 0,
+  /* 856 */ 'D', 'I', 'H', 0,
+  /* 860 */ 'S', 'I', 'H', 0,
+  /* 864 */ 'B', 'P', 'H', 0,
+  /* 868 */ 'S', 'P', 'H', 0,
+  /* 872 */ 'R', '1', '0', 'W', 'H', 0,
+  /* 878 */ 'R', '1', '1', 'W', 'H', 0,
+  /* 884 */ 'R', '1', '2', 'W', 'H', 0,
+  /* 890 */ 'R', '1', '3', 'W', 'H', 0,
+  /* 896 */ 'R', '1', '4', 'W', 'H', 0,
+  /* 902 */ 'R', '1', '5', 'W', 'H', 0,
+  /* 908 */ 'R', '8', 'W', 'H', 0,
+  /* 913 */ 'R', '9', 'W', 'H', 0,
+  /* 918 */ 'H', 'D', 'I', 0,
+  /* 922 */ 'H', 'S', 'I', 0,
+  /* 926 */ 'H', 'B', 'P', 0,
+  /* 930 */ 'H', 'I', 'P', 0,
+  /* 934 */ 'H', 'S', 'P', 0,
+  /* 938 */ 'H', 'A', 'X', 0,
+  /* 942 */ 'H', 'B', 'X', 0,
+  /* 946 */ 'H', 'C', 'X', 0,
+  /* 950 */ 'H', 'D', 'X', 0,
+  /* 954 */ 'r', '1', '0', 'b', 0,
+  /* 959 */ 'r', '1', '1', 'b', 0,
+  /* 964 */ 'r', '1', '2', 'b', 0,
+  /* 969 */ 'r', '1', '3', 'b', 0,
+  /* 974 */ 'r', '1', '4', 'b', 0,
+  /* 979 */ 'r', '1', '5', 'b', 0,
+  /* 984 */ 'r', '8', 'b', 0,
+  /* 988 */ 'r', '9', 'b', 0,
+  /* 992 */ 'r', '1', '0', 'd', 0,
+  /* 997 */ 'r', '1', '1', 'd', 0,
+  /* 1002 */ 'r', '1', '2', 'd', 0,
+  /* 1007 */ 'r', '1', '3', 'd', 0,
+  /* 1012 */ 'r', '1', '4', 'd', 0,
+  /* 1017 */ 'r', '1', '5', 'd', 0,
+  /* 1022 */ 'r', '8', 'd', 0,
+  /* 1026 */ 'r', '9', 'd', 0,
+  /* 1030 */ 'd', 'i', 'r', 'f', 'l', 'a', 'g', 0,
+  /* 1038 */ 'a', 'h', 0,
+  /* 1041 */ 'b', 'h', 0,
+  /* 1044 */ 'c', 'h', 0,
+  /* 1047 */ 'd', 'h', 0,
+  /* 1050 */ 'e', 'd', 'i', 0,
+  /* 1054 */ 'r', 'd', 'i', 0,
+  /* 1058 */ 'e', 's', 'i', 0,
+  /* 1062 */ 'r', 's', 'i', 0,
+  /* 1066 */ 'a', 'l', 0,
+  /* 1069 */ 'b', 'l', 0,
+  /* 1072 */ 'c', 'l', 0,
+  /* 1075 */ 'd', 'l', 0,
+  /* 1078 */ 'd', 'i', 'l', 0,
+  /* 1082 */ 's', 'i', 'l', 0,
+  /* 1086 */ 'b', 'p', 'l', 0,
+  /* 1090 */ 's', 'p', 'l', 0,
+  /* 1094 */ 'e', 'b', 'p', 0,
+  /* 1098 */ 'r', 'b', 'p', 0,
+  /* 1102 */ 'e', 'i', 'p', 0,
+  /* 1106 */ 'r', 'i', 'p', 0,
+  /* 1110 */ 'e', 's', 'p', 0,
+  /* 1114 */ 'r', 's', 'p', 0,
+  /* 1118 */ 's', 's', 'p', 0,
+  /* 1122 */ 'c', 's', 0,
+  /* 1125 */ 'd', 's', 0,
+  /* 1128 */ 'e', 's', 0,
+  /* 1131 */ 'f', 's', 0,
+  /* 1134 */ 'f', 'l', 'a', 'g', 's', 0,
+  /* 1140 */ 's', 's', 0,
+  /* 1143 */ 'r', '1', '0', 'w', 0,
+  /* 1148 */ 'r', '1', '1', 'w', 0,
+  /* 1153 */ 'r', '1', '2', 'w', 0,
+  /* 1158 */ 'r', '1', '3', 'w', 0,
+  /* 1163 */ 'r', '1', '4', 'w', 0,
+  /* 1168 */ 'r', '1', '5', 'w', 0,
+  /* 1173 */ 'r', '8', 'w', 0,
+  /* 1177 */ 'r', '9', 'w', 0,
+  /* 1181 */ 'f', 'p', 's', 'w', 0,
+  /* 1186 */ 'e', 'a', 'x', 0,
+  /* 1190 */ 'r', 'a', 'x', 0,
+  /* 1194 */ 'e', 'b', 'x', 0,
+  /* 1198 */ 'r', 'b', 'x', 0,
+  /* 1202 */ 'e', 'c', 'x', 0,
+  /* 1206 */ 'r', 'c', 'x', 0,
+  /* 1210 */ 'e', 'd', 'x', 0,
+  /* 1214 */ 'r', 'd', 'x', 0,
+  /* 1218 */ 'e', 'i', 'z', 0,
+  /* 1222 */ 'r', 'i', 'z', 0,
+  };
+
+  static const uint16_t RegAsmOffset[] = {
+    1038, 1066, 1187, 1041, 1069, 1095, 864, 1086, 1195, 1044, 1072, 1122, 1203, 1030,
+    1047, 1051, 856, 1078, 1075, 1125, 1211, 1186, 1094, 1194, 1202, 1050, 1210, 1134,
+    1102, 1218, 1128, 1058, 1110, 1181, 1131, 1137, 938, 926, 942, 946, 918, 950,
+    930, 922, 934, 1103, 1190, 1098, 1198, 1206, 1054, 1214, 1106, 1222, 1062, 1114,
+    1059, 860, 1082, 1111, 868, 1090, 1140, 1118, 112, 211, 292, 373, 139, 238,
+    319, 400, 476, 552, 618, 684, 743, 802, 66, 165, 264, 345, 426, 502,
+    143, 242, 323, 404, 480, 556, 622, 688, 747, 806, 71, 170, 269, 350,
+    431, 507, 135, 234, 315, 396, 472, 548, 614, 680, 117, 216, 297, 378,
+    454, 530, 596, 662, 121, 220, 301, 382, 458, 534, 600, 666, 744, 803,
+    67, 166, 265, 346, 427, 503, 0, 6, 12, 18, 24, 30, 36, 42,
+    120, 219, 300, 381, 457, 533, 599, 665, 728, 787, 48, 147, 246, 327,
+    408, 484, 560, 626, 692, 751, 76, 175, 274, 355, 436, 512, 578, 644,
+    710, 769, 94, 193, 125, 224, 305, 386, 462, 538, 604, 670, 733, 792,
+    54, 153, 252, 333, 414, 490, 566, 632, 698, 757, 82, 181, 280, 361,
+    442, 518, 584, 650, 716, 775, 100, 199, 130, 229, 310, 391, 467, 543,
+    609, 675, 738, 797, 60, 159, 258, 339, 420, 496, 572, 638, 704, 763,
+    88, 187, 286, 367, 448, 524, 590, 656, 722, 781, 106, 205, 984, 988,
+    954, 959, 964, 969, 974, 979, 846, 851, 810, 816, 822, 828, 834, 840,
+    1022, 1026, 992, 997, 1002, 1007, 1012, 1017, 1173, 1177, 1143, 1148, 1153, 1158,
+    1163, 1168, 908, 913, 872, 878, 884, 890, 896, 902,
+  };
+
+  return AsmStrs+RegAsmOffset[RegNo-1];
+#else
+  return NULL;
+#endif
+}
+

thirdparty/capstone/arch/X86/X86GenRegisterName1.inc

@@ -0,0 +1,291 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+/// getRegisterName - This method is automatically generated by tblgen
+/// from the register set description.  This returns the assembler name
+/// for the specified register.
+static const char *getRegisterName(unsigned RegNo)
+{
+
+#ifndef CAPSTONE_DIET
+  static const char AsmStrs[] = {
+  /* 0 */ 's', 't', '(', '0', ')', 0,
+  /* 6 */ 's', 't', '(', '1', ')', 0,
+  /* 12 */ 's', 't', '(', '2', ')', 0,
+  /* 18 */ 's', 't', '(', '3', ')', 0,
+  /* 24 */ 's', 't', '(', '4', ')', 0,
+  /* 30 */ 's', 't', '(', '5', ')', 0,
+  /* 36 */ 's', 't', '(', '6', ')', 0,
+  /* 42 */ 's', 't', '(', '7', ')', 0,
+  /* 48 */ 'x', 'm', 'm', '1', '0', 0,
+  /* 54 */ 'y', 'm', 'm', '1', '0', 0,
+  /* 60 */ 'z', 'm', 'm', '1', '0', 0,
+  /* 66 */ 'c', 'r', '1', '0', 0,
+  /* 71 */ 'd', 'r', '1', '0', 0,
+  /* 76 */ 'x', 'm', 'm', '2', '0', 0,
+  /* 82 */ 'y', 'm', 'm', '2', '0', 0,
+  /* 88 */ 'z', 'm', 'm', '2', '0', 0,
+  /* 94 */ 'x', 'm', 'm', '3', '0', 0,
+  /* 100 */ 'y', 'm', 'm', '3', '0', 0,
+  /* 106 */ 'z', 'm', 'm', '3', '0', 0,
+  /* 112 */ 'b', 'n', 'd', '0', 0,
+  /* 117 */ 'k', '0', 0,
+  /* 120 */ 'x', 'm', 'm', '0', 0,
+  /* 125 */ 'y', 'm', 'm', '0', 0,
+  /* 130 */ 'z', 'm', 'm', '0', 0,
+  /* 135 */ 'f', 'p', '0', 0,
+  /* 139 */ 'c', 'r', '0', 0,
+  /* 143 */ 'd', 'r', '0', 0,
+  /* 147 */ 'x', 'm', 'm', '1', '1', 0,
+  /* 153 */ 'y', 'm', 'm', '1', '1', 0,
+  /* 159 */ 'z', 'm', 'm', '1', '1', 0,
+  /* 165 */ 'c', 'r', '1', '1', 0,
+  /* 170 */ 'd', 'r', '1', '1', 0,
+  /* 175 */ 'x', 'm', 'm', '2', '1', 0,
+  /* 181 */ 'y', 'm', 'm', '2', '1', 0,
+  /* 187 */ 'z', 'm', 'm', '2', '1', 0,
+  /* 193 */ 'x', 'm', 'm', '3', '1', 0,
+  /* 199 */ 'y', 'm', 'm', '3', '1', 0,
+  /* 205 */ 'z', 'm', 'm', '3', '1', 0,
+  /* 211 */ 'b', 'n', 'd', '1', 0,
+  /* 216 */ 'k', '1', 0,
+  /* 219 */ 'x', 'm', 'm', '1', 0,
+  /* 224 */ 'y', 'm', 'm', '1', 0,
+  /* 229 */ 'z', 'm', 'm', '1', 0,
+  /* 234 */ 'f', 'p', '1', 0,
+  /* 238 */ 'c', 'r', '1', 0,
+  /* 242 */ 'd', 'r', '1', 0,
+  /* 246 */ 'x', 'm', 'm', '1', '2', 0,
+  /* 252 */ 'y', 'm', 'm', '1', '2', 0,
+  /* 258 */ 'z', 'm', 'm', '1', '2', 0,
+  /* 264 */ 'c', 'r', '1', '2', 0,
+  /* 269 */ 'd', 'r', '1', '2', 0,
+  /* 274 */ 'x', 'm', 'm', '2', '2', 0,
+  /* 280 */ 'y', 'm', 'm', '2', '2', 0,
+  /* 286 */ 'z', 'm', 'm', '2', '2', 0,
+  /* 292 */ 'b', 'n', 'd', '2', 0,
+  /* 297 */ 'k', '2', 0,
+  /* 300 */ 'x', 'm', 'm', '2', 0,
+  /* 305 */ 'y', 'm', 'm', '2', 0,
+  /* 310 */ 'z', 'm', 'm', '2', 0,
+  /* 315 */ 'f', 'p', '2', 0,
+  /* 319 */ 'c', 'r', '2', 0,
+  /* 323 */ 'd', 'r', '2', 0,
+  /* 327 */ 'x', 'm', 'm', '1', '3', 0,
+  /* 333 */ 'y', 'm', 'm', '1', '3', 0,
+  /* 339 */ 'z', 'm', 'm', '1', '3', 0,
+  /* 345 */ 'c', 'r', '1', '3', 0,
+  /* 350 */ 'd', 'r', '1', '3', 0,
+  /* 355 */ 'x', 'm', 'm', '2', '3', 0,
+  /* 361 */ 'y', 'm', 'm', '2', '3', 0,
+  /* 367 */ 'z', 'm', 'm', '2', '3', 0,
+  /* 373 */ 'b', 'n', 'd', '3', 0,
+  /* 378 */ 'k', '3', 0,
+  /* 381 */ 'x', 'm', 'm', '3', 0,
+  /* 386 */ 'y', 'm', 'm', '3', 0,
+  /* 391 */ 'z', 'm', 'm', '3', 0,
+  /* 396 */ 'f', 'p', '3', 0,
+  /* 400 */ 'c', 'r', '3', 0,
+  /* 404 */ 'd', 'r', '3', 0,
+  /* 408 */ 'x', 'm', 'm', '1', '4', 0,
+  /* 414 */ 'y', 'm', 'm', '1', '4', 0,
+  /* 420 */ 'z', 'm', 'm', '1', '4', 0,
+  /* 426 */ 'c', 'r', '1', '4', 0,
+  /* 431 */ 'd', 'r', '1', '4', 0,
+  /* 436 */ 'x', 'm', 'm', '2', '4', 0,
+  /* 442 */ 'y', 'm', 'm', '2', '4', 0,
+  /* 448 */ 'z', 'm', 'm', '2', '4', 0,
+  /* 454 */ 'k', '4', 0,
+  /* 457 */ 'x', 'm', 'm', '4', 0,
+  /* 462 */ 'y', 'm', 'm', '4', 0,
+  /* 467 */ 'z', 'm', 'm', '4', 0,
+  /* 472 */ 'f', 'p', '4', 0,
+  /* 476 */ 'c', 'r', '4', 0,
+  /* 480 */ 'd', 'r', '4', 0,
+  /* 484 */ 'x', 'm', 'm', '1', '5', 0,
+  /* 490 */ 'y', 'm', 'm', '1', '5', 0,
+  /* 496 */ 'z', 'm', 'm', '1', '5', 0,
+  /* 502 */ 'c', 'r', '1', '5', 0,
+  /* 507 */ 'd', 'r', '1', '5', 0,
+  /* 512 */ 'x', 'm', 'm', '2', '5', 0,
+  /* 518 */ 'y', 'm', 'm', '2', '5', 0,
+  /* 524 */ 'z', 'm', 'm', '2', '5', 0,
+  /* 530 */ 'k', '5', 0,
+  /* 533 */ 'x', 'm', 'm', '5', 0,
+  /* 538 */ 'y', 'm', 'm', '5', 0,
+  /* 543 */ 'z', 'm', 'm', '5', 0,
+  /* 548 */ 'f', 'p', '5', 0,
+  /* 552 */ 'c', 'r', '5', 0,
+  /* 556 */ 'd', 'r', '5', 0,
+  /* 560 */ 'x', 'm', 'm', '1', '6', 0,
+  /* 566 */ 'y', 'm', 'm', '1', '6', 0,
+  /* 572 */ 'z', 'm', 'm', '1', '6', 0,
+  /* 578 */ 'x', 'm', 'm', '2', '6', 0,
+  /* 584 */ 'y', 'm', 'm', '2', '6', 0,
+  /* 590 */ 'z', 'm', 'm', '2', '6', 0,
+  /* 596 */ 'k', '6', 0,
+  /* 599 */ 'x', 'm', 'm', '6', 0,
+  /* 604 */ 'y', 'm', 'm', '6', 0,
+  /* 609 */ 'z', 'm', 'm', '6', 0,
+  /* 614 */ 'f', 'p', '6', 0,
+  /* 618 */ 'c', 'r', '6', 0,
+  /* 622 */ 'd', 'r', '6', 0,
+  /* 626 */ 'x', 'm', 'm', '1', '7', 0,
+  /* 632 */ 'y', 'm', 'm', '1', '7', 0,
+  /* 638 */ 'z', 'm', 'm', '1', '7', 0,
+  /* 644 */ 'x', 'm', 'm', '2', '7', 0,
+  /* 650 */ 'y', 'm', 'm', '2', '7', 0,
+  /* 656 */ 'z', 'm', 'm', '2', '7', 0,
+  /* 662 */ 'k', '7', 0,
+  /* 665 */ 'x', 'm', 'm', '7', 0,
+  /* 670 */ 'y', 'm', 'm', '7', 0,
+  /* 675 */ 'z', 'm', 'm', '7', 0,
+  /* 680 */ 'f', 'p', '7', 0,
+  /* 684 */ 'c', 'r', '7', 0,
+  /* 688 */ 'd', 'r', '7', 0,
+  /* 692 */ 'x', 'm', 'm', '1', '8', 0,
+  /* 698 */ 'y', 'm', 'm', '1', '8', 0,
+  /* 704 */ 'z', 'm', 'm', '1', '8', 0,
+  /* 710 */ 'x', 'm', 'm', '2', '8', 0,
+  /* 716 */ 'y', 'm', 'm', '2', '8', 0,
+  /* 722 */ 'z', 'm', 'm', '2', '8', 0,
+  /* 728 */ 'x', 'm', 'm', '8', 0,
+  /* 733 */ 'y', 'm', 'm', '8', 0,
+  /* 738 */ 'z', 'm', 'm', '8', 0,
+  /* 743 */ 'c', 'r', '8', 0,
+  /* 747 */ 'd', 'r', '8', 0,
+  /* 751 */ 'x', 'm', 'm', '1', '9', 0,
+  /* 757 */ 'y', 'm', 'm', '1', '9', 0,
+  /* 763 */ 'z', 'm', 'm', '1', '9', 0,
+  /* 769 */ 'x', 'm', 'm', '2', '9', 0,
+  /* 775 */ 'y', 'm', 'm', '2', '9', 0,
+  /* 781 */ 'z', 'm', 'm', '2', '9', 0,
+  /* 787 */ 'x', 'm', 'm', '9', 0,
+  /* 792 */ 'y', 'm', 'm', '9', 0,
+  /* 797 */ 'z', 'm', 'm', '9', 0,
+  /* 802 */ 'c', 'r', '9', 0,
+  /* 806 */ 'd', 'r', '9', 0,
+  /* 810 */ 'R', '1', '0', 'B', 'H', 0,
+  /* 816 */ 'R', '1', '1', 'B', 'H', 0,
+  /* 822 */ 'R', '1', '2', 'B', 'H', 0,
+  /* 828 */ 'R', '1', '3', 'B', 'H', 0,
+  /* 834 */ 'R', '1', '4', 'B', 'H', 0,
+  /* 840 */ 'R', '1', '5', 'B', 'H', 0,
+  /* 846 */ 'R', '8', 'B', 'H', 0,
+  /* 851 */ 'R', '9', 'B', 'H', 0,
+  /* 856 */ 'D', 'I', 'H', 0,
+  /* 860 */ 'S', 'I', 'H', 0,
+  /* 864 */ 'B', 'P', 'H', 0,
+  /* 868 */ 'S', 'P', 'H', 0,
+  /* 872 */ 'R', '1', '0', 'W', 'H', 0,
+  /* 878 */ 'R', '1', '1', 'W', 'H', 0,
+  /* 884 */ 'R', '1', '2', 'W', 'H', 0,
+  /* 890 */ 'R', '1', '3', 'W', 'H', 0,
+  /* 896 */ 'R', '1', '4', 'W', 'H', 0,
+  /* 902 */ 'R', '1', '5', 'W', 'H', 0,
+  /* 908 */ 'R', '8', 'W', 'H', 0,
+  /* 913 */ 'R', '9', 'W', 'H', 0,
+  /* 918 */ 'H', 'D', 'I', 0,
+  /* 922 */ 'H', 'S', 'I', 0,
+  /* 926 */ 'H', 'B', 'P', 0,
+  /* 930 */ 'H', 'I', 'P', 0,
+  /* 934 */ 'H', 'S', 'P', 0,
+  /* 938 */ 'H', 'A', 'X', 0,
+  /* 942 */ 'H', 'B', 'X', 0,
+  /* 946 */ 'H', 'C', 'X', 0,
+  /* 950 */ 'H', 'D', 'X', 0,
+  /* 954 */ 'r', '1', '0', 'b', 0,
+  /* 959 */ 'r', '1', '1', 'b', 0,
+  /* 964 */ 'r', '1', '2', 'b', 0,
+  /* 969 */ 'r', '1', '3', 'b', 0,
+  /* 974 */ 'r', '1', '4', 'b', 0,
+  /* 979 */ 'r', '1', '5', 'b', 0,
+  /* 984 */ 'r', '8', 'b', 0,
+  /* 988 */ 'r', '9', 'b', 0,
+  /* 992 */ 'r', '1', '0', 'd', 0,
+  /* 997 */ 'r', '1', '1', 'd', 0,
+  /* 1002 */ 'r', '1', '2', 'd', 0,
+  /* 1007 */ 'r', '1', '3', 'd', 0,
+  /* 1012 */ 'r', '1', '4', 'd', 0,
+  /* 1017 */ 'r', '1', '5', 'd', 0,
+  /* 1022 */ 'r', '8', 'd', 0,
+  /* 1026 */ 'r', '9', 'd', 0,
+  /* 1030 */ 'd', 'i', 'r', 'f', 'l', 'a', 'g', 0,
+  /* 1038 */ 'a', 'h', 0,
+  /* 1041 */ 'b', 'h', 0,
+  /* 1044 */ 'c', 'h', 0,
+  /* 1047 */ 'd', 'h', 0,
+  /* 1050 */ 'e', 'd', 'i', 0,
+  /* 1054 */ 'r', 'd', 'i', 0,
+  /* 1058 */ 'e', 's', 'i', 0,
+  /* 1062 */ 'r', 's', 'i', 0,
+  /* 1066 */ 'a', 'l', 0,
+  /* 1069 */ 'b', 'l', 0,
+  /* 1072 */ 'c', 'l', 0,
+  /* 1075 */ 'd', 'l', 0,
+  /* 1078 */ 'd', 'i', 'l', 0,
+  /* 1082 */ 's', 'i', 'l', 0,
+  /* 1086 */ 'b', 'p', 'l', 0,
+  /* 1090 */ 's', 'p', 'l', 0,
+  /* 1094 */ 'e', 'b', 'p', 0,
+  /* 1098 */ 'r', 'b', 'p', 0,
+  /* 1102 */ 'e', 'i', 'p', 0,
+  /* 1106 */ 'r', 'i', 'p', 0,
+  /* 1110 */ 'e', 's', 'p', 0,
+  /* 1114 */ 'r', 's', 'p', 0,
+  /* 1118 */ 's', 's', 'p', 0,
+  /* 1122 */ 'c', 's', 0,
+  /* 1125 */ 'd', 's', 0,
+  /* 1128 */ 'e', 's', 0,
+  /* 1131 */ 'f', 's', 0,
+  /* 1134 */ 'f', 'l', 'a', 'g', 's', 0,
+  /* 1140 */ 's', 's', 0,
+  /* 1143 */ 'r', '1', '0', 'w', 0,
+  /* 1148 */ 'r', '1', '1', 'w', 0,
+  /* 1153 */ 'r', '1', '2', 'w', 0,
+  /* 1158 */ 'r', '1', '3', 'w', 0,
+  /* 1163 */ 'r', '1', '4', 'w', 0,
+  /* 1168 */ 'r', '1', '5', 'w', 0,
+  /* 1173 */ 'r', '8', 'w', 0,
+  /* 1177 */ 'r', '9', 'w', 0,
+  /* 1181 */ 'f', 'p', 's', 'w', 0,
+  /* 1186 */ 'e', 'a', 'x', 0,
+  /* 1190 */ 'r', 'a', 'x', 0,
+  /* 1194 */ 'e', 'b', 'x', 0,
+  /* 1198 */ 'r', 'b', 'x', 0,
+  /* 1202 */ 'e', 'c', 'x', 0,
+  /* 1206 */ 'r', 'c', 'x', 0,
+  /* 1210 */ 'e', 'd', 'x', 0,
+  /* 1214 */ 'r', 'd', 'x', 0,
+  /* 1218 */ 'e', 'i', 'z', 0,
+  /* 1222 */ 'r', 'i', 'z', 0,
+  };
+
+  static const uint16_t RegAsmOffset[] = {
+    1038, 1066, 1187, 1041, 1069, 1095, 864, 1086, 1195, 1044, 1072, 1122, 1203, 1030,
+    1047, 1051, 856, 1078, 1075, 1125, 1211, 1186, 1094, 1194, 1202, 1050, 1210, 1134,
+    1102, 1218, 1128, 1058, 1110, 1181, 1131, 1137, 938, 926, 942, 946, 918, 950,
+    930, 922, 934, 1103, 1190, 1098, 1198, 1206, 1054, 1214, 1106, 1222, 1062, 1114,
+    1059, 860, 1082, 1111, 868, 1090, 1140, 1118, 112, 211, 292, 373, 139, 238,
+    319, 400, 476, 552, 618, 684, 743, 802, 66, 165, 264, 345, 426, 502,
+    143, 242, 323, 404, 480, 556, 622, 688, 747, 806, 71, 170, 269, 350,
+    431, 507, 135, 234, 315, 396, 472, 548, 614, 680, 117, 216, 297, 378,
+    454, 530, 596, 662, 121, 220, 301, 382, 458, 534, 600, 666, 744, 803,
+    67, 166, 265, 346, 427, 503, 0, 6, 12, 18, 24, 30, 36, 42,
+    120, 219, 300, 381, 457, 533, 599, 665, 728, 787, 48, 147, 246, 327,
+    408, 484, 560, 626, 692, 751, 76, 175, 274, 355, 436, 512, 578, 644,
+    710, 769, 94, 193, 125, 224, 305, 386, 462, 538, 604, 670, 733, 792,
+    54, 153, 252, 333, 414, 490, 566, 632, 698, 757, 82, 181, 280, 361,
+    442, 518, 584, 650, 716, 775, 100, 199, 130, 229, 310, 391, 467, 543,
+    609, 675, 738, 797, 60, 159, 258, 339, 420, 496, 572, 638, 704, 763,
+    88, 187, 286, 367, 448, 524, 590, 656, 722, 781, 106, 205, 984, 988,
+    954, 959, 964, 969, 974, 979, 846, 851, 810, 816, 822, 828, 834, 840,
+    1022, 1026, 992, 997, 1002, 1007, 1012, 1017, 1173, 1177, 1143, 1148, 1153, 1158,
+    1163, 1168, 908, 913, 872, 878, 884, 890, 896, 902,
+  };
+
+  return AsmStrs+RegAsmOffset[RegNo-1];
+#else
+  return NULL;
+#endif
+}

thirdparty/capstone/arch/X86/X86ImmSize.inc

@@ -0,0 +1,335 @@
+{1, 1, X86_AAD8i8},
+{1, 1, X86_AAM8i8},
+{2, 2, X86_ADC16i16},
+{2, 2, X86_ADC16mi},
+{1, 2, X86_ADC16mi8},
+{2, 2, X86_ADC16ri},
+{1, 2, X86_ADC16ri8},
+{4, 4, X86_ADC32i32},
+{4, 4, X86_ADC32mi},
+{1, 4, X86_ADC32mi8},
+{4, 4, X86_ADC32ri},
+{1, 4, X86_ADC32ri8},
+{4, 8, X86_ADC64i32},
+{4, 8, X86_ADC64mi32},
+{1, 8, X86_ADC64mi8},
+{4, 8, X86_ADC64ri32},
+{1, 8, X86_ADC64ri8},
+{1, 1, X86_ADC8i8},
+{1, 1, X86_ADC8mi},
+{1, 1, X86_ADC8mi8},
+{1, 1, X86_ADC8ri},
+{1, 1, X86_ADC8ri8},
+{2, 2, X86_ADD16i16},
+{2, 2, X86_ADD16mi},
+{1, 2, X86_ADD16mi8},
+{2, 2, X86_ADD16ri},
+{1, 2, X86_ADD16ri8},
+{4, 4, X86_ADD32i32},
+{4, 4, X86_ADD32mi},
+{1, 4, X86_ADD32mi8},
+{4, 4, X86_ADD32ri},
+{1, 4, X86_ADD32ri8},
+{4, 8, X86_ADD64i32},
+{4, 8, X86_ADD64mi32},
+{1, 8, X86_ADD64mi8},
+{4, 8, X86_ADD64ri32},
+{1, 8, X86_ADD64ri8},
+{1, 1, X86_ADD8i8},
+{1, 1, X86_ADD8mi},
+{1, 1, X86_ADD8mi8},
+{1, 1, X86_ADD8ri},
+{1, 1, X86_ADD8ri8},
+{2, 2, X86_AND16i16},
+{2, 2, X86_AND16mi},
+{1, 2, X86_AND16mi8},
+{2, 2, X86_AND16ri},
+{1, 2, X86_AND16ri8},
+{4, 4, X86_AND32i32},
+{4, 4, X86_AND32mi},
+{1, 4, X86_AND32mi8},
+{4, 4, X86_AND32ri},
+{1, 4, X86_AND32ri8},
+{4, 8, X86_AND64i32},
+{4, 8, X86_AND64mi32},
+{1, 8, X86_AND64mi8},
+{4, 8, X86_AND64ri32},
+{1, 8, X86_AND64ri8},
+{1, 1, X86_AND8i8},
+{1, 1, X86_AND8mi},
+{1, 1, X86_AND8mi8},
+{1, 1, X86_AND8ri},
+{1, 1, X86_AND8ri8},
+{1, 1, X86_BT16mi8},
+{1, 1, X86_BT16ri8},
+{1, 1, X86_BT32mi8},
+{1, 1, X86_BT32ri8},
+{1, 1, X86_BT64mi8},
+{1, 1, X86_BT64ri8},
+{1, 1, X86_BTC16mi8},
+{1, 1, X86_BTC16ri8},
+{1, 1, X86_BTC32mi8},
+{1, 1, X86_BTC32ri8},
+{1, 1, X86_BTC64mi8},
+{1, 1, X86_BTC64ri8},
+{1, 1, X86_BTR16mi8},
+{1, 1, X86_BTR16ri8},
+{1, 1, X86_BTR32mi8},
+{1, 1, X86_BTR32ri8},
+{1, 1, X86_BTR64mi8},
+{1, 1, X86_BTR64ri8},
+{1, 1, X86_BTS16mi8},
+{1, 1, X86_BTS16ri8},
+{1, 1, X86_BTS32mi8},
+{1, 1, X86_BTS32ri8},
+{1, 1, X86_BTS64mi8},
+{1, 1, X86_BTS64ri8},
+{2, 2, X86_CALLpcrel16},
+{2, 4, X86_CALLpcrel32},
+{2, 2, X86_CMP16i16},
+{2, 2, X86_CMP16mi},
+{1, 2, X86_CMP16mi8},
+{2, 2, X86_CMP16ri},
+{1, 2, X86_CMP16ri8},
+{4, 4, X86_CMP32i32},
+{4, 4, X86_CMP32mi},
+{1, 4, X86_CMP32mi8},
+{4, 4, X86_CMP32ri},
+{1, 4, X86_CMP32ri8},
+{4, 8, X86_CMP64i32},
+{4, 8, X86_CMP64mi32},
+{1, 8, X86_CMP64mi8},
+{4, 8, X86_CMP64ri32},
+{1, 8, X86_CMP64ri8},
+{1, 1, X86_CMP8i8},
+{1, 1, X86_CMP8mi},
+{1, 1, X86_CMP8mi8},
+{1, 1, X86_CMP8ri},
+{1, 1, X86_CMP8ri8},
+{1, 2, X86_IMUL16rmi8},
+{1, 2, X86_IMUL16rri8},
+{1, 4, X86_IMUL32rmi8},
+{1, 4, X86_IMUL32rri8},
+{4, 8, X86_IMUL64rmi32},
+{1, 8, X86_IMUL64rmi8},
+{4, 8, X86_IMUL64rri32},
+{1, 8, X86_IMUL64rri8},
+{2, 2, X86_IN16ri},
+{4, 4, X86_IN32ri},
+{1, 1, X86_IN8ri},
+{2, 2, X86_JMP_2},
+{2, 2, X86_MOV16mi},
+{2, 2, X86_MOV16ri},
+{2, 2, X86_MOV16ri_alt},
+{4, 4, X86_MOV32mi},
+{4, 4, X86_MOV32ri},
+{4, 4, X86_MOV32ri_alt},
+{4, 8, X86_MOV64mi32},
+{8, 8, X86_MOV64ri},
+{4, 8, X86_MOV64ri32},
+{1, 1, X86_MOV8mi},
+{1, 1, X86_MOV8ri},
+{1, 1, X86_MOV8ri_alt},
+{2, 2, X86_OR16i16},
+{2, 2, X86_OR16mi},
+{1, 2, X86_OR16mi8},
+{2, 2, X86_OR16ri},
+{1, 2, X86_OR16ri8},
+{4, 4, X86_OR32i32},
+{4, 4, X86_OR32mi},
+{1, 4, X86_OR32mi8},
+{4, 4, X86_OR32ri},
+{1, 4, X86_OR32ri8},
+{4, 8, X86_OR64i32},
+{4, 8, X86_OR64mi32},
+{1, 8, X86_OR64mi8},
+{4, 8, X86_OR64ri32},
+{1, 8, X86_OR64ri8},
+{1, 1, X86_OR8i8},
+{1, 1, X86_OR8mi},
+{1, 1, X86_OR8mi8},
+{1, 1, X86_OR8ri},
+{1, 1, X86_OR8ri8},
+{1, 2, X86_PUSH16i8},
+{1, 4, X86_PUSH32i8},
+{4, 8, X86_PUSH64i32},
+{1, 8, X86_PUSH64i8},
+{2, 2, X86_PUSHi16},
+{4, 4, X86_PUSHi32},
+{1, 1, X86_RCL16mi},
+{1, 1, X86_RCL16ri},
+{1, 1, X86_RCL32mi},
+{1, 1, X86_RCL32ri},
+{1, 1, X86_RCL64mi},
+{1, 1, X86_RCL64ri},
+{1, 1, X86_RCL8mi},
+{1, 1, X86_RCL8ri},
+{1, 1, X86_RCR16mi},
+{1, 1, X86_RCR16ri},
+{1, 1, X86_RCR32mi},
+{1, 1, X86_RCR32ri},
+{1, 1, X86_RCR64mi},
+{1, 1, X86_RCR64ri},
+{1, 1, X86_RCR8mi},
+{1, 1, X86_RCR8ri},
+//{4, 4, X86_RELEASE_ADD32mi},
+//{4, 8, X86_RELEASE_ADD64mi32},
+//{1, 1, X86_RELEASE_ADD8mi},
+//{4, 4, X86_RELEASE_AND32mi},
+//{4, 8, X86_RELEASE_AND64mi32},
+//{1, 1, X86_RELEASE_AND8mi},
+//{2, 2, X86_RELEASE_MOV16mi},
+//{4, 4, X86_RELEASE_MOV32mi},
+//{4, 8, X86_RELEASE_MOV64mi32},
+//{1, 1, X86_RELEASE_MOV8mi},
+//{4, 4, X86_RELEASE_OR32mi},
+//{4, 8, X86_RELEASE_OR64mi32},
+//{1, 1, X86_RELEASE_OR8mi},
+//{4, 4, X86_RELEASE_XOR32mi},
+//{4, 8, X86_RELEASE_XOR64mi32},
+//{1, 1, X86_RELEASE_XOR8mi},
+{1, 1, X86_ROL16mi},
+{1, 1, X86_ROL16ri},
+{1, 1, X86_ROL32mi},
+{1, 1, X86_ROL32ri},
+{1, 1, X86_ROL64mi},
+{1, 1, X86_ROL64ri},
+{1, 1, X86_ROL8mi},
+{1, 1, X86_ROL8ri},
+{1, 1, X86_ROR16mi},
+{1, 1, X86_ROR16ri},
+{1, 1, X86_ROR32mi},
+{1, 1, X86_ROR32ri},
+{1, 1, X86_ROR64mi},
+{1, 1, X86_ROR64ri},
+{1, 1, X86_ROR8mi},
+{1, 1, X86_ROR8ri},
+{4, 4, X86_RORX32mi},
+{4, 4, X86_RORX32ri},
+{8, 8, X86_RORX64mi},
+{8, 8, X86_RORX64ri},
+{1, 1, X86_SAL16mi},
+{1, 1, X86_SAL16ri},
+{1, 1, X86_SAL32mi},
+{1, 1, X86_SAL32ri},
+{1, 1, X86_SAL64mi},
+{1, 1, X86_SAL64ri},
+{1, 1, X86_SAL8mi},
+{1, 1, X86_SAL8ri},
+{1, 1, X86_SAR16mi},
+{1, 1, X86_SAR16ri},
+{1, 1, X86_SAR32mi},
+{1, 1, X86_SAR32ri},
+{1, 1, X86_SAR64mi},
+{1, 1, X86_SAR64ri},
+{1, 1, X86_SAR8mi},
+{1, 1, X86_SAR8ri},
+{2, 2, X86_SBB16i16},
+{2, 2, X86_SBB16mi},
+{1, 2, X86_SBB16mi8},
+{2, 2, X86_SBB16ri},
+{1, 2, X86_SBB16ri8},
+{4, 4, X86_SBB32i32},
+{4, 4, X86_SBB32mi},
+{1, 4, X86_SBB32mi8},
+{4, 4, X86_SBB32ri},
+{1, 4, X86_SBB32ri8},
+{4, 8, X86_SBB64i32},
+{4, 8, X86_SBB64mi32},
+{1, 8, X86_SBB64mi8},
+{4, 8, X86_SBB64ri32},
+{1, 8, X86_SBB64ri8},
+{1, 1, X86_SBB8i8},
+{1, 1, X86_SBB8mi},
+{1, 1, X86_SBB8mi8},
+{1, 1, X86_SBB8ri},
+{1, 1, X86_SBB8ri8},
+{1, 1, X86_SHL16mi},
+{1, 1, X86_SHL16ri},
+{1, 1, X86_SHL32mi},
+{1, 1, X86_SHL32ri},
+{1, 1, X86_SHL64mi},
+{1, 1, X86_SHL64ri},
+{1, 1, X86_SHL8mi},
+{1, 1, X86_SHL8ri},
+{1, 1, X86_SHLD16mri8},
+{1, 1, X86_SHLD16rri8},
+{1, 1, X86_SHLD32mri8},
+{1, 1, X86_SHLD32rri8},
+{1, 1, X86_SHLD64mri8},
+{1, 1, X86_SHLD64rri8},
+{1, 1, X86_SHR16mi},
+{1, 1, X86_SHR16ri},
+{1, 1, X86_SHR32mi},
+{1, 1, X86_SHR32ri},
+{1, 1, X86_SHR64mi},
+{1, 1, X86_SHR64ri},
+{1, 1, X86_SHR8mi},
+{1, 1, X86_SHR8ri},
+{1, 1, X86_SHRD16mri8},
+{1, 1, X86_SHRD16rri8},
+{1, 1, X86_SHRD32mri8},
+{1, 1, X86_SHRD32rri8},
+{1, 1, X86_SHRD64mri8},
+{1, 1, X86_SHRD64rri8},
+{2, 2, X86_SUB16i16},
+{2, 2, X86_SUB16mi},
+{1, 2, X86_SUB16mi8},
+{2, 2, X86_SUB16ri},
+{1, 2, X86_SUB16ri8},
+{4, 4, X86_SUB32i32},
+{4, 4, X86_SUB32mi},
+{1, 4, X86_SUB32mi8},
+{4, 4, X86_SUB32ri},
+{1, 4, X86_SUB32ri8},
+{4, 8, X86_SUB64i32},
+{4, 8, X86_SUB64mi32},
+{1, 8, X86_SUB64mi8},
+{4, 8, X86_SUB64ri32},
+{1, 8, X86_SUB64ri8},
+{1, 1, X86_SUB8i8},
+{1, 1, X86_SUB8mi},
+{1, 1, X86_SUB8mi8},
+{1, 1, X86_SUB8ri},
+{1, 1, X86_SUB8ri8},
+{2, 2, X86_TEST16i16},
+{2, 2, X86_TEST16mi},
+// {2, 2, X86_TEST16mi_alt},
+{2, 2, X86_TEST16ri},
+//{2, 2, X86_TEST16ri_alt},
+{4, 4, X86_TEST32i32},
+{4, 4, X86_TEST32mi},
+//{4, 4, X86_TEST32mi_alt},
+{4, 4, X86_TEST32ri},
+//{4, 4, X86_TEST32ri_alt},
+{4, 8, X86_TEST64i32},
+{4, 8, X86_TEST64mi32},
+//{4, 4, X86_TEST64mi32_alt},
+{4, 8, X86_TEST64ri32},
+//{4, 4, X86_TEST64ri32_alt},
+{1, 1, X86_TEST8i8},
+{1, 1, X86_TEST8mi},
+//{1, 1, X86_TEST8mi_alt},
+{1, 1, X86_TEST8ri},
+//{1, 1, X86_TEST8ri_NOREX},
+//{1, 1, X86_TEST8ri_alt},
+{2, 2, X86_XOR16i16},
+{2, 2, X86_XOR16mi},
+{1, 2, X86_XOR16mi8},
+{2, 2, X86_XOR16ri},
+{1, 2, X86_XOR16ri8},
+{4, 4, X86_XOR32i32},
+{4, 4, X86_XOR32mi},
+{1, 4, X86_XOR32mi8},
+{4, 4, X86_XOR32ri},
+{1, 4, X86_XOR32ri8},
+{4, 8, X86_XOR64i32},
+{4, 8, X86_XOR64mi32},
+{1, 8, X86_XOR64mi8},
+{4, 8, X86_XOR64ri32},
+{1, 8, X86_XOR64ri8},
+{1, 1, X86_XOR8i8},
+{1, 1, X86_XOR8mi},
+{1, 1, X86_XOR8mi8},
+{1, 1, X86_XOR8ri},
+{1, 1, X86_XOR8ri8},

thirdparty/capstone/arch/X86/X86InstPrinter.h

@@ -0,0 +1,26 @@
+//= X86IntelInstPrinter.h - Convert X86 MCInst to assembly syntax -*- C++ -*-=//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class prints an X86 MCInst to Intel style .s file syntax.
+//
+//===----------------------------------------------------------------------===//
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_X86_INSTPRINTER_H
+#define CS_X86_INSTPRINTER_H
+
+#include "../../MCInst.h"
+#include "../../SStream.h"
+
+void X86_Intel_printInst(MCInst *MI, SStream *OS, void *Info);
+void X86_ATT_printInst(MCInst *MI, SStream *OS, void *Info);
+
+#endif

thirdparty/capstone/arch/X86/X86InstPrinterCommon.c

@@ -0,0 +1,116 @@
+//===--- X86InstPrinterCommon.cpp - X86 assembly instruction printing -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file includes common code for rendering MCInst instances as Intel-style
+// and Intel-style assembly.
+//
+//===----------------------------------------------------------------------===//
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifdef _MSC_VER
+#pragma warning(disable:4996)			// disable MSVC's warning on strncpy()
+#pragma warning(disable:28719)		// disable MSVC's warning on strncpy()
+#endif
+
+#if !defined(CAPSTONE_HAS_OSXKERNEL)
+#include <ctype.h>
+#endif
+#include <capstone/platform.h>
+
+#if defined(CAPSTONE_HAS_OSXKERNEL)
+#include <Availability.h>
+#include <libkern/libkern.h>
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#include <string.h>
+
+#include "../../utils.h"
+#include "../../MCInst.h"
+#include "../../SStream.h"
+
+#include "X86InstPrinterCommon.h"
+#include "X86Mapping.h"
+
+#ifndef CAPSTONE_X86_REDUCE
+void printSSEAVXCC(MCInst *MI, unsigned Op, SStream *O)
+{
+	uint8_t Imm = (uint8_t)(MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x1f);
+	switch (Imm) {
+		default: break;//printf("Invalid avxcc argument!\n"); break;
+		case    0: SStream_concat0(O, "eq"); op_addAvxCC(MI, X86_AVX_CC_EQ); break;
+		case    1: SStream_concat0(O, "lt"); op_addAvxCC(MI, X86_AVX_CC_LT); break;
+		case    2: SStream_concat0(O, "le"); op_addAvxCC(MI, X86_AVX_CC_LE); break;
+		case    3: SStream_concat0(O, "unord"); op_addAvxCC(MI, X86_AVX_CC_UNORD); break;
+		case    4: SStream_concat0(O, "neq"); op_addAvxCC(MI, X86_AVX_CC_NEQ); break;
+		case    5: SStream_concat0(O, "nlt"); op_addAvxCC(MI, X86_AVX_CC_NLT); break;
+		case    6: SStream_concat0(O, "nle"); op_addAvxCC(MI, X86_AVX_CC_NLE); break;
+		case    7: SStream_concat0(O, "ord"); op_addAvxCC(MI, X86_AVX_CC_ORD); break;
+		case    8: SStream_concat0(O, "eq_uq"); op_addAvxCC(MI, X86_AVX_CC_EQ_UQ); break;
+		case    9: SStream_concat0(O, "nge"); op_addAvxCC(MI, X86_AVX_CC_NGE); break;
+		case  0xa: SStream_concat0(O, "ngt"); op_addAvxCC(MI, X86_AVX_CC_NGT); break;
+		case  0xb: SStream_concat0(O, "false"); op_addAvxCC(MI, X86_AVX_CC_FALSE); break;
+		case  0xc: SStream_concat0(O, "neq_oq"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OQ); break;
+		case  0xd: SStream_concat0(O, "ge"); op_addAvxCC(MI, X86_AVX_CC_GE); break;
+		case  0xe: SStream_concat0(O, "gt"); op_addAvxCC(MI, X86_AVX_CC_GT); break;
+		case  0xf: SStream_concat0(O, "true"); op_addAvxCC(MI, X86_AVX_CC_TRUE); break;
+		case 0x10: SStream_concat0(O, "eq_os"); op_addAvxCC(MI, X86_AVX_CC_EQ_OS); break;
+		case 0x11: SStream_concat0(O, "lt_oq"); op_addAvxCC(MI, X86_AVX_CC_LT_OQ); break;
+		case 0x12: SStream_concat0(O, "le_oq"); op_addAvxCC(MI, X86_AVX_CC_LE_OQ); break;
+		case 0x13: SStream_concat0(O, "unord_s"); op_addAvxCC(MI, X86_AVX_CC_UNORD_S); break;
+		case 0x14: SStream_concat0(O, "neq_us"); op_addAvxCC(MI, X86_AVX_CC_NEQ_US); break;
+		case 0x15: SStream_concat0(O, "nlt_uq"); op_addAvxCC(MI, X86_AVX_CC_NLT_UQ); break;
+		case 0x16: SStream_concat0(O, "nle_uq"); op_addAvxCC(MI, X86_AVX_CC_NLE_UQ); break;
+		case 0x17: SStream_concat0(O, "ord_s"); op_addAvxCC(MI, X86_AVX_CC_ORD_S); break;
+		case 0x18: SStream_concat0(O, "eq_us"); op_addAvxCC(MI, X86_AVX_CC_EQ_US); break;
+		case 0x19: SStream_concat0(O, "nge_uq"); op_addAvxCC(MI, X86_AVX_CC_NGE_UQ); break;
+		case 0x1a: SStream_concat0(O, "ngt_uq"); op_addAvxCC(MI, X86_AVX_CC_NGT_UQ); break;
+		case 0x1b: SStream_concat0(O, "false_os"); op_addAvxCC(MI, X86_AVX_CC_FALSE_OS); break;
+		case 0x1c: SStream_concat0(O, "neq_os"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OS); break;
+		case 0x1d: SStream_concat0(O, "ge_oq"); op_addAvxCC(MI, X86_AVX_CC_GE_OQ); break;
+		case 0x1e: SStream_concat0(O, "gt_oq"); op_addAvxCC(MI, X86_AVX_CC_GT_OQ); break;
+		case 0x1f: SStream_concat0(O, "true_us"); op_addAvxCC(MI, X86_AVX_CC_TRUE_US); break;
+	}
+
+	MI->popcode_adjust = Imm + 1;
+}
+
+void printXOPCC(MCInst *MI, unsigned Op, SStream *O)
+{
+	int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op));
+
+	switch (Imm) {
+		default: // llvm_unreachable("Invalid xopcc argument!");
+		case 0: SStream_concat0(O, "lt"); op_addXopCC(MI, X86_XOP_CC_LT); break;
+		case 1: SStream_concat0(O, "le"); op_addXopCC(MI, X86_XOP_CC_LE); break;
+		case 2: SStream_concat0(O, "gt"); op_addXopCC(MI, X86_XOP_CC_GT); break;
+		case 3: SStream_concat0(O, "ge"); op_addXopCC(MI, X86_XOP_CC_GE); break;
+		case 4: SStream_concat0(O, "eq"); op_addXopCC(MI, X86_XOP_CC_EQ); break;
+		case 5: SStream_concat0(O, "neq"); op_addXopCC(MI, X86_XOP_CC_NEQ); break;
+		case 6: SStream_concat0(O, "false"); op_addXopCC(MI, X86_XOP_CC_FALSE); break;
+		case 7: SStream_concat0(O, "true"); op_addXopCC(MI, X86_XOP_CC_TRUE); break;
+	}
+}
+
+void printRoundingControl(MCInst *MI, unsigned Op, SStream *O)
+{
+	int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x3;
+	switch (Imm) {
+		case 0: SStream_concat0(O, "{rn-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RN); break;
+		case 1: SStream_concat0(O, "{rd-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RD); break;
+		case 2: SStream_concat0(O, "{ru-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RU); break;
+		case 3: SStream_concat0(O, "{rz-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RZ); break;
+		default: break;	// never reach
+	}
+}
+#endif

thirdparty/capstone/arch/X86/X86InstPrinterCommon.h

@@ -0,0 +1,16 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_X86_INSTPRINTERCOMMON_H
+#define CS_X86_INSTPRINTERCOMMON_H
+
+#include "../../MCInst.h"
+#include "../../SStream.h"
+
+#define CS_X86_MAXIMUM_OPERAND_SIZE 6
+
+void printSSEAVXCC(MCInst *MI, unsigned Op, SStream *O);
+void printXOPCC(MCInst *MI, unsigned Op, SStream *O);
+void printRoundingControl(MCInst *MI, unsigned Op, SStream *O);
+
+#endif

thirdparty/capstone/arch/X86/X86Mapping.h

@@ -0,0 +1,96 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_X86_MAP_H
+#define CS_X86_MAP_H
+
+#include "capstone/capstone.h"
+#include "../../cs_priv.h"
+
+// map instruction to its characteristics
+typedef struct insn_map_x86 {
+	unsigned short id;
+	unsigned short mapid;
+	unsigned char is64bit;
+#ifndef CAPSTONE_DIET
+	uint16_t regs_use[12]; // list of implicit registers used by this instruction
+	uint16_t regs_mod[20]; // list of implicit registers modified by this instruction
+	unsigned char groups[8]; // list of group this instruction belong to
+	bool branch;	// branch instruction?
+	bool indirect_branch;	// indirect branch instruction?
+#endif
+} insn_map_x86;
+
+extern const insn_map_x86 insns[];
+
+// map sib_base to x86_reg
+x86_reg x86_map_sib_base(int r);
+
+// map sib_index to x86_reg
+x86_reg x86_map_sib_index(int r);
+
+// map seg_override to x86_reg
+x86_reg x86_map_segment(int r);
+
+// return name of register in friendly string
+const char *X86_reg_name(csh handle, unsigned int reg);
+
+// given internal insn id, return public instruction info
+void X86_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
+
+// return insn name, given insn id
+const char *X86_insn_name(csh handle, unsigned int id);
+
+// return group name, given group id
+const char *X86_group_name(csh handle, unsigned int id);
+
+// return register of given instruction id
+// return 0 if not found
+// this is to handle instructions embedding accumulate registers into AsmStrs[]
+x86_reg X86_insn_reg_intel(unsigned int id, enum cs_ac_type *access);
+x86_reg X86_insn_reg_att(unsigned int id, enum cs_ac_type *access);
+bool X86_insn_reg_intel2(unsigned int id, x86_reg *reg1, enum cs_ac_type *access1, x86_reg *reg2, enum cs_ac_type *access2);
+bool X86_insn_reg_att2(unsigned int id, x86_reg *reg1, enum cs_ac_type *access1, x86_reg *reg2, enum cs_ac_type *access2);
+
+extern const uint64_t arch_masks[9];
+
+// handle LOCK/REP/REPNE prefixes
+// return True if we patch mnemonic, like in MULPD case
+bool X86_lockrep(MCInst *MI, SStream *O);
+
+// map registers to sizes
+extern const uint8_t regsize_map_32[];
+extern const uint8_t regsize_map_64[];
+
+void op_addReg(MCInst *MI, int reg);
+void op_addImm(MCInst *MI, int v);
+
+void op_addAvxBroadcast(MCInst *MI, x86_avx_bcast v);
+
+void op_addXopCC(MCInst *MI, int v);
+void op_addSseCC(MCInst *MI, int v);
+void op_addAvxCC(MCInst *MI, int v);
+
+void op_addAvxZeroOpmask(MCInst *MI);
+
+void op_addAvxSae(MCInst *MI);
+
+void op_addAvxRoundingMode(MCInst *MI, int v);
+
+// given internal insn id, return operand access info
+const uint8_t *X86_get_op_access(cs_struct *h, unsigned int id, uint64_t *eflags);
+
+void X86_reg_access(const cs_insn *insn,
+		cs_regs regs_read, uint8_t *regs_read_count,
+		cs_regs regs_write, uint8_t *regs_write_count);
+
+// given the instruction id, return the size of its immediate operand (or 0)
+uint8_t X86_immediate_size(unsigned int id, uint8_t *enc_size);
+
+unsigned short X86_register_map(unsigned short id);
+
+unsigned int find_insn(unsigned int id);
+
+void X86_postprinter(csh handle, cs_insn *insn, char *mnem, MCInst *mci);
+
+#endif

thirdparty/capstone/arch/X86/X86MappingInsnName_reduce.inc

@@ -0,0 +1,348 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+	"aaa", // X86_INS_AAA
+	"aad", // X86_INS_AAD
+	"aam", // X86_INS_AAM
+	"aas", // X86_INS_AAS
+	"adc", // X86_INS_ADC
+	"adcx", // X86_INS_ADCX
+	"add", // X86_INS_ADD
+	"adox", // X86_INS_ADOX
+	"and", // X86_INS_AND
+	"andn", // X86_INS_ANDN
+	"arpl", // X86_INS_ARPL
+	"bextr", // X86_INS_BEXTR
+	"blcfill", // X86_INS_BLCFILL
+	"blci", // X86_INS_BLCI
+	"blcic", // X86_INS_BLCIC
+	"blcmsk", // X86_INS_BLCMSK
+	"blcs", // X86_INS_BLCS
+	"blsfill", // X86_INS_BLSFILL
+	"blsi", // X86_INS_BLSI
+	"blsic", // X86_INS_BLSIC
+	"blsmsk", // X86_INS_BLSMSK
+	"blsr", // X86_INS_BLSR
+	"bound", // X86_INS_BOUND
+	"bsf", // X86_INS_BSF
+	"bsr", // X86_INS_BSR
+	"bswap", // X86_INS_BSWAP
+	"bt", // X86_INS_BT
+	"btc", // X86_INS_BTC
+	"btr", // X86_INS_BTR
+	"bts", // X86_INS_BTS
+	"bzhi", // X86_INS_BZHI
+	"call", // X86_INS_CALL
+	"cbw", // X86_INS_CBW
+	"cdq", // X86_INS_CDQ
+	"cdqe", // X86_INS_CDQE
+	"clac", // X86_INS_CLAC
+	"clc", // X86_INS_CLC
+	"cld", // X86_INS_CLD
+	"cldemote", // X86_INS_CLDEMOTE
+	"clflushopt", // X86_INS_CLFLUSHOPT
+	"clgi", // X86_INS_CLGI
+	"cli", // X86_INS_CLI
+	"clrssbsy", // X86_INS_CLRSSBSY
+	"clts", // X86_INS_CLTS
+	"clwb", // X86_INS_CLWB
+	"clzero", // X86_INS_CLZERO
+	"cmc", // X86_INS_CMC
+	"cmova", // X86_INS_CMOVA
+	"cmovae", // X86_INS_CMOVAE
+	"cmovb", // X86_INS_CMOVB
+	"cmovbe", // X86_INS_CMOVBE
+	"cmove", // X86_INS_CMOVE
+	"cmovg", // X86_INS_CMOVG
+	"cmovge", // X86_INS_CMOVGE
+	"cmovl", // X86_INS_CMOVL
+	"cmovle", // X86_INS_CMOVLE
+	"cmovne", // X86_INS_CMOVNE
+	"cmovno", // X86_INS_CMOVNO
+	"cmovnp", // X86_INS_CMOVNP
+	"cmovns", // X86_INS_CMOVNS
+	"cmovo", // X86_INS_CMOVO
+	"cmovp", // X86_INS_CMOVP
+	"cmovs", // X86_INS_CMOVS
+	"cmp", // X86_INS_CMP
+	"cmpsb", // X86_INS_CMPSB
+	"cmpsd", // X86_INS_CMPSD
+	"cmpsq", // X86_INS_CMPSQ
+	"cmpsw", // X86_INS_CMPSW
+	"cmpxchg16b", // X86_INS_CMPXCHG16B
+	"cmpxchg", // X86_INS_CMPXCHG
+	"cmpxchg8b", // X86_INS_CMPXCHG8B
+	"cpuid", // X86_INS_CPUID
+	"cqo", // X86_INS_CQO
+	"cwd", // X86_INS_CWD
+	"cwde", // X86_INS_CWDE
+	"daa", // X86_INS_DAA
+	"das", // X86_INS_DAS
+	"data16", // X86_INS_DATA16
+	"dec", // X86_INS_DEC
+	"div", // X86_INS_DIV
+	"endbr32", // X86_INS_ENDBR32
+	"endbr64", // X86_INS_ENDBR64
+	"enter", // X86_INS_ENTER
+	"lcall", // X86_INS_LCALL
+	"ljmp", // X86_INS_LJMP
+	"jmp", // X86_INS_JMP
+	"fsetpm", // X86_INS_FSETPM
+	"getsec", // X86_INS_GETSEC
+	"hlt", // X86_INS_HLT
+	"idiv", // X86_INS_IDIV
+	"imul", // X86_INS_IMUL
+	"in", // X86_INS_IN
+	"inc", // X86_INS_INC
+	"incsspd", // X86_INS_INCSSPD
+	"incsspq", // X86_INS_INCSSPQ
+	"insb", // X86_INS_INSB
+	"insd", // X86_INS_INSD
+	"insw", // X86_INS_INSW
+	"int", // X86_INS_INT
+	"int1", // X86_INS_INT1
+	"int3", // X86_INS_INT3
+	"into", // X86_INS_INTO
+	"invd", // X86_INS_INVD
+	"invept", // X86_INS_INVEPT
+	"invlpg", // X86_INS_INVLPG
+	"invlpga", // X86_INS_INVLPGA
+	"invpcid", // X86_INS_INVPCID
+	"invvpid", // X86_INS_INVVPID
+	"iret", // X86_INS_IRET
+	"iretd", // X86_INS_IRETD
+	"iretq", // X86_INS_IRETQ
+	"jae", // X86_INS_JAE
+	"ja", // X86_INS_JA
+	"jbe", // X86_INS_JBE
+	"jb", // X86_INS_JB
+	"jcxz", // X86_INS_JCXZ
+	"jecxz", // X86_INS_JECXZ
+	"je", // X86_INS_JE
+	"jge", // X86_INS_JGE
+	"jg", // X86_INS_JG
+	"jle", // X86_INS_JLE
+	"jl", // X86_INS_JL
+	"jne", // X86_INS_JNE
+	"jno", // X86_INS_JNO
+	"jnp", // X86_INS_JNP
+	"jns", // X86_INS_JNS
+	"jo", // X86_INS_JO
+	"jp", // X86_INS_JP
+	"jrcxz", // X86_INS_JRCXZ
+	"js", // X86_INS_JS
+	"lahf", // X86_INS_LAHF
+	"lar", // X86_INS_LAR
+	"lds", // X86_INS_LDS
+	"lea", // X86_INS_LEA
+	"leave", // X86_INS_LEAVE
+	"les", // X86_INS_LES
+	"lfs", // X86_INS_LFS
+	"lgdt", // X86_INS_LGDT
+	"lgs", // X86_INS_LGS
+	"lidt", // X86_INS_LIDT
+	"lldt", // X86_INS_LLDT
+	"llwpcb", // X86_INS_LLWPCB
+	"lmsw", // X86_INS_LMSW
+	"lock", // X86_INS_LOCK
+	"lodsb", // X86_INS_LODSB
+	"lodsd", // X86_INS_LODSD
+	"lodsq", // X86_INS_LODSQ
+	"lodsw", // X86_INS_LODSW
+	"loop", // X86_INS_LOOP
+	"loope", // X86_INS_LOOPE
+	"loopne", // X86_INS_LOOPNE
+	"retf", // X86_INS_RETF
+	"retfq", // X86_INS_RETFQ
+	"lsl", // X86_INS_LSL
+	"lss", // X86_INS_LSS
+	"ltr", // X86_INS_LTR
+	"lwpins", // X86_INS_LWPINS
+	"lwpval", // X86_INS_LWPVAL
+	"lzcnt", // X86_INS_LZCNT
+	"monitorx", // X86_INS_MONITORX
+	"montmul", // X86_INS_MONTMUL
+	"mov", // X86_INS_MOV
+	"movabs", // X86_INS_MOVABS
+	"movbe", // X86_INS_MOVBE
+	"movdir64b", // X86_INS_MOVDIR64B
+	"movdiri", // X86_INS_MOVDIRI
+	"movsb", // X86_INS_MOVSB
+	"movsd", // X86_INS_MOVSD
+	"movsq", // X86_INS_MOVSQ
+	"movsw", // X86_INS_MOVSW
+	"movsx", // X86_INS_MOVSX
+	"movsxd", // X86_INS_MOVSXD
+	"movzx", // X86_INS_MOVZX
+	"mul", // X86_INS_MUL
+	"mulx", // X86_INS_MULX
+	"mwaitx", // X86_INS_MWAITX
+	"neg", // X86_INS_NEG
+	"nop", // X86_INS_NOP
+	"not", // X86_INS_NOT
+	"or", // X86_INS_OR
+	"out", // X86_INS_OUT
+	"outsb", // X86_INS_OUTSB
+	"outsd", // X86_INS_OUTSD
+	"outsw", // X86_INS_OUTSW
+	"pconfig", // X86_INS_PCONFIG
+	"pdep", // X86_INS_PDEP
+	"pext", // X86_INS_PEXT
+	"pop", // X86_INS_POP
+	"popaw", // X86_INS_POPAW
+	"popal", // X86_INS_POPAL
+	"popf", // X86_INS_POPF
+	"popfd", // X86_INS_POPFD
+	"popfq", // X86_INS_POPFQ
+	"ptwrite", // X86_INS_PTWRITE
+	"push", // X86_INS_PUSH
+	"pushaw", // X86_INS_PUSHAW
+	"pushal", // X86_INS_PUSHAL
+	"pushf", // X86_INS_PUSHF
+	"pushfd", // X86_INS_PUSHFD
+	"pushfq", // X86_INS_PUSHFQ
+	"rcl", // X86_INS_RCL
+	"rcr", // X86_INS_RCR
+	"rdfsbase", // X86_INS_RDFSBASE
+	"rdgsbase", // X86_INS_RDGSBASE
+	"rdmsr", // X86_INS_RDMSR
+	"rdpid", // X86_INS_RDPID
+	"rdpkru", // X86_INS_RDPKRU
+	"rdpmc", // X86_INS_RDPMC
+	"rdrand", // X86_INS_RDRAND
+	"rdseed", // X86_INS_RDSEED
+	"rdsspd", // X86_INS_RDSSPD
+	"rdsspq", // X86_INS_RDSSPQ
+	"rdtsc", // X86_INS_RDTSC
+	"rdtscp", // X86_INS_RDTSCP
+	"repne", // X86_INS_REPNE
+	"rep", // X86_INS_REP
+	"ret", // X86_INS_RET
+	"rex64", // X86_INS_REX64
+	"rol", // X86_INS_ROL
+	"ror", // X86_INS_ROR
+	"rorx", // X86_INS_RORX
+	"rsm", // X86_INS_RSM
+	"rstorssp", // X86_INS_RSTORSSP
+	"sahf", // X86_INS_SAHF
+	"sal", // X86_INS_SAL
+	"salc", // X86_INS_SALC
+	"sar", // X86_INS_SAR
+	"sarx", // X86_INS_SARX
+	"saveprevssp", // X86_INS_SAVEPREVSSP
+	"sbb", // X86_INS_SBB
+	"scasb", // X86_INS_SCASB
+	"scasd", // X86_INS_SCASD
+	"scasq", // X86_INS_SCASQ
+	"scasw", // X86_INS_SCASW
+	"setae", // X86_INS_SETAE
+	"seta", // X86_INS_SETA
+	"setbe", // X86_INS_SETBE
+	"setb", // X86_INS_SETB
+	"sete", // X86_INS_SETE
+	"setge", // X86_INS_SETGE
+	"setg", // X86_INS_SETG
+	"setle", // X86_INS_SETLE
+	"setl", // X86_INS_SETL
+	"setne", // X86_INS_SETNE
+	"setno", // X86_INS_SETNO
+	"setnp", // X86_INS_SETNP
+	"setns", // X86_INS_SETNS
+	"seto", // X86_INS_SETO
+	"setp", // X86_INS_SETP
+	"setssbsy", // X86_INS_SETSSBSY
+	"sets", // X86_INS_SETS
+	"sgdt", // X86_INS_SGDT
+	"shl", // X86_INS_SHL
+	"shld", // X86_INS_SHLD
+	"shlx", // X86_INS_SHLX
+	"shr", // X86_INS_SHR
+	"shrd", // X86_INS_SHRD
+	"shrx", // X86_INS_SHRX
+	"sidt", // X86_INS_SIDT
+	"skinit", // X86_INS_SKINIT
+	"sldt", // X86_INS_SLDT
+	"slwpcb", // X86_INS_SLWPCB
+	"smsw", // X86_INS_SMSW
+	"stac", // X86_INS_STAC
+	"stc", // X86_INS_STC
+	"std", // X86_INS_STD
+	"stgi", // X86_INS_STGI
+	"sti", // X86_INS_STI
+	"stosb", // X86_INS_STOSB
+	"stosd", // X86_INS_STOSD
+	"stosq", // X86_INS_STOSQ
+	"stosw", // X86_INS_STOSW
+	"str", // X86_INS_STR
+	"sub", // X86_INS_SUB
+	"swapgs", // X86_INS_SWAPGS
+	"syscall", // X86_INS_SYSCALL
+	"sysenter", // X86_INS_SYSENTER
+	"sysexit", // X86_INS_SYSEXIT
+	"sysexitq", // X86_INS_SYSEXITQ
+	"sysret", // X86_INS_SYSRET
+	"sysretq", // X86_INS_SYSRETQ
+	"t1mskc", // X86_INS_T1MSKC
+	"test", // X86_INS_TEST
+	"tpause", // X86_INS_TPAUSE
+	"tzcnt", // X86_INS_TZCNT
+	"tzmsk", // X86_INS_TZMSK
+	"ud0", // X86_INS_UD0
+	"ud1", // X86_INS_UD1
+	"ud2", // X86_INS_UD2
+	"umonitor", // X86_INS_UMONITOR
+	"umwait", // X86_INS_UMWAIT
+	"verr", // X86_INS_VERR
+	"verw", // X86_INS_VERW
+	"vmcall", // X86_INS_VMCALL
+	"vmclear", // X86_INS_VMCLEAR
+	"vmfunc", // X86_INS_VMFUNC
+	"vmlaunch", // X86_INS_VMLAUNCH
+	"vmload", // X86_INS_VMLOAD
+	"vmmcall", // X86_INS_VMMCALL
+	"vmptrld", // X86_INS_VMPTRLD
+	"vmptrst", // X86_INS_VMPTRST
+	"vmread", // X86_INS_VMREAD
+	"vmresume", // X86_INS_VMRESUME
+	"vmrun", // X86_INS_VMRUN
+	"vmsave", // X86_INS_VMSAVE
+	"vmwrite", // X86_INS_VMWRITE
+	"vmxoff", // X86_INS_VMXOFF
+	"vmxon", // X86_INS_VMXON
+	"wbinvd", // X86_INS_WBINVD
+	"wbnoinvd", // X86_INS_WBNOINVD
+	"wrfsbase", // X86_INS_WRFSBASE
+	"wrgsbase", // X86_INS_WRGSBASE
+	"wrmsr", // X86_INS_WRMSR
+	"wrpkru", // X86_INS_WRPKRU
+	"wrssd", // X86_INS_WRSSD
+	"wrssq", // X86_INS_WRSSQ
+	"wrussd", // X86_INS_WRUSSD
+	"wrussq", // X86_INS_WRUSSQ
+	"xadd", // X86_INS_XADD
+	"xchg", // X86_INS_XCHG
+	"xcryptcbc", // X86_INS_XCRYPTCBC
+	"xcryptcfb", // X86_INS_XCRYPTCFB
+	"xcryptctr", // X86_INS_XCRYPTCTR
+	"xcryptecb", // X86_INS_XCRYPTECB
+	"xcryptofb", // X86_INS_XCRYPTOFB
+	"xgetbv", // X86_INS_XGETBV
+	"xlatb", // X86_INS_XLATB
+	"xor", // X86_INS_XOR
+	"xrstor", // X86_INS_XRSTOR
+	"xrstor64", // X86_INS_XRSTOR64
+	"xrstors", // X86_INS_XRSTORS
+	"xrstors64", // X86_INS_XRSTORS64
+	"xsave", // X86_INS_XSAVE
+	"xsave64", // X86_INS_XSAVE64
+	"xsavec", // X86_INS_XSAVEC
+	"xsavec64", // X86_INS_XSAVEC64
+	"xsaveopt", // X86_INS_XSAVEOPT
+	"xsaveopt64", // X86_INS_XSAVEOPT64
+	"xsaves", // X86_INS_XSAVES
+	"xsaves64", // X86_INS_XSAVES64
+	"xsetbv", // X86_INS_XSETBV
+	"xsha1", // X86_INS_XSHA1
+	"xsha256", // X86_INS_XSHA256
+	"xstore", // X86_INS_XSTORE

thirdparty/capstone/arch/X86/X86MappingReg.inc

@@ -0,0 +1,280 @@
+/* Capstone Disassembly Engine, http://www.capstone-engine.org */
+/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+{ X86_AH, X86_REG_AH },
+{ X86_AL, X86_REG_AL },
+{ X86_AX, X86_REG_AX },
+{ X86_BH, X86_REG_BH },
+{ X86_BL, X86_REG_BL },
+{ X86_BP, X86_REG_BP },
+{ X86_BPH, 0 },
+{ X86_BPL, X86_REG_BPL },
+{ X86_BX, X86_REG_BX },
+{ X86_CH, X86_REG_CH },
+{ X86_CL, X86_REG_CL },
+{ X86_CS, X86_REG_CS },
+{ X86_CX, X86_REG_CX },
+{ X86_DF, 0 },
+{ X86_DH, X86_REG_DH },
+{ X86_DI, X86_REG_DI },
+{ X86_DIH, 0 },
+{ X86_DIL, X86_REG_DIL },
+{ X86_DL, X86_REG_DL },
+{ X86_DS, X86_REG_DS },
+{ X86_DX, X86_REG_DX },
+{ X86_EAX, X86_REG_EAX },
+{ X86_EBP, X86_REG_EBP },
+{ X86_EBX, X86_REG_EBX },
+{ X86_ECX, X86_REG_ECX },
+{ X86_EDI, X86_REG_EDI },
+{ X86_EDX, X86_REG_EDX },
+{ X86_EFLAGS, X86_REG_EFLAGS },
+{ X86_EIP, X86_REG_EIP },
+{ X86_EIZ, X86_REG_EIZ },
+{ X86_ES, X86_REG_ES },
+{ X86_ESI, X86_REG_ESI },
+{ X86_ESP, X86_REG_ESP },
+{ X86_FPSW, X86_REG_FPSW },
+{ X86_FS, X86_REG_FS },
+{ X86_GS, X86_REG_GS },
+{ X86_HAX, 0 },
+{ X86_HBP, 0 },
+{ X86_HBX, 0 },
+{ X86_HCX, 0 },
+{ X86_HDI, 0 },
+{ X86_HDX, 0 },
+{ X86_HIP, 0 },
+{ X86_HSI, 0 },
+{ X86_HSP, 0 },
+{ X86_IP, X86_REG_IP },
+{ X86_RAX, X86_REG_RAX },
+{ X86_RBP, X86_REG_RBP },
+{ X86_RBX, X86_REG_RBX },
+{ X86_RCX, X86_REG_RCX },
+{ X86_RDI, X86_REG_RDI },
+{ X86_RDX, X86_REG_RDX },
+{ X86_RIP, X86_REG_RIP },
+{ X86_RIZ, X86_REG_RIZ },
+{ X86_RSI, X86_REG_RSI },
+{ X86_RSP, X86_REG_RSP },
+{ X86_SI, X86_REG_SI },
+{ X86_SIH, 0 },
+{ X86_SIL, X86_REG_SIL },
+{ X86_SP, X86_REG_SP },
+{ X86_SPH, 0 },
+{ X86_SPL, X86_REG_SPL },
+{ X86_SS, X86_REG_SS },
+{ X86_SSP, 0 },
+{ X86_BND0, X86_REG_BND0 },
+{ X86_BND1, X86_REG_BND1 },
+{ X86_BND2, X86_REG_BND2 },
+{ X86_BND3, X86_REG_BND3 },
+{ X86_CR0, X86_REG_CR0 },
+{ X86_CR1, X86_REG_CR1 },
+{ X86_CR2, X86_REG_CR2 },
+{ X86_CR3, X86_REG_CR3 },
+{ X86_CR4, X86_REG_CR4 },
+{ X86_CR5, X86_REG_CR5 },
+{ X86_CR6, X86_REG_CR6 },
+{ X86_CR7, X86_REG_CR7 },
+{ X86_CR8, X86_REG_CR8 },
+{ X86_CR9, X86_REG_CR9 },
+{ X86_CR10, X86_REG_CR10 },
+{ X86_CR11, X86_REG_CR11 },
+{ X86_CR12, X86_REG_CR12 },
+{ X86_CR13, X86_REG_CR13 },
+{ X86_CR14, X86_REG_CR14 },
+{ X86_CR15, X86_REG_CR15 },
+{ X86_DR0, X86_REG_DR0 },
+{ X86_DR1, X86_REG_DR1 },
+{ X86_DR2, X86_REG_DR2 },
+{ X86_DR3, X86_REG_DR3 },
+{ X86_DR4, X86_REG_DR4 },
+{ X86_DR5, X86_REG_DR5 },
+{ X86_DR6, X86_REG_DR6 },
+{ X86_DR7, X86_REG_DR7 },
+{ X86_DR8, X86_REG_DR8 },
+{ X86_DR9, X86_REG_DR9 },
+{ X86_DR10, X86_REG_DR10 },
+{ X86_DR11, X86_REG_DR11 },
+{ X86_DR12, X86_REG_DR12 },
+{ X86_DR13, X86_REG_DR13 },
+{ X86_DR14, X86_REG_DR14 },
+{ X86_DR15, X86_REG_DR15 },
+{ X86_FP0, X86_REG_FP0 },
+{ X86_FP1, X86_REG_FP1 },
+{ X86_FP2, X86_REG_FP2 },
+{ X86_FP3, X86_REG_FP3 },
+{ X86_FP4, X86_REG_FP4 },
+{ X86_FP5, X86_REG_FP5 },
+{ X86_FP6, X86_REG_FP6 },
+{ X86_FP7, X86_REG_FP7 },
+{ X86_K0, X86_REG_K0 },
+{ X86_K1, X86_REG_K1 },
+{ X86_K2, X86_REG_K2 },
+{ X86_K3, X86_REG_K3 },
+{ X86_K4, X86_REG_K4 },
+{ X86_K5, X86_REG_K5 },
+{ X86_K6, X86_REG_K6 },
+{ X86_K7, X86_REG_K7 },
+{ X86_MM0, X86_REG_MM0 },
+{ X86_MM1, X86_REG_MM1 },
+{ X86_MM2, X86_REG_MM2 },
+{ X86_MM3, X86_REG_MM3 },
+{ X86_MM4, X86_REG_MM4 },
+{ X86_MM5, X86_REG_MM5 },
+{ X86_MM6, X86_REG_MM6 },
+{ X86_MM7, X86_REG_MM7 },
+{ X86_R8, X86_REG_R8 },
+{ X86_R9, X86_REG_R9 },
+{ X86_R10, X86_REG_R10 },
+{ X86_R11, X86_REG_R11 },
+{ X86_R12, X86_REG_R12 },
+{ X86_R13, X86_REG_R13 },
+{ X86_R14, X86_REG_R14 },
+{ X86_R15, X86_REG_R15 },
+{ X86_ST0, X86_REG_ST0 },
+{ X86_ST1, X86_REG_ST1 },
+{ X86_ST2, X86_REG_ST2 },
+{ X86_ST3, X86_REG_ST3 },
+{ X86_ST4, X86_REG_ST4 },
+{ X86_ST5, X86_REG_ST5 },
+{ X86_ST6, X86_REG_ST6 },
+{ X86_ST7, X86_REG_ST7 },
+{ X86_XMM0, X86_REG_XMM0 },
+{ X86_XMM1, X86_REG_XMM1 },
+{ X86_XMM2, X86_REG_XMM2 },
+{ X86_XMM3, X86_REG_XMM3 },
+{ X86_XMM4, X86_REG_XMM4 },
+{ X86_XMM5, X86_REG_XMM5 },
+{ X86_XMM6, X86_REG_XMM6 },
+{ X86_XMM7, X86_REG_XMM7 },
+{ X86_XMM8, X86_REG_XMM8 },
+{ X86_XMM9, X86_REG_XMM9 },
+{ X86_XMM10, X86_REG_XMM10 },
+{ X86_XMM11, X86_REG_XMM11 },
+{ X86_XMM12, X86_REG_XMM12 },
+{ X86_XMM13, X86_REG_XMM13 },
+{ X86_XMM14, X86_REG_XMM14 },
+{ X86_XMM15, X86_REG_XMM15 },
+{ X86_XMM16, X86_REG_XMM16 },
+{ X86_XMM17, X86_REG_XMM17 },
+{ X86_XMM18, X86_REG_XMM18 },
+{ X86_XMM19, X86_REG_XMM19 },
+{ X86_XMM20, X86_REG_XMM20 },
+{ X86_XMM21, X86_REG_XMM21 },
+{ X86_XMM22, X86_REG_XMM22 },
+{ X86_XMM23, X86_REG_XMM23 },
+{ X86_XMM24, X86_REG_XMM24 },
+{ X86_XMM25, X86_REG_XMM25 },
+{ X86_XMM26, X86_REG_XMM26 },
+{ X86_XMM27, X86_REG_XMM27 },
+{ X86_XMM28, X86_REG_XMM28 },
+{ X86_XMM29, X86_REG_XMM29 },
+{ X86_XMM30, X86_REG_XMM30 },
+{ X86_XMM31, X86_REG_XMM31 },
+{ X86_YMM0, X86_REG_YMM0 },
+{ X86_YMM1, X86_REG_YMM1 },
+{ X86_YMM2, X86_REG_YMM2 },
+{ X86_YMM3, X86_REG_YMM3 },
+{ X86_YMM4, X86_REG_YMM4 },
+{ X86_YMM5, X86_REG_YMM5 },
+{ X86_YMM6, X86_REG_YMM6 },
+{ X86_YMM7, X86_REG_YMM7 },
+{ X86_YMM8, X86_REG_YMM8 },
+{ X86_YMM9, X86_REG_YMM9 },
+{ X86_YMM10, X86_REG_YMM10 },
+{ X86_YMM11, X86_REG_YMM11 },
+{ X86_YMM12, X86_REG_YMM12 },
+{ X86_YMM13, X86_REG_YMM13 },
+{ X86_YMM14, X86_REG_YMM14 },
+{ X86_YMM15, X86_REG_YMM15 },
+{ X86_YMM16, X86_REG_YMM16 },
+{ X86_YMM17, X86_REG_YMM17 },
+{ X86_YMM18, X86_REG_YMM18 },
+{ X86_YMM19, X86_REG_YMM19 },
+{ X86_YMM20, X86_REG_YMM20 },
+{ X86_YMM21, X86_REG_YMM21 },
+{ X86_YMM22, X86_REG_YMM22 },
+{ X86_YMM23, X86_REG_YMM23 },
+{ X86_YMM24, X86_REG_YMM24 },
+{ X86_YMM25, X86_REG_YMM25 },
+{ X86_YMM26, X86_REG_YMM26 },
+{ X86_YMM27, X86_REG_YMM27 },
+{ X86_YMM28, X86_REG_YMM28 },
+{ X86_YMM29, X86_REG_YMM29 },
+{ X86_YMM30, X86_REG_YMM30 },
+{ X86_YMM31, X86_REG_YMM31 },
+{ X86_ZMM0, X86_REG_ZMM0 },
+{ X86_ZMM1, X86_REG_ZMM1 },
+{ X86_ZMM2, X86_REG_ZMM2 },
+{ X86_ZMM3, X86_REG_ZMM3 },
+{ X86_ZMM4, X86_REG_ZMM4 },
+{ X86_ZMM5, X86_REG_ZMM5 },
+{ X86_ZMM6, X86_REG_ZMM6 },
+{ X86_ZMM7, X86_REG_ZMM7 },
+{ X86_ZMM8, X86_REG_ZMM8 },
+{ X86_ZMM9, X86_REG_ZMM9 },
+{ X86_ZMM10, X86_REG_ZMM10 },
+{ X86_ZMM11, X86_REG_ZMM11 },
+{ X86_ZMM12, X86_REG_ZMM12 },
+{ X86_ZMM13, X86_REG_ZMM13 },
+{ X86_ZMM14, X86_REG_ZMM14 },
+{ X86_ZMM15, X86_REG_ZMM15 },
+{ X86_ZMM16, X86_REG_ZMM16 },
+{ X86_ZMM17, X86_REG_ZMM17 },
+{ X86_ZMM18, X86_REG_ZMM18 },
+{ X86_ZMM19, X86_REG_ZMM19 },
+{ X86_ZMM20, X86_REG_ZMM20 },
+{ X86_ZMM21, X86_REG_ZMM21 },
+{ X86_ZMM22, X86_REG_ZMM22 },
+{ X86_ZMM23, X86_REG_ZMM23 },
+{ X86_ZMM24, X86_REG_ZMM24 },
+{ X86_ZMM25, X86_REG_ZMM25 },
+{ X86_ZMM26, X86_REG_ZMM26 },
+{ X86_ZMM27, X86_REG_ZMM27 },
+{ X86_ZMM28, X86_REG_ZMM28 },
+{ X86_ZMM29, X86_REG_ZMM29 },
+{ X86_ZMM30, X86_REG_ZMM30 },
+{ X86_ZMM31, X86_REG_ZMM31 },
+{ X86_R8B, X86_REG_R8B },
+{ X86_R9B, X86_REG_R9B },
+{ X86_R10B, X86_REG_R10B },
+{ X86_R11B, X86_REG_R11B },
+{ X86_R12B, X86_REG_R12B },
+{ X86_R13B, X86_REG_R13B },
+{ X86_R14B, X86_REG_R14B },
+{ X86_R15B, X86_REG_R15B },
+{ X86_R8BH, 0 },
+{ X86_R9BH, 0 },
+{ X86_R10BH, 0 },
+{ X86_R11BH, 0 },
+{ X86_R12BH, 0 },
+{ X86_R13BH, 0 },
+{ X86_R14BH, 0 },
+{ X86_R15BH, 0 },
+{ X86_R8D, X86_REG_R8D },
+{ X86_R9D, X86_REG_R9D },
+{ X86_R10D, X86_REG_R10D },
+{ X86_R11D, X86_REG_R11D },
+{ X86_R12D, X86_REG_R12D },
+{ X86_R13D, X86_REG_R13D },
+{ X86_R14D, X86_REG_R14D },
+{ X86_R15D, X86_REG_R15D },
+{ X86_R8W, X86_REG_R8W },
+{ X86_R9W, X86_REG_R9W },
+{ X86_R10W, X86_REG_R10W },
+{ X86_R11W, X86_REG_R11W },
+{ X86_R12W, X86_REG_R12W },
+{ X86_R13W, X86_REG_R13W },
+{ X86_R14W, X86_REG_R14W },
+{ X86_R15W, X86_REG_R15W },
+{ X86_R8WH, 0 },
+{ X86_R9WH, 0 },
+{ X86_R10WH, 0 },
+{ X86_R11WH, 0 },
+{ X86_R12WH, 0 },
+{ X86_R13WH, 0 },
+{ X86_R14WH, 0 },
+{ X86_R15WH, 0 },

thirdparty/capstone/arch/X86/X86Module.c

@@ -0,0 +1,94 @@
+/* Capstone Disassembly Engine */
+/* By Dang Hoang Vu <danghvu@gmail.com> 2013 */
+
+#ifdef CAPSTONE_HAS_X86
+
+#include "../../cs_priv.h"
+#include "../../MCRegisterInfo.h"
+#include "X86Disassembler.h"
+#include "X86InstPrinter.h"
+#include "X86Mapping.h"
+#include "X86Module.h"
+
+cs_err X86_global_init(cs_struct *ud)
+{
+	MCRegisterInfo *mri;
+	mri = cs_mem_malloc(sizeof(*mri));
+
+	X86_init(mri);
+
+	// by default, we use Intel syntax
+	ud->printer = X86_Intel_printInst;
+	ud->syntax = CS_OPT_SYNTAX_INTEL;
+	ud->printer_info = mri;
+	ud->disasm = X86_getInstruction;
+	ud->reg_name = X86_reg_name;
+	ud->insn_id = X86_get_insn_id;
+	ud->insn_name = X86_insn_name;
+	ud->group_name = X86_group_name;
+	ud->post_printer = X86_postprinter;
+#ifndef CAPSTONE_DIET
+	ud->reg_access = X86_reg_access;
+#endif
+
+	if (ud->mode == CS_MODE_64)
+		ud->regsize_map = regsize_map_64;
+	else
+		ud->regsize_map = regsize_map_32;
+
+	return CS_ERR_OK;
+}
+
+cs_err X86_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+	switch(type) {
+		default:
+			break;
+		case CS_OPT_MODE:
+			if (value == CS_MODE_64)
+				handle->regsize_map = regsize_map_64;
+			else
+				handle->regsize_map = regsize_map_32;
+
+			handle->mode = (cs_mode)value;
+			break;
+		case CS_OPT_SYNTAX:
+			switch(value) {
+				default:
+					// wrong syntax value
+					handle->errnum = CS_ERR_OPTION;
+					return CS_ERR_OPTION;
+
+				case CS_OPT_SYNTAX_DEFAULT:
+				case CS_OPT_SYNTAX_INTEL:
+					handle->syntax = CS_OPT_SYNTAX_INTEL;
+					handle->printer = X86_Intel_printInst;
+					break;
+
+				case CS_OPT_SYNTAX_MASM:
+					handle->printer = X86_Intel_printInst;
+					handle->syntax = (int)value;
+					break;
+
+				case CS_OPT_SYNTAX_ATT:
+#if !defined(CAPSTONE_DIET) && !defined(CAPSTONE_X86_ATT_DISABLE)
+					handle->printer = X86_ATT_printInst;
+					handle->syntax = CS_OPT_SYNTAX_ATT;
+					break;
+#elif !defined(CAPSTONE_DIET) && defined(CAPSTONE_X86_ATT_DISABLE)
+					// ATT syntax is unsupported
+					handle->errnum = CS_ERR_X86_ATT;
+					return CS_ERR_X86_ATT;
+#else	// CAPSTONE_DIET
+					// this is irrelevant in CAPSTONE_DIET mode
+					handle->errnum = CS_ERR_DIET;
+					return CS_ERR_DIET;
+#endif
+			}
+			break;
+	}
+
+	return CS_ERR_OK;
+}
+
+#endif

thirdparty/capstone/arch/X86/X86Module.h

@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Travis Finkenauer <tmfinken@gmail.com>, 2018 */
+
+#ifndef CS_X86_MODULE_H
+#define CS_X86_MODULE_H
+
+#include "../../utils.h"
+
+cs_err X86_global_init(cs_struct *ud);
+cs_err X86_option(cs_struct *handle, cs_opt_type type, size_t value);
+
+#endif

thirdparty/capstone/bindings/vb6/Project1.vbp

@@ -0,0 +1,46 @@
+Type=Exe
+Reference=*\G{00020430-0000-0000-C000-000000000046}#2.0#0#C:\Windows\SysWOW64\stdole2.tlb#OLE Automation
+Form=Form1.frm
+Module=mCapStone; Module1.bas
+Module=mx86; mx86.bas
+Module=mMisc; mMisc.bas
+Class=CInstruction; CInstruction.cls
+Class=CInstDetails; CInstDetails.cls
+Class=CDisassembler; CDisassembler.cls
+Object={831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0; MSCOMCTL.OCX
+Class=CX86Inst; CX86Inst.cls
+Class=CX86Operand; CX86Operand.cls
+Class=CX86OpMem; CX86OpMem.cls
+Startup="Form1"
+ExeName32="Project1.exe"
+Command32=""
+Name="Project1"
+HelpContextID="0"
+CompatibleMode="0"
+MajorVer=1
+MinorVer=0
+RevisionVer=0
+AutoIncrementVer=0
+ServerSupportFiles=0
+VersionCompanyName="sandsprite"
+CompilationType=0
+OptimizationType=0
+FavorPentiumPro(tm)=0
+CodeViewDebugInfo=0
+NoAliasing=0
+BoundsCheck=0
+OverflowCheck=0
+FlPointCheck=0
+FDIVCheck=0
+UnroundedFP=0
+StartMode=0
+Unattended=0
+Retained=0
+ThreadPerObject=0
+MaxNumberOfThreads=1
+
+[MS Transaction Server]
+AutoRefresh=1
+
+[fastBuild]
+fullPath=%ap%\bin\demo.exe

thirdparty/capstone/bindings/vb6/Project1.vbw

@@ -0,0 +1,10 @@
+Form1 = 110, 110, 1233, 906, , 88, 88, 1116, 749, C
+mCapStone = 22, 22, 1050, 683, 
+mx86 = 88, 88, 1040, 757, 
+mMisc = 66, 66, 1094, 727, 
+CInstruction = 182, 182, 1070, 558, 
+CInstDetails = 132, 132, 1084, 801, 
+CDisassembler = 44, 44, 1229, 809, 
+CX86Inst = 154, 154, 1106, 823, 
+CX86Operand = 176, 176, 1128, 845, 
+CX86OpMem = 198, 198, 1150, 867, 

thirdparty/capstone/suite/MC/ARM/arm-aliases.s.cs

@@ -0,0 +1,7 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x03,0x10,0x82,0xe0 = add r1, r2, r3
+0x03,0x10,0x42,0xe0 = sub r1, r2, r3
+0x03,0x10,0x22,0xe0 = eor r1, r2, r3
+0x03,0x10,0x82,0xe1 = orr r1, r2, r3
+0x03,0x10,0x02,0xe0 = and r1, r2, r3
+0x03,0x10,0xc2,0xe1 = bic r1, r2, r3

thirdparty/capstone/suite/MC/ARM/arm-arithmetic-aliases.s.cs

@@ -0,0 +1,50 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x06,0x20,0x42,0xe2 = sub r2, r2, #6
+0x06,0x20,0x42,0xe2 = sub r2, r2, #6
+0x03,0x20,0x42,0xe0 = sub r2, r2, r3
+0x03,0x20,0x42,0xe0 = sub r2, r2, r3
+0x06,0x20,0x82,0xe2 = add r2, r2, #6
+0x06,0x20,0x82,0xe2 = add r2, r2, #6
+0x03,0x20,0x82,0xe0 = add r2, r2, r3
+0x03,0x20,0x82,0xe0 = add r2, r2, r3
+0x06,0x20,0x02,0xe2 = and r2, r2, #6
+0x06,0x20,0x02,0xe2 = and r2, r2, #6
+0x03,0x20,0x02,0xe0 = and r2, r2, r3
+0x03,0x20,0x02,0xe0 = and r2, r2, r3
+0x06,0x20,0x82,0xe3 = orr r2, r2, #6
+0x06,0x20,0x82,0xe3 = orr r2, r2, #6
+0x03,0x20,0x82,0xe1 = orr r2, r2, r3
+0x03,0x20,0x82,0xe1 = orr r2, r2, r3
+0x06,0x20,0x22,0xe2 = eor r2, r2, #6
+0x06,0x20,0x22,0xe2 = eor r2, r2, #6
+0x03,0x20,0x22,0xe0 = eor r2, r2, r3
+0x03,0x20,0x22,0xe0 = eor r2, r2, r3
+0x06,0x20,0xc2,0xe3 = bic r2, r2, #6
+0x06,0x20,0xc2,0xe3 = bic r2, r2, #6
+0x03,0x20,0xc2,0xe1 = bic r2, r2, r3
+0x03,0x20,0xc2,0xe1 = bic r2, r2, r3
+0x06,0x20,0x52,0x02 = subseq r2, r2, #6
+0x06,0x20,0x52,0x02 = subseq r2, r2, #6
+0x03,0x20,0x52,0x00 = subseq r2, r2, r3
+0x03,0x20,0x52,0x00 = subseq r2, r2, r3
+0x06,0x20,0x92,0x02 = addseq r2, r2, #6
+0x06,0x20,0x92,0x02 = addseq r2, r2, #6
+0x03,0x20,0x92,0x00 = addseq r2, r2, r3
+0x03,0x20,0x92,0x00 = addseq r2, r2, r3
+0x06,0x20,0x12,0x02 = andseq r2, r2, #6
+0x06,0x20,0x12,0x02 = andseq r2, r2, #6
+0x03,0x20,0x12,0x00 = andseq r2, r2, r3
+0x03,0x20,0x12,0x00 = andseq r2, r2, r3
+0x06,0x20,0x92,0x03 = orrseq r2, r2, #6
+0x06,0x20,0x92,0x03 = orrseq r2, r2, #6
+0x03,0x20,0x92,0x01 = orrseq r2, r2, r3
+0x03,0x20,0x92,0x01 = orrseq r2, r2, r3
+0x06,0x20,0x32,0x02 = eorseq r2, r2, #6
+0x06,0x20,0x32,0x02 = eorseq r2, r2, #6
+0x03,0x20,0x32,0x00 = eorseq r2, r2, r3
+0x03,0x20,0x32,0x00 = eorseq r2, r2, r3
+0x06,0x20,0xd2,0x03 = bicseq r2, r2, #6
+0x06,0x20,0xd2,0x03 = bicseq r2, r2, #6
+0x03,0x20,0xd2,0x01 = bicseq r2, r2, r3
+0x03,0x20,0xd2,0x01 = bicseq r2, r2, r3
+0x7b,0x00,0x8f,0xe2 = add r0, pc, #0x7b

thirdparty/capstone/suite/MC/ARM/arm-branches.s.cs

@@ -0,0 +1,6 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x01,0x00,0x00,0xea = b #4
+0x01,0x00,0x00,0xeb = bl #4
+0x01,0x00,0x00,0x0a = beq #4
+0x00,0x00,0x00,0xfb = blx #2
+0x01,0x00,0x00,0xea = b #4

thirdparty/capstone/suite/MC/ARM/arm-it-block.s.cs

@@ -0,0 +1,2 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x03,0x20,0xa0,0x01 = moveq r2, r3

thirdparty/capstone/suite/MC/ARM/arm-memory-instructions.s.cs

@@ -0,0 +1,143 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x00,0x50,0x97,0xe5 = ldr r5, [r7]
+0x3f,0x60,0x93,0xe5 = ldr r6, [r3, #0x3f]
+0xff,0x2f,0xb4,0xe5 = ldr r2, [r4, #0xfff]!
+0x1e,0x10,0x92,0xe4 = ldr r1, [r2], #0x1e
+0x1e,0x30,0x11,0xe4 = ldr r3, [r1], #-0x1e
+0x00,0x90,0x12,0xe4 = ldr r9, [r2], #-0
+0x01,0x30,0x98,0xe7 = ldr r3, [r8, r1]
+0x03,0x20,0x15,0xe7 = ldr r2, [r5, -r3]
+0x09,0x10,0xb5,0xe7 = ldr r1, [r5, r9]!
+0x08,0x60,0x37,0xe7 = ldr r6, [r7, -r8]!
+0xa2,0x11,0xb0,0xe7 = ldr r1, [r0, r2, lsr #3]!
+0x02,0x50,0x99,0xe6 = ldr r5, [r9], r2
+0x06,0x40,0x13,0xe6 = ldr r4, [r3], -r6
+0x82,0x37,0x18,0xe7 = ldr r3, [r8, -r2, lsl #0xf]
+0xc3,0x17,0x95,0xe6 = ldr r1, [r5], r3, asr #0xf
+0x00,0x30,0xd8,0xe5 = ldrb r3, [r8]
+0x3f,0x10,0xdd,0xe5 = ldrb r1, [sp, #0x3f]
+0xff,0x9f,0xf3,0xe5 = ldrb r9, [r3, #0xfff]!
+0x16,0x80,0xd1,0xe4 = ldrb r8, [r1], #0x16
+0x13,0x20,0x57,0xe4 = ldrb r2, [r7], #-0x13
+0x05,0x90,0xd8,0xe7 = ldrb r9, [r8, r5]
+0x01,0x10,0x55,0xe7 = ldrb r1, [r5, -r1]
+0x02,0x30,0xf5,0xe7 = ldrb r3, [r5, r2]!
+0x03,0x60,0x79,0xe7 = ldrb r6, [r9, -r3]!
+0x04,0x20,0xd1,0xe6 = ldrb r2, [r1], r4
+0x05,0x80,0x54,0xe6 = ldrb r8, [r4], -r5
+0x81,0x77,0x5c,0xe7 = ldrb r7, [r12, -r1, lsl #0xf]
+0xc9,0x57,0xd2,0xe6 = ldrb r5, [r2], r9, asr #0xf
+0x04,0x30,0xf1,0xe4 = ldrbt r3, [r1], #4
+0x08,0x20,0x78,0xe4 = ldrbt r2, [r8], #-8
+0x06,0x80,0xf7,0xe6 = ldrbt r8, [r7], r6
+0x06,0x16,0x72,0xe6 = ldrbt r1, [r2], -r6, lsl #0xc
+0xd0,0x20,0xc5,0xe1 = ldrd r2, r3, [r5]
+0xdf,0x60,0xc2,0xe1 = ldrd r6, r7, [r2, #0xf]
+0xd0,0x02,0xe9,0xe1 = ldrd r0, r1, [r9, #0x20]!
+0xd8,0x60,0xc1,0xe0 = ldrd r6, r7, [r1], #8
+0xd0,0x00,0xc8,0xe0 = ldrd r0, r1, [r8], #0
+0xd0,0x00,0xc8,0xe0 = ldrd r0, r1, [r8], #0
+0xd0,0x00,0x48,0xe0 = ldrd r0, r1, [r8], #-0
+0xd3,0x40,0x81,0xe1 = ldrd r4, r5, [r1, r3]
+0xd2,0x40,0xa7,0xe1 = ldrd r4, r5, [r7, r2]!
+0xdc,0x00,0x88,0xe0 = ldrd r0, r1, [r8], r12
+0xdc,0x00,0x08,0xe0 = ldrd r0, r1, [r8], -r12
+0xb0,0x30,0xd4,0xe1 = ldrh r3, [r4]
+0xb4,0x20,0xd7,0xe1 = ldrh r2, [r7, #4]
+0xb0,0x14,0xf8,0xe1 = ldrh r1, [r8, #0x40]!
+0xb4,0xc0,0xdd,0xe0 = ldrh r12, [sp], #4
+0xb4,0x60,0x95,0xe1 = ldrh r6, [r5, r4]
+0xbb,0x30,0xb8,0xe1 = ldrh r3, [r8, r11]!
+0xb1,0x10,0x32,0xe1 = ldrh r1, [r2, -r1]!
+0xb2,0x90,0x97,0xe0 = ldrh r9, [r7], r2
+0xb2,0x40,0x13,0xe0 = ldrh r4, [r3], -r2
+0xb0,0x98,0xf7,0xe0 = ldrht r9, [r7], #0x80
+0xbb,0x44,0x73,0xe0 = ldrht r4, [r3], #-0x4b
+0xb0,0x40,0xf3,0xe0 = ldrht r4, [r3], #0
+0xb2,0x90,0xb7,0xe0 = ldrht r9, [r7], r2
+0xb2,0x40,0x33,0xe0 = ldrht r4, [r3], -r2
+0xd0,0x30,0xd4,0xe1 = ldrsb r3, [r4]
+0xd1,0x21,0xd7,0xe1 = ldrsb r2, [r7, #0x11]
+0xdf,0x1f,0xf8,0xe1 = ldrsb r1, [r8, #0xff]!
+0xd9,0xc0,0xdd,0xe0 = ldrsb r12, [sp], #0x9
+0xd4,0x60,0x95,0xe1 = ldrsb r6, [r5, r4]
+0xdb,0x30,0xb8,0xe1 = ldrsb r3, [r8, r11]!
+0xd1,0x10,0x32,0xe1 = ldrsb r1, [r2, -r1]!
+0xd2,0x90,0x97,0xe0 = ldrsb r9, [r7], r2
+0xd2,0x40,0x13,0xe0 = ldrsb r4, [r3], -r2
+0xd1,0x50,0xf6,0xe0 = ldrsbt r5, [r6], #1
+0xdc,0x30,0x78,0xe0 = ldrsbt r3, [r8], #-0xc
+0xd0,0x50,0xf6,0xe0 = ldrsbt r5, [r6], #0
+0xd5,0x80,0xb9,0xe0 = ldrsbt r8, [r9], r5
+0xd4,0x20,0x31,0xe0 = ldrsbt r2, [r1], -r4
+0xf0,0x50,0xd9,0xe1 = ldrsh r5, [r9]
+0xf7,0x40,0xd5,0xe1 = ldrsh r4, [r5, #7]
+0xf7,0x33,0xf6,0xe1 = ldrsh r3, [r6, #0x37]!
+0xf9,0x20,0x57,0xe0 = ldrsh r2, [r7], #-0x9
+0xf5,0x30,0x91,0xe1 = ldrsh r3, [r1, r5]
+0xf1,0x40,0xb6,0xe1 = ldrsh r4, [r6, r1]!
+0xf6,0x50,0x33,0xe1 = ldrsh r5, [r3, -r6]!
+0xf8,0x60,0x99,0xe0 = ldrsh r6, [r9], r8
+0xf3,0x70,0x18,0xe0 = ldrsh r7, [r8], -r3
+0xf1,0x50,0xf6,0xe0 = ldrsht r5, [r6], #1
+0xfc,0x30,0x78,0xe0 = ldrsht r3, [r8], #-0xc
+0xf0,0x50,0xf6,0xe0 = ldrsht r5, [r6], #0
+0xf5,0x80,0xb9,0xe0 = ldrsht r8, [r9], r5
+0xf4,0x20,0x31,0xe0 = ldrsht r2, [r1], -r4
+0x00,0x80,0x8c,0xe5 = str r8, [r12]
+0x0c,0x70,0x81,0xe5 = str r7, [r1, #0xc]
+0x28,0x30,0xa5,0xe5 = str r3, [r5, #0x28]!
+0xff,0x9f,0x8d,0xe4 = str r9, [sp], #0xfff
+0x80,0x10,0x07,0xe4 = str r1, [r7], #-0x80
+0x00,0x10,0x00,0xe4 = str r1, [r0], #-0
+0x03,0x90,0x86,0xe7 = str r9, [r6, r3]
+0x02,0x80,0x00,0xe7 = str r8, [r0, -r2]
+0x06,0x70,0xa1,0xe7 = str r7, [r1, r6]!
+0x01,0x60,0x2d,0xe7 = str r6, [sp, -r1]!
+0x09,0x50,0x83,0xe6 = str r5, [r3], r9
+0x05,0x40,0x02,0xe6 = str r4, [r2], -r5
+0x02,0x31,0x04,0xe7 = str r3, [r4, -r2, lsl #2]
+0x43,0x2c,0x87,0xe6 = str r2, [r7], r3, asr #0x18
+0x00,0x90,0xc2,0xe5 = strb r9, [r2]
+0x03,0x70,0xc1,0xe5 = strb r7, [r1, #3]
+0x95,0x61,0xe4,0xe5 = strb r6, [r4, #0x195]!
+0x48,0x50,0xc7,0xe4 = strb r5, [r7], #0x48
+0x01,0x10,0x4d,0xe4 = strb r1, [sp], #-1
+0x09,0x10,0xc2,0xe7 = strb r1, [r2, r9]
+0x08,0x20,0x43,0xe7 = strb r2, [r3, -r8]
+0x07,0x30,0xe4,0xe7 = strb r3, [r4, r7]!
+0x06,0x40,0x65,0xe7 = strb r4, [r5, -r6]!
+0x05,0x50,0xc6,0xe6 = strb r5, [r6], r5
+0x04,0x60,0x42,0xe6 = strb r6, [r2], -r4
+0x83,0x72,0x4c,0xe7 = strb r7, [r12, -r3, lsl #5]
+0x42,0xd6,0xc7,0xe6 = strb sp, [r7], r2, asr #0xc
+0x0c,0x60,0xe2,0xe4 = strbt r6, [r2], #0xc
+0x0d,0x50,0x66,0xe4 = strbt r5, [r6], #-0xd
+0x05,0x40,0xe9,0xe6 = strbt r4, [r9], r5
+0x82,0x31,0x68,0xe6 = strbt r3, [r8], -r2, lsl #3
+0xf0,0x20,0xc4,0xe1 = strd r2, r3, [r4]
+0xf1,0x20,0xc6,0xe1 = strd r2, r3, [r6, #1]
+0xf6,0x01,0xe7,0xe1 = strd r0, r1, [r7, #0x16]!
+0xf7,0x40,0xc8,0xe0 = strd r4, r5, [r8], #7
+0xf0,0x40,0xcd,0xe0 = strd r4, r5, [sp], #0
+0xf0,0x60,0xce,0xe0 = strd r6, r7, [lr], #0
+0xf0,0xa0,0x49,0xe0 = strd r10, r11, [r9], #-0
+0xf1,0x80,0x84,0xe1 = strd r8, r9, [r4, r1]
+0xf9,0x60,0xa3,0xe1 = strd r6, r7, [r3, r9]!
+0xf8,0x60,0x85,0xe0 = strd r6, r7, [r5], r8
+0xfa,0x40,0x0c,0xe0 = strd r4, r5, [r12], -r10
+0xb0,0x30,0xc4,0xe1 = strh r3, [r4]
+0xb4,0x20,0xc7,0xe1 = strh r2, [r7, #4]
+0xb0,0x14,0xe8,0xe1 = strh r1, [r8, #0x40]!
+0xb4,0xc0,0xcd,0xe0 = strh r12, [sp], #4
+0xb4,0x60,0x85,0xe1 = strh r6, [r5, r4]
+0xbb,0x30,0xa8,0xe1 = strh r3, [r8, r11]!
+0xb1,0x10,0x22,0xe1 = strh r1, [r2, -r1]!
+0xb2,0x90,0x87,0xe0 = strh r9, [r7], r2
+0xb2,0x40,0x03,0xe0 = strh r4, [r3], -r2
+0xbc,0x24,0xe5,0xe0 = strht r2, [r5], #0x4c
+0xb9,0x81,0x61,0xe0 = strht r8, [r1], #-0x19
+0xb4,0x50,0xa3,0xe0 = strht r5, [r3], r4
+0xb0,0x60,0x28,0xe0 = strht r6, [r8], -r0
+0xd0,0x00,0xcd,0xe1 = ldrd r0, r1, [sp]
+0xf0,0x00,0xcd,0xe1 = strd r0, r1, [sp]

thirdparty/capstone/suite/MC/ARM/arm-shift-encoding.s.cs

@@ -0,0 +1,50 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x00,0x00,0x90,0xe7 = ldr r0, [r0, r0]
+0x20,0x00,0x90,0xe7 = ldr r0, [r0, r0, lsr #0x20]
+0x20,0x08,0x90,0xe7 = ldr r0, [r0, r0, lsr #0x10]
+0x00,0x00,0x90,0xe7 = ldr r0, [r0, r0]
+0x00,0x08,0x90,0xe7 = ldr r0, [r0, r0, lsl #0x10]
+0x40,0x00,0x90,0xe7 = ldr r0, [r0, r0, asr #0x20]
+0x40,0x08,0x90,0xe7 = ldr r0, [r0, r0, asr #0x10]
+0x60,0x00,0x90,0xe7 = ldr r0, [r0, r0, rrx]
+0x60,0x08,0x90,0xe7 = ldr r0, [r0, r0, ror #0x10]
+0x00,0xf0,0xd0,0xf7 = pld [r0, r0]
+0x20,0xf0,0xd0,0xf7 = pld [r0, r0, lsr #0x20]
+0x20,0xf8,0xd0,0xf7 = pld [r0, r0, lsr #0x10]
+0x00,0xf0,0xd0,0xf7 = pld [r0, r0]
+0x00,0xf8,0xd0,0xf7 = pld [r0, r0, lsl #0x10]
+0x40,0xf0,0xd0,0xf7 = pld [r0, r0, asr #0x20]
+0x40,0xf8,0xd0,0xf7 = pld [r0, r0, asr #0x10]
+0x60,0xf0,0xd0,0xf7 = pld [r0, r0, rrx]
+0x60,0xf8,0xd0,0xf7 = pld [r0, r0, ror #0x10]
+0x00,0x00,0x80,0xe7 = str r0, [r0, r0]
+0x20,0x00,0x80,0xe7 = str r0, [r0, r0, lsr #0x20]
+0x20,0x08,0x80,0xe7 = str r0, [r0, r0, lsr #0x10]
+0x00,0x00,0x80,0xe7 = str r0, [r0, r0]
+0x00,0x08,0x80,0xe7 = str r0, [r0, r0, lsl #0x10]
+0x40,0x00,0x80,0xe7 = str r0, [r0, r0, asr #0x20]
+0x40,0x08,0x80,0xe7 = str r0, [r0, r0, asr #0x10]
+0x60,0x00,0x80,0xe7 = str r0, [r0, r0, rrx]
+0x60,0x08,0x80,0xe7 = str r0, [r0, r0, ror #0x10]
+0x62,0x00,0x91,0xe6 = ldr r0, [r1], r2, rrx
+0x05,0x30,0x94,0xe6 = ldr r3, [r4], r5
+0x08,0x60,0x87,0xe6 = str r6, [r7], r8
+0x0b,0x90,0x8a,0xe6 = str r9, [r10], r11
+0x0f,0xd0,0xae,0xe0 = adc sp, lr, pc
+0x29,0x10,0xa8,0xe0 = adc r1, r8, r9, lsr #0x20
+0x2f,0x28,0xa7,0xe0 = adc r2, r7, pc, lsr #0x10
+0x0a,0x30,0xa6,0xe0 = adc r3, r6, r10
+0x0e,0x48,0xa5,0xe0 = adc r4, r5, lr, lsl #0x10
+0x4b,0x50,0xa4,0xe0 = adc r5, r4, r11, asr #0x20
+0x4d,0x68,0xa3,0xe0 = adc r6, r3, sp, asr #0x10
+0x6c,0x70,0xa2,0xe0 = adc r7, r2, r12, rrx
+0x60,0x88,0xa1,0xe0 = adc r8, r1, r0, ror #0x10
+0x0e,0x00,0x5d,0xe1 = cmp sp, lr
+0x28,0x00,0x51,0xe1 = cmp r1, r8, lsr #0x20
+0x27,0x08,0x52,0xe1 = cmp r2, r7, lsr #0x10
+0x06,0x00,0x53,0xe1 = cmp r3, r6
+0x05,0x08,0x54,0xe1 = cmp r4, r5, lsl #0x10
+0x44,0x00,0x55,0xe1 = cmp r5, r4, asr #0x20
+0x43,0x08,0x56,0xe1 = cmp r6, r3, asr #0x10
+0x62,0x00,0x57,0xe1 = cmp r7, r2, rrx
+0x61,0x08,0x58,0xe1 = cmp r8, r1, ror #0x10

thirdparty/capstone/suite/MC/ARM/arm-thumb-trustzone.s.cs

@@ -0,0 +1,3 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0xff,0xf7,0x00,0x80 = smc #15
+0x0c,0xbf = ite eq

thirdparty/capstone/suite/MC/ARM/arm-trustzone.s.cs

@@ -0,0 +1,3 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x7f,0x00,0x60,0xe1 = smc #15
+0x70,0x00,0x60,0x01 = smceq #0

thirdparty/capstone/suite/MC/ARM/arm_addrmode2.s.cs

@@ -0,0 +1,19 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x02,0x10,0xb0,0xe6 = ldrt r1, [r0], r2
+0xa2,0x11,0xb0,0xe6 = ldrt r1, [r0], r2, lsr #3
+0x04,0x10,0xb0,0xe4 = ldrt r1, [r0], #4
+0x00,0x10,0xb0,0xe4 = ldrt r1, [r0], #0
+0x02,0x10,0xf0,0xe6 = ldrbt r1, [r0], r2
+0xa2,0x11,0xf0,0xe6 = ldrbt r1, [r0], r2, lsr #3
+0x04,0x10,0xf0,0xe4 = ldrbt r1, [r0], #4
+0x00,0x10,0xf0,0xe4 = ldrbt r1, [r0], #0
+0x02,0x10,0xa0,0xe6 = strt r1, [r0], r2
+0xa2,0x11,0xa0,0xe6 = strt r1, [r0], r2, lsr #3
+0x04,0x10,0xa0,0xe4 = strt r1, [r0], #4
+0x00,0x10,0xa0,0xe4 = strt r1, [r0], #0
+0x02,0x10,0xe0,0xe6 = strbt r1, [r0], r2
+0xa2,0x11,0xe0,0xe6 = strbt r1, [r0], r2, lsr #3
+0x04,0x10,0xe0,0xe4 = strbt r1, [r0], #4
+0x00,0x10,0xe0,0xe4 = strbt r1, [r0], #0
+0xa2,0x11,0xb0,0xe7 = ldr r1, [r0, r2, lsr #3]!
+0xa2,0x11,0xf0,0xe7 = ldrb r1, [r0, r2, lsr #3]!

thirdparty/capstone/suite/MC/ARM/arm_addrmode3.s.cs

@@ -0,0 +1,9 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0xd2,0x10,0xb0,0xe0 = ldrsbt r1, [r0], r2
+0xd4,0x10,0xf0,0xe0 = ldrsbt r1, [r0], #4
+0xf2,0x10,0xb0,0xe0 = ldrsht r1, [r0], r2
+0xf4,0x10,0xf0,0xe0 = ldrsht r1, [r0], #4
+0xb2,0x10,0xb0,0xe0 = ldrht r1, [r0], r2
+0xb4,0x10,0xf0,0xe0 = ldrht r1, [r0], #4
+0xb2,0x10,0xa0,0xe0 = strht r1, [r0], r2
+0xb4,0x10,0xe0,0xe0 = strht r1, [r0], #4

thirdparty/capstone/suite/MC/ARM/arm_instructions.s.cs

@@ -0,0 +1,23 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x03,0x10,0x02,0xe0 = and r1, r2, r3
+0x03,0x10,0x12,0xe0 = ands r1, r2, r3
+0x03,0x10,0x22,0xe0 = eor r1, r2, r3
+0x03,0x10,0x32,0xe0 = eors r1, r2, r3
+0x03,0x10,0x42,0xe0 = sub r1, r2, r3
+0x03,0x10,0x52,0xe0 = subs r1, r2, r3
+0x03,0x10,0x82,0xe0 = add r1, r2, r3
+0x03,0x10,0x92,0xe0 = adds r1, r2, r3
+0x03,0x10,0xa2,0xe0 = adc r1, r2, r3
+0x03,0x10,0xc2,0xe1 = bic r1, r2, r3
+0x03,0x10,0xd2,0xe1 = bics r1, r2, r3
+0x02,0x10,0xa0,0xe1 = mov r1, r2
+0x02,0x10,0xe0,0xe1 = mvn r1, r2
+0x02,0x10,0xf0,0xe1 = mvns r1, r2
+0x90,0x02,0xcb,0xe7 = bfi r0, r0, #5, #7
+0x7a,0x00,0x20,0xe1 = bkpt #0xa
+0x81,0x17,0x11,0xee = cdp p7, #1, c1, c1, c1, #4
+0x81,0x17,0x11,0xfe = cdp2 p7, #1, c1, c1, c1, #4
+0x13,0x14,0x82,0xe0 = add r1, r2, r3, lsl r4
+0x30,0x0f,0xa6,0xe6 = ssat16 r0, #7, r0
+0x00,0x00,0x0a,0xf1 = cpsie none, #0
+0xb0,0x30,0x42,0xe1 = strh r3, [r2, #-0]

thirdparty/capstone/suite/MC/ARM/armv8.1m-pacbti.s.cs

@@ -0,0 +1,6 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0xaf,0xf3,0x2d,0x80 = aut r12, lr, sp
+0xaf,0xf3,0x0f,0x80 = bti
+0xaf,0xf3,0x0f,0x80 = bti
+0xaf,0xf3,0x1d,0x80 = pac r12, lr, sp
+0xaf,0xf3,0x0d,0x80 = pacbti r12, lr, sp

thirdparty/capstone/suite/MC/ARM/armv8.2a-dotprod-a32.s.cs

@@ -0,0 +1,9 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x12,0x0d,0x21,0xfc = vudot.u8 d0, d1, d2
+0x02,0x0d,0x21,0xfc = vsdot.s8 d0, d1, d2
+0x58,0x0d,0x22,0xfc = vudot.u8 q0, q1, q4
+0x48,0x0d,0x22,0xfc = vsdot.s8 q0, q1, q4
+0x12,0x0d,0x21,0xfe = vudot.u8 d0, d1, d2[0]
+0x22,0x0d,0x21,0xfe = vsdot.s8 d0, d1, d2[1]
+0x54,0x0d,0x22,0xfe = vudot.u8 q0, q1, d4[0]
+0x64,0x0d,0x22,0xfe = vsdot.s8 q0, q1, d4[1]

thirdparty/capstone/suite/MC/ARM/armv8.2a-dotprod-t32.s.cs

@@ -0,0 +1,9 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0x21,0xfc,0x12,0x0d = vudot.u8 d0, d1, d2
+0x21,0xfc,0x02,0x0d = vsdot.s8 d0, d1, d2
+0x22,0xfc,0x58,0x0d = vudot.u8 q0, q1, q4
+0x22,0xfc,0x48,0x0d = vsdot.s8 q0, q1, q4
+0x21,0xfe,0x12,0x0d = vudot.u8 d0, d1, d2[0]
+0x21,0xfe,0x22,0x0d = vsdot.s8 d0, d1, d2[1]
+0x22,0xfe,0x54,0x0d = vudot.u8 q0, q1, d4[0]
+0x22,0xfe,0x64,0x0d = vsdot.s8 q0, q1, d4[1]

thirdparty/capstone/suite/MC/ARM/armv8.5a-sb.s.cs

@@ -0,0 +1,2 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x70,0xf0,0x7f,0xf5 = sb

thirdparty/capstone/suite/MC/ARM/armv8a-fpmul.s.cs

@@ -0,0 +1,9 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x91,0x08,0x20,0xfc = vfmal.f16 d0, s1, s2
+0x91,0x08,0xa0,0xfc = vfmsl.f16 d0, s1, s2
+0x52,0x08,0x21,0xfc = vfmal.f16 q0, d1, d2
+0x52,0x08,0xa1,0xfc = vfmsl.f16 q0, d1, d2
+0x99,0x08,0x00,0xfe = vfmal.f16 d0, s1, s2[1]
+0x99,0x08,0x10,0xfe = vfmsl.f16 d0, s1, s2[1]
+0x7a,0x08,0x01,0xfe = vfmal.f16 q0, d1, d2[3]
+0x7a,0x08,0x11,0xfe = vfmsl.f16 q0, d1, d2[3]

thirdparty/capstone/suite/MC/ARM/basic-arm-instructions-v8.s.cs

@@ -0,0 +1,10 @@
+# CS_ARCH_ARM, CS_MODE_ARM+CS_MODE_V8, None
+0x59,0xf0,0x7f,0xf5 = dmb ishld
+0x51,0xf0,0x7f,0xf5 = dmb oshld
+0x55,0xf0,0x7f,0xf5 = dmb nshld
+0x5d,0xf0,0x7f,0xf5 = dmb ld
+0x49,0xf0,0x7f,0xf5 = dsb ishld
+0x41,0xf0,0x7f,0xf5 = dsb oshld
+0x45,0xf0,0x7f,0xf5 = dsb nshld
+0x4d,0xf0,0x7f,0xf5 = dsb ld
+0x05,0xf0,0x20,0xe3 = sevl 

thirdparty/capstone/suite/MC/ARM/basic-thumb-instructions.s.cs

@@ -0,0 +1,130 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0x74,0x41 = adcs r4, r6
+0xd1,0x1c = adds r1, r2, #3
+0x03,0x32 = adds r2, #3
+0x08,0x32 = adds r2, #8
+0xd1,0x18 = adds r1, r2, r3
+0x42,0x44 = add r2, r8
+0x01,0xb0 = add sp, #4
+0x7f,0xb0 = add sp, #0x1fc
+0x01,0xb0 = add sp, #4
+0x02,0xaa = add r2, sp, #8
+0xff,0xaa = add r2, sp, #0x3fc
+0x82,0xb0 = sub sp, #8
+0x82,0xb0 = sub sp, #8
+0x9d,0x44 = add sp, r3
+0x6a,0x44 = add r2, sp, r2
+0x00,0xa5 = adr r5, #0
+0x01,0xa2 = adr r2, #4
+0xff,0xa3 = adr r3, #0x3fc
+0x1a,0x10 = asrs r2, r3, #0x20
+0x5a,0x11 = asrs r2, r3, #5
+0x5a,0x10 = asrs r2, r3, #1
+0x6d,0x15 = asrs r5, r5, #0x15
+0x6d,0x15 = asrs r5, r5, #0x15
+0x6b,0x15 = asrs r3, r5, #0x15
+0x15,0x41 = asrs r5, r2
+0x97,0xe3 = b #0x72e
+0x2e,0xe7 = b #-0x1a4
+0x80,0xd0 = beq #-0x100
+0x50,0xd0 = beq #0xa0
+0xd8,0xf0,0x20,0xe8 = blx #0xd8040
+0xb0,0xf1,0x40,0xe8 = blx #0x1b0080
+0xb1,0x43 = bics r1, r6
+0x00,0xbe = bkpt #0
+0xff,0xbe = bkpt #0xff
+0xa0,0x47 = blx r4
+0x10,0x47 = bx r2
+0xcd,0x42 = cmn r5, r1
+0x20,0x2e = cmp r6, #0x20
+0xa3,0x42 = cmp r3, r4
+0x88,0x45 = cmp r8, r1
+0x61,0xb6 = cpsie f
+0x74,0xb6 = cpsid a
+0x6c,0x40 = eors r4, r5
+0xff,0xcb = ldm r3, {r0, r1, r2, r3, r4, r5, r6, r7}
+0xba,0xca = ldm r2!, {r1, r3, r4, r5, r7}
+0x02,0xc9 = ldm r1, {r1}
+0x29,0x68 = ldr r1, [r5]
+0x32,0x6a = ldr r2, [r6, #0x20]
+0xfb,0x6f = ldr r3, [r7, #0x7c]
+0x00,0x99 = ldr r1, [sp]
+0x06,0x9a = ldr r2, [sp, #0x18]
+0xff,0x9b = ldr r3, [sp, #0x3fc]
+0x97,0x4b = ldr r3, [pc, #0x25c]
+0x5c,0x4b = ldr r3, [pc, #0x170]
+0xd1,0x58 = ldr r1, [r2, r3]
+0x1c,0x78 = ldrb r4, [r3]
+0x35,0x78 = ldrb r5, [r6]
+0xfe,0x7f = ldrb r6, [r7, #0x1f]
+0x66,0x5d = ldrb r6, [r4, r5]
+0x1b,0x88 = ldrh r3, [r3]
+0x74,0x88 = ldrh r4, [r6, #2]
+0xfd,0x8f = ldrh r5, [r7, #0x3e]
+0x96,0x5b = ldrh r6, [r2, r6]
+0x96,0x57 = ldrsb r6, [r2, r6]
+0x7b,0x5e = ldrsh r3, [r7, r1]
+0x2c,0x00 = movs r4, r5
+0x2c,0x01 = lsls r4, r5, #4
+0x1b,0x03 = lsls r3, r3, #0xc
+0x1b,0x03 = lsls r3, r3, #0xc
+0x19,0x03 = lsls r1, r3, #0xc
+0xb2,0x40 = lsls r2, r6
+0x59,0x08 = lsrs r1, r3, #1
+0x19,0x08 = lsrs r1, r3, #0x20
+0x24,0x0d = lsrs r4, r4, #0x14
+0x24,0x0d = lsrs r4, r4, #0x14
+0x22,0x0d = lsrs r2, r4, #0x14
+0xf2,0x40 = lsrs r2, r6
+0x00,0x22 = movs r2, #0
+0xff,0x22 = movs r2, #0xff
+0x17,0x22 = movs r2, #0x17
+0x23,0x46 = mov r3, r4
+0x19,0x00 = movs r1, r3
+0x51,0x43 = muls r1, r2, r1
+0x5a,0x43 = muls r2, r3, r2
+0x63,0x43 = muls r3, r4, r3
+0xde,0x43 = mvns r6, r3
+0x63,0x42 = rsbs r3, r4, #0
+0x4c,0xbc = pop {r2, r3, r6}
+0x86,0xb4 = push {r1, r2, r7}
+0x1e,0xba = rev r6, r3
+0x57,0xba = rev16 r7, r2
+0xcd,0xba = revsh r5, r1
+0xfa,0x41 = rors r2, r7
+0x59,0x42 = rsbs r1, r3, #0
+0x9c,0x41 = sbcs r4, r3
+0x58,0xb6 = setend be
+0x50,0xb6 = setend le
+0x44,0xc1 = stm r1!, {r2, r6}
+0x8e,0xc1 = stm r1!, {r1, r2, r3, r7}
+0x3a,0x60 = str r2, [r7]
+0x3a,0x60 = str r2, [r7]
+0x4d,0x60 = str r5, [r1, #4]
+0xfb,0x67 = str r3, [r7, #0x7c]
+0x00,0x92 = str r2, [sp]
+0x00,0x93 = str r3, [sp]
+0x05,0x94 = str r4, [sp, #0x14]
+0xff,0x95 = str r5, [sp, #0x3fc]
+0xfa,0x50 = str r2, [r7, r3]
+0x1c,0x70 = strb r4, [r3]
+0x35,0x70 = strb r5, [r6]
+0xfe,0x77 = strb r6, [r7, #0x1f]
+0x66,0x55 = strb r6, [r4, r5]
+0x1b,0x80 = strh r3, [r3]
+0x74,0x80 = strh r4, [r6, #2]
+0xfd,0x87 = strh r5, [r7, #0x3e]
+0x96,0x53 = strh r6, [r2, r6]
+0xd1,0x1e = subs r1, r2, #3
+0x03,0x3a = subs r2, #3
+0x08,0x3a = subs r2, #8
+0x83,0xb0 = sub sp, #0xc
+0xff,0xb0 = sub sp, #0x1fc
+0xd1,0x1a = subs r1, r2, r3
+0x00,0xdf = svc #0
+0xff,0xdf = svc #0xff
+0x6b,0xb2 = sxtb r3, r5
+0x2b,0xb2 = sxth r3, r5
+0x0e,0x42 = tst r6, r1
+0xd7,0xb2 = uxtb r7, r2
+0xa1,0xb2 = uxth r1, r4

thirdparty/capstone/suite/MC/ARM/basic-thumb2-instructions-v8.s.cs

@@ -0,0 +1 @@
+# CS_ARCH_ARM, CS_MODE_THUMB+CS_MODE_V8, None

thirdparty/capstone/suite/MC/ARM/bfloat16-a32.s.cs

@@ -0,0 +1,2 @@
+# CS_ARCH_ARM, CS_MODE_ARM, None
+0x05,0x3d,0x04,0xfc = vdot.bf16 d3, d4, d5

thirdparty/capstone/suite/MC/ARM/bfloat16-t32.s.cs

@@ -0,0 +1,4 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0xb6,0xff,0x46,0x16 = vcvt.bf16.f32 d1, q3
+0x18,0xbf = it ne
+0xf3,0xee,0xe1,0x09 = vcvtt.bf16.f32  s1, s3

thirdparty/capstone/suite/MC/ARM/cde-integer.s.cs

@@ -0,0 +1,2 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0x06,0xbf = itte eq

thirdparty/capstone/suite/MC/ARM/cde-vec-pred.s.cs

@@ -0,0 +1,2 @@
+# CS_ARCH_ARM, CS_MODE_THUMB+CS_MODE_V8+CS_MODE_MCLASS, None
+0x41,0xfe,0x00,0xef = vptete.i8 eq, q0, q0

thirdparty/capstone/suite/MC/ARM/clrm-asm.s.cs

@@ -0,0 +1,7 @@
+# CS_ARCH_ARM, CS_MODE_THUMB+CS_MODE_V8, None
+0x9f,0xe8,0x0f,0x00 = clrm {r0, r1, r2, r3}
+0x9f,0xe8,0x1e,0x00 = clrm {r1, r2, r3, r4}
+0x9f,0xe8,0xff,0xdf = clrm {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, lr, apsr}
+0x9f,0xe8,0x00,0xc0 = clrm {lr, apsr}
+0x9f,0xe8,0x03,0x80 = clrm {r0, r1, apsr}
+0x9f,0xe8,0x1f,0xc0 = clrm {r0, r1, r2, r3, r4, lr, apsr}

thirdparty/capstone/suite/MC/ARM/cps.s.cs

@@ -0,0 +1,4 @@
+# CS_ARCH_ARM, CS_MODE_THUMB, None
+0x61,0xb6 = cpsie f
+0xaf,0xf3,0x43,0x85 = cpsie i, #3
+0xaf,0xf3,0x00,0x81 = cps #0

thirdparty/capstone/suite/MC/ARM/crc32-thumb.s.cs

@@ -0,0 +1,7 @@
+# CS_ARCH_ARM, CS_MODE_THUMB+CS_MODE_V8, None
+0xc1,0xfa,0x82,0xf0 = crc32b r0, r1, r2
+0xc1,0xfa,0x92,0xf0 = crc32h r0, r1, r2
+0xc1,0xfa,0xa2,0xf0 = crc32w r0, r1, r2
+0xd1,0xfa,0x82,0xf0 = crc32cb r0, r1, r2
+0xd1,0xfa,0x92,0xf0 = crc32ch r0, r1, r2
+0xd1,0xfa,0xa2,0xf0 = crc32cw r0, r1, r2