Initial Commit

thirdparty/capstone/arch/AArch64/AArch64AddressingModes.h

@@ -0,0 +1,999 @@
+/* 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: <commit> */
+/* LLVM-tag: <tag> */
+
+/* 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 */
+
+//===- AArch64AddressingModes.h - AArch64 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 AArch64 addressing mode implementation stuff.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64ADDRESSINGMODES_H
+#define LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64ADDRESSINGMODES_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <capstone/platform.h>
+
+#include "../../MathExtras.h"
+#include <assert.h>
+#include "../../MathExtras.h"
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+/// AArch64_AM - AArch64 Addressing Mode Stuff
+// CS namespace begin: AArch64_AM
+
+//===----------------------------------------------------------------------===//
+// Shifts
+//
+typedef enum ShiftExtendType {
+	AArch64_AM_InvalidShiftExtend = -1,
+	AArch64_AM_LSL = 0,
+	AArch64_AM_LSR,
+	AArch64_AM_ASR,
+	AArch64_AM_ROR,
+	AArch64_AM_MSL,
+
+	AArch64_AM_UXTB,
+	AArch64_AM_UXTH,
+	AArch64_AM_UXTW,
+	AArch64_AM_UXTX,
+
+	AArch64_AM_SXTB,
+	AArch64_AM_SXTH,
+	AArch64_AM_SXTW,
+	AArch64_AM_SXTX,
+} AArch64_AM_ShiftExtendType;
+
+/// getShiftName - Get the string encoding for the shift type.
+static inline const char *
+AArch64_AM_getShiftExtendName(AArch64_AM_ShiftExtendType ST)
+{
+	switch (ST) {
+	default:
+		assert(0 && "unhandled shift type!");
+	case AArch64_AM_LSL:
+		return "lsl";
+	case AArch64_AM_LSR:
+		return "lsr";
+	case AArch64_AM_ASR:
+		return "asr";
+	case AArch64_AM_ROR:
+		return "ror";
+	case AArch64_AM_MSL:
+		return "msl";
+	case AArch64_AM_UXTB:
+		return "uxtb";
+	case AArch64_AM_UXTH:
+		return "uxth";
+	case AArch64_AM_UXTW:
+		return "uxtw";
+	case AArch64_AM_UXTX:
+		return "uxtx";
+	case AArch64_AM_SXTB:
+		return "sxtb";
+	case AArch64_AM_SXTH:
+		return "sxth";
+	case AArch64_AM_SXTW:
+		return "sxtw";
+	case AArch64_AM_SXTX:
+		return "sxtx";
+	}
+	return NULL;
+}
+
+/// getShiftType - Extract the shift type.
+static inline AArch64_AM_ShiftExtendType AArch64_AM_getShiftType(unsigned Imm)
+{
+	switch ((Imm >> 6) & 0x7) {
+	default:
+		return AArch64_AM_InvalidShiftExtend;
+	case 0:
+		return AArch64_AM_LSL;
+	case 1:
+		return AArch64_AM_LSR;
+	case 2:
+		return AArch64_AM_ASR;
+	case 3:
+		return AArch64_AM_ROR;
+	case 4:
+		return AArch64_AM_MSL;
+	}
+}
+
+/// getShiftValue - Extract the shift value.
+static inline unsigned AArch64_AM_getShiftValue(unsigned Imm)
+{
+	return Imm & 0x3f;
+}
+
+/// getShifterImm - Encode the shift type and amount:
+///   imm:     6-bit shift amount
+///   shifter: 000 ==> lsl
+///            001 ==> lsr
+///            010 ==> asr
+///            011 ==> ror
+///            100 ==> msl
+///   {8-6}  = shifter
+///   {5-0}  = imm
+static inline unsigned AArch64_AM_getShifterImm(AArch64_AM_ShiftExtendType ST,
+						unsigned Imm)
+{
+	unsigned STEnc = 0;
+	switch (ST) {
+	default:
+		assert(0 && "Invalid shift requested");
+	case AArch64_AM_LSL:
+		STEnc = 0;
+		break;
+	case AArch64_AM_LSR:
+		STEnc = 1;
+		break;
+	case AArch64_AM_ASR:
+		STEnc = 2;
+		break;
+	case AArch64_AM_ROR:
+		STEnc = 3;
+		break;
+	case AArch64_AM_MSL:
+		STEnc = 4;
+		break;
+	}
+	return (STEnc << 6) | (Imm & 0x3f);
+}
+
+//===----------------------------------------------------------------------===//
+// Extends
+//
+/// getArithShiftValue - get the arithmetic shift value.
+static inline unsigned AArch64_AM_getArithShiftValue(unsigned Imm)
+{
+	return Imm & 0x7;
+}
+
+/// getExtendType - Extract the extend type for operands of arithmetic ops.
+static inline AArch64_AM_ShiftExtendType AArch64_AM_getExtendType(unsigned Imm)
+{
+	switch (Imm) {
+	default:
+		assert(0 && "Compiler bug!");
+	case 0:
+		return AArch64_AM_UXTB;
+	case 1:
+		return AArch64_AM_UXTH;
+	case 2:
+		return AArch64_AM_UXTW;
+	case 3:
+		return AArch64_AM_UXTX;
+	case 4:
+		return AArch64_AM_SXTB;
+	case 5:
+		return AArch64_AM_SXTH;
+	case 6:
+		return AArch64_AM_SXTW;
+	case 7:
+		return AArch64_AM_SXTX;
+	}
+}
+
+static inline AArch64_AM_ShiftExtendType
+AArch64_AM_getArithExtendType(unsigned Imm)
+{
+	return AArch64_AM_getExtendType((Imm >> 3) & 0x7);
+}
+
+/// Mapping from extend bits to required operation:
+///   shifter: 000 ==> uxtb
+///            001 ==> uxth
+///            010 ==> uxtw
+///            011 ==> uxtx
+///            100 ==> sxtb
+///            101 ==> sxth
+///            110 ==> sxtw
+///            111 ==> sxtx
+static inline unsigned
+AArch64_AM_getExtendEncoding(AArch64_AM_ShiftExtendType ET)
+{
+	switch (ET) {
+	default:
+		assert(0 && "Invalid extend type requested");
+	case AArch64_AM_UXTB:
+		return 0;
+		break;
+	case AArch64_AM_UXTH:
+		return 1;
+		break;
+	case AArch64_AM_UXTW:
+		return 2;
+		break;
+	case AArch64_AM_UXTX:
+		return 3;
+		break;
+	case AArch64_AM_SXTB:
+		return 4;
+		break;
+	case AArch64_AM_SXTH:
+		return 5;
+		break;
+	case AArch64_AM_SXTW:
+		return 6;
+		break;
+	case AArch64_AM_SXTX:
+		return 7;
+		break;
+	}
+}
+
+/// getArithExtendImm - Encode the extend type and shift amount for an
+///                     arithmetic instruction:
+///   imm:     3-bit extend amount
+///   {5-3}  = shifter
+///   {2-0}  = imm3
+static inline unsigned
+AArch64_AM_getArithExtendImm(AArch64_AM_ShiftExtendType ET, unsigned Imm)
+{
+	return (AArch64_AM_getExtendEncoding(ET) << 3) | (Imm & 0x7);
+}
+
+/// getMemDoShift - Extract the "do shift" flag value for load/store
+/// instructions.
+static inline bool AArch64_AM_getMemDoShift(unsigned Imm)
+{
+	return (Imm & 0x1) != 0;
+}
+
+/// getExtendType - Extract the extend type for the offset operand of
+/// loads/stores.
+static inline AArch64_AM_ShiftExtendType
+AArch64_AM_getMemExtendType(unsigned Imm)
+{
+	return AArch64_AM_getExtendType((Imm >> 1) & 0x7);
+}
+
+/// getExtendImm - Encode the extend type and amount for a load/store inst:
+///   doshift:     should the offset be scaled by the access size
+///   shifter: 000 ==> uxtb
+///            001 ==> uxth
+///            010 ==> uxtw
+///            011 ==> uxtx
+///            100 ==> sxtb
+///            101 ==> sxth
+///            110 ==> sxtw
+///            111 ==> sxtx
+///   {3-1}  = shifter
+///   {0}  = doshift
+static inline unsigned AArch64_AM_getMemExtendImm(AArch64_AM_ShiftExtendType ET,
+						  bool DoShift)
+{
+	return (AArch64_AM_getExtendEncoding(ET) << 1) | (unsigned)DoShift;
+}
+
+static inline uint64_t AArch64_AM_ror(uint64_t elt, unsigned size)
+{
+	return ((elt & 1) << (size - 1)) | (elt >> 1);
+}
+
+/// processLogicalImmediate - Determine if an immediate value can be encoded
+/// as the immediate operand of a logical instruction for the given register
+/// size.  If so, return true with "encoding" set to the encoded value in
+/// the form N:immr:imms.
+static inline bool AArch64_AM_processLogicalImmediate(uint64_t Imm,
+						      unsigned RegSize,
+						      uint64_t *Encoding)
+{
+	if (Imm == 0ULL || Imm == ~0ULL ||
+	    (RegSize != 64 &&
+	     (Imm >> RegSize != 0 || Imm == (~0ULL >> (64 - RegSize)))))
+		return false;
+
+	// First, determine the element size.
+	unsigned Size = RegSize;
+
+	do {
+		Size /= 2;
+		uint64_t Mask = (1ULL << Size) - 1;
+
+		if ((Imm & Mask) != ((Imm >> Size) & Mask)) {
+			Size *= 2;
+			break;
+		}
+	} while (Size > 2);
+
+	// Second, determine the rotation to make the element be: 0^m 1^n.
+	uint32_t CTO, I;
+	uint64_t Mask = ((uint64_t)-1LL) >> (64 - Size);
+	Imm &= Mask;
+
+	if (isShiftedMask_64(Imm)) {
+		I = CountTrailingZeros_64(Imm);
+
+		CTO = CountTrailingOnes_64(Imm >> I);
+	} else {
+		Imm |= ~Mask;
+		if (!isShiftedMask_64(~Imm))
+			return false;
+
+		unsigned CLO = CountLeadingOnes_64(Imm);
+		I = 64 - CLO;
+		CTO = CLO + CountTrailingOnes_64(Imm) - (64 - Size);
+	}
+
+	// Encode in Immr the number of RORs it would take to get *from* 0^m 1^n
+	// to our target value, where I is the number of RORs to go the opposite
+	// direction.
+
+	unsigned Immr = (Size - I) & (Size - 1);
+
+	// If size has a 1 in the n'th bit, create a value that has zeroes in
+	// bits [0, n] and ones above that.
+	uint64_t NImms = ~(Size - 1) << 1;
+
+	// Or the CTO value into the low bits, which must be below the Nth bit
+	// bit mentioned above.
+	NImms |= (CTO - 1);
+
+	// Extract the seventh bit and toggle it to create the N field.
+	unsigned N = ((NImms >> 6) & 1) ^ 1;
+
+	*Encoding = (N << 12) | (Immr << 6) | (NImms & 0x3f);
+	return true;
+}
+
+/// isLogicalImmediate - Return true if the immediate is valid for a logical
+/// immediate instruction of the given register size. Return false otherwise.
+static inline bool AArch64_AM_isLogicalImmediate(uint64_t imm, unsigned regSize)
+{
+	uint64_t encoding = 0;
+	return AArch64_AM_processLogicalImmediate(imm, regSize, &encoding);
+}
+
+/// encodeLogicalImmediate - Return the encoded immediate value for a logical
+/// immediate instruction of the given register size.
+static inline uint64_t AArch64_AM_encodeLogicalImmediate(uint64_t imm,
+							 unsigned regSize)
+{
+	uint64_t encoding = 0;
+	bool res = AArch64_AM_processLogicalImmediate(imm, regSize, &encoding);
+
+	(void)res;
+	return encoding;
+}
+
+/// decodeLogicalImmediate - Decode a logical immediate value in the form
+/// "N:immr:imms" (where the immr and imms fields are each 6 bits) into the
+/// integer value it represents with regSize bits.
+static inline uint64_t AArch64_AM_decodeLogicalImmediate(uint64_t val,
+							 unsigned regSize)
+{
+	// Extract the N, imms, and immr fields.
+	unsigned N = (val >> 12) & 1;
+	unsigned immr = (val >> 6) & 0x3f;
+	unsigned imms = val & 0x3f;
+
+	int len = 31 - countLeadingZeros((N << 6) | (~imms & 0x3f));
+	assert(len >= 1);
+
+	unsigned size = (1 << len);
+	unsigned R = immr & (size - 1);
+	unsigned S = imms & (size - 1);
+
+	uint64_t pattern = (1ULL << (S + 1)) - 1;
+	for (unsigned i = 0; i < R; ++i)
+		pattern = AArch64_AM_ror(pattern, size);
+
+	// Replicate the pattern to fill the regSize.
+	while (size != regSize) {
+		pattern |= (pattern << size);
+		size *= 2;
+	}
+	return pattern;
+}
+
+/// isValidDecodeLogicalImmediate - Check to see if the logical immediate value
+/// in the form "N:immr:imms" (where the immr and imms fields are each 6 bits)
+/// is a valid encoding for an integer value with regSize bits.
+static inline bool AArch64_AM_isValidDecodeLogicalImmediate(uint64_t val,
+							    unsigned regSize)
+{
+	// Extract the N and imms fields needed for checking.
+	unsigned N = (val >> 12) & 1;
+	unsigned imms = val & 0x3f;
+
+	if (regSize == 32 && N != 0) // undefined logical immediate encoding
+		return false;
+	int len = 31 - countLeadingZeros((N << 6) | (~imms & 0x3f));
+	if (len < 0)		     // undefined logical immediate encoding
+		return false;
+	unsigned size = (1 << len);
+	unsigned S = imms & (size - 1);
+	if (S == size - 1) // undefined logical immediate encoding
+		return false;
+
+	return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Floating-point Immediates
+//
+static inline float AArch64_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);
+}
+
+//===--------------------------------------------------------------------===//
+// AdvSIMD Modified Immediates
+//===--------------------------------------------------------------------===//
+// 0x00 0x00 0x00 abcdefgh 0x00 0x00 0x00 abcdefgh
+static inline bool AArch64_AM_isAdvSIMDModImmType1(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0xffffff00ffffff00ULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType1(uint64_t Imm)
+{
+	return (Imm & 0xffULL);
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType1(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 32) | EncVal;
+}
+
+// 0x00 0x00 abcdefgh 0x00 0x00 0x00 abcdefgh 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType2(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0xffff00ffffff00ffULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType2(uint64_t Imm)
+{
+	return (Imm & 0xff00ULL) >> 8;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType2(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 40) | (EncVal << 8);
+}
+
+// 0x00 abcdefgh 0x00 0x00 0x00 abcdefgh 0x00 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType3(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0xff00ffffff00ffffULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType3(uint64_t Imm)
+{
+	return (Imm & 0xff0000ULL) >> 16;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType3(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 48) | (EncVal << 16);
+}
+
+// abcdefgh 0x00 0x00 0x00 abcdefgh 0x00 0x00 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType4(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0x00ffffff00ffffffULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType4(uint64_t Imm)
+{
+	return (Imm & 0xff000000ULL) >> 24;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType4(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 56) | (EncVal << 24);
+}
+
+// 0x00 abcdefgh 0x00 abcdefgh 0x00 abcdefgh 0x00 abcdefgh
+static inline bool AArch64_AM_isAdvSIMDModImmType5(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       (((Imm & 0x00ff0000ULL) >> 16) == (Imm & 0x000000ffULL)) &&
+	       ((Imm & 0xff00ff00ff00ff00ULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType5(uint64_t Imm)
+{
+	return (Imm & 0xffULL);
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType5(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 48) | (EncVal << 32) | (EncVal << 16) | EncVal;
+}
+
+// abcdefgh 0x00 abcdefgh 0x00 abcdefgh 0x00 abcdefgh 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType6(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       (((Imm & 0xff000000ULL) >> 16) == (Imm & 0x0000ff00ULL)) &&
+	       ((Imm & 0x00ff00ff00ff00ffULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType6(uint64_t Imm)
+{
+	return (Imm & 0xff00ULL) >> 8;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType6(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 56) | (EncVal << 40) | (EncVal << 24) | (EncVal << 8);
+}
+
+// 0x00 0x00 abcdefgh 0xFF 0x00 0x00 abcdefgh 0xFF
+static inline bool AArch64_AM_isAdvSIMDModImmType7(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0xffff00ffffff00ffULL) == 0x000000ff000000ffULL);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType7(uint64_t Imm)
+{
+	return (Imm & 0xff00ULL) >> 8;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType7(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 40) | (EncVal << 8) | 0x000000ff000000ffULL;
+}
+
+// 0x00 abcdefgh 0xFF 0xFF 0x00 abcdefgh 0xFF 0xFF
+static inline bool AArch64_AM_isAdvSIMDModImmType8(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm & 0xff00ffffff00ffffULL) == 0x0000ffff0000ffffULL);
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType8(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	return (EncVal << 48) | (EncVal << 16) | 0x0000ffff0000ffffULL;
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType8(uint64_t Imm)
+{
+	return (Imm & 0x00ff0000ULL) >> 16;
+}
+
+// abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh
+static inline bool AArch64_AM_isAdvSIMDModImmType9(uint64_t Imm)
+{
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       ((Imm >> 48) == (Imm & 0x0000ffffULL)) &&
+	       ((Imm >> 56) == (Imm & 0x000000ffULL));
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType9(uint64_t Imm)
+{
+	return (Imm & 0xffULL);
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType9(uint8_t Imm)
+{
+	uint64_t EncVal = Imm;
+	EncVal |= (EncVal << 8);
+	EncVal |= (EncVal << 16);
+	EncVal |= (EncVal << 32);
+	return EncVal;
+}
+
+// aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh
+// cmode: 1110, op: 1
+static inline bool AArch64_AM_isAdvSIMDModImmType10(uint64_t Imm)
+{
+#if defined(_MSC_VER) && _MSC_VER == 1937 && !defined(__clang__) && \
+	defined(_M_ARM64)
+	// The MSVC compiler 19.37 for ARM64 has an optimization bug that
+	// causes an incorrect behavior with the orignal version. Work around
+	// by using a slightly different variation.
+	// https://developercommunity.visualstudio.com/t/C-ARM64-compiler-optimization-bug/10481261
+	constexpr uint64_t Mask = 0xFFULL;
+	uint64_t ByteA = (Imm >> 56) & Mask;
+	uint64_t ByteB = (Imm >> 48) & Mask;
+	uint64_t ByteC = (Imm >> 40) & Mask;
+	uint64_t ByteD = (Imm >> 32) & Mask;
+	uint64_t ByteE = (Imm >> 24) & Mask;
+	uint64_t ByteF = (Imm >> 16) & Mask;
+	uint64_t ByteG = (Imm >> 8) & Mask;
+	uint64_t ByteH = Imm & Mask;
+
+	return (ByteA == 0ULL || ByteA == Mask) &&
+	       (ByteB == 0ULL || ByteB == Mask) &&
+	       (ByteC == 0ULL || ByteC == Mask) &&
+	       (ByteD == 0ULL || ByteD == Mask) &&
+	       (ByteE == 0ULL || ByteE == Mask) &&
+	       (ByteF == 0ULL || ByteF == Mask) &&
+	       (ByteG == 0ULL || ByteG == Mask) &&
+	       (ByteH == 0ULL || ByteH == Mask);
+#else
+	uint64_t ByteA = Imm & 0xff00000000000000ULL;
+	uint64_t ByteB = Imm & 0x00ff000000000000ULL;
+	uint64_t ByteC = Imm & 0x0000ff0000000000ULL;
+	uint64_t ByteD = Imm & 0x000000ff00000000ULL;
+	uint64_t ByteE = Imm & 0x00000000ff000000ULL;
+	uint64_t ByteF = Imm & 0x0000000000ff0000ULL;
+	uint64_t ByteG = Imm & 0x000000000000ff00ULL;
+	uint64_t ByteH = Imm & 0x00000000000000ffULL;
+
+	return (ByteA == 0ULL || ByteA == 0xff00000000000000ULL) &&
+	       (ByteB == 0ULL || ByteB == 0x00ff000000000000ULL) &&
+	       (ByteC == 0ULL || ByteC == 0x0000ff0000000000ULL) &&
+	       (ByteD == 0ULL || ByteD == 0x000000ff00000000ULL) &&
+	       (ByteE == 0ULL || ByteE == 0x00000000ff000000ULL) &&
+	       (ByteF == 0ULL || ByteF == 0x0000000000ff0000ULL) &&
+	       (ByteG == 0ULL || ByteG == 0x000000000000ff00ULL) &&
+	       (ByteH == 0ULL || ByteH == 0x00000000000000ffULL);
+#endif
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType10(uint64_t Imm)
+{
+	uint8_t BitA = (Imm & 0xff00000000000000ULL) != 0;
+	uint8_t BitB = (Imm & 0x00ff000000000000ULL) != 0;
+	uint8_t BitC = (Imm & 0x0000ff0000000000ULL) != 0;
+	uint8_t BitD = (Imm & 0x000000ff00000000ULL) != 0;
+	uint8_t BitE = (Imm & 0x00000000ff000000ULL) != 0;
+	uint8_t BitF = (Imm & 0x0000000000ff0000ULL) != 0;
+	uint8_t BitG = (Imm & 0x000000000000ff00ULL) != 0;
+	uint8_t BitH = (Imm & 0x00000000000000ffULL) != 0;
+
+	uint8_t EncVal = BitA;
+	EncVal <<= 1;
+	EncVal |= BitB;
+	EncVal <<= 1;
+	EncVal |= BitC;
+	EncVal <<= 1;
+	EncVal |= BitD;
+	EncVal <<= 1;
+	EncVal |= BitE;
+	EncVal <<= 1;
+	EncVal |= BitF;
+	EncVal <<= 1;
+	EncVal |= BitG;
+	EncVal <<= 1;
+	EncVal |= BitH;
+	return EncVal;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType10(uint8_t Imm)
+{
+	uint64_t EncVal = 0;
+	if (Imm & 0x80)
+		EncVal |= 0xff00000000000000ULL;
+	if (Imm & 0x40)
+		EncVal |= 0x00ff000000000000ULL;
+	if (Imm & 0x20)
+		EncVal |= 0x0000ff0000000000ULL;
+	if (Imm & 0x10)
+		EncVal |= 0x000000ff00000000ULL;
+	if (Imm & 0x08)
+		EncVal |= 0x00000000ff000000ULL;
+	if (Imm & 0x04)
+		EncVal |= 0x0000000000ff0000ULL;
+	if (Imm & 0x02)
+		EncVal |= 0x000000000000ff00ULL;
+	if (Imm & 0x01)
+		EncVal |= 0x00000000000000ffULL;
+	return EncVal;
+}
+
+// aBbbbbbc defgh000 0x00 0x00 aBbbbbbc defgh000 0x00 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType11(uint64_t Imm)
+{
+	uint64_t BString = (Imm & 0x7E000000ULL) >> 25;
+	return ((Imm >> 32) == (Imm & 0xffffffffULL)) &&
+	       (BString == 0x1f || BString == 0x20) &&
+	       ((Imm & 0x0007ffff0007ffffULL) == 0);
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType11(uint64_t Imm)
+{
+	uint8_t BitA = (Imm & 0x80000000ULL) != 0;
+	uint8_t BitB = (Imm & 0x20000000ULL) != 0;
+	uint8_t BitC = (Imm & 0x01000000ULL) != 0;
+	uint8_t BitD = (Imm & 0x00800000ULL) != 0;
+	uint8_t BitE = (Imm & 0x00400000ULL) != 0;
+	uint8_t BitF = (Imm & 0x00200000ULL) != 0;
+	uint8_t BitG = (Imm & 0x00100000ULL) != 0;
+	uint8_t BitH = (Imm & 0x00080000ULL) != 0;
+
+	uint8_t EncVal = BitA;
+	EncVal <<= 1;
+	EncVal |= BitB;
+	EncVal <<= 1;
+	EncVal |= BitC;
+	EncVal <<= 1;
+	EncVal |= BitD;
+	EncVal <<= 1;
+	EncVal |= BitE;
+	EncVal <<= 1;
+	EncVal |= BitF;
+	EncVal <<= 1;
+	EncVal |= BitG;
+	EncVal <<= 1;
+	EncVal |= BitH;
+	return EncVal;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType11(uint8_t Imm)
+{
+	uint64_t EncVal = 0;
+	if (Imm & 0x80)
+		EncVal |= 0x80000000ULL;
+	if (Imm & 0x40)
+		EncVal |= 0x3e000000ULL;
+	else
+		EncVal |= 0x40000000ULL;
+	if (Imm & 0x20)
+		EncVal |= 0x01000000ULL;
+	if (Imm & 0x10)
+		EncVal |= 0x00800000ULL;
+	if (Imm & 0x08)
+		EncVal |= 0x00400000ULL;
+	if (Imm & 0x04)
+		EncVal |= 0x00200000ULL;
+	if (Imm & 0x02)
+		EncVal |= 0x00100000ULL;
+	if (Imm & 0x01)
+		EncVal |= 0x00080000ULL;
+	return (EncVal << 32) | EncVal;
+}
+
+// aBbbbbbb bbcdefgh 0x00 0x00 0x00 0x00 0x00 0x00
+static inline bool AArch64_AM_isAdvSIMDModImmType12(uint64_t Imm)
+{
+	uint64_t BString = (Imm & 0x7fc0000000000000ULL) >> 54;
+	return ((BString == 0xff || BString == 0x100) &&
+		((Imm & 0x0000ffffffffffffULL) == 0));
+}
+
+static inline uint8_t AArch64_AM_encodeAdvSIMDModImmType12(uint64_t Imm)
+{
+	uint8_t BitA = (Imm & 0x8000000000000000ULL) != 0;
+	uint8_t BitB = (Imm & 0x0040000000000000ULL) != 0;
+	uint8_t BitC = (Imm & 0x0020000000000000ULL) != 0;
+	uint8_t BitD = (Imm & 0x0010000000000000ULL) != 0;
+	uint8_t BitE = (Imm & 0x0008000000000000ULL) != 0;
+	uint8_t BitF = (Imm & 0x0004000000000000ULL) != 0;
+	uint8_t BitG = (Imm & 0x0002000000000000ULL) != 0;
+	uint8_t BitH = (Imm & 0x0001000000000000ULL) != 0;
+
+	uint8_t EncVal = BitA;
+	EncVal <<= 1;
+	EncVal |= BitB;
+	EncVal <<= 1;
+	EncVal |= BitC;
+	EncVal <<= 1;
+	EncVal |= BitD;
+	EncVal <<= 1;
+	EncVal |= BitE;
+	EncVal <<= 1;
+	EncVal |= BitF;
+	EncVal <<= 1;
+	EncVal |= BitG;
+	EncVal <<= 1;
+	EncVal |= BitH;
+	return EncVal;
+}
+
+static inline uint64_t AArch64_AM_decodeAdvSIMDModImmType12(uint8_t Imm)
+{
+	uint64_t EncVal = 0;
+	if (Imm & 0x80)
+		EncVal |= 0x8000000000000000ULL;
+	if (Imm & 0x40)
+		EncVal |= 0x3fc0000000000000ULL;
+	else
+		EncVal |= 0x4000000000000000ULL;
+	if (Imm & 0x20)
+		EncVal |= 0x0020000000000000ULL;
+	if (Imm & 0x10)
+		EncVal |= 0x0010000000000000ULL;
+	if (Imm & 0x08)
+		EncVal |= 0x0008000000000000ULL;
+	if (Imm & 0x04)
+		EncVal |= 0x0004000000000000ULL;
+	if (Imm & 0x02)
+		EncVal |= 0x0002000000000000ULL;
+	if (Imm & 0x01)
+		EncVal |= 0x0001000000000000ULL;
+	return (EncVal << 32) | EncVal;
+}
+
+/// Returns true if Imm is the concatenation of a repeating pattern of type T.
+#define DEFINE_isSVEMaskOfIdenticalElements(T) \
+	static inline bool CONCAT(AArch64_AM_isSVEMaskOfIdenticalElements, \
+				  T)(int64_t Imm) \
+	{ \
+		union { \
+			int64_t In; \
+			T Out[sizeof(int64_t) / sizeof(T)]; \
+		} U_Parts; \
+		U_Parts.In = Imm; \
+		T *Parts = U_Parts.Out; \
+		for (int i = 0; i < (sizeof(int64_t) / sizeof(T)); i++) { \
+			if (Parts[i] != Parts[0]) \
+				return false; \
+		} \
+		return true; \
+	}
+DEFINE_isSVEMaskOfIdenticalElements(int8_t);
+DEFINE_isSVEMaskOfIdenticalElements(int16_t);
+DEFINE_isSVEMaskOfIdenticalElements(int32_t);
+DEFINE_isSVEMaskOfIdenticalElements(int64_t);
+
+static inline bool isSVECpyImm8(int64_t Imm)
+{
+	bool IsImm8 = (int8_t)Imm == Imm;
+
+	return IsImm8 || (uint8_t)Imm == Imm;
+}
+
+static inline bool isSVECpyImm16(int64_t Imm)
+{
+	bool IsImm8 = (int8_t)Imm == Imm;
+	bool IsImm16 = (int16_t)(Imm & ~0xff) == Imm;
+
+	return IsImm8 || IsImm16 || (uint16_t)(Imm & ~0xff) == Imm;
+}
+
+static inline bool isSVECpyImm32(int64_t Imm)
+{
+	bool IsImm8 = (int8_t)Imm == Imm;
+	bool IsImm16 = (int16_t)(Imm & ~0xff) == Imm;
+
+	return IsImm8 || IsImm16;
+}
+
+static inline bool isSVECpyImm64(int64_t Imm)
+{
+	bool IsImm8 = (int8_t)Imm == Imm;
+	bool IsImm16 = (int16_t)(Imm & ~0xff) == Imm;
+
+	return IsImm8 || IsImm16;
+}
+
+/// Return true if Imm is valid for DUPM and has no single CPY/DUP equivalent.
+static inline bool
+AArch64_AM_isSVEMoveMaskPreferredLogicalImmediate(int64_t Imm)
+{
+	if (isSVECpyImm64(Imm))
+		return false;
+
+	union {
+		int64_t In;
+		int32_t Out[2];
+	} U_S;
+	U_S.In = Imm;
+	int32_t *S = U_S.Out;
+	union {
+		int64_t In;
+		int16_t Out[4];
+	} U_H;
+	U_H.In = Imm;
+	int16_t *H = U_H.Out;
+	union {
+		int64_t In;
+		int8_t Out[8];
+	} U_B;
+	U_B.In = Imm;
+	int8_t *B = U_B.Out;
+
+	if (CONCAT(AArch64_AM_isSVEMaskOfIdenticalElements, int32_t)(Imm) &&
+	    isSVECpyImm32(S[0]))
+		return false;
+	if (CONCAT(AArch64_AM_isSVEMaskOfIdenticalElements, int16_t)(Imm) &&
+	    isSVECpyImm16(H[0]))
+		return false;
+	if (CONCAT(AArch64_AM_isSVEMaskOfIdenticalElements, int8_t)(Imm) &&
+	    isSVECpyImm8(B[0]))
+		return false;
+	return AArch64_AM_isLogicalImmediate(Imm, 64);
+}
+
+inline static bool AArch64_AM_isAnyMOVZMovAlias(uint64_t Value, int RegWidth)
+{
+	for (int Shift = 0; Shift <= RegWidth - 16; Shift += 16)
+		if ((Value & ~(0xffffULL << Shift)) == 0)
+			return true;
+
+	return false;
+}
+
+inline static bool AArch64_AM_isMOVZMovAlias(uint64_t Value, int Shift,
+					     int RegWidth)
+{
+	if (RegWidth == 32)
+		Value &= 0xffffffffULL;
+
+	// "lsl #0" takes precedence: in practice this only affects "#0, lsl #0".
+	if (Value == 0 && Shift != 0)
+		return false;
+
+	return (Value & ~(0xffffULL << Shift)) == 0;
+}
+
+inline static bool AArch64_AM_isMOVNMovAlias(uint64_t Value, int Shift,
+					     int RegWidth)
+{
+	// MOVZ takes precedence over MOVN.
+	if (AArch64_AM_isAnyMOVZMovAlias(Value, RegWidth))
+		return false;
+
+	Value = ~Value;
+	if (RegWidth == 32)
+		Value &= 0xffffffffULL;
+
+	return AArch64_AM_isMOVZMovAlias(Value, Shift, RegWidth);
+}
+
+inline static bool AArch64_AM_isAnyMOVWMovAlias(uint64_t Value, int RegWidth)
+{
+	if (AArch64_AM_isAnyMOVZMovAlias(Value, RegWidth))
+		return true;
+
+	// It's not a MOVZ, but it might be a MOVN.
+	Value = ~Value;
+	if (RegWidth == 32)
+		Value &= 0xffffffffULL;
+
+	return AArch64_AM_isAnyMOVZMovAlias(Value, RegWidth);
+}
+
+// CS namespace end: AArch64_AM
+
+// end namespace AArch64_AM
+
+// end namespace llvm
+
+#endif

thirdparty/capstone/arch/AArch64/AArch64BaseInfo.c

@@ -0,0 +1,175 @@
+/* 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: <commit> */
+/* LLVM-tag: <tag> */
+
+/* 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 */
+
+//===-- AArch64BaseInfo.cpp - AArch64 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 AArch64.
+//
+//===----------------------------------------------------------------------===//
+#include <capstone/platform.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "AArch64BaseInfo.h"
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+#define GET_AT_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_AT_IMPL
+
+#define GET_DBNXS_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_DBNXS_IMPL
+
+#define GET_DB_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_DB_IMPL
+
+#define GET_DC_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_DC_IMPL
+
+#define GET_IC_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_IC_IMPL
+
+#define GET_ISB_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_ISB_IMPL
+
+#define GET_TSB_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_TSB_IMPL
+
+#define GET_PRCTX_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_PRCTX_IMPL
+
+#define GET_PRFM_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_PRFM_IMPL
+
+#define GET_SVEPRFM_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_SVEPRFM_IMPL
+
+#define GET_RPRFM_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_RPRFM_IMPL
+
+// namespace AArch64RPRFM
+// namespace llvm
+
+#define GET_SVEPREDPAT_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_SVEPREDPAT_IMPL
+
+#define GET_SVEVECLENSPECIFIER_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_SVEVECLENSPECIFIER_IMPL
+
+// namespace AArch64SVEVecLenSpecifier
+// namespace llvm
+
+#define GET_EXACTFPIMM_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_EXACTFPIMM_IMPL
+
+#define GET_PSTATEIMM0_15_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_PSTATEIMM0_15_IMPL
+
+#define GET_PSTATEIMM0_1_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_PSTATEIMM0_1_IMPL
+
+#define GET_PSB_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_PSB_IMPL
+
+#define GET_BTI_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_BTI_IMPL
+
+#define SysReg AArch64SysReg_SysReg
+#define GET_SYSREG_IMPL
+#include "AArch64GenSystemOperands.inc"
+#undef GET_SYSREG_IMPL
+
+#undef SysReg
+
+// return a string representing the number X
+// NOTE: result must be big enough to contain the data
+static void utostr(uint64_t X, bool isNeg, char *result)
+{
+	char Buffer[22];
+	char *BufPtr = Buffer + 21;
+
+	Buffer[21] = '\0';
+	if (X == 0)
+		*--BufPtr = '0'; // Handle special case...
+
+	while (X) {
+		*--BufPtr = X % 10 + '0';
+		X /= 10;
+	}
+
+	if (isNeg)
+		*--BufPtr = '-'; // Add negative sign...
+
+	// suppose that result is big enough
+	strncpy(result, BufPtr, sizeof(Buffer));
+}
+
+// NOTE: result must be big enough to contain the result
+void AArch64SysReg_genericRegisterString(uint32_t Bits, char *result)
+{
+	// assert(Bits < 0x10000);
+	char Op0Str[32], Op1Str[32], CRnStr[32], CRmStr[32], Op2Str[32];
+	int dummy;
+	uint32_t Op0 = (Bits >> 14) & 0x3;
+	uint32_t Op1 = (Bits >> 11) & 0x7;
+	uint32_t CRn = (Bits >> 7) & 0xf;
+	uint32_t CRm = (Bits >> 3) & 0xf;
+	uint32_t Op2 = Bits & 0x7;
+
+	utostr(Op0, false, Op0Str);
+	utostr(Op1, false, Op1Str);
+	utostr(Op2, false, Op2Str);
+	utostr(CRn, false, CRnStr);
+	utostr(CRm, false, CRmStr);
+
+	dummy = cs_snprintf(result, AARCH64_GRS_LEN, "s%s_%s_c%s_c%s_%s",
+			    Op0Str, Op1Str, CRnStr, CRmStr, Op2Str);
+	(void)dummy;
+}
+
+#define GET_TLBITable_IMPL
+
+#include "AArch64GenSystemOperands.inc"
+#undef GET_TLBITable_IMPL
+
+#define GET_SVCR_IMPL
+
+#include "AArch64GenSystemOperands.inc"
+#undef GET_SVCR_IMPL

thirdparty/capstone/arch/AArch64/AArch64BaseInfo.h

@@ -0,0 +1,983 @@
+/* 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: <commit> */
+/* LLVM-tag: <tag> */
+
+/* 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 */
+
+//===-- AArch64BaseInfo.h - Top level definitions for AArch64 ---*- 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 AArch64 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 LLVM_LIB_TARGET_AARCH64_UTILS_AARCH64BASEINFO_H
+#define LLVM_LIB_TARGET_AARCH64_UTILS_AARCH64BASEINFO_H
+
+// FIXME: Is it easiest to fix this layering violation by moving the .inc
+// #includes from AArch64MCTargetDesc.h to here?
+#include <capstone/platform.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../MCInstPrinter.h"
+
+#include "../../utils.h"
+#include "capstone/aarch64.h"
+
+#define GET_SUBTARGETINFO_ENUM
+#include "AArch64GenSubtargetInfo.inc"
+
+#define GET_REGINFO_ENUM
+#define GET_REGINFO_MC_DESC
+#include "AArch64GenRegisterInfo.inc"
+
+#define GET_INSTRINFO_ENUM
+#include "AArch64GenInstrInfo.inc"
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+
+static inline unsigned getWRegFromXReg(unsigned Reg)
+{
+	switch (Reg) {
+	case AArch64_X0:
+		return AArch64_W0;
+	case AArch64_X1:
+		return AArch64_W1;
+	case AArch64_X2:
+		return AArch64_W2;
+	case AArch64_X3:
+		return AArch64_W3;
+	case AArch64_X4:
+		return AArch64_W4;
+	case AArch64_X5:
+		return AArch64_W5;
+	case AArch64_X6:
+		return AArch64_W6;
+	case AArch64_X7:
+		return AArch64_W7;
+	case AArch64_X8:
+		return AArch64_W8;
+	case AArch64_X9:
+		return AArch64_W9;
+	case AArch64_X10:
+		return AArch64_W10;
+	case AArch64_X11:
+		return AArch64_W11;
+	case AArch64_X12:
+		return AArch64_W12;
+	case AArch64_X13:
+		return AArch64_W13;
+	case AArch64_X14:
+		return AArch64_W14;
+	case AArch64_X15:
+		return AArch64_W15;
+	case AArch64_X16:
+		return AArch64_W16;
+	case AArch64_X17:
+		return AArch64_W17;
+	case AArch64_X18:
+		return AArch64_W18;
+	case AArch64_X19:
+		return AArch64_W19;
+	case AArch64_X20:
+		return AArch64_W20;
+	case AArch64_X21:
+		return AArch64_W21;
+	case AArch64_X22:
+		return AArch64_W22;
+	case AArch64_X23:
+		return AArch64_W23;
+	case AArch64_X24:
+		return AArch64_W24;
+	case AArch64_X25:
+		return AArch64_W25;
+	case AArch64_X26:
+		return AArch64_W26;
+	case AArch64_X27:
+		return AArch64_W27;
+	case AArch64_X28:
+		return AArch64_W28;
+	case AArch64_FP:
+		return AArch64_W29;
+	case AArch64_LR:
+		return AArch64_W30;
+	case AArch64_SP:
+		return AArch64_WSP;
+	case AArch64_XZR:
+		return AArch64_WZR;
+	}
+	// For anything else, return it unchanged.
+	return Reg;
+}
+
+static inline unsigned getXRegFromWReg(unsigned Reg)
+{
+	switch (Reg) {
+	case AArch64_W0:
+		return AArch64_X0;
+	case AArch64_W1:
+		return AArch64_X1;
+	case AArch64_W2:
+		return AArch64_X2;
+	case AArch64_W3:
+		return AArch64_X3;
+	case AArch64_W4:
+		return AArch64_X4;
+	case AArch64_W5:
+		return AArch64_X5;
+	case AArch64_W6:
+		return AArch64_X6;
+	case AArch64_W7:
+		return AArch64_X7;
+	case AArch64_W8:
+		return AArch64_X8;
+	case AArch64_W9:
+		return AArch64_X9;
+	case AArch64_W10:
+		return AArch64_X10;
+	case AArch64_W11:
+		return AArch64_X11;
+	case AArch64_W12:
+		return AArch64_X12;
+	case AArch64_W13:
+		return AArch64_X13;
+	case AArch64_W14:
+		return AArch64_X14;
+	case AArch64_W15:
+		return AArch64_X15;
+	case AArch64_W16:
+		return AArch64_X16;
+	case AArch64_W17:
+		return AArch64_X17;
+	case AArch64_W18:
+		return AArch64_X18;
+	case AArch64_W19:
+		return AArch64_X19;
+	case AArch64_W20:
+		return AArch64_X20;
+	case AArch64_W21:
+		return AArch64_X21;
+	case AArch64_W22:
+		return AArch64_X22;
+	case AArch64_W23:
+		return AArch64_X23;
+	case AArch64_W24:
+		return AArch64_X24;
+	case AArch64_W25:
+		return AArch64_X25;
+	case AArch64_W26:
+		return AArch64_X26;
+	case AArch64_W27:
+		return AArch64_X27;
+	case AArch64_W28:
+		return AArch64_X28;
+	case AArch64_W29:
+		return AArch64_FP;
+	case AArch64_W30:
+		return AArch64_LR;
+	case AArch64_WSP:
+		return AArch64_SP;
+	case AArch64_WZR:
+		return AArch64_XZR;
+	}
+	// For anything else, return it unchanged.
+	return Reg;
+}
+
+static inline unsigned getXRegFromXRegTuple(unsigned RegTuple)
+{
+	switch (RegTuple) {
+	case AArch64_X0_X1_X2_X3_X4_X5_X6_X7:
+		return AArch64_X0;
+	case AArch64_X2_X3_X4_X5_X6_X7_X8_X9:
+		return AArch64_X2;
+	case AArch64_X4_X5_X6_X7_X8_X9_X10_X11:
+		return AArch64_X4;
+	case AArch64_X6_X7_X8_X9_X10_X11_X12_X13:
+		return AArch64_X6;
+	case AArch64_X8_X9_X10_X11_X12_X13_X14_X15:
+		return AArch64_X8;
+	case AArch64_X10_X11_X12_X13_X14_X15_X16_X17:
+		return AArch64_X10;
+	case AArch64_X12_X13_X14_X15_X16_X17_X18_X19:
+		return AArch64_X12;
+	case AArch64_X14_X15_X16_X17_X18_X19_X20_X21:
+		return AArch64_X14;
+	case AArch64_X16_X17_X18_X19_X20_X21_X22_X23:
+		return AArch64_X16;
+	case AArch64_X18_X19_X20_X21_X22_X23_X24_X25:
+		return AArch64_X18;
+	case AArch64_X20_X21_X22_X23_X24_X25_X26_X27:
+		return AArch64_X20;
+	case AArch64_X22_X23_X24_X25_X26_X27_X28_FP:
+		return AArch64_X22;
+	}
+	// For anything else, return it unchanged.
+	return RegTuple;
+}
+
+static inline unsigned getBRegFromDReg(unsigned Reg)
+{
+	switch (Reg) {
+	case AArch64_D0:
+		return AArch64_B0;
+	case AArch64_D1:
+		return AArch64_B1;
+	case AArch64_D2:
+		return AArch64_B2;
+	case AArch64_D3:
+		return AArch64_B3;
+	case AArch64_D4:
+		return AArch64_B4;
+	case AArch64_D5:
+		return AArch64_B5;
+	case AArch64_D6:
+		return AArch64_B6;
+	case AArch64_D7:
+		return AArch64_B7;
+	case AArch64_D8:
+		return AArch64_B8;
+	case AArch64_D9:
+		return AArch64_B9;
+	case AArch64_D10:
+		return AArch64_B10;
+	case AArch64_D11:
+		return AArch64_B11;
+	case AArch64_D12:
+		return AArch64_B12;
+	case AArch64_D13:
+		return AArch64_B13;
+	case AArch64_D14:
+		return AArch64_B14;
+	case AArch64_D15:
+		return AArch64_B15;
+	case AArch64_D16:
+		return AArch64_B16;
+	case AArch64_D17:
+		return AArch64_B17;
+	case AArch64_D18:
+		return AArch64_B18;
+	case AArch64_D19:
+		return AArch64_B19;
+	case AArch64_D20:
+		return AArch64_B20;
+	case AArch64_D21:
+		return AArch64_B21;
+	case AArch64_D22:
+		return AArch64_B22;
+	case AArch64_D23:
+		return AArch64_B23;
+	case AArch64_D24:
+		return AArch64_B24;
+	case AArch64_D25:
+		return AArch64_B25;
+	case AArch64_D26:
+		return AArch64_B26;
+	case AArch64_D27:
+		return AArch64_B27;
+	case AArch64_D28:
+		return AArch64_B28;
+	case AArch64_D29:
+		return AArch64_B29;
+	case AArch64_D30:
+		return AArch64_B30;
+	case AArch64_D31:
+		return AArch64_B31;
+	}
+	// For anything else, return it unchanged.
+	return Reg;
+}
+
+static inline unsigned getDRegFromBReg(unsigned Reg)
+{
+	switch (Reg) {
+	case AArch64_B0:
+		return AArch64_D0;
+	case AArch64_B1:
+		return AArch64_D1;
+	case AArch64_B2:
+		return AArch64_D2;
+	case AArch64_B3:
+		return AArch64_D3;
+	case AArch64_B4:
+		return AArch64_D4;
+	case AArch64_B5:
+		return AArch64_D5;
+	case AArch64_B6:
+		return AArch64_D6;
+	case AArch64_B7:
+		return AArch64_D7;
+	case AArch64_B8:
+		return AArch64_D8;
+	case AArch64_B9:
+		return AArch64_D9;
+	case AArch64_B10:
+		return AArch64_D10;
+	case AArch64_B11:
+		return AArch64_D11;
+	case AArch64_B12:
+		return AArch64_D12;
+	case AArch64_B13:
+		return AArch64_D13;
+	case AArch64_B14:
+		return AArch64_D14;
+	case AArch64_B15:
+		return AArch64_D15;
+	case AArch64_B16:
+		return AArch64_D16;
+	case AArch64_B17:
+		return AArch64_D17;
+	case AArch64_B18:
+		return AArch64_D18;
+	case AArch64_B19:
+		return AArch64_D19;
+	case AArch64_B20:
+		return AArch64_D20;
+	case AArch64_B21:
+		return AArch64_D21;
+	case AArch64_B22:
+		return AArch64_D22;
+	case AArch64_B23:
+		return AArch64_D23;
+	case AArch64_B24:
+		return AArch64_D24;
+	case AArch64_B25:
+		return AArch64_D25;
+	case AArch64_B26:
+		return AArch64_D26;
+	case AArch64_B27:
+		return AArch64_D27;
+	case AArch64_B28:
+		return AArch64_D28;
+	case AArch64_B29:
+		return AArch64_D29;
+	case AArch64_B30:
+		return AArch64_D30;
+	case AArch64_B31:
+		return AArch64_D31;
+	}
+	// For anything else, return it unchanged.
+	return Reg;
+}
+
+static inline bool atomicBarrierDroppedOnZero(unsigned Opcode)
+{
+	switch (Opcode) {
+	case AArch64_LDADDAB:
+	case AArch64_LDADDAH:
+	case AArch64_LDADDAW:
+	case AArch64_LDADDAX:
+	case AArch64_LDADDALB:
+	case AArch64_LDADDALH:
+	case AArch64_LDADDALW:
+	case AArch64_LDADDALX:
+	case AArch64_LDCLRAB:
+	case AArch64_LDCLRAH:
+	case AArch64_LDCLRAW:
+	case AArch64_LDCLRAX:
+	case AArch64_LDCLRALB:
+	case AArch64_LDCLRALH:
+	case AArch64_LDCLRALW:
+	case AArch64_LDCLRALX:
+	case AArch64_LDEORAB:
+	case AArch64_LDEORAH:
+	case AArch64_LDEORAW:
+	case AArch64_LDEORAX:
+	case AArch64_LDEORALB:
+	case AArch64_LDEORALH:
+	case AArch64_LDEORALW:
+	case AArch64_LDEORALX:
+	case AArch64_LDSETAB:
+	case AArch64_LDSETAH:
+	case AArch64_LDSETAW:
+	case AArch64_LDSETAX:
+	case AArch64_LDSETALB:
+	case AArch64_LDSETALH:
+	case AArch64_LDSETALW:
+	case AArch64_LDSETALX:
+	case AArch64_LDSMAXAB:
+	case AArch64_LDSMAXAH:
+	case AArch64_LDSMAXAW:
+	case AArch64_LDSMAXAX:
+	case AArch64_LDSMAXALB:
+	case AArch64_LDSMAXALH:
+	case AArch64_LDSMAXALW:
+	case AArch64_LDSMAXALX:
+	case AArch64_LDSMINAB:
+	case AArch64_LDSMINAH:
+	case AArch64_LDSMINAW:
+	case AArch64_LDSMINAX:
+	case AArch64_LDSMINALB:
+	case AArch64_LDSMINALH:
+	case AArch64_LDSMINALW:
+	case AArch64_LDSMINALX:
+	case AArch64_LDUMAXAB:
+	case AArch64_LDUMAXAH:
+	case AArch64_LDUMAXAW:
+	case AArch64_LDUMAXAX:
+	case AArch64_LDUMAXALB:
+	case AArch64_LDUMAXALH:
+	case AArch64_LDUMAXALW:
+	case AArch64_LDUMAXALX:
+	case AArch64_LDUMINAB:
+	case AArch64_LDUMINAH:
+	case AArch64_LDUMINAW:
+	case AArch64_LDUMINAX:
+	case AArch64_LDUMINALB:
+	case AArch64_LDUMINALH:
+	case AArch64_LDUMINALW:
+	case AArch64_LDUMINALX:
+	case AArch64_SWPAB:
+	case AArch64_SWPAH:
+	case AArch64_SWPAW:
+	case AArch64_SWPAX:
+	case AArch64_SWPALB:
+	case AArch64_SWPALH:
+	case AArch64_SWPALW:
+	case AArch64_SWPALX:
+		return true;
+	}
+	return false;
+}
+
+// MOVE-NOTICE: AArch64CC_CondCode : moved to aarch64.h
+// MOVE-NOTICE: AArch64CC_getCondCodeName : moved to aarch64.h
+// MOVE-NOTICE: AArch64CC_getInvertedCondCode : moved to aarch64.h
+// MOVE-NOTICE: AArch64CC_getNZCVToSatisfyCondCode : moved to aarch64.h
+
+typedef struct SysAlias {
+	const char *Name;
+	aarch64_sysop_alias SysAlias;
+	uint16_t Encoding;
+	aarch64_insn_group FeaturesRequired[3];
+} SysAlias;
+
+typedef struct SysAliasReg {
+	const char *Name;
+	aarch64_sysop_reg SysReg;
+	uint16_t Encoding;
+	bool NeedsReg;
+	aarch64_insn_group FeaturesRequired[3];
+} SysAliasReg;
+
+typedef struct SysAliasImm {
+	const char *Name;
+	aarch64_sysop_imm SysImm;
+	uint16_t ImmValue;
+	uint16_t Encoding;
+	aarch64_insn_group FeaturesRequired[3];
+} SysAliasImm;
+
+// CS namespace begin: AArch64SVCR
+
+#define AArch64SVCR_SVCR SysAlias
+
+#define GET_SVCR_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64SVCR
+
+// CS namespace begin: AArch64AT
+
+#define AArch64AT_AT SysAlias
+
+#define GET_AT_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64AT
+
+// CS namespace begin: AArch64DB
+
+#define AArch64DB_DB SysAlias
+
+#define GET_DB_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64DB
+
+// CS namespace begin: AArch64DBnXS
+
+#define AArch64DBnXS_DBnXS SysAliasImm
+
+#define GET_DBNXS_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64DBnXS
+
+// CS namespace begin: AArch64DC
+
+#define AArch64DC_DC SysAlias
+
+#define GET_DC_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64DC
+
+// CS namespace begin: AArch64IC
+
+#define AArch64IC_IC SysAliasReg
+
+#define GET_IC_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64IC
+
+// CS namespace begin: AArch64ISB
+
+#define AArch64ISB_ISB SysAlias
+
+#define GET_ISB_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64ISB
+
+// CS namespace begin: AArch64TSB
+
+#define AArch64TSB_TSB SysAlias
+
+#define GET_TSB_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64TSB
+
+// CS namespace begin: AArch64PRFM
+
+#define AArch64PRFM_PRFM SysAlias
+
+#define GET_PRFM_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64PRFM
+
+// CS namespace begin: AArch64SVEPRFM
+
+#define AArch64SVEPRFM_SVEPRFM SysAlias
+
+#define GET_SVEPRFM_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64SVEPRFM
+
+// CS namespace begin: AArch64RPRFM
+
+#define AArch64RPRFM_RPRFM SysAlias
+
+#define GET_RPRFM_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64RPRFM
+
+// CS namespace begin: AArch64SVEPredPattern
+
+typedef struct SVEPREDPAT {
+	const char *Name;
+	aarch64_sysop_alias SysAlias;
+	uint16_t Encoding;
+} AArch64SVEPredPattern_SVEPREDPAT;
+
+#define GET_SVEPREDPAT_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64SVEPredPattern
+
+// CS namespace begin: AArch64SVEVecLenSpecifier
+
+typedef struct SVEVECLENSPECIFIER {
+	const char *Name;
+	aarch64_sysop_alias SysAlias;
+	uint16_t Encoding;
+} AArch64SVEVecLenSpecifier_SVEVECLENSPECIFIER;
+
+#define GET_SVEVECLENSPECIFIER_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64SVEVecLenSpecifier
+
+// namespace AArch64SVEVecLenSpecifier
+
+/// Return the number of active elements for VL1 to VL256 predicate pattern,
+/// zero for all other patterns.
+static inline unsigned getNumElementsFromSVEPredPattern(unsigned Pattern)
+{
+	switch (Pattern) {
+	default:
+		return 0;
+	case AARCH64_SVEPREDPAT_VL1:
+	case AARCH64_SVEPREDPAT_VL2:
+	case AARCH64_SVEPREDPAT_VL3:
+	case AARCH64_SVEPREDPAT_VL4:
+	case AARCH64_SVEPREDPAT_VL5:
+	case AARCH64_SVEPREDPAT_VL6:
+	case AARCH64_SVEPREDPAT_VL7:
+	case AARCH64_SVEPREDPAT_VL8:
+		return Pattern;
+	case AARCH64_SVEPREDPAT_VL16:
+		return 16;
+	case AARCH64_SVEPREDPAT_VL32:
+		return 32;
+	case AARCH64_SVEPREDPAT_VL64:
+		return 64;
+	case AARCH64_SVEPREDPAT_VL128:
+		return 128;
+	case AARCH64_SVEPREDPAT_VL256:
+		return 256;
+	}
+}
+
+/// Return specific VL predicate pattern based on the number of elements.
+static inline unsigned getSVEPredPatternFromNumElements(unsigned MinNumElts)
+{
+	switch (MinNumElts) {
+	default:
+		return 0;
+	case 1:
+	case 2:
+	case 3:
+	case 4:
+	case 5:
+	case 6:
+	case 7:
+	case 8:
+		return MinNumElts;
+	case 16:
+		return AARCH64_SVEPREDPAT_VL16;
+	case 32:
+		return AARCH64_SVEPREDPAT_VL32;
+	case 64:
+		return AARCH64_SVEPREDPAT_VL64;
+	case 128:
+		return AARCH64_SVEPREDPAT_VL128;
+	case 256:
+		return AARCH64_SVEPREDPAT_VL256;
+	}
+}
+
+// CS namespace begin: AArch64ExactFPImm
+
+typedef struct ExactFPImm {
+	const char *Name;
+	aarch64_sysop_imm SysImm;
+	int Enum;
+	const char *Repr;
+} AArch64ExactFPImm_ExactFPImm;
+
+enum {
+	AArch64ExactFPImm_half = 1,
+	AArch64ExactFPImm_one = 2,
+	AArch64ExactFPImm_two = 3,
+	AArch64ExactFPImm_zero = 0,
+};
+
+#define GET_EXACTFPIMM_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64ExactFPImm
+
+// CS namespace begin: AArch64PState
+
+#define AArch64PState_PStateImm0_15 SysAlias
+
+#define GET_PSTATEIMM0_15_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+#define AArch64PState_PStateImm0_1 SysAlias
+
+#define GET_PSTATEIMM0_1_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64PState
+
+// CS namespace begin: AArch64PSBHint
+
+#define AArch64PSBHint_PSB SysAlias
+
+#define GET_PSB_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64PSBHint
+
+// CS namespace begin: AArch64BTIHint
+
+#define AArch64BTIHint_BTI SysAlias
+
+#define GET_BTI_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64BTIHint
+
+// CS namespace begin: AArch64SE
+
+typedef enum ShiftExtSpecifiers {
+	AArch64SE_Invalid = -1,
+	AArch64SE_LSL,
+	AArch64SE_MSL,
+	AArch64SE_LSR,
+	AArch64SE_ASR,
+	AArch64SE_ROR,
+
+	AArch64SE_UXTB,
+	AArch64SE_UXTH,
+	AArch64SE_UXTW,
+	AArch64SE_UXTX,
+
+	AArch64SE_SXTB,
+	AArch64SE_SXTH,
+	AArch64SE_SXTW,
+	AArch64SE_SXTX
+} AArch64SE_ShiftExtSpecifiers;
+
+// CS namespace end: AArch64SE
+
+// CS namespace begin: AArch64Layout
+
+// MOVE_NOTICE: AArch64Layout_VectorLayout - move to aarch64.h
+// MOVE_NOTICE: AArch64VectorLayoutToString - move to aarch64.h
+// MOVE_NOTICE: AArch64StringToVectorLayout - move to aarch64.h
+
+// CS namespace end: AArch64Layout
+
+// CS namespace begin: AArch64SysReg
+
+typedef struct SysReg {
+	const char *Name;
+	aarch64_sysop_reg SysReg;
+	const char *AltName;
+	aarch64_sysop_reg AliasReg;
+	unsigned Encoding;
+	bool Readable;
+	bool Writeable;
+	aarch64_insn_group FeaturesRequired[3];
+} AArch64SysReg_SysReg;
+
+#define GET_SYSREG_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+const AArch64SysReg_SysReg *AArch64SysReg_lookupSysRegByName(const char *Name);
+const AArch64SysReg_SysReg *
+AArch64SysReg_lookupSysRegByEncoding(uint16_t Encoding);
+#define AARCH64_GRS_LEN 128
+void AArch64SysReg_genericRegisterString(uint32_t Bits, char *result);
+
+// CS namespace end: AArch64SysReg
+
+// CS namespace begin: AArch64TLBI
+
+#define AArch64TLBI_TLBI SysAliasReg
+
+#define GET_TLBITable_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64TLBI
+
+// CS namespace begin: AArch64PRCTX
+
+#define AArch64PRCTX_PRCTX SysAliasReg
+
+#define GET_PRCTX_DECL
+
+#include "AArch64GenSystemOperands.inc"
+
+// CS namespace end: AArch64PRCTX
+
+// CS namespace begin: AArch64II
+
+/// Target Operand Flag enum.
+typedef enum TOF {
+	//===------------------------------------------------------------------===//
+	// AArch64 Specific MachineOperand flags.
+
+	AArch64II_MO_NO_FLAG,
+
+	AArch64II_MO_FRAGMENT = 0x7,
+
+	/// MO_PAGE - A symbol operand with this flag represents the pc-relative
+	/// offset of the 4K page containing the symbol.  This is used with the
+	/// ADRP instruction.
+	AArch64II_MO_PAGE = 1,
+
+	/// MO_PAGEOFF - A symbol operand with this flag represents the offset of
+	/// that symbol within a 4K page.  This offset is added to the page address
+	/// to produce the complete address.
+	AArch64II_MO_PAGEOFF = 2,
+
+	/// MO_G3 - A symbol operand with this flag (granule 3) represents the high
+	/// 16-bits of a 64-bit address, used in a MOVZ or MOVK instruction
+	AArch64II_MO_G3 = 3,
+
+	/// MO_G2 - A symbol operand with this flag (granule 2) represents the bits
+	/// 32-47 of a 64-bit address, used in a MOVZ or MOVK instruction
+	AArch64II_MO_G2 = 4,
+
+	/// MO_G1 - A symbol operand with this flag (granule 1) represents the bits
+	/// 16-31 of a 64-bit address, used in a MOVZ or MOVK instruction
+	AArch64II_MO_G1 = 5,
+
+	/// MO_G0 - A symbol operand with this flag (granule 0) represents the bits
+	/// 0-15 of a 64-bit address, used in a MOVZ or MOVK instruction
+	AArch64II_MO_G0 = 6,
+
+	/// MO_HI12 - This flag indicates that a symbol operand represents the bits
+	/// 13-24 of a 64-bit address, used in a arithmetic immediate-shifted-left-
+	/// by-12-bits instruction.
+	AArch64II_MO_HI12 = 7,
+
+	/// 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.
+	AArch64II_MO_COFFSTUB = 0x8,
+
+	/// MO_GOT - This flag indicates that a symbol operand represents the
+	/// address of the GOT entry for the symbol, rather than the address of
+	/// the symbol itself.
+	AArch64II_MO_GOT = 0x10,
+
+	/// MO_NC - Indicates whether the linker is expected to check the symbol
+	/// reference for overflow. For example in an ADRP/ADD pair of relocations
+	/// the ADRP usually does check, but not the ADD.
+	AArch64II_MO_NC = 0x20,
+
+	/// MO_TLS - Indicates that the operand being accessed is some kind of
+	/// thread-local symbol. On Darwin, only one type of thread-local access
+	/// exists (pre linker-relaxation), but on ELF the TLSModel used for the
+	/// referee will affect interpretation.
+	AArch64II_MO_TLS = 0x40,
+
+	/// 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.
+	AArch64II_MO_DLLIMPORT = 0x80,
+
+	/// MO_S - Indicates that the bits of the symbol operand represented by
+	/// MO_G0 etc are signed.
+	AArch64II_MO_S = 0x100,
+
+	/// MO_PREL - Indicates that the bits of the symbol operand represented by
+	/// MO_G0 etc are PC relative.
+	AArch64II_MO_PREL = 0x200,
+
+	/// MO_TAGGED - With MO_PAGE, indicates that the page includes a memory tag
+	/// in bits 56-63.
+	/// On a FrameIndex operand, indicates that the underlying memory is tagged
+	/// with an unknown tag value (MTE); this needs to be lowered either to an
+	/// SP-relative load or store instruction (which do not check tags), or to
+	/// an LDG instruction to obtain the tag value.
+	AArch64II_MO_TAGGED = 0x400,
+
+	/// MO_ARM64EC_CALLMANGLE - Operand refers to the Arm64EC-mangled version
+	/// of a symbol, not the original. For dllimport symbols, this means it
+	/// uses "__imp_aux".  For other symbols, this means it uses the mangled
+	/// ("#" prefix for C) name.
+	AArch64II_MO_ARM64EC_CALLMANGLE = 0x800,
+} AArch64II_TOF;
+
+// CS namespace end: AArch64II
+
+// end namespace AArch64II
+
+//===----------------------------------------------------------------------===//
+// v8.3a Pointer Authentication
+//
+
+// CS namespace begin: AArch64PACKey
+
+typedef enum ID {
+	AArch64PACKey_IA = 0,
+	AArch64PACKey_IB = 1,
+	AArch64PACKey_DA = 2,
+	AArch64PACKey_DB = 3,
+	AArch64PACKey_LAST = AArch64PACKey_DB
+} AArch64PACKey_ID;
+
+// CS namespace end: AArch64PACKey
+
+// namespace AArch64PACKey
+
+/// Return 2-letter identifier string for numeric key ID.
+static inline const char *AArch64PACKeyIDToString(AArch64PACKey_ID KeyID)
+{
+	switch (KeyID) {
+	case AArch64PACKey_IA:
+		return "ia";
+	case AArch64PACKey_IB:
+		return "ib";
+	case AArch64PACKey_DA:
+		return "da";
+	case AArch64PACKey_DB:
+		return "db";
+	}
+	return NULL;
+}
+
+/// Return numeric key ID for 2-letter identifier string.
+static inline AArch64PACKey_ID AArch64StringToPACKeyID(const char *Name)
+{
+	if (strcmp(Name, "ia") == 0)
+		return AArch64PACKey_IA;
+	if (strcmp(Name, "ib") == 0)
+		return AArch64PACKey_IB;
+	if (strcmp(Name, "da") == 0)
+		return AArch64PACKey_DA;
+	if (strcmp(Name, "db") == 0)
+		return AArch64PACKey_DB;
+	assert(0 && "Invalid PAC key");
+	return AArch64PACKey_LAST;
+}
+
+// CS namespace begin: AArch64
+
+// The number of bits in a SVE register is architecturally defined
+// to be a multiple of this value.  If <M x t> has this number of bits,
+// a <n x M x t> vector can be stored in a SVE register without any
+// redundant bits.  If <M x t> has this number of bits divided by P,
+// a <n x M x t> vector is stored in a SVE register by placing index i
+// in index i*P of a <n x (M*P) x t> vector.  The other elements of the
+// <n x (M*P) x t> vector (such as index 1) are undefined.
+static const unsigned SVEBitsPerBlock = 128;
+
+static const unsigned SVEMaxBitsPerVector = 2048;
+
+// CS namespace end: AArch64
+
+// end namespace AArch64
+// end namespace llvm
+
+#endif

thirdparty/capstone/arch/AArch64/AArch64DisassemblerExtension.c

@@ -0,0 +1,24 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+/*    Rot127 <unisono@quyllur.org>, 2022-2023 */
+
+#include "AArch64DisassemblerExtension.h"
+#include "AArch64BaseInfo.h"
+
+bool AArch64_getFeatureBits(unsigned int mode, unsigned int feature)
+{
+	// we support everything
+	return true;
+}
+
+/// Tests a NULL terminated array of features if they are enabled.
+bool AArch64_testFeatureList(unsigned int mode, const unsigned int *features)
+{
+	int i = 0;
+	while (features[i]) {
+		if (!AArch64_getFeatureBits(mode, features[i]))
+			return false;
+		++i;
+	}
+	return true;
+}

thirdparty/capstone/arch/AArch64/AArch64DisassemblerExtension.h

@@ -0,0 +1,19 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+/*    Rot127 <unisono@quyllur.org>, 2022-2023 */
+
+#ifndef CS_AARCH64_DISASSEMBLER_EXTENSION_H
+#define CS_AARCH64_DISASSEMBLER_EXTENSION_H
+
+#include "../../MCDisassembler.h"
+#include "../../MCRegisterInfo.h"
+#include "../../MathExtras.h"
+#include "../../cs_priv.h"
+#include "AArch64AddressingModes.h"
+#include "capstone/aarch64.h"
+#include "capstone/capstone.h"
+
+bool AArch64_getFeatureBits(unsigned int mode, unsigned int feature);
+bool AArch64_testFeatureList(unsigned int mode, const unsigned int *features);
+
+#endif // CS_AARCH64_DISASSEMBLER_EXTENSION_H

thirdparty/capstone/arch/AArch64/AArch64GenCSAliasMnemMap.inc

@@ -0,0 +1,375 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2024 */
+/* 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 */
+
+	{ AARCH64_INS_ALIAS_ADDPT, "addpt" },
+	{ AARCH64_INS_ALIAS_GCSB, "gcsb" },
+	{ AARCH64_INS_ALIAS_GCSPOPM, "gcspopm" },
+	{ AARCH64_INS_ALIAS_LDAPUR, "ldapur" },
+	{ AARCH64_INS_ALIAS_STLLRB, "stllrb" },
+	{ AARCH64_INS_ALIAS_STLLRH, "stllrh" },
+	{ AARCH64_INS_ALIAS_STLLR, "stllr" },
+	{ AARCH64_INS_ALIAS_STLRB, "stlrb" },
+	{ AARCH64_INS_ALIAS_STLRH, "stlrh" },
+	{ AARCH64_INS_ALIAS_STLR, "stlr" },
+	{ AARCH64_INS_ALIAS_STLUR, "stlur" },
+	{ AARCH64_INS_ALIAS_SUBPT, "subpt" },
+	{ AARCH64_INS_ALIAS_LDRAA, "ldraa" },
+	{ AARCH64_INS_ALIAS_ADD, "add" },
+	{ AARCH64_INS_ALIAS_CMN, "cmn" },
+	{ AARCH64_INS_ALIAS_ADDS, "adds" },
+	{ AARCH64_INS_ALIAS_AND, "and" },
+	{ AARCH64_INS_ALIAS_ANDS, "ands" },
+	{ AARCH64_INS_ALIAS_LDR, "ldr" },
+	{ AARCH64_INS_ALIAS_STR, "str" },
+	{ AARCH64_INS_ALIAS_LDRB, "ldrb" },
+	{ AARCH64_INS_ALIAS_STRB, "strb" },
+	{ AARCH64_INS_ALIAS_LDRH, "ldrh" },
+	{ AARCH64_INS_ALIAS_STRH, "strh" },
+	{ AARCH64_INS_ALIAS_PRFM, "prfm" },
+	{ AARCH64_INS_ALIAS_LDAPURB, "ldapurb" },
+	{ AARCH64_INS_ALIAS_STLURB, "stlurb" },
+	{ AARCH64_INS_ALIAS_LDUR, "ldur" },
+	{ AARCH64_INS_ALIAS_STUR, "stur" },
+	{ AARCH64_INS_ALIAS_PRFUM, "prfum" },
+	{ AARCH64_INS_ALIAS_LDTR, "ldtr" },
+	{ AARCH64_INS_ALIAS_STTR, "sttr" },
+	{ AARCH64_INS_ALIAS_LDP, "ldp" },
+	{ AARCH64_INS_ALIAS_STGP, "stgp" },
+	{ AARCH64_INS_ALIAS_LDNP, "ldnp" },
+	{ AARCH64_INS_ALIAS_STNP, "stnp" },
+	{ AARCH64_INS_ALIAS_STG, "stg" },
+	{ AARCH64_INS_ALIAS_MOV, "mov" },
+	{ AARCH64_INS_ALIAS_LD1, "ld1" },
+	{ AARCH64_INS_ALIAS_LD1R, "ld1r" },
+	{ AARCH64_INS_ALIAS_STADDLB, "staddlb" },
+	{ AARCH64_INS_ALIAS_STADDLH, "staddlh" },
+	{ AARCH64_INS_ALIAS_STADDL, "staddl" },
+	{ AARCH64_INS_ALIAS_STADDB, "staddb" },
+	{ AARCH64_INS_ALIAS_STADDH, "staddh" },
+	{ AARCH64_INS_ALIAS_STADD, "stadd" },
+	{ AARCH64_INS_ALIAS_PTRUE, "ptrue" },
+	{ AARCH64_INS_ALIAS_PTRUES, "ptrues" },
+	{ AARCH64_INS_ALIAS_CNTB, "cntb" },
+	{ AARCH64_INS_ALIAS_SQINCH, "sqinch" },
+	{ AARCH64_INS_ALIAS_INCB, "incb" },
+	{ AARCH64_INS_ALIAS_SQINCB, "sqincb" },
+	{ AARCH64_INS_ALIAS_UQINCB, "uqincb" },
+	{ AARCH64_INS_ALIAS_ORR, "orr" },
+	{ AARCH64_INS_ALIAS_DUPM, "dupm" },
+	{ AARCH64_INS_ALIAS_FMOV, "fmov" },
+	{ AARCH64_INS_ALIAS_EOR3, "eor3" },
+	{ AARCH64_INS_ALIAS_ST1B, "st1b" },
+	{ AARCH64_INS_ALIAS_ST2B, "st2b" },
+	{ AARCH64_INS_ALIAS_ST2Q, "st2q" },
+	{ AARCH64_INS_ALIAS_STNT1B, "stnt1b" },
+	{ AARCH64_INS_ALIAS_LD1B, "ld1b" },
+	{ AARCH64_INS_ALIAS_LDNT1B, "ldnt1b" },
+	{ AARCH64_INS_ALIAS_LD1RQB, "ld1rqb" },
+	{ AARCH64_INS_ALIAS_LD1RB, "ld1rb" },
+	{ AARCH64_INS_ALIAS_LDFF1B, "ldff1b" },
+	{ AARCH64_INS_ALIAS_LDNF1B, "ldnf1b" },
+	{ AARCH64_INS_ALIAS_LD2B, "ld2b" },
+	{ AARCH64_INS_ALIAS_LD1SB, "ld1sb" },
+	{ AARCH64_INS_ALIAS_PRFB, "prfb" },
+	{ AARCH64_INS_ALIAS_LDNT1SB, "ldnt1sb" },
+	{ AARCH64_INS_ALIAS_LD1ROB, "ld1rob" },
+	{ AARCH64_INS_ALIAS_LD1Q, "ld1q" },
+	{ AARCH64_INS_ALIAS_ST1Q, "st1q" },
+	{ AARCH64_INS_ALIAS_LD1W, "ld1w" },
+	{ AARCH64_INS_ALIAS_PMOV, "pmov" },
+	{ AARCH64_INS_ALIAS_SMSTART, "smstart" },
+	{ AARCH64_INS_ALIAS_SMSTOP, "smstop" },
+	{ AARCH64_INS_ALIAS_ZERO, "zero" },
+	{ AARCH64_INS_ALIAS_MOVT, "movt" },
+	{ AARCH64_INS_ALIAS_NOP, "nop" },
+	{ AARCH64_INS_ALIAS_YIELD, "yield" },
+	{ AARCH64_INS_ALIAS_WFE, "wfe" },
+	{ AARCH64_INS_ALIAS_WFI, "wfi" },
+	{ AARCH64_INS_ALIAS_SEV, "sev" },
+	{ AARCH64_INS_ALIAS_SEVL, "sevl" },
+	{ AARCH64_INS_ALIAS_DGH, "dgh" },
+	{ AARCH64_INS_ALIAS_ESB, "esb" },
+	{ AARCH64_INS_ALIAS_CSDB, "csdb" },
+	{ AARCH64_INS_ALIAS_BTI, "bti" },
+	{ AARCH64_INS_ALIAS_PSB, "psb" },
+	{ AARCH64_INS_ALIAS_CHKFEAT, "chkfeat" },
+	{ AARCH64_INS_ALIAS_PACIAZ, "paciaz" },
+	{ AARCH64_INS_ALIAS_PACIBZ, "pacibz" },
+	{ AARCH64_INS_ALIAS_AUTIAZ, "autiaz" },
+	{ AARCH64_INS_ALIAS_AUTIBZ, "autibz" },
+	{ AARCH64_INS_ALIAS_PACIASP, "paciasp" },
+	{ AARCH64_INS_ALIAS_PACIBSP, "pacibsp" },
+	{ AARCH64_INS_ALIAS_AUTIASP, "autiasp" },
+	{ AARCH64_INS_ALIAS_AUTIBSP, "autibsp" },
+	{ AARCH64_INS_ALIAS_PACIA1716, "pacia1716" },
+	{ AARCH64_INS_ALIAS_PACIB1716, "pacib1716" },
+	{ AARCH64_INS_ALIAS_AUTIA1716, "autia1716" },
+	{ AARCH64_INS_ALIAS_AUTIB1716, "autib1716" },
+	{ AARCH64_INS_ALIAS_XPACLRI, "xpaclri" },
+	{ AARCH64_INS_ALIAS_LDRAB, "ldrab" },
+	{ AARCH64_INS_ALIAS_PACM, "pacm" },
+	{ AARCH64_INS_ALIAS_CLREX, "clrex" },
+	{ AARCH64_INS_ALIAS_ISB, "isb" },
+	{ AARCH64_INS_ALIAS_SSBB, "ssbb" },
+	{ AARCH64_INS_ALIAS_PSSBB, "pssbb" },
+	{ AARCH64_INS_ALIAS_DFB, "dfb" },
+	{ AARCH64_INS_ALIAS_SYS, "sys" },
+	{ AARCH64_INS_ALIAS_MOVN, "movn" },
+	{ AARCH64_INS_ALIAS_MOVZ, "movz" },
+	{ AARCH64_INS_ALIAS_NGC, "ngc" },
+	{ AARCH64_INS_ALIAS_NGCS, "ngcs" },
+	{ AARCH64_INS_ALIAS_SUB, "sub" },
+	{ AARCH64_INS_ALIAS_CMP, "cmp" },
+	{ AARCH64_INS_ALIAS_SUBS, "subs" },
+	{ AARCH64_INS_ALIAS_NEG, "neg" },
+	{ AARCH64_INS_ALIAS_NEGS, "negs" },
+	{ AARCH64_INS_ALIAS_MUL, "mul" },
+	{ AARCH64_INS_ALIAS_MNEG, "mneg" },
+	{ AARCH64_INS_ALIAS_SMULL, "smull" },
+	{ AARCH64_INS_ALIAS_SMNEGL, "smnegl" },
+	{ AARCH64_INS_ALIAS_UMULL, "umull" },
+	{ AARCH64_INS_ALIAS_UMNEGL, "umnegl" },
+	{ AARCH64_INS_ALIAS_STCLRLB, "stclrlb" },
+	{ AARCH64_INS_ALIAS_STCLRLH, "stclrlh" },
+	{ AARCH64_INS_ALIAS_STCLRL, "stclrl" },
+	{ AARCH64_INS_ALIAS_STCLRB, "stclrb" },
+	{ AARCH64_INS_ALIAS_STCLRH, "stclrh" },
+	{ AARCH64_INS_ALIAS_STCLR, "stclr" },
+	{ AARCH64_INS_ALIAS_STEORLB, "steorlb" },
+	{ AARCH64_INS_ALIAS_STEORLH, "steorlh" },
+	{ AARCH64_INS_ALIAS_STEORL, "steorl" },
+	{ AARCH64_INS_ALIAS_STEORB, "steorb" },
+	{ AARCH64_INS_ALIAS_STEORH, "steorh" },
+	{ AARCH64_INS_ALIAS_STEOR, "steor" },
+	{ AARCH64_INS_ALIAS_STSETLB, "stsetlb" },
+	{ AARCH64_INS_ALIAS_STSETLH, "stsetlh" },
+	{ AARCH64_INS_ALIAS_STSETL, "stsetl" },
+	{ AARCH64_INS_ALIAS_STSETB, "stsetb" },
+	{ AARCH64_INS_ALIAS_STSETH, "stseth" },
+	{ AARCH64_INS_ALIAS_STSET, "stset" },
+	{ AARCH64_INS_ALIAS_STSMAXLB, "stsmaxlb" },
+	{ AARCH64_INS_ALIAS_STSMAXLH, "stsmaxlh" },
+	{ AARCH64_INS_ALIAS_STSMAXL, "stsmaxl" },
+	{ AARCH64_INS_ALIAS_STSMAXB, "stsmaxb" },
+	{ AARCH64_INS_ALIAS_STSMAXH, "stsmaxh" },
+	{ AARCH64_INS_ALIAS_STSMAX, "stsmax" },
+	{ AARCH64_INS_ALIAS_STSMINLB, "stsminlb" },
+	{ AARCH64_INS_ALIAS_STSMINLH, "stsminlh" },
+	{ AARCH64_INS_ALIAS_STSMINL, "stsminl" },
+	{ AARCH64_INS_ALIAS_STSMINB, "stsminb" },
+	{ AARCH64_INS_ALIAS_STSMINH, "stsminh" },
+	{ AARCH64_INS_ALIAS_STSMIN, "stsmin" },
+	{ AARCH64_INS_ALIAS_STUMAXLB, "stumaxlb" },
+	{ AARCH64_INS_ALIAS_STUMAXLH, "stumaxlh" },
+	{ AARCH64_INS_ALIAS_STUMAXL, "stumaxl" },
+	{ AARCH64_INS_ALIAS_STUMAXB, "stumaxb" },
+	{ AARCH64_INS_ALIAS_STUMAXH, "stumaxh" },
+	{ AARCH64_INS_ALIAS_STUMAX, "stumax" },
+	{ AARCH64_INS_ALIAS_STUMINLB, "stuminlb" },
+	{ AARCH64_INS_ALIAS_STUMINLH, "stuminlh" },
+	{ AARCH64_INS_ALIAS_STUMINL, "stuminl" },
+	{ AARCH64_INS_ALIAS_STUMINB, "stuminb" },
+	{ AARCH64_INS_ALIAS_STUMINH, "stuminh" },
+	{ AARCH64_INS_ALIAS_STUMIN, "stumin" },
+	{ AARCH64_INS_ALIAS_IRG, "irg" },
+	{ AARCH64_INS_ALIAS_LDG, "ldg" },
+	{ AARCH64_INS_ALIAS_STZG, "stzg" },
+	{ AARCH64_INS_ALIAS_ST2G, "st2g" },
+	{ AARCH64_INS_ALIAS_STZ2G, "stz2g" },
+	{ AARCH64_INS_ALIAS_BICS, "bics" },
+	{ AARCH64_INS_ALIAS_BIC, "bic" },
+	{ AARCH64_INS_ALIAS_EON, "eon" },
+	{ AARCH64_INS_ALIAS_EOR, "eor" },
+	{ AARCH64_INS_ALIAS_ORN, "orn" },
+	{ AARCH64_INS_ALIAS_MVN, "mvn" },
+	{ AARCH64_INS_ALIAS_TST, "tst" },
+	{ AARCH64_INS_ALIAS_ROR, "ror" },
+	{ AARCH64_INS_ALIAS_ASR, "asr" },
+	{ AARCH64_INS_ALIAS_SXTB, "sxtb" },
+	{ AARCH64_INS_ALIAS_SXTH, "sxth" },
+	{ AARCH64_INS_ALIAS_SXTW, "sxtw" },
+	{ AARCH64_INS_ALIAS_LSR, "lsr" },
+	{ AARCH64_INS_ALIAS_UXTB, "uxtb" },
+	{ AARCH64_INS_ALIAS_UXTH, "uxth" },
+	{ AARCH64_INS_ALIAS_UXTW, "uxtw" },
+	{ AARCH64_INS_ALIAS_CSET, "cset" },
+	{ AARCH64_INS_ALIAS_CSETM, "csetm" },
+	{ AARCH64_INS_ALIAS_CINC, "cinc" },
+	{ AARCH64_INS_ALIAS_CINV, "cinv" },
+	{ AARCH64_INS_ALIAS_CNEG, "cneg" },
+	{ AARCH64_INS_ALIAS_RET, "ret" },
+	{ AARCH64_INS_ALIAS_DCPS1, "dcps1" },
+	{ AARCH64_INS_ALIAS_DCPS2, "dcps2" },
+	{ AARCH64_INS_ALIAS_DCPS3, "dcps3" },
+	{ AARCH64_INS_ALIAS_LDPSW, "ldpsw" },
+	{ AARCH64_INS_ALIAS_LDRSH, "ldrsh" },
+	{ AARCH64_INS_ALIAS_LDRSB, "ldrsb" },
+	{ AARCH64_INS_ALIAS_LDRSW, "ldrsw" },
+	{ AARCH64_INS_ALIAS_LDURH, "ldurh" },
+	{ AARCH64_INS_ALIAS_LDURB, "ldurb" },
+	{ AARCH64_INS_ALIAS_LDURSH, "ldursh" },
+	{ AARCH64_INS_ALIAS_LDURSB, "ldursb" },
+	{ AARCH64_INS_ALIAS_LDURSW, "ldursw" },
+	{ AARCH64_INS_ALIAS_LDTRH, "ldtrh" },
+	{ AARCH64_INS_ALIAS_LDTRB, "ldtrb" },
+	{ AARCH64_INS_ALIAS_LDTRSH, "ldtrsh" },
+	{ AARCH64_INS_ALIAS_LDTRSB, "ldtrsb" },
+	{ AARCH64_INS_ALIAS_LDTRSW, "ldtrsw" },
+	{ AARCH64_INS_ALIAS_STP, "stp" },
+	{ AARCH64_INS_ALIAS_STURH, "sturh" },
+	{ AARCH64_INS_ALIAS_STURB, "sturb" },
+	{ AARCH64_INS_ALIAS_STLURH, "stlurh" },
+	{ AARCH64_INS_ALIAS_LDAPURSB, "ldapursb" },
+	{ AARCH64_INS_ALIAS_LDAPURH, "ldapurh" },
+	{ AARCH64_INS_ALIAS_LDAPURSH, "ldapursh" },
+	{ AARCH64_INS_ALIAS_LDAPURSW, "ldapursw" },
+	{ AARCH64_INS_ALIAS_STTRH, "sttrh" },
+	{ AARCH64_INS_ALIAS_STTRB, "sttrb" },
+	{ AARCH64_INS_ALIAS_BIC_4H, "bic_4h" },
+	{ AARCH64_INS_ALIAS_BIC_8H, "bic_8h" },
+	{ AARCH64_INS_ALIAS_BIC_2S, "bic_2s" },
+	{ AARCH64_INS_ALIAS_BIC_4S, "bic_4s" },
+	{ AARCH64_INS_ALIAS_ORR_4H, "orr_4h" },
+	{ AARCH64_INS_ALIAS_ORR_8H, "orr_8h" },
+	{ AARCH64_INS_ALIAS_ORR_2S, "orr_2s" },
+	{ AARCH64_INS_ALIAS_ORR_4S, "orr_4s" },
+	{ AARCH64_INS_ALIAS_SXTL_8H, "sxtl_8h" },
+	{ AARCH64_INS_ALIAS_SXTL, "sxtl" },
+	{ AARCH64_INS_ALIAS_SXTL_4S, "sxtl_4s" },
+	{ AARCH64_INS_ALIAS_SXTL_2D, "sxtl_2d" },
+	{ AARCH64_INS_ALIAS_SXTL2_8H, "sxtl2_8h" },
+	{ AARCH64_INS_ALIAS_SXTL2, "sxtl2" },
+	{ AARCH64_INS_ALIAS_SXTL2_4S, "sxtl2_4s" },
+	{ AARCH64_INS_ALIAS_SXTL2_2D, "sxtl2_2d" },
+	{ AARCH64_INS_ALIAS_UXTL_8H, "uxtl_8h" },
+	{ AARCH64_INS_ALIAS_UXTL, "uxtl" },
+	{ AARCH64_INS_ALIAS_UXTL_4S, "uxtl_4s" },
+	{ AARCH64_INS_ALIAS_UXTL_2D, "uxtl_2d" },
+	{ AARCH64_INS_ALIAS_UXTL2_8H, "uxtl2_8h" },
+	{ AARCH64_INS_ALIAS_UXTL2, "uxtl2" },
+	{ AARCH64_INS_ALIAS_UXTL2_4S, "uxtl2_4s" },
+	{ AARCH64_INS_ALIAS_UXTL2_2D, "uxtl2_2d" },
+	{ AARCH64_INS_ALIAS_LD2, "ld2" },
+	{ AARCH64_INS_ALIAS_LD3, "ld3" },
+	{ AARCH64_INS_ALIAS_LD4, "ld4" },
+	{ AARCH64_INS_ALIAS_ST1, "st1" },
+	{ AARCH64_INS_ALIAS_ST2, "st2" },
+	{ AARCH64_INS_ALIAS_ST3, "st3" },
+	{ AARCH64_INS_ALIAS_ST4, "st4" },
+	{ AARCH64_INS_ALIAS_LD2R, "ld2r" },
+	{ AARCH64_INS_ALIAS_LD3R, "ld3r" },
+	{ AARCH64_INS_ALIAS_LD4R, "ld4r" },
+	{ AARCH64_INS_ALIAS_CLRBHB, "clrbhb" },
+	{ AARCH64_INS_ALIAS_STILP, "stilp" },
+	{ AARCH64_INS_ALIAS_STL1, "stl1" },
+	{ AARCH64_INS_ALIAS_SYSP, "sysp" },
+	{ AARCH64_INS_ALIAS_LD1SW, "ld1sw" },
+	{ AARCH64_INS_ALIAS_LD1H, "ld1h" },
+	{ AARCH64_INS_ALIAS_LD1SH, "ld1sh" },
+	{ AARCH64_INS_ALIAS_LD1D, "ld1d" },
+	{ AARCH64_INS_ALIAS_LD1RSW, "ld1rsw" },
+	{ AARCH64_INS_ALIAS_LD1RH, "ld1rh" },
+	{ AARCH64_INS_ALIAS_LD1RSH, "ld1rsh" },
+	{ AARCH64_INS_ALIAS_LD1RW, "ld1rw" },
+	{ AARCH64_INS_ALIAS_LD1RSB, "ld1rsb" },
+	{ AARCH64_INS_ALIAS_LD1RD, "ld1rd" },
+	{ AARCH64_INS_ALIAS_LD1RQH, "ld1rqh" },
+	{ AARCH64_INS_ALIAS_LD1RQW, "ld1rqw" },
+	{ AARCH64_INS_ALIAS_LD1RQD, "ld1rqd" },
+	{ AARCH64_INS_ALIAS_LDNF1SW, "ldnf1sw" },
+	{ AARCH64_INS_ALIAS_LDNF1H, "ldnf1h" },
+	{ AARCH64_INS_ALIAS_LDNF1SH, "ldnf1sh" },
+	{ AARCH64_INS_ALIAS_LDNF1W, "ldnf1w" },
+	{ AARCH64_INS_ALIAS_LDNF1SB, "ldnf1sb" },
+	{ AARCH64_INS_ALIAS_LDNF1D, "ldnf1d" },
+	{ AARCH64_INS_ALIAS_LDFF1SW, "ldff1sw" },
+	{ AARCH64_INS_ALIAS_LDFF1H, "ldff1h" },
+	{ AARCH64_INS_ALIAS_LDFF1SH, "ldff1sh" },
+	{ AARCH64_INS_ALIAS_LDFF1W, "ldff1w" },
+	{ AARCH64_INS_ALIAS_LDFF1SB, "ldff1sb" },
+	{ AARCH64_INS_ALIAS_LDFF1D, "ldff1d" },
+	{ AARCH64_INS_ALIAS_LD3B, "ld3b" },
+	{ AARCH64_INS_ALIAS_LD4B, "ld4b" },
+	{ AARCH64_INS_ALIAS_LD2H, "ld2h" },
+	{ AARCH64_INS_ALIAS_LD3H, "ld3h" },
+	{ AARCH64_INS_ALIAS_LD4H, "ld4h" },
+	{ AARCH64_INS_ALIAS_LD2W, "ld2w" },
+	{ AARCH64_INS_ALIAS_LD3W, "ld3w" },
+	{ AARCH64_INS_ALIAS_LD4W, "ld4w" },
+	{ AARCH64_INS_ALIAS_LD2D, "ld2d" },
+	{ AARCH64_INS_ALIAS_LD3D, "ld3d" },
+	{ AARCH64_INS_ALIAS_LD4D, "ld4d" },
+	{ AARCH64_INS_ALIAS_LD2Q, "ld2q" },
+	{ AARCH64_INS_ALIAS_LD3Q, "ld3q" },
+	{ AARCH64_INS_ALIAS_LD4Q, "ld4q" },
+	{ AARCH64_INS_ALIAS_LDNT1H, "ldnt1h" },
+	{ AARCH64_INS_ALIAS_LDNT1W, "ldnt1w" },
+	{ AARCH64_INS_ALIAS_LDNT1D, "ldnt1d" },
+	{ AARCH64_INS_ALIAS_ST1H, "st1h" },
+	{ AARCH64_INS_ALIAS_ST1W, "st1w" },
+	{ AARCH64_INS_ALIAS_ST1D, "st1d" },
+	{ AARCH64_INS_ALIAS_ST3B, "st3b" },
+	{ AARCH64_INS_ALIAS_ST4B, "st4b" },
+	{ AARCH64_INS_ALIAS_ST2H, "st2h" },
+	{ AARCH64_INS_ALIAS_ST3H, "st3h" },
+	{ AARCH64_INS_ALIAS_ST4H, "st4h" },
+	{ AARCH64_INS_ALIAS_ST2W, "st2w" },
+	{ AARCH64_INS_ALIAS_ST3W, "st3w" },
+	{ AARCH64_INS_ALIAS_ST4W, "st4w" },
+	{ AARCH64_INS_ALIAS_ST2D, "st2d" },
+	{ AARCH64_INS_ALIAS_ST3D, "st3d" },
+	{ AARCH64_INS_ALIAS_ST4D, "st4d" },
+	{ AARCH64_INS_ALIAS_ST3Q, "st3q" },
+	{ AARCH64_INS_ALIAS_ST4Q, "st4q" },
+	{ AARCH64_INS_ALIAS_STNT1H, "stnt1h" },
+	{ AARCH64_INS_ALIAS_STNT1W, "stnt1w" },
+	{ AARCH64_INS_ALIAS_STNT1D, "stnt1d" },
+	{ AARCH64_INS_ALIAS_PRFH, "prfh" },
+	{ AARCH64_INS_ALIAS_PRFW, "prfw" },
+	{ AARCH64_INS_ALIAS_PRFD, "prfd" },
+	{ AARCH64_INS_ALIAS_CNTH, "cnth" },
+	{ AARCH64_INS_ALIAS_CNTW, "cntw" },
+	{ AARCH64_INS_ALIAS_CNTD, "cntd" },
+	{ AARCH64_INS_ALIAS_DECB, "decb" },
+	{ AARCH64_INS_ALIAS_INCH, "inch" },
+	{ AARCH64_INS_ALIAS_DECH, "dech" },
+	{ AARCH64_INS_ALIAS_INCW, "incw" },
+	{ AARCH64_INS_ALIAS_DECW, "decw" },
+	{ AARCH64_INS_ALIAS_INCD, "incd" },
+	{ AARCH64_INS_ALIAS_DECD, "decd" },
+	{ AARCH64_INS_ALIAS_SQDECB, "sqdecb" },
+	{ AARCH64_INS_ALIAS_UQDECB, "uqdecb" },
+	{ AARCH64_INS_ALIAS_UQINCH, "uqinch" },
+	{ AARCH64_INS_ALIAS_SQDECH, "sqdech" },
+	{ AARCH64_INS_ALIAS_UQDECH, "uqdech" },
+	{ AARCH64_INS_ALIAS_SQINCW, "sqincw" },
+	{ AARCH64_INS_ALIAS_UQINCW, "uqincw" },
+	{ AARCH64_INS_ALIAS_SQDECW, "sqdecw" },
+	{ AARCH64_INS_ALIAS_UQDECW, "uqdecw" },
+	{ AARCH64_INS_ALIAS_SQINCD, "sqincd" },
+	{ AARCH64_INS_ALIAS_UQINCD, "uqincd" },
+	{ AARCH64_INS_ALIAS_SQDECD, "sqdecd" },
+	{ AARCH64_INS_ALIAS_UQDECD, "uqdecd" },
+	{ AARCH64_INS_ALIAS_MOVS, "movs" },
+	{ AARCH64_INS_ALIAS_NOT, "not" },
+	{ AARCH64_INS_ALIAS_NOTS, "nots" },
+	{ AARCH64_INS_ALIAS_LD1ROH, "ld1roh" },
+	{ AARCH64_INS_ALIAS_LD1ROW, "ld1row" },
+	{ AARCH64_INS_ALIAS_LD1ROD, "ld1rod" },
+	{ AARCH64_INS_ALIAS_BCAX, "bcax" },
+	{ AARCH64_INS_ALIAS_BSL, "bsl" },
+	{ AARCH64_INS_ALIAS_BSL1N, "bsl1n" },
+	{ AARCH64_INS_ALIAS_BSL2N, "bsl2n" },
+	{ AARCH64_INS_ALIAS_NBSL, "nbsl" },
+	{ AARCH64_INS_ALIAS_LDNT1SH, "ldnt1sh" },
+	{ AARCH64_INS_ALIAS_LDNT1SW, "ldnt1sw" },

thirdparty/capstone/arch/AArch64/AArch64GenCSFeatureName.inc

@@ -0,0 +1,136 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2024 */
+/* 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 */
+
+{ AARCH64_FEATURE_HASV8_0A, "HasV8_0a" },
+{ AARCH64_FEATURE_HASV8_1A, "HasV8_1a" },
+{ AARCH64_FEATURE_HASV8_2A, "HasV8_2a" },
+{ AARCH64_FEATURE_HASV8_3A, "HasV8_3a" },
+{ AARCH64_FEATURE_HASV8_4A, "HasV8_4a" },
+{ AARCH64_FEATURE_HASV8_5A, "HasV8_5a" },
+{ AARCH64_FEATURE_HASV8_6A, "HasV8_6a" },
+{ AARCH64_FEATURE_HASV8_7A, "HasV8_7a" },
+{ AARCH64_FEATURE_HASV8_8A, "HasV8_8a" },
+{ AARCH64_FEATURE_HASV8_9A, "HasV8_9a" },
+{ AARCH64_FEATURE_HASV9_0A, "HasV9_0a" },
+{ AARCH64_FEATURE_HASV9_1A, "HasV9_1a" },
+{ AARCH64_FEATURE_HASV9_2A, "HasV9_2a" },
+{ AARCH64_FEATURE_HASV9_3A, "HasV9_3a" },
+{ AARCH64_FEATURE_HASV9_4A, "HasV9_4a" },
+{ AARCH64_FEATURE_HASV8_0R, "HasV8_0r" },
+{ AARCH64_FEATURE_HASEL2VMSA, "HasEL2VMSA" },
+{ AARCH64_FEATURE_HASEL3, "HasEL3" },
+{ AARCH64_FEATURE_HASVH, "HasVH" },
+{ AARCH64_FEATURE_HASLOR, "HasLOR" },
+{ AARCH64_FEATURE_HASPAUTH, "HasPAuth" },
+{ AARCH64_FEATURE_HASPAUTHLR, "HasPAuthLR" },
+{ AARCH64_FEATURE_HASJS, "HasJS" },
+{ AARCH64_FEATURE_HASCCIDX, "HasCCIDX" },
+{ AARCH64_FEATURE_HASCOMPLXNUM, "HasComplxNum" },
+{ AARCH64_FEATURE_HASNV, "HasNV" },
+{ AARCH64_FEATURE_HASMPAM, "HasMPAM" },
+{ AARCH64_FEATURE_HASDIT, "HasDIT" },
+{ AARCH64_FEATURE_HASTRACEV8_4, "HasTRACEV8_4" },
+{ AARCH64_FEATURE_HASAM, "HasAM" },
+{ AARCH64_FEATURE_HASSEL2, "HasSEL2" },
+{ AARCH64_FEATURE_HASTLB_RMI, "HasTLB_RMI" },
+{ AARCH64_FEATURE_HASFLAGM, "HasFlagM" },
+{ AARCH64_FEATURE_HASRCPC_IMMO, "HasRCPC_IMMO" },
+{ AARCH64_FEATURE_HASFPARMV8, "HasFPARMv8" },
+{ AARCH64_FEATURE_HASNEON, "HasNEON" },
+{ AARCH64_FEATURE_HASSM4, "HasSM4" },
+{ AARCH64_FEATURE_HASSHA3, "HasSHA3" },
+{ AARCH64_FEATURE_HASSHA2, "HasSHA2" },
+{ AARCH64_FEATURE_HASAES, "HasAES" },
+{ AARCH64_FEATURE_HASDOTPROD, "HasDotProd" },
+{ AARCH64_FEATURE_HASCRC, "HasCRC" },
+{ AARCH64_FEATURE_HASCSSC, "HasCSSC" },
+{ AARCH64_FEATURE_HASLSE, "HasLSE" },
+{ AARCH64_FEATURE_HASRAS, "HasRAS" },
+{ AARCH64_FEATURE_HASRDM, "HasRDM" },
+{ AARCH64_FEATURE_HASFULLFP16, "HasFullFP16" },
+{ AARCH64_FEATURE_HASFP16FML, "HasFP16FML" },
+{ AARCH64_FEATURE_HASSPE, "HasSPE" },
+{ AARCH64_FEATURE_HASFUSEAES, "HasFuseAES" },
+{ AARCH64_FEATURE_HASSVE, "HasSVE" },
+{ AARCH64_FEATURE_HASSVE2, "HasSVE2" },
+{ AARCH64_FEATURE_HASSVE2P1, "HasSVE2p1" },
+{ AARCH64_FEATURE_HASSVE2AES, "HasSVE2AES" },
+{ AARCH64_FEATURE_HASSVE2SM4, "HasSVE2SM4" },
+{ AARCH64_FEATURE_HASSVE2SHA3, "HasSVE2SHA3" },
+{ AARCH64_FEATURE_HASSVE2BITPERM, "HasSVE2BitPerm" },
+{ AARCH64_FEATURE_HASB16B16, "HasB16B16" },
+{ AARCH64_FEATURE_HASSME, "HasSME" },
+{ AARCH64_FEATURE_HASSMEF64F64, "HasSMEF64F64" },
+{ AARCH64_FEATURE_HASSMEF16F16, "HasSMEF16F16" },
+{ AARCH64_FEATURE_HASSMEFA64, "HasSMEFA64" },
+{ AARCH64_FEATURE_HASSMEI16I64, "HasSMEI16I64" },
+{ AARCH64_FEATURE_HASSME2, "HasSME2" },
+{ AARCH64_FEATURE_HASSME2P1, "HasSME2p1" },
+{ AARCH64_FEATURE_HASFPMR, "HasFPMR" },
+{ AARCH64_FEATURE_HASFP8, "HasFP8" },
+{ AARCH64_FEATURE_HASFAMINMAX, "HasFAMINMAX" },
+{ AARCH64_FEATURE_HASFP8FMA, "HasFP8FMA" },
+{ AARCH64_FEATURE_HASSSVE_FP8FMA, "HasSSVE_FP8FMA" },
+{ AARCH64_FEATURE_HASFP8DOT2, "HasFP8DOT2" },
+{ AARCH64_FEATURE_HASSSVE_FP8DOT2, "HasSSVE_FP8DOT2" },
+{ AARCH64_FEATURE_HASFP8DOT4, "HasFP8DOT4" },
+{ AARCH64_FEATURE_HASSSVE_FP8DOT4, "HasSSVE_FP8DOT4" },
+{ AARCH64_FEATURE_HASLUT, "HasLUT" },
+{ AARCH64_FEATURE_HASSME_LUTV2, "HasSME_LUTv2" },
+{ AARCH64_FEATURE_HASSMEF8F16, "HasSMEF8F16" },
+{ AARCH64_FEATURE_HASSMEF8F32, "HasSMEF8F32" },
+{ AARCH64_FEATURE_HASSVEORSME, "HasSVEorSME" },
+{ AARCH64_FEATURE_HASSVE2ORSME, "HasSVE2orSME" },
+{ AARCH64_FEATURE_HASSVE2ORSME2, "HasSVE2orSME2" },
+{ AARCH64_FEATURE_HASSVE2P1_OR_HASSME, "HasSVE2p1_or_HasSME" },
+{ AARCH64_FEATURE_HASSVE2P1_OR_HASSME2, "HasSVE2p1_or_HasSME2" },
+{ AARCH64_FEATURE_HASSVE2P1_OR_HASSME2P1, "HasSVE2p1_or_HasSME2p1" },
+{ AARCH64_FEATURE_HASNEONORSME, "HasNEONorSME" },
+{ AARCH64_FEATURE_HASRCPC, "HasRCPC" },
+{ AARCH64_FEATURE_HASALTNZCV, "HasAltNZCV" },
+{ AARCH64_FEATURE_HASFRINT3264, "HasFRInt3264" },
+{ AARCH64_FEATURE_HASSB, "HasSB" },
+{ AARCH64_FEATURE_HASPREDRES, "HasPredRes" },
+{ AARCH64_FEATURE_HASCCDP, "HasCCDP" },
+{ AARCH64_FEATURE_HASBTI, "HasBTI" },
+{ AARCH64_FEATURE_HASMTE, "HasMTE" },
+{ AARCH64_FEATURE_HASTME, "HasTME" },
+{ AARCH64_FEATURE_HASETE, "HasETE" },
+{ AARCH64_FEATURE_HASTRBE, "HasTRBE" },
+{ AARCH64_FEATURE_HASBF16, "HasBF16" },
+{ AARCH64_FEATURE_HASMATMULINT8, "HasMatMulInt8" },
+{ AARCH64_FEATURE_HASMATMULFP32, "HasMatMulFP32" },
+{ AARCH64_FEATURE_HASMATMULFP64, "HasMatMulFP64" },
+{ AARCH64_FEATURE_HASXS, "HasXS" },
+{ AARCH64_FEATURE_HASWFXT, "HasWFxT" },
+{ AARCH64_FEATURE_HASLS64, "HasLS64" },
+{ AARCH64_FEATURE_HASBRBE, "HasBRBE" },
+{ AARCH64_FEATURE_HASSPE_EEF, "HasSPE_EEF" },
+{ AARCH64_FEATURE_HASHBC, "HasHBC" },
+{ AARCH64_FEATURE_HASMOPS, "HasMOPS" },
+{ AARCH64_FEATURE_HASCLRBHB, "HasCLRBHB" },
+{ AARCH64_FEATURE_HASSPECRES2, "HasSPECRES2" },
+{ AARCH64_FEATURE_HASITE, "HasITE" },
+{ AARCH64_FEATURE_HASTHE, "HasTHE" },
+{ AARCH64_FEATURE_HASRCPC3, "HasRCPC3" },
+{ AARCH64_FEATURE_HASLSE128, "HasLSE128" },
+{ AARCH64_FEATURE_HASD128, "HasD128" },
+{ AARCH64_FEATURE_HASCHK, "HasCHK" },
+{ AARCH64_FEATURE_HASGCS, "HasGCS" },
+{ AARCH64_FEATURE_HASCPA, "HasCPA" },
+{ AARCH64_FEATURE_USENEGATIVEIMMEDIATES, "UseNegativeImmediates" },
+{ AARCH64_FEATURE_HASCCPP, "HasCCPP" },
+{ AARCH64_FEATURE_HASPAN, "HasPAN" },
+{ AARCH64_FEATURE_HASPSUAO, "HasPsUAO" },
+{ AARCH64_FEATURE_HASPAN_RWV, "HasPAN_RWV" },
+{ AARCH64_FEATURE_HASCONTEXTIDREL2, "HasCONTEXTIDREL2" },

thirdparty/capstone/arch/AArch64/AArch64GenCSOpGroup.inc

@@ -0,0 +1,180 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2024 */
+/* 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 */
+
+  AArch64_OP_GROUP_AMNoIndex = 0,
+  AArch64_OP_GROUP_AdrLabel = 1,
+  AArch64_OP_GROUP_AdrpLabel = 2,
+  AArch64_OP_GROUP_BTIHintOp = 3,
+  AArch64_OP_GROUP_ImplicitlyTypedVectorList = 4,
+  AArch64_OP_GROUP_InverseCondCode = 5,
+  AArch64_OP_GROUP_LogicalImm_int16_t = 6,
+  AArch64_OP_GROUP_LogicalImm_int8_t = 7,
+  AArch64_OP_GROUP_MatrixIndex_0 = 8,
+  AArch64_OP_GROUP_MatrixIndex_1 = 9,
+  AArch64_OP_GROUP_MatrixIndex_8 = 10,
+  AArch64_OP_GROUP_PSBHintOp = 11,
+  AArch64_OP_GROUP_PrefetchOp_1 = 12,
+  AArch64_OP_GROUP_SVELogicalImm_int16_t = 13,
+  AArch64_OP_GROUP_SVELogicalImm_int32_t = 14,
+  AArch64_OP_GROUP_SVELogicalImm_int64_t = 15,
+  AArch64_OP_GROUP_SVERegOp_0 = 16,
+  AArch64_OP_GROUP_VectorIndex_8 = 17,
+  AArch64_OP_GROUP_ZPRasFPR_128 = 18,
+  AArch64_OP_GROUP_Operand = 19,
+  AArch64_OP_GROUP_SVERegOp_b = 20,
+  AArch64_OP_GROUP_SVERegOp_d = 21,
+  AArch64_OP_GROUP_SVERegOp_h = 22,
+  AArch64_OP_GROUP_SVERegOp_s = 23,
+  AArch64_OP_GROUP_TypedVectorList_0_d = 24,
+  AArch64_OP_GROUP_TypedVectorList_0_s = 25,
+  AArch64_OP_GROUP_VRegOperand = 26,
+  AArch64_OP_GROUP_TypedVectorList_0_h = 27,
+  AArch64_OP_GROUP_VectorIndex_1 = 28,
+  AArch64_OP_GROUP_ImmRangeScale_2_1 = 29,
+  AArch64_OP_GROUP_AlignedLabel = 30,
+  AArch64_OP_GROUP_CondCode = 31,
+  AArch64_OP_GROUP_ExactFPImm_AArch64ExactFPImm_half_AArch64ExactFPImm_one = 32,
+  AArch64_OP_GROUP_TypedVectorList_0_b = 33,
+  AArch64_OP_GROUP_ExactFPImm_AArch64ExactFPImm_zero_AArch64ExactFPImm_one = 34,
+  AArch64_OP_GROUP_ImmRangeScale_4_3 = 35,
+  AArch64_OP_GROUP_ExactFPImm_AArch64ExactFPImm_half_AArch64ExactFPImm_two = 36,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_8_x_d = 37,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_8_w_d = 38,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_8_w_d = 39,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_8_w_s = 40,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_8_w_s = 41,
+  AArch64_OP_GROUP_ImmScale_8 = 42,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_64_x_d = 43,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_64_w_d = 44,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_64_w_d = 45,
+  AArch64_OP_GROUP_ImmScale_2 = 46,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_16_x_d = 47,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_16_w_d = 48,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_16_w_d = 49,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_16_w_s = 50,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_16_w_s = 51,
+  AArch64_OP_GROUP_ImmScale_4 = 52,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_32_x_d = 53,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_32_w_d = 54,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_32_w_d = 55,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_32_w_s = 56,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_32_w_s = 57,
+  AArch64_OP_GROUP_PredicateAsCounter_0 = 58,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_8_x_0 = 59,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_64_x_0 = 60,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_16_x_0 = 61,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_32_x_0 = 62,
+  AArch64_OP_GROUP_SVCROp = 63,
+  AArch64_OP_GROUP_ImmScale_16 = 64,
+  AArch64_OP_GROUP_MatrixTile = 65,
+  AArch64_OP_GROUP_Shifter = 66,
+  AArch64_OP_GROUP_AddSubImm = 67,
+  AArch64_OP_GROUP_ShiftedRegister = 68,
+  AArch64_OP_GROUP_ExtendedRegister = 69,
+  AArch64_OP_GROUP_ArithExtend = 70,
+  AArch64_OP_GROUP_Matrix_64 = 71,
+  AArch64_OP_GROUP_Matrix_32 = 72,
+  AArch64_OP_GROUP_Imm8OptLsl_uint8_t = 73,
+  AArch64_OP_GROUP_Imm8OptLsl_uint64_t = 74,
+  AArch64_OP_GROUP_Imm8OptLsl_uint16_t = 75,
+  AArch64_OP_GROUP_Imm8OptLsl_uint32_t = 76,
+  AArch64_OP_GROUP_AdrAdrpLabel = 77,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_8_x_s = 78,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_16_x_s = 79,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_32_x_s = 80,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_64_x_s = 81,
+  AArch64_OP_GROUP_LogicalImm_int32_t = 82,
+  AArch64_OP_GROUP_LogicalImm_int64_t = 83,
+  AArch64_OP_GROUP_ZPRasFPR_8 = 84,
+  AArch64_OP_GROUP_ZPRasFPR_64 = 85,
+  AArch64_OP_GROUP_ZPRasFPR_16 = 86,
+  AArch64_OP_GROUP_ZPRasFPR_32 = 87,
+  AArch64_OP_GROUP_Matrix_16 = 88,
+  AArch64_OP_GROUP_Imm = 89,
+  AArch64_OP_GROUP_ImmHex = 90,
+  AArch64_OP_GROUP_ComplexRotationOp_180_90 = 91,
+  AArch64_OP_GROUP_GPRSeqPairsClassOperand_32 = 92,
+  AArch64_OP_GROUP_GPRSeqPairsClassOperand_64 = 93,
+  AArch64_OP_GROUP_ComplexRotationOp_90_0 = 94,
+  AArch64_OP_GROUP_SVEPattern = 95,
+  AArch64_OP_GROUP_PredicateAsCounter_8 = 96,
+  AArch64_OP_GROUP_SVEVecLenSpecifier = 97,
+  AArch64_OP_GROUP_PredicateAsCounter_64 = 98,
+  AArch64_OP_GROUP_PredicateAsCounter_16 = 99,
+  AArch64_OP_GROUP_PredicateAsCounter_32 = 100,
+  AArch64_OP_GROUP_Imm8OptLsl_int8_t = 101,
+  AArch64_OP_GROUP_Imm8OptLsl_int64_t = 102,
+  AArch64_OP_GROUP_Imm8OptLsl_int16_t = 103,
+  AArch64_OP_GROUP_Imm8OptLsl_int32_t = 104,
+  AArch64_OP_GROUP_BarrierOption = 105,
+  AArch64_OP_GROUP_BarriernXSOption = 106,
+  AArch64_OP_GROUP_SVERegOp_q = 107,
+  AArch64_OP_GROUP_MatrixTileVector_0 = 108,
+  AArch64_OP_GROUP_MatrixTileVector_1 = 109,
+  AArch64_OP_GROUP_FPImmOperand = 110,
+  AArch64_OP_GROUP_TypedVectorList_0_q = 111,
+  AArch64_OP_GROUP_SImm_8 = 112,
+  AArch64_OP_GROUP_SImm_16 = 113,
+  AArch64_OP_GROUP_TypedVectorList_16_b = 114,
+  AArch64_OP_GROUP_PostIncOperand_64 = 115,
+  AArch64_OP_GROUP_TypedVectorList_1_d = 116,
+  AArch64_OP_GROUP_PostIncOperand_32 = 117,
+  AArch64_OP_GROUP_TypedVectorList_2_d = 118,
+  AArch64_OP_GROUP_TypedVectorList_2_s = 119,
+  AArch64_OP_GROUP_TypedVectorList_4_h = 120,
+  AArch64_OP_GROUP_TypedVectorList_4_s = 121,
+  AArch64_OP_GROUP_TypedVectorList_8_b = 122,
+  AArch64_OP_GROUP_TypedVectorList_8_h = 123,
+  AArch64_OP_GROUP_PostIncOperand_16 = 124,
+  AArch64_OP_GROUP_PostIncOperand_8 = 125,
+  AArch64_OP_GROUP_ImmScale_32 = 126,
+  AArch64_OP_GROUP_PostIncOperand_1 = 127,
+  AArch64_OP_GROUP_PostIncOperand_4 = 128,
+  AArch64_OP_GROUP_PostIncOperand_2 = 129,
+  AArch64_OP_GROUP_PostIncOperand_48 = 130,
+  AArch64_OP_GROUP_PostIncOperand_24 = 131,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_128_x_0 = 132,
+  AArch64_OP_GROUP_ImmScale_3 = 133,
+  AArch64_OP_GROUP_PostIncOperand_3 = 134,
+  AArch64_OP_GROUP_PostIncOperand_12 = 135,
+  AArch64_OP_GROUP_PostIncOperand_6 = 136,
+  AArch64_OP_GROUP_GPR64x8 = 137,
+  AArch64_OP_GROUP_MemExtend_w_8 = 138,
+  AArch64_OP_GROUP_MemExtend_x_8 = 139,
+  AArch64_OP_GROUP_UImm12Offset_1 = 140,
+  AArch64_OP_GROUP_MemExtend_w_64 = 141,
+  AArch64_OP_GROUP_MemExtend_x_64 = 142,
+  AArch64_OP_GROUP_UImm12Offset_8 = 143,
+  AArch64_OP_GROUP_MemExtend_w_16 = 144,
+  AArch64_OP_GROUP_MemExtend_x_16 = 145,
+  AArch64_OP_GROUP_UImm12Offset_2 = 146,
+  AArch64_OP_GROUP_MemExtend_w_128 = 147,
+  AArch64_OP_GROUP_MemExtend_x_128 = 148,
+  AArch64_OP_GROUP_UImm12Offset_16 = 149,
+  AArch64_OP_GROUP_MemExtend_w_32 = 150,
+  AArch64_OP_GROUP_MemExtend_x_32 = 151,
+  AArch64_OP_GROUP_UImm12Offset_4 = 152,
+  AArch64_OP_GROUP_Matrix_0 = 153,
+  AArch64_OP_GROUP_TypedVectorList_0_0 = 154,
+  AArch64_OP_GROUP_SIMDType10Operand = 155,
+  AArch64_OP_GROUP_MRSSystemRegister = 156,
+  AArch64_OP_GROUP_MSRSystemRegister = 157,
+  AArch64_OP_GROUP_SystemPStateField = 158,
+  AArch64_OP_GROUP_RegWithShiftExtend_1_64_w_s = 159,
+  AArch64_OP_GROUP_RegWithShiftExtend_0_64_w_s = 160,
+  AArch64_OP_GROUP_PrefetchOp_0 = 161,
+  AArch64_OP_GROUP_RPRFMOperand = 162,
+  AArch64_OP_GROUP_GPR64as32 = 163,
+  AArch64_OP_GROUP_SysCROperand = 164,
+  AArch64_OP_GROUP_SyspXzrPair = 165,
+  AArch64_OP_GROUP_MatrixTileList = 166,

thirdparty/capstone/arch/AArch64/AArch64GenRegisterName.inc

@@ -0,0 +1,714 @@
+/* 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, unsigned AltIdx)
+{
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+#endif
+#ifndef CAPSTONE_DIET
+  static const char AsmStrsNoRegAltName[] = {
+  /* 0 */ "D7_D8_D9_D10\0"
+  /* 13 */ "Q7_Q8_Q9_Q10\0"
+  /* 26 */ "Z7_Z8_Z9_Z10\0"
+  /* 39 */ "b10\0"
+  /* 43 */ "d10\0"
+  /* 47 */ "h10\0"
+  /* 51 */ "p10\0"
+  /* 55 */ "q10\0"
+  /* 59 */ "s10\0"
+  /* 63 */ "w10\0"
+  /* 67 */ "x10\0"
+  /* 71 */ "z10\0"
+  /* 75 */ "D17_D18_D19_D20\0"
+  /* 91 */ "Q17_Q18_Q19_Q20\0"
+  /* 107 */ "Z17_Z18_Z19_Z20\0"
+  /* 123 */ "b20\0"
+  /* 127 */ "d20\0"
+  /* 131 */ "h20\0"
+  /* 135 */ "q20\0"
+  /* 139 */ "s20\0"
+  /* 143 */ "w20\0"
+  /* 147 */ "x20\0"
+  /* 151 */ "z20\0"
+  /* 155 */ "D27_D28_D29_D30\0"
+  /* 171 */ "Q27_Q28_Q29_Q30\0"
+  /* 187 */ "Z27_Z28_Z29_Z30\0"
+  /* 203 */ "b30\0"
+  /* 207 */ "d30\0"
+  /* 211 */ "h30\0"
+  /* 215 */ "q30\0"
+  /* 219 */ "s30\0"
+  /* 223 */ "w30\0"
+  /* 227 */ "x30\0"
+  /* 231 */ "z30\0"
+  /* 235 */ "D29_D30_D31_D0\0"
+  /* 250 */ "Q29_Q30_Q31_Q0\0"
+  /* 265 */ "Z29_Z30_Z31_Z0\0"
+  /* 280 */ "b0\0"
+  /* 283 */ "d0\0"
+  /* 286 */ "h0\0"
+  /* 289 */ "p0\0"
+  /* 292 */ "q0\0"
+  /* 295 */ "s0\0"
+  /* 298 */ "w0\0"
+  /* 301 */ "x0\0"
+  /* 304 */ "z0\0"
+  /* 307 */ "D8_D9_D10_D11\0"
+  /* 321 */ "Q8_Q9_Q10_Q11\0"
+  /* 335 */ "W10_W11\0"
+  /* 343 */ "X4_X5_X6_X7_X8_X9_X10_X11\0"
+  /* 369 */ "Z8_Z9_Z10_Z11\0"
+  /* 383 */ "b11\0"
+  /* 387 */ "d11\0"
+  /* 391 */ "h11\0"
+  /* 395 */ "p11\0"
+  /* 399 */ "q11\0"
+  /* 403 */ "s11\0"
+  /* 407 */ "w11\0"
+  /* 411 */ "x11\0"
+  /* 415 */ "z11\0"
+  /* 419 */ "D18_D19_D20_D21\0"
+  /* 435 */ "Q18_Q19_Q20_Q21\0"
+  /* 451 */ "W20_W21\0"
+  /* 459 */ "X14_X15_X16_X17_X18_X19_X20_X21\0"
+  /* 491 */ "Z18_Z19_Z20_Z21\0"
+  /* 507 */ "b21\0"
+  /* 511 */ "d21\0"
+  /* 515 */ "h21\0"
+  /* 519 */ "q21\0"
+  /* 523 */ "s21\0"
+  /* 527 */ "w21\0"
+  /* 531 */ "x21\0"
+  /* 535 */ "z21\0"
+  /* 539 */ "D28_D29_D30_D31\0"
+  /* 555 */ "Q28_Q29_Q30_Q31\0"
+  /* 571 */ "Z28_Z29_Z30_Z31\0"
+  /* 587 */ "b31\0"
+  /* 591 */ "d31\0"
+  /* 595 */ "h31\0"
+  /* 599 */ "q31\0"
+  /* 603 */ "s31\0"
+  /* 607 */ "z31\0"
+  /* 611 */ "D30_D31_D0_D1\0"
+  /* 625 */ "Q30_Q31_Q0_Q1\0"
+  /* 639 */ "W0_W1\0"
+  /* 645 */ "X0_X1\0"
+  /* 651 */ "Z30_Z31_Z0_Z1\0"
+  /* 665 */ "b1\0"
+  /* 668 */ "d1\0"
+  /* 671 */ "h1\0"
+  /* 674 */ "p1\0"
+  /* 677 */ "q1\0"
+  /* 680 */ "s1\0"
+  /* 683 */ "w1\0"
+  /* 686 */ "x1\0"
+  /* 689 */ "z1\0"
+  /* 692 */ "D9_D10_D11_D12\0"
+  /* 707 */ "Q9_Q10_Q11_Q12\0"
+  /* 722 */ "Z9_Z10_Z11_Z12\0"
+  /* 737 */ "b12\0"
+  /* 741 */ "d12\0"
+  /* 745 */ "h12\0"
+  /* 749 */ "p12\0"
+  /* 753 */ "q12\0"
+  /* 757 */ "s12\0"
+  /* 761 */ "w12\0"
+  /* 765 */ "x12\0"
+  /* 769 */ "z12\0"
+  /* 773 */ "D19_D20_D21_D22\0"
+  /* 789 */ "Q19_Q20_Q21_Q22\0"
+  /* 805 */ "Z19_Z20_Z21_Z22\0"
+  /* 821 */ "b22\0"
+  /* 825 */ "d22\0"
+  /* 829 */ "h22\0"
+  /* 833 */ "q22\0"
+  /* 837 */ "s22\0"
+  /* 841 */ "w22\0"
+  /* 845 */ "x22\0"
+  /* 849 */ "z22\0"
+  /* 853 */ "D31_D0_D1_D2\0"
+  /* 866 */ "Q31_Q0_Q1_Q2\0"
+  /* 879 */ "Z31_Z0_Z1_Z2\0"
+  /* 892 */ "b2\0"
+  /* 895 */ "d2\0"
+  /* 898 */ "h2\0"
+  /* 901 */ "p2\0"
+  /* 904 */ "q2\0"
+  /* 907 */ "s2\0"
+  /* 910 */ "w2\0"
+  /* 913 */ "x2\0"
+  /* 916 */ "z2\0"
+  /* 919 */ "D10_D11_D12_D13\0"
+  /* 935 */ "Q10_Q11_Q12_Q13\0"
+  /* 951 */ "W12_W13\0"
+  /* 959 */ "X6_X7_X8_X9_X10_X11_X12_X13\0"
+  /* 987 */ "Z10_Z11_Z12_Z13\0"
+  /* 1003 */ "b13\0"
+  /* 1007 */ "d13\0"
+  /* 1011 */ "h13\0"
+  /* 1015 */ "p13\0"
+  /* 1019 */ "q13\0"
+  /* 1023 */ "s13\0"
+  /* 1027 */ "w13\0"
+  /* 1031 */ "x13\0"
+  /* 1035 */ "z13\0"
+  /* 1039 */ "D20_D21_D22_D23\0"
+  /* 1055 */ "Q20_Q21_Q22_Q23\0"
+  /* 1071 */ "W22_W23\0"
+  /* 1079 */ "X16_X17_X18_X19_X20_X21_X22_X23\0"
+  /* 1111 */ "Z20_Z21_Z22_Z23\0"
+  /* 1127 */ "b23\0"
+  /* 1131 */ "d23\0"
+  /* 1135 */ "h23\0"
+  /* 1139 */ "q23\0"
+  /* 1143 */ "s23\0"
+  /* 1147 */ "w23\0"
+  /* 1151 */ "x23\0"
+  /* 1155 */ "z23\0"
+  /* 1159 */ "D0_D1_D2_D3\0"
+  /* 1171 */ "Q0_Q1_Q2_Q3\0"
+  /* 1183 */ "W2_W3\0"
+  /* 1189 */ "X2_X3\0"
+  /* 1195 */ "Z0_Z1_Z2_Z3\0"
+  /* 1207 */ "b3\0"
+  /* 1210 */ "d3\0"
+  /* 1213 */ "h3\0"
+  /* 1216 */ "p3\0"
+  /* 1219 */ "q3\0"
+  /* 1222 */ "s3\0"
+  /* 1225 */ "w3\0"
+  /* 1228 */ "x3\0"
+  /* 1231 */ "z3\0"
+  /* 1234 */ "D11_D12_D13_D14\0"
+  /* 1250 */ "Q11_Q12_Q13_Q14\0"
+  /* 1266 */ "Z11_Z12_Z13_Z14\0"
+  /* 1282 */ "b14\0"
+  /* 1286 */ "d14\0"
+  /* 1290 */ "h14\0"
+  /* 1294 */ "p14\0"
+  /* 1298 */ "q14\0"
+  /* 1302 */ "s14\0"
+  /* 1306 */ "w14\0"
+  /* 1310 */ "x14\0"
+  /* 1314 */ "z14\0"
+  /* 1318 */ "D21_D22_D23_D24\0"
+  /* 1334 */ "Q21_Q22_Q23_Q24\0"
+  /* 1350 */ "Z21_Z22_Z23_Z24\0"
+  /* 1366 */ "b24\0"
+  /* 1370 */ "d24\0"
+  /* 1374 */ "h24\0"
+  /* 1378 */ "q24\0"
+  /* 1382 */ "s24\0"
+  /* 1386 */ "w24\0"
+  /* 1390 */ "x24\0"
+  /* 1394 */ "z24\0"
+  /* 1398 */ "D1_D2_D3_D4\0"
+  /* 1410 */ "Q1_Q2_Q3_Q4\0"
+  /* 1422 */ "Z1_Z2_Z3_Z4\0"
+  /* 1434 */ "b4\0"
+  /* 1437 */ "d4\0"
+  /* 1440 */ "h4\0"
+  /* 1443 */ "p4\0"
+  /* 1446 */ "q4\0"
+  /* 1449 */ "s4\0"
+  /* 1452 */ "w4\0"
+  /* 1455 */ "x4\0"
+  /* 1458 */ "z4\0"
+  /* 1461 */ "D12_D13_D14_D15\0"
+  /* 1477 */ "Q12_Q13_Q14_Q15\0"
+  /* 1493 */ "W14_W15\0"
+  /* 1501 */ "X8_X9_X10_X11_X12_X13_X14_X15\0"
+  /* 1531 */ "Z12_Z13_Z14_Z15\0"
+  /* 1547 */ "b15\0"
+  /* 1551 */ "d15\0"
+  /* 1555 */ "h15\0"
+  /* 1559 */ "p15\0"
+  /* 1563 */ "q15\0"
+  /* 1567 */ "s15\0"
+  /* 1571 */ "w15\0"
+  /* 1575 */ "x15\0"
+  /* 1579 */ "z15\0"
+  /* 1583 */ "D22_D23_D24_D25\0"
+  /* 1599 */ "Q22_Q23_Q24_Q25\0"
+  /* 1615 */ "W24_W25\0"
+  /* 1623 */ "X18_X19_X20_X21_X22_X23_X24_X25\0"
+  /* 1655 */ "Z22_Z23_Z24_Z25\0"
+  /* 1671 */ "b25\0"
+  /* 1675 */ "d25\0"
+  /* 1679 */ "h25\0"
+  /* 1683 */ "q25\0"
+  /* 1687 */ "s25\0"
+  /* 1691 */ "w25\0"
+  /* 1695 */ "x25\0"
+  /* 1699 */ "z25\0"
+  /* 1703 */ "D2_D3_D4_D5\0"
+  /* 1715 */ "Q2_Q3_Q4_Q5\0"
+  /* 1727 */ "W4_W5\0"
+  /* 1733 */ "X4_X5\0"
+  /* 1739 */ "Z2_Z3_Z4_Z5\0"
+  /* 1751 */ "b5\0"
+  /* 1754 */ "d5\0"
+  /* 1757 */ "h5\0"
+  /* 1760 */ "p5\0"
+  /* 1763 */ "q5\0"
+  /* 1766 */ "s5\0"
+  /* 1769 */ "w5\0"
+  /* 1772 */ "x5\0"
+  /* 1775 */ "z5\0"
+  /* 1778 */ "D13_D14_D15_D16\0"
+  /* 1794 */ "Q13_Q14_Q15_Q16\0"
+  /* 1810 */ "Z13_Z14_Z15_Z16\0"
+  /* 1826 */ "b16\0"
+  /* 1830 */ "d16\0"
+  /* 1834 */ "h16\0"
+  /* 1838 */ "q16\0"
+  /* 1842 */ "s16\0"
+  /* 1846 */ "w16\0"
+  /* 1850 */ "x16\0"
+  /* 1854 */ "z16\0"
+  /* 1858 */ "D23_D24_D25_D26\0"
+  /* 1874 */ "Q23_Q24_Q25_Q26\0"
+  /* 1890 */ "Z23_Z24_Z25_Z26\0"
+  /* 1906 */ "b26\0"
+  /* 1910 */ "d26\0"
+  /* 1914 */ "h26\0"
+  /* 1918 */ "q26\0"
+  /* 1922 */ "s26\0"
+  /* 1926 */ "w26\0"
+  /* 1930 */ "x26\0"
+  /* 1934 */ "z26\0"
+  /* 1938 */ "D3_D4_D5_D6\0"
+  /* 1950 */ "Q3_Q4_Q5_Q6\0"
+  /* 1962 */ "Z3_Z4_Z5_Z6\0"
+  /* 1974 */ "b6\0"
+  /* 1977 */ "d6\0"
+  /* 1980 */ "h6\0"
+  /* 1983 */ "p6\0"
+  /* 1986 */ "q6\0"
+  /* 1989 */ "s6\0"
+  /* 1992 */ "w6\0"
+  /* 1995 */ "x6\0"
+  /* 1998 */ "z6\0"
+  /* 2001 */ "D14_D15_D16_D17\0"
+  /* 2017 */ "Q14_Q15_Q16_Q17\0"
+  /* 2033 */ "W16_W17\0"
+  /* 2041 */ "X10_X11_X12_X13_X14_X15_X16_X17\0"
+  /* 2073 */ "Z14_Z15_Z16_Z17\0"
+  /* 2089 */ "b17\0"
+  /* 2093 */ "d17\0"
+  /* 2097 */ "h17\0"
+  /* 2101 */ "q17\0"
+  /* 2105 */ "s17\0"
+  /* 2109 */ "w17\0"
+  /* 2113 */ "x17\0"
+  /* 2117 */ "z17\0"
+  /* 2121 */ "D24_D25_D26_D27\0"
+  /* 2137 */ "Q24_Q25_Q26_Q27\0"
+  /* 2153 */ "W26_W27\0"
+  /* 2161 */ "X20_X21_X22_X23_X24_X25_X26_X27\0"
+  /* 2193 */ "Z24_Z25_Z26_Z27\0"
+  /* 2209 */ "b27\0"
+  /* 2213 */ "d27\0"
+  /* 2217 */ "h27\0"
+  /* 2221 */ "q27\0"
+  /* 2225 */ "s27\0"
+  /* 2229 */ "w27\0"
+  /* 2233 */ "x27\0"
+  /* 2237 */ "z27\0"
+  /* 2241 */ "D4_D5_D6_D7\0"
+  /* 2253 */ "Q4_Q5_Q6_Q7\0"
+  /* 2265 */ "W6_W7\0"
+  /* 2271 */ "X0_X1_X2_X3_X4_X5_X6_X7\0"
+  /* 2295 */ "Z4_Z5_Z6_Z7\0"
+  /* 2307 */ "b7\0"
+  /* 2310 */ "d7\0"
+  /* 2313 */ "h7\0"
+  /* 2316 */ "p7\0"
+  /* 2319 */ "q7\0"
+  /* 2322 */ "s7\0"
+  /* 2325 */ "w7\0"
+  /* 2328 */ "x7\0"
+  /* 2331 */ "z7\0"
+  /* 2334 */ "D15_D16_D17_D18\0"
+  /* 2350 */ "Q15_Q16_Q17_Q18\0"
+  /* 2366 */ "Z15_Z16_Z17_Z18\0"
+  /* 2382 */ "b18\0"
+  /* 2386 */ "d18\0"
+  /* 2390 */ "h18\0"
+  /* 2394 */ "q18\0"
+  /* 2398 */ "s18\0"
+  /* 2402 */ "w18\0"
+  /* 2406 */ "x18\0"
+  /* 2410 */ "z18\0"
+  /* 2414 */ "D25_D26_D27_D28\0"
+  /* 2430 */ "Q25_Q26_Q27_Q28\0"
+  /* 2446 */ "Z25_Z26_Z27_Z28\0"
+  /* 2462 */ "b28\0"
+  /* 2466 */ "d28\0"
+  /* 2470 */ "h28\0"
+  /* 2474 */ "q28\0"
+  /* 2478 */ "s28\0"
+  /* 2482 */ "w28\0"
+  /* 2486 */ "x28\0"
+  /* 2490 */ "z28\0"
+  /* 2494 */ "D5_D6_D7_D8\0"
+  /* 2506 */ "Q5_Q6_Q7_Q8\0"
+  /* 2518 */ "Z5_Z6_Z7_Z8\0"
+  /* 2530 */ "b8\0"
+  /* 2533 */ "d8\0"
+  /* 2536 */ "h8\0"
+  /* 2539 */ "p8\0"
+  /* 2542 */ "q8\0"
+  /* 2545 */ "s8\0"
+  /* 2548 */ "w8\0"
+  /* 2551 */ "x8\0"
+  /* 2554 */ "z8\0"
+  /* 2557 */ "D16_D17_D18_D19\0"
+  /* 2573 */ "Q16_Q17_Q18_Q19\0"
+  /* 2589 */ "W18_W19\0"
+  /* 2597 */ "X12_X13_X14_X15_X16_X17_X18_X19\0"
+  /* 2629 */ "Z16_Z17_Z18_Z19\0"
+  /* 2645 */ "b19\0"
+  /* 2649 */ "d19\0"
+  /* 2653 */ "h19\0"
+  /* 2657 */ "q19\0"
+  /* 2661 */ "s19\0"
+  /* 2665 */ "w19\0"
+  /* 2669 */ "x19\0"
+  /* 2673 */ "z19\0"
+  /* 2677 */ "D26_D27_D28_D29\0"
+  /* 2693 */ "Q26_Q27_Q28_Q29\0"
+  /* 2709 */ "W28_W29\0"
+  /* 2717 */ "Z26_Z27_Z28_Z29\0"
+  /* 2733 */ "b29\0"
+  /* 2737 */ "d29\0"
+  /* 2741 */ "h29\0"
+  /* 2745 */ "q29\0"
+  /* 2749 */ "s29\0"
+  /* 2753 */ "w29\0"
+  /* 2757 */ "x29\0"
+  /* 2761 */ "z29\0"
+  /* 2765 */ "D6_D7_D8_D9\0"
+  /* 2777 */ "Q6_Q7_Q8_Q9\0"
+  /* 2789 */ "W8_W9\0"
+  /* 2795 */ "X2_X3_X4_X5_X6_X7_X8_X9\0"
+  /* 2819 */ "Z6_Z7_Z8_Z9\0"
+  /* 2831 */ "b9\0"
+  /* 2834 */ "d9\0"
+  /* 2837 */ "h9\0"
+  /* 2840 */ "p9\0"
+  /* 2843 */ "q9\0"
+  /* 2846 */ "s9\0"
+  /* 2849 */ "w9\0"
+  /* 2852 */ "x9\0"
+  /* 2855 */ "z9\0"
+  /* 2858 */ "X22_X23_X24_X25_X26_X27_X28_FP\0"
+  /* 2889 */ "W30_WZR\0"
+  /* 2897 */ "LR_XZR\0"
+  /* 2904 */ "za\0"
+  /* 2907 */ "za0.b\0"
+  /* 2913 */ "za0.d\0"
+  /* 2919 */ "za1.d\0"
+  /* 2925 */ "za2.d\0"
+  /* 2931 */ "za3.d\0"
+  /* 2937 */ "za4.d\0"
+  /* 2943 */ "za5.d\0"
+  /* 2949 */ "za6.d\0"
+  /* 2955 */ "za7.d\0"
+  /* 2961 */ "vg\0"
+  /* 2964 */ "za0.h\0"
+  /* 2970 */ "za1.h\0"
+  /* 2976 */ "z10_hi\0"
+  /* 2983 */ "z20_hi\0"
+  /* 2990 */ "z30_hi\0"
+  /* 2997 */ "z0_hi\0"
+  /* 3003 */ "z11_hi\0"
+  /* 3010 */ "z21_hi\0"
+  /* 3017 */ "z31_hi\0"
+  /* 3024 */ "z1_hi\0"
+  /* 3030 */ "z12_hi\0"
+  /* 3037 */ "z22_hi\0"
+  /* 3044 */ "z2_hi\0"
+  /* 3050 */ "z13_hi\0"
+  /* 3057 */ "z23_hi\0"
+  /* 3064 */ "z3_hi\0"
+  /* 3070 */ "z14_hi\0"
+  /* 3077 */ "z24_hi\0"
+  /* 3084 */ "z4_hi\0"
+  /* 3090 */ "z15_hi\0"
+  /* 3097 */ "z25_hi\0"
+  /* 3104 */ "z5_hi\0"
+  /* 3110 */ "z16_hi\0"
+  /* 3117 */ "z26_hi\0"
+  /* 3124 */ "z6_hi\0"
+  /* 3130 */ "z17_hi\0"
+  /* 3137 */ "z27_hi\0"
+  /* 3144 */ "z7_hi\0"
+  /* 3150 */ "z18_hi\0"
+  /* 3157 */ "z28_hi\0"
+  /* 3164 */ "z8_hi\0"
+  /* 3170 */ "z19_hi\0"
+  /* 3177 */ "z29_hi\0"
+  /* 3184 */ "z9_hi\0"
+  /* 3190 */ "wsp\0"
+  /* 3194 */ "za10.q\0"
+  /* 3201 */ "za0.q\0"
+  /* 3207 */ "za11.q\0"
+  /* 3214 */ "za1.q\0"
+  /* 3220 */ "za12.q\0"
+  /* 3227 */ "za2.q\0"
+  /* 3233 */ "za13.q\0"
+  /* 3240 */ "za3.q\0"
+  /* 3246 */ "za14.q\0"
+  /* 3253 */ "za4.q\0"
+  /* 3259 */ "za15.q\0"
+  /* 3266 */ "za5.q\0"
+  /* 3272 */ "za6.q\0"
+  /* 3278 */ "za7.q\0"
+  /* 3284 */ "za8.q\0"
+  /* 3290 */ "za9.q\0"
+  /* 3296 */ "ffr\0"
+  /* 3300 */ "wzr\0"
+  /* 3304 */ "xzr\0"
+  /* 3308 */ "za0.s\0"
+  /* 3314 */ "za1.s\0"
+  /* 3320 */ "za2.s\0"
+  /* 3326 */ "za3.s\0"
+  /* 3332 */ "nzcv\0"
+};
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+  static const uint16_t RegAsmOffsetNoRegAltName[] = {
+    3296, 2757, 227, 3332, 3191, 2961, 3190, 3300, 3304, 2904, 280, 665, 892, 1207,
+    1434, 1751, 1974, 2307, 2530, 2831, 39, 383, 737, 1003, 1282, 1547, 1826, 2089,
+    2382, 2645, 123, 507, 821, 1127, 1366, 1671, 1906, 2209, 2462, 2733, 203, 587,
+    283, 668, 895, 1210, 1437, 1754, 1977, 2310, 2533, 2834, 43, 387, 741, 1007,
+    1286, 1551, 1830, 2093, 2386, 2649, 127, 511, 825, 1131, 1370, 1675, 1910, 2213,
+    2466, 2737, 207, 591, 286, 671, 898, 1213, 1440, 1757, 1980, 2313, 2536, 2837,
+    47, 391, 745, 1011, 1290, 1555, 1834, 2097, 2390, 2653, 131, 515, 829, 1135,
+    1374, 1679, 1914, 2217, 2470, 2741, 211, 595, 289, 674, 901, 1216, 1443, 1760,
+    1983, 2316, 2539, 2840, 51, 395, 749, 1015, 1294, 1559, 292, 677, 904, 1219,
+    1446, 1763, 1986, 2319, 2542, 2843, 55, 399, 753, 1019, 1298, 1563, 1838, 2101,
+    2394, 2657, 135, 519, 833, 1139, 1378, 1683, 1918, 2221, 2474, 2745, 215, 599,
+    295, 680, 907, 1222, 1449, 1766, 1989, 2322, 2545, 2846, 59, 403, 757, 1023,
+    1302, 1567, 1842, 2105, 2398, 2661, 139, 523, 837, 1143, 1382, 1687, 1922, 2225,
+    2478, 2749, 219, 603, 298, 683, 910, 1225, 1452, 1769, 1992, 2325, 2548, 2849,
+    63, 407, 761, 1027, 1306, 1571, 1846, 2109, 2402, 2665, 143, 527, 841, 1147,
+    1386, 1691, 1926, 2229, 2482, 2753, 223, 301, 686, 913, 1228, 1455, 1772, 1995,
+    2328, 2551, 2852, 67, 411, 765, 1031, 1310, 1575, 1850, 2113, 2406, 2669, 147,
+    531, 845, 1151, 1390, 1695, 1930, 2233, 2486, 304, 689, 916, 1231, 1458, 1775,
+    1998, 2331, 2554, 2855, 71, 415, 769, 1035, 1314, 1579, 1854, 2117, 2410, 2673,
+    151, 535, 849, 1155, 1394, 1699, 1934, 2237, 2490, 2761, 231, 607, 2907, 2913,
+    2919, 2925, 2931, 2937, 2943, 2949, 2955, 2964, 2970, 3201, 3214, 3227, 3240, 3253,
+    3266, 3272, 3278, 3284, 3290, 3194, 3207, 3220, 3233, 3246, 3259, 3308, 3314, 3320,
+    3326, 2997, 3024, 3044, 3064, 3084, 3104, 3124, 3144, 3164, 3184, 2976, 3003, 3030,
+    3050, 3070, 3090, 3110, 3130, 3150, 3170, 2983, 3010, 3037, 3057, 3077, 3097, 3117,
+    3137, 3157, 3177, 2990, 3017, 619, 860, 1165, 1404, 1709, 1944, 2247, 2500, 2771,
+    6, 313, 699, 927, 1242, 1469, 1786, 2009, 2342, 2565, 83, 427, 781, 1047,
+    1326, 1591, 1866, 2129, 2422, 2685, 163, 547, 243, 1159, 1398, 1703, 1938, 2241,
+    2494, 2765, 0, 307, 692, 919, 1234, 1461, 1778, 2001, 2334, 2557, 75, 419,
+    773, 1039, 1318, 1583, 1858, 2121, 2414, 2677, 155, 539, 235, 611, 853, 857,
+    1162, 1401, 1706, 1941, 2244, 2497, 2768, 3, 310, 695, 923, 1238, 1465, 1782,
+    2005, 2338, 2561, 79, 423, 777, 1043, 1322, 1587, 1862, 2125, 2418, 2681, 159,
+    543, 239, 615, 633, 873, 1177, 1416, 1721, 1956, 2259, 2512, 2783, 19, 327,
+    714, 943, 1258, 1485, 1802, 2025, 2358, 2581, 99, 443, 797, 1063, 1342, 1607,
+    1882, 2145, 2438, 2701, 179, 563, 258, 1171, 1410, 1715, 1950, 2253, 2506, 2777,
+    13, 321, 707, 935, 1250, 1477, 1794, 2017, 2350, 2573, 91, 435, 789, 1055,
+    1334, 1599, 1874, 2137, 2430, 2693, 171, 555, 250, 625, 866, 870, 1174, 1413,
+    1718, 1953, 2256, 2509, 2780, 16, 324, 710, 939, 1254, 1481, 1798, 2021, 2354,
+    2577, 95, 439, 793, 1059, 1338, 1603, 1878, 2141, 2434, 2697, 175, 559, 254,
+    629, 2858, 2271, 2795, 343, 959, 1501, 2041, 2597, 459, 1079, 1623, 2161, 2889,
+    639, 1183, 1727, 2265, 2789, 335, 951, 1493, 2033, 2589, 451, 1071, 1615, 2153,
+    2709, 2897, 2882, 645, 1189, 1733, 2289, 2813, 361, 979, 1523, 2065, 2621, 483,
+    1103, 1647, 2185, 659, 886, 1201, 1428, 1745, 1968, 2301, 2524, 2825, 32, 375,
+    729, 995, 1274, 1539, 1818, 2081, 2374, 2637, 115, 499, 813, 1119, 1358, 1663,
+    1898, 2201, 2454, 2725, 195, 579, 273, 1195, 1422, 1739, 1962, 2295, 2518, 2819,
+    26, 369, 722, 987, 1266, 1531, 1810, 2073, 2366, 2629, 107, 491, 805, 1111,
+    1350, 1655, 1890, 2193, 2446, 2717, 187, 571, 265, 651, 879, 883, 1198, 1425,
+    1742, 1965, 2298, 2521, 2822, 29, 372, 725, 991, 1270, 1535, 1814, 2077, 2370,
+    2633, 111, 495, 809, 1115, 1354, 1659, 1894, 2197, 2450, 2721, 191, 575, 269,
+    655,
+  };
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+#endif
+  static const char AsmStrsvlist1[] = {
+  /* 0 */ "\0"
+};
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+  static const uint8_t RegAsmOffsetvlist1[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0,
+  };
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+#endif
+  static const char AsmStrsvreg[] = {
+  /* 0 */ "v10\0"
+  /* 4 */ "v20\0"
+  /* 8 */ "v30\0"
+  /* 12 */ "v0\0"
+  /* 15 */ "v11\0"
+  /* 19 */ "v21\0"
+  /* 23 */ "v31\0"
+  /* 27 */ "v1\0"
+  /* 30 */ "v12\0"
+  /* 34 */ "v22\0"
+  /* 38 */ "v2\0"
+  /* 41 */ "v13\0"
+  /* 45 */ "v23\0"
+  /* 49 */ "v3\0"
+  /* 52 */ "v14\0"
+  /* 56 */ "v24\0"
+  /* 60 */ "v4\0"
+  /* 63 */ "v15\0"
+  /* 67 */ "v25\0"
+  /* 71 */ "v5\0"
+  /* 74 */ "v16\0"
+  /* 78 */ "v26\0"
+  /* 82 */ "v6\0"
+  /* 85 */ "v17\0"
+  /* 89 */ "v27\0"
+  /* 93 */ "v7\0"
+  /* 96 */ "v18\0"
+  /* 100 */ "v28\0"
+  /* 104 */ "v8\0"
+  /* 107 */ "v19\0"
+  /* 111 */ "v29\0"
+  /* 115 */ "v9\0"
+};
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+  static const uint8_t RegAsmOffsetvreg[] = {
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    12, 27, 38, 49, 60, 71, 82, 93, 104, 115, 0, 15, 30, 41,
+    52, 63, 74, 85, 96, 107, 4, 19, 34, 45, 56, 67, 78, 89,
+    100, 111, 8, 23, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 12, 27, 38, 49,
+    60, 71, 82, 93, 104, 115, 0, 15, 30, 41, 52, 63, 74, 85,
+    96, 107, 4, 19, 34, 45, 56, 67, 78, 89, 100, 111, 8, 23,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 12, 27, 38, 49, 60, 71, 82, 93, 104,
+    115, 0, 15, 30, 41, 52, 63, 74, 85, 96, 107, 4, 19, 34,
+    45, 56, 67, 78, 89, 100, 111, 8, 23, 12, 27, 38, 49, 60,
+    71, 82, 93, 104, 115, 0, 15, 30, 41, 52, 63, 74, 85, 96,
+    107, 4, 19, 34, 45, 56, 67, 78, 89, 100, 111, 8, 23, 12,
+    27, 38, 49, 60, 71, 82, 93, 104, 115, 0, 15, 30, 41, 52,
+    63, 74, 85, 96, 107, 4, 19, 34, 45, 56, 67, 78, 89, 100,
+    111, 8, 23, 12, 27, 38, 49, 60, 71, 82, 93, 104, 115, 0,
+    15, 30, 41, 52, 63, 74, 85, 96, 107, 4, 19, 34, 45, 56,
+    67, 78, 89, 100, 111, 8, 23, 12, 27, 38, 49, 60, 71, 82,
+    93, 104, 115, 0, 15, 30, 41, 52, 63, 74, 85, 96, 107, 4,
+    19, 34, 45, 56, 67, 78, 89, 100, 111, 8, 23, 12, 27, 38,
+    49, 60, 71, 82, 93, 104, 115, 0, 15, 30, 41, 52, 63, 74,
+    85, 96, 107, 4, 19, 34, 45, 56, 67, 78, 89, 100, 111, 8,
+    23, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    3,
+  };
+
+  switch(AltIdx) {
+  default:
+    return (const char *)(sizeof(RegAsmOffsetvreg)/sizeof(RegAsmOffsetvreg[0]));
+  case AArch64_NoRegAltName:
+    return AsmStrsNoRegAltName+RegAsmOffsetNoRegAltName[RegNo-1];
+  case AArch64_vlist1:
+    return AsmStrsvlist1+RegAsmOffsetvlist1[RegNo-1];
+  case AArch64_vreg:
+    return AsmStrsvreg+RegAsmOffsetvreg[RegNo-1];
+  }
+#else
+  return NULL;
+#endif
+}

thirdparty/capstone/arch/AArch64/AArch64GenSubtargetInfo.inc

@@ -0,0 +1,298 @@
+/* Capstone Disassembly Engine, https://www.capstone-engine.org */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */
+/*    Rot127 <unisono@quyllur.org> 2022-2024 */
+/* 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 */
+
+#ifdef GET_SUBTARGETINFO_ENUM
+#undef GET_SUBTARGETINFO_ENUM
+
+enum {
+  AArch64_FeatureAES = 0,
+  AArch64_FeatureALULSLFast = 1,
+  AArch64_FeatureAM = 2,
+  AArch64_FeatureAMVS = 3,
+  AArch64_FeatureAddrLSLFast = 4,
+  AArch64_FeatureAggressiveFMA = 5,
+  AArch64_FeatureAll = 6,
+  AArch64_FeatureAltFPCmp = 7,
+  AArch64_FeatureAlternateSExtLoadCVTF32Pattern = 8,
+  AArch64_FeatureAppleA7SysReg = 9,
+  AArch64_FeatureArithmeticBccFusion = 10,
+  AArch64_FeatureArithmeticCbzFusion = 11,
+  AArch64_FeatureAscendStoreAddress = 12,
+  AArch64_FeatureB16B16 = 13,
+  AArch64_FeatureBF16 = 14,
+  AArch64_FeatureBRBE = 15,
+  AArch64_FeatureBalanceFPOps = 16,
+  AArch64_FeatureBranchTargetId = 17,
+  AArch64_FeatureCCIDX = 18,
+  AArch64_FeatureCCPP = 19,
+  AArch64_FeatureCHK = 20,
+  AArch64_FeatureCLRBHB = 21,
+  AArch64_FeatureCONTEXTIDREL2 = 22,
+  AArch64_FeatureCPA = 23,
+  AArch64_FeatureCRC = 24,
+  AArch64_FeatureCSSC = 25,
+  AArch64_FeatureCacheDeepPersist = 26,
+  AArch64_FeatureCallSavedX8 = 27,
+  AArch64_FeatureCallSavedX9 = 28,
+  AArch64_FeatureCallSavedX10 = 29,
+  AArch64_FeatureCallSavedX11 = 30,
+  AArch64_FeatureCallSavedX12 = 31,
+  AArch64_FeatureCallSavedX13 = 32,
+  AArch64_FeatureCallSavedX14 = 33,
+  AArch64_FeatureCallSavedX15 = 34,
+  AArch64_FeatureCallSavedX18 = 35,
+  AArch64_FeatureCmpBccFusion = 36,
+  AArch64_FeatureComplxNum = 37,
+  AArch64_FeatureCrypto = 38,
+  AArch64_FeatureD128 = 39,
+  AArch64_FeatureDIT = 40,
+  AArch64_FeatureDisableLatencySchedHeuristic = 41,
+  AArch64_FeatureDisableLdp = 42,
+  AArch64_FeatureDisableStp = 43,
+  AArch64_FeatureDotProd = 44,
+  AArch64_FeatureEL2VMSA = 45,
+  AArch64_FeatureEL3 = 46,
+  AArch64_FeatureETE = 47,
+  AArch64_FeatureEnableSelectOptimize = 48,
+  AArch64_FeatureEnhancedCounterVirtualization = 49,
+  AArch64_FeatureExperimentalZeroingPseudos = 50,
+  AArch64_FeatureExynosCheapAsMoveHandling = 51,
+  AArch64_FeatureFAMINMAX = 52,
+  AArch64_FeatureFMV = 53,
+  AArch64_FeatureFP8 = 54,
+  AArch64_FeatureFP8DOT2 = 55,
+  AArch64_FeatureFP8DOT4 = 56,
+  AArch64_FeatureFP8FMA = 57,
+  AArch64_FeatureFP16FML = 58,
+  AArch64_FeatureFPARMv8 = 59,
+  AArch64_FeatureFPMR = 60,
+  AArch64_FeatureFRInt3264 = 61,
+  AArch64_FeatureFineGrainedTraps = 62,
+  AArch64_FeatureFixCortexA53_835769 = 63,
+  AArch64_FeatureFlagM = 64,
+  AArch64_FeatureForce32BitJumpTables = 65,
+  AArch64_FeatureFullFP16 = 66,
+  AArch64_FeatureFuseAES = 67,
+  AArch64_FeatureFuseAddSub2RegAndConstOne = 68,
+  AArch64_FeatureFuseAddress = 69,
+  AArch64_FeatureFuseAdrpAdd = 70,
+  AArch64_FeatureFuseArithmeticLogic = 71,
+  AArch64_FeatureFuseCCSelect = 72,
+  AArch64_FeatureFuseCryptoEOR = 73,
+  AArch64_FeatureFuseLiterals = 74,
+  AArch64_FeatureGCS = 75,
+  AArch64_FeatureHBC = 76,
+  AArch64_FeatureHCX = 77,
+  AArch64_FeatureHardenSlsBlr = 78,
+  AArch64_FeatureHardenSlsNoComdat = 79,
+  AArch64_FeatureHardenSlsRetBr = 80,
+  AArch64_FeatureITE = 81,
+  AArch64_FeatureJS = 82,
+  AArch64_FeatureLOR = 83,
+  AArch64_FeatureLS64 = 84,
+  AArch64_FeatureLSE = 85,
+  AArch64_FeatureLSE2 = 86,
+  AArch64_FeatureLSE128 = 87,
+  AArch64_FeatureLUT = 88,
+  AArch64_FeatureLdpAlignedOnly = 89,
+  AArch64_FeatureMEC = 90,
+  AArch64_FeatureMOPS = 91,
+  AArch64_FeatureMPAM = 92,
+  AArch64_FeatureMTE = 93,
+  AArch64_FeatureMatMulFP32 = 94,
+  AArch64_FeatureMatMulFP64 = 95,
+  AArch64_FeatureMatMulInt8 = 96,
+  AArch64_FeatureNEON = 97,
+  AArch64_FeatureNMI = 98,
+  AArch64_FeatureNV = 99,
+  AArch64_FeatureNoBTIAtReturnTwice = 100,
+  AArch64_FeatureNoNegativeImmediates = 101,
+  AArch64_FeatureNoSVEFPLD1R = 102,
+  AArch64_FeatureNoZCZeroingFP = 103,
+  AArch64_FeatureOutlineAtomics = 104,
+  AArch64_FeaturePAN = 105,
+  AArch64_FeaturePAN_RWV = 106,
+  AArch64_FeaturePAuth = 107,
+  AArch64_FeaturePAuthLR = 108,
+  AArch64_FeaturePRFM_SLC = 109,
+  AArch64_FeaturePerfMon = 110,
+  AArch64_FeaturePostRAScheduler = 111,
+  AArch64_FeaturePredRes = 112,
+  AArch64_FeaturePredictableSelectIsExpensive = 113,
+  AArch64_FeaturePsUAO = 114,
+  AArch64_FeatureRAS = 115,
+  AArch64_FeatureRASv2 = 116,
+  AArch64_FeatureRCPC = 117,
+  AArch64_FeatureRCPC3 = 118,
+  AArch64_FeatureRCPC_IMMO = 119,
+  AArch64_FeatureRDM = 120,
+  AArch64_FeatureRME = 121,
+  AArch64_FeatureRandGen = 122,
+  AArch64_FeatureReserveX1 = 123,
+  AArch64_FeatureReserveX2 = 124,
+  AArch64_FeatureReserveX3 = 125,
+  AArch64_FeatureReserveX4 = 126,
+  AArch64_FeatureReserveX5 = 127,
+  AArch64_FeatureReserveX6 = 128,
+  AArch64_FeatureReserveX7 = 129,
+  AArch64_FeatureReserveX9 = 130,
+  AArch64_FeatureReserveX10 = 131,
+  AArch64_FeatureReserveX11 = 132,
+  AArch64_FeatureReserveX12 = 133,
+  AArch64_FeatureReserveX13 = 134,
+  AArch64_FeatureReserveX14 = 135,
+  AArch64_FeatureReserveX15 = 136,
+  AArch64_FeatureReserveX18 = 137,
+  AArch64_FeatureReserveX20 = 138,
+  AArch64_FeatureReserveX21 = 139,
+  AArch64_FeatureReserveX22 = 140,
+  AArch64_FeatureReserveX23 = 141,
+  AArch64_FeatureReserveX24 = 142,
+  AArch64_FeatureReserveX25 = 143,
+  AArch64_FeatureReserveX26 = 144,
+  AArch64_FeatureReserveX27 = 145,
+  AArch64_FeatureReserveX28 = 146,
+  AArch64_FeatureReserveX30 = 147,
+  AArch64_FeatureSB = 148,
+  AArch64_FeatureSEL2 = 149,
+  AArch64_FeatureSHA2 = 150,
+  AArch64_FeatureSHA3 = 151,
+  AArch64_FeatureSM4 = 152,
+  AArch64_FeatureSME = 153,
+  AArch64_FeatureSME2 = 154,
+  AArch64_FeatureSME2p1 = 155,
+  AArch64_FeatureSMEF8F16 = 156,
+  AArch64_FeatureSMEF8F32 = 157,
+  AArch64_FeatureSMEF16F16 = 158,
+  AArch64_FeatureSMEF64F64 = 159,
+  AArch64_FeatureSMEFA64 = 160,
+  AArch64_FeatureSMEI16I64 = 161,
+  AArch64_FeatureSME_LUTv2 = 162,
+  AArch64_FeatureSPE = 163,
+  AArch64_FeatureSPECRES2 = 164,
+  AArch64_FeatureSPE_EEF = 165,
+  AArch64_FeatureSSBS = 166,
+  AArch64_FeatureSSVE_FP8DOT2 = 167,
+  AArch64_FeatureSSVE_FP8DOT4 = 168,
+  AArch64_FeatureSSVE_FP8FMA = 169,
+  AArch64_FeatureSVE = 170,
+  AArch64_FeatureSVE2 = 171,
+  AArch64_FeatureSVE2AES = 172,
+  AArch64_FeatureSVE2BitPerm = 173,
+  AArch64_FeatureSVE2SHA3 = 174,
+  AArch64_FeatureSVE2SM4 = 175,
+  AArch64_FeatureSVE2p1 = 176,
+  AArch64_FeatureSlowMisaligned128Store = 177,
+  AArch64_FeatureSlowPaired128 = 178,
+  AArch64_FeatureSlowSTRQro = 179,
+  AArch64_FeatureSpecRestrict = 180,
+  AArch64_FeatureStorePairSuppress = 181,
+  AArch64_FeatureStpAlignedOnly = 182,
+  AArch64_FeatureStrictAlign = 183,
+  AArch64_FeatureTHE = 184,
+  AArch64_FeatureTLBIW = 185,
+  AArch64_FeatureTLB_RMI = 186,
+  AArch64_FeatureTME = 187,
+  AArch64_FeatureTRACEV8_4 = 188,
+  AArch64_FeatureTRBE = 189,
+  AArch64_FeatureTaggedGlobals = 190,
+  AArch64_FeatureUseEL1ForTP = 191,
+  AArch64_FeatureUseEL2ForTP = 192,
+  AArch64_FeatureUseEL3ForTP = 193,
+  AArch64_FeatureUseROEL0ForTP = 194,
+  AArch64_FeatureUseRSqrt = 195,
+  AArch64_FeatureUseScalarIncVL = 196,
+  AArch64_FeatureVH = 197,
+  AArch64_FeatureWFxT = 198,
+  AArch64_FeatureXS = 199,
+  AArch64_FeatureZCRegMove = 200,
+  AArch64_FeatureZCZeroing = 201,
+  AArch64_FeatureZCZeroingFPWorkaround = 202,
+  AArch64_FeatureZCZeroingGP = 203,
+  AArch64_HasV8_0aOps = 204,
+  AArch64_HasV8_0rOps = 205,
+  AArch64_HasV8_1aOps = 206,
+  AArch64_HasV8_2aOps = 207,
+  AArch64_HasV8_3aOps = 208,
+  AArch64_HasV8_4aOps = 209,
+  AArch64_HasV8_5aOps = 210,
+  AArch64_HasV8_6aOps = 211,
+  AArch64_HasV8_7aOps = 212,
+  AArch64_HasV8_8aOps = 213,
+  AArch64_HasV8_9aOps = 214,
+  AArch64_HasV9_0aOps = 215,
+  AArch64_HasV9_1aOps = 216,
+  AArch64_HasV9_2aOps = 217,
+  AArch64_HasV9_3aOps = 218,
+  AArch64_HasV9_4aOps = 219,
+  AArch64_HasV9_5aOps = 220,
+  AArch64_TuneA35 = 221,
+  AArch64_TuneA53 = 222,
+  AArch64_TuneA55 = 223,
+  AArch64_TuneA57 = 224,
+  AArch64_TuneA64FX = 225,
+  AArch64_TuneA65 = 226,
+  AArch64_TuneA72 = 227,
+  AArch64_TuneA73 = 228,
+  AArch64_TuneA75 = 229,
+  AArch64_TuneA76 = 230,
+  AArch64_TuneA77 = 231,
+  AArch64_TuneA78 = 232,
+  AArch64_TuneA78C = 233,
+  AArch64_TuneA510 = 234,
+  AArch64_TuneA520 = 235,
+  AArch64_TuneA710 = 236,
+  AArch64_TuneA715 = 237,
+  AArch64_TuneA720 = 238,
+  AArch64_TuneAmpere1 = 239,
+  AArch64_TuneAmpere1A = 240,
+  AArch64_TuneAmpere1B = 241,
+  AArch64_TuneAppleA7 = 242,
+  AArch64_TuneAppleA10 = 243,
+  AArch64_TuneAppleA11 = 244,
+  AArch64_TuneAppleA12 = 245,
+  AArch64_TuneAppleA13 = 246,
+  AArch64_TuneAppleA14 = 247,
+  AArch64_TuneAppleA15 = 248,
+  AArch64_TuneAppleA16 = 249,
+  AArch64_TuneAppleA17 = 250,
+  AArch64_TuneCarmel = 251,
+  AArch64_TuneExynosM3 = 252,
+  AArch64_TuneExynosM4 = 253,
+  AArch64_TuneFalkor = 254,
+  AArch64_TuneKryo = 255,
+  AArch64_TuneNeoverse512TVB = 256,
+  AArch64_TuneNeoverseE1 = 257,
+  AArch64_TuneNeoverseN1 = 258,
+  AArch64_TuneNeoverseN2 = 259,
+  AArch64_TuneNeoverseV1 = 260,
+  AArch64_TuneNeoverseV2 = 261,
+  AArch64_TuneR82 = 262,
+  AArch64_TuneSaphira = 263,
+  AArch64_TuneTSV110 = 264,
+  AArch64_TuneThunderX = 265,
+  AArch64_TuneThunderX2T99 = 266,
+  AArch64_TuneThunderX3T110 = 267,
+  AArch64_TuneThunderXT81 = 268,
+  AArch64_TuneThunderXT83 = 269,
+  AArch64_TuneThunderXT88 = 270,
+  AArch64_TuneX1 = 271,
+  AArch64_TuneX2 = 272,
+  AArch64_TuneX3 = 273,
+  AArch64_TuneX4 = 274,
+  AArch64_NumSubtargetFeatures = 275
+};
+#endif // GET_SUBTARGETINFO_ENUM
+
+
+

thirdparty/capstone/arch/AArch64/AArch64InstPrinter.h

@@ -0,0 +1,350 @@
+/* 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: <commit> */
+/* LLVM-tag: <tag> */
+
+/* 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 */
+
+//===-- AArch64InstPrinter.h - Convert AArch64 MCInst to assembly syntax --===//
+//
+// 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 AArch64 MCInst to a .s file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64INSTPRINTER_H
+#define LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64INSTPRINTER_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <capstone/platform.h>
+
+#include "AArch64Mapping.h"
+
+#include "../../MCInst.h"
+#include "../../MCRegisterInfo.h"
+#include "../../MCInstPrinter.h"
+#include "../../SStream.h"
+#include "../../utils.h"
+
+#define CONCAT(a, b) CONCAT_(a, b)
+#define CONCAT_(a, b) a##_##b
+#define CHAR(c) #c[0]
+
+void printInst(MCInst *MI, uint64_t Address, const char *Annot, SStream *O);
+void printRegName(SStream *OS, unsigned Reg);
+void printRegNameAlt(SStream *OS, unsigned Reg, unsigned AltIdx);
+// Autogenerated by tblgen.
+const char *getRegName(unsigned Reg);
+bool printSysAlias(MCInst *MI, SStream *O);
+bool printSyspAlias(MCInst *MI, SStream *O);
+bool printRangePrefetchAlias(MCInst *MI, SStream *O, const char *Annot);
+// Operand printers
+void printOperand(MCInst *MI, unsigned OpNo, SStream *O);
+void printImm(MCInst *MI, unsigned OpNo, SStream *O);
+void printImmHex(MCInst *MI, unsigned OpNo, SStream *O);
+#define DECLARE_printSImm(Size) \
+	void CONCAT(printSImm, Size)(MCInst * MI, unsigned OpNo, SStream *O);
+DECLARE_printSImm(16);
+DECLARE_printSImm(8);
+
+#define DECLARE_printImmSVE(T) void CONCAT(printImmSVE, T)(T Val, SStream * O);
+DECLARE_printImmSVE(int16_t);
+DECLARE_printImmSVE(int8_t);
+DECLARE_printImmSVE(int64_t);
+DECLARE_printImmSVE(int32_t);
+DECLARE_printImmSVE(uint16_t);
+DECLARE_printImmSVE(uint8_t);
+DECLARE_printImmSVE(uint64_t);
+DECLARE_printImmSVE(uint32_t);
+
+void printPostIncOperand(MCInst *MI, unsigned OpNo, unsigned Imm, SStream *O);
+#define DEFINE_printPostIncOperand(Amount) \
+	static inline void CONCAT(printPostIncOperand, Amount)( \
+		MCInst * MI, unsigned OpNo, SStream *O) \
+	{ \
+		add_cs_detail(MI, \
+			      CONCAT(AArch64_OP_GROUP_PostIncOperand, Amount), \
+			      OpNo, Amount); \
+		printPostIncOperand(MI, OpNo, Amount, O); \
+	}
+DEFINE_printPostIncOperand(64);
+DEFINE_printPostIncOperand(32);
+DEFINE_printPostIncOperand(16);
+DEFINE_printPostIncOperand(8);
+DEFINE_printPostIncOperand(1);
+DEFINE_printPostIncOperand(4);
+DEFINE_printPostIncOperand(2);
+DEFINE_printPostIncOperand(48);
+DEFINE_printPostIncOperand(24);
+DEFINE_printPostIncOperand(3);
+DEFINE_printPostIncOperand(12);
+DEFINE_printPostIncOperand(6);
+
+void printVRegOperand(MCInst *MI, unsigned OpNo, SStream *O);
+void printSysCROperand(MCInst *MI, unsigned OpNo, SStream *O);
+void printAddSubImm(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printLogicalImm(T) \
+	void CONCAT(printLogicalImm, T)(MCInst * MI, unsigned OpNum, \
+					SStream *O);
+DECLARE_printLogicalImm(int64_t);
+DECLARE_printLogicalImm(int32_t);
+DECLARE_printLogicalImm(int8_t);
+DECLARE_printLogicalImm(int16_t);
+
+void printShifter(MCInst *MI, unsigned OpNum, SStream *O);
+void printShiftedRegister(MCInst *MI, unsigned OpNum, SStream *O);
+void printExtendedRegister(MCInst *MI, unsigned OpNum, SStream *O);
+void printArithExtend(MCInst *MI, unsigned OpNum, SStream *O);
+
+void printMemExtend(MCInst *MI, unsigned OpNum, SStream *O, char SrcRegKind,
+		    unsigned Width);
+void printMemExtend(MCInst *MI, unsigned OpNum, SStream *O, char SrcRegKind,
+		    unsigned Width);
+#define DEFINE_printMemExtend(SrcRegKind, Width) \
+	static inline void CONCAT(printMemExtend, CONCAT(SrcRegKind, Width))( \
+		MCInst * MI, unsigned OpNum, SStream *O) \
+	{ \
+		add_cs_detail( \
+			MI, \
+			CONCAT(CONCAT(AArch64_OP_GROUP_MemExtend, SrcRegKind), \
+			       Width), \
+			OpNum, CHAR(SrcRegKind), Width); \
+		printMemExtend(MI, OpNum, O, CHAR(SrcRegKind), Width); \
+	}
+DEFINE_printMemExtend(w, 8);
+DEFINE_printMemExtend(x, 8);
+DEFINE_printMemExtend(w, 64);
+DEFINE_printMemExtend(x, 64);
+DEFINE_printMemExtend(w, 16);
+DEFINE_printMemExtend(x, 16);
+DEFINE_printMemExtend(w, 128);
+DEFINE_printMemExtend(x, 128);
+DEFINE_printMemExtend(w, 32);
+DEFINE_printMemExtend(x, 32);
+
+#define DECLARE_printRegWithShiftExtend(SignedExtend, ExtWidth, SrcRegKind, \
+					Suffix) \
+	void CONCAT(printRegWithShiftExtend, \
+		    CONCAT(SignedExtend, \
+			   CONCAT(ExtWidth, CONCAT(SrcRegKind, Suffix))))( \
+		MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printRegWithShiftExtend(false, 8, x, d);
+DECLARE_printRegWithShiftExtend(true, 8, w, d);
+DECLARE_printRegWithShiftExtend(false, 8, w, d);
+DECLARE_printRegWithShiftExtend(false, 8, x, 0);
+DECLARE_printRegWithShiftExtend(true, 8, w, s);
+DECLARE_printRegWithShiftExtend(false, 8, w, s);
+DECLARE_printRegWithShiftExtend(false, 64, x, d);
+DECLARE_printRegWithShiftExtend(true, 64, w, d);
+DECLARE_printRegWithShiftExtend(false, 64, w, d);
+DECLARE_printRegWithShiftExtend(false, 64, x, 0);
+DECLARE_printRegWithShiftExtend(true, 64, w, s);
+DECLARE_printRegWithShiftExtend(false, 64, w, s);
+DECLARE_printRegWithShiftExtend(false, 16, x, d);
+DECLARE_printRegWithShiftExtend(true, 16, w, d);
+DECLARE_printRegWithShiftExtend(false, 16, w, d);
+DECLARE_printRegWithShiftExtend(false, 16, x, 0);
+DECLARE_printRegWithShiftExtend(true, 16, w, s);
+DECLARE_printRegWithShiftExtend(false, 16, w, s);
+DECLARE_printRegWithShiftExtend(false, 32, x, d);
+DECLARE_printRegWithShiftExtend(true, 32, w, d);
+DECLARE_printRegWithShiftExtend(false, 32, w, d);
+DECLARE_printRegWithShiftExtend(false, 32, x, 0);
+DECLARE_printRegWithShiftExtend(true, 32, w, s);
+DECLARE_printRegWithShiftExtend(false, 32, w, s);
+DECLARE_printRegWithShiftExtend(false, 8, x, s);
+DECLARE_printRegWithShiftExtend(false, 16, x, s);
+DECLARE_printRegWithShiftExtend(false, 32, x, s);
+DECLARE_printRegWithShiftExtend(false, 64, x, s);
+DECLARE_printRegWithShiftExtend(false, 128, x, 0);
+
+void printCondCode(MCInst *MI, unsigned OpNum, SStream *O);
+void printInverseCondCode(MCInst *MI, unsigned OpNum, SStream *O);
+void printAlignedLabel(MCInst *MI, uint64_t Address, unsigned OpNum,
+		       SStream *O);
+void printUImm12Offset(MCInst *MI, unsigned OpNum, unsigned Scale, SStream *O);
+void printAMIndexedWB(MCInst *MI, unsigned OpNum, unsigned Scale, SStream *O);
+#define DEFINE_printUImm12Offset(Scale) \
+	static inline void CONCAT(printUImm12Offset, Scale)( \
+		MCInst * MI, unsigned OpNum, SStream *O) \
+	{ \
+		add_cs_detail(MI, \
+			      CONCAT(AArch64_OP_GROUP_UImm12Offset, Scale), \
+			      OpNum, Scale); \
+		printUImm12Offset(MI, OpNum, Scale, O); \
+	}
+DEFINE_printUImm12Offset(1);
+DEFINE_printUImm12Offset(8);
+DEFINE_printUImm12Offset(2);
+DEFINE_printUImm12Offset(16);
+DEFINE_printUImm12Offset(4);
+
+void printAMNoIndex(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printImmScale(Scale) \
+	void CONCAT(printImmScale, Scale)(MCInst * MI, unsigned OpNum, \
+					  SStream *O);
+DECLARE_printImmScale(8);
+DECLARE_printImmScale(2);
+DECLARE_printImmScale(4);
+DECLARE_printImmScale(16);
+DECLARE_printImmScale(32);
+DECLARE_printImmScale(3);
+
+#define DECLARE_printImmRangeScale(Scale, Offset) \
+	void CONCAT(printImmRangeScale, CONCAT(Scale, Offset))( \
+		MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printImmRangeScale(2, 1);
+DECLARE_printImmRangeScale(4, 3);
+
+#define DECLARE_printPrefetchOp(IsSVEPrefetch) \
+	void CONCAT(printPrefetchOp, \
+		    IsSVEPrefetch)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printPrefetchOp(true);
+DECLARE_printPrefetchOp(false);
+
+void printRPRFMOperand(MCInst *MI, unsigned OpNum, SStream *O);
+void printPSBHintOp(MCInst *MI, unsigned OpNum, SStream *O);
+void printBTIHintOp(MCInst *MI, unsigned OpNum, SStream *O);
+void printVectorList(MCInst *MI, unsigned OpNum, SStream *O,
+		     const char *LayoutSuffix);
+void printMatrixTileList(MCInst *MI, unsigned OpNum, SStream *O);
+/// (i.e. attached to the instruction rather than the registers).
+/// Print a list of vector registers where the type suffix is implicit
+void printImplicitlyTypedVectorList(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printTypedVectorList(NumLanes, LaneKind) \
+	void CONCAT(printTypedVectorList, CONCAT(NumLanes, LaneKind))( \
+		MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printTypedVectorList(0, b);
+DECLARE_printTypedVectorList(0, d);
+DECLARE_printTypedVectorList(0, h);
+DECLARE_printTypedVectorList(0, s);
+DECLARE_printTypedVectorList(0, q);
+DECLARE_printTypedVectorList(16, b);
+DECLARE_printTypedVectorList(1, d);
+DECLARE_printTypedVectorList(2, d);
+DECLARE_printTypedVectorList(2, s);
+DECLARE_printTypedVectorList(4, h);
+DECLARE_printTypedVectorList(4, s);
+DECLARE_printTypedVectorList(8, b);
+DECLARE_printTypedVectorList(8, h);
+DECLARE_printTypedVectorList(0, 0);
+
+#define DECLARE_printVectorIndex(Scale) \
+	void CONCAT(printVectorIndex, Scale)(MCInst * MI, unsigned OpNum, \
+					     SStream *O);
+DECLARE_printVectorIndex(1);
+DECLARE_printVectorIndex(8);
+
+void printAdrAdrpLabel(MCInst *MI, uint64_t Address, unsigned OpNum,
+		       SStream *O);
+void printBarrierOption(MCInst *MI, unsigned OpNum, SStream *O);
+void printBarriernXSOption(MCInst *MI, unsigned OpNum, SStream *O);
+void printMSRSystemRegister(MCInst *MI, unsigned OpNum, SStream *O);
+void printMRSSystemRegister(MCInst *MI, unsigned OpNum, SStream *O);
+void printSystemPStateField(MCInst *MI, unsigned OpNum, SStream *O);
+void printSIMDType10Operand(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printPredicateAsCounter(EltSize) \
+	void CONCAT(printPredicateAsCounter, \
+		    EltSize)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printPredicateAsCounter(8);
+DECLARE_printPredicateAsCounter(64);
+DECLARE_printPredicateAsCounter(16);
+DECLARE_printPredicateAsCounter(32);
+DECLARE_printPredicateAsCounter(0);
+
+#define DECLARE_printGPRSeqPairsClassOperand(size) \
+	void CONCAT(printGPRSeqPairsClassOperand, \
+		    size)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printGPRSeqPairsClassOperand(32);
+DECLARE_printGPRSeqPairsClassOperand(64);
+
+#define DECLARE_printImm8OptLsl(T) \
+	void CONCAT(printImm8OptLsl, T)(MCInst * MI, unsigned OpNum, \
+					SStream *O);
+DECLARE_printImm8OptLsl(int16_t);
+DECLARE_printImm8OptLsl(int8_t);
+DECLARE_printImm8OptLsl(int64_t);
+DECLARE_printImm8OptLsl(int32_t);
+DECLARE_printImm8OptLsl(uint16_t);
+DECLARE_printImm8OptLsl(uint8_t);
+DECLARE_printImm8OptLsl(uint64_t);
+DECLARE_printImm8OptLsl(uint32_t);
+
+#define DECLARE_printSVELogicalImm(T) \
+	void CONCAT(printSVELogicalImm, T)(MCInst * MI, unsigned OpNum, \
+					   SStream *O);
+DECLARE_printSVELogicalImm(int16_t);
+DECLARE_printSVELogicalImm(int32_t);
+DECLARE_printSVELogicalImm(int64_t);
+
+void printSVEPattern(MCInst *MI, unsigned OpNum, SStream *O);
+void printSVEVecLenSpecifier(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printMatrixTileVector(IsVertical) \
+	void CONCAT(printMatrixTileVector, \
+		    IsVertical)(MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printMatrixTileVector(0);
+DECLARE_printMatrixTileVector(1);
+
+void printMatrixTile(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printMatrix(EltSize) \
+	void CONCAT(printMatrix, EltSize)(MCInst * MI, unsigned OpNum, \
+					  SStream *O);
+DECLARE_printMatrix(64);
+DECLARE_printMatrix(32);
+DECLARE_printMatrix(16);
+DECLARE_printMatrix(0);
+
+void printSVCROp(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printSVERegOp(char) \
+	void CONCAT(printSVERegOp, char)(MCInst * MI, unsigned OpNum, \
+					 SStream *O);
+DECLARE_printSVERegOp(b);
+DECLARE_printSVERegOp(d);
+DECLARE_printSVERegOp(h);
+DECLARE_printSVERegOp(s);
+DECLARE_printSVERegOp(0);
+DECLARE_printSVERegOp(q);
+
+void printGPR64as32(MCInst *MI, unsigned OpNum, SStream *O);
+void printGPR64x8(MCInst *MI, unsigned OpNum, SStream *O);
+void printSyspXzrPair(MCInst *MI, unsigned OpNum, SStream *O);
+#define DECLARE_printZPRasFPR(Width) \
+	void CONCAT(printZPRasFPR, Width)(MCInst * MI, unsigned OpNum, \
+					  SStream *O);
+DECLARE_printZPRasFPR(8);
+DECLARE_printZPRasFPR(64);
+DECLARE_printZPRasFPR(16);
+DECLARE_printZPRasFPR(32);
+DECLARE_printZPRasFPR(128);
+
+#define DECLARE_printExactFPImm(ImmIs0, ImmIs1) \
+	void CONCAT(printExactFPImm, CONCAT(ImmIs0, ImmIs1))( \
+		MCInst * MI, unsigned OpNum, SStream *O);
+DECLARE_printExactFPImm(AArch64ExactFPImm_half, AArch64ExactFPImm_one);
+DECLARE_printExactFPImm(AArch64ExactFPImm_zero, AArch64ExactFPImm_one);
+DECLARE_printExactFPImm(AArch64ExactFPImm_half, AArch64ExactFPImm_two);
+
+#define DECLARE_printMatrixIndex(Scale) \
+	void CONCAT(printMatrixIndex, Scale)(MCInst * MI, unsigned OpNum, \
+					     SStream *O);
+DECLARE_printMatrixIndex(8);
+DECLARE_printMatrixIndex(0);
+DECLARE_printMatrixIndex(1);
+
+// end namespace llvm
+
+#endif // LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64INSTPRINTER_H

thirdparty/capstone/arch/AArch64/AArch64Linkage.h

@@ -0,0 +1,23 @@
+/* Capstone Disassembly Engine */
+/* By Rot127 <unisono@quyllur.org> 2022-2023 */
+
+#ifndef CS_AARCH64_LINKAGE_H
+#define CS_AARCH64_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 AArch64_LLVM_getInstruction(csh handle, const uint8_t *Bytes,
+					 size_t ByteLen, MCInst *MI,
+					 uint16_t *Size, uint64_t Address,
+					 void *Info);
+const char *AArch64_LLVM_getRegisterName(unsigned RegNo, unsigned AltIdx);
+void AArch64_LLVM_printInstruction(MCInst *MI, SStream *O,
+				   void * /* MCRegisterInfo* */ info);
+
+#endif // CS_AARCH64_LINKAGE_H

thirdparty/capstone/arch/AArch64/AArch64Mapping.h

@@ -0,0 +1,82 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
+
+#ifndef CS_AARCH64_MAP_H
+#define CS_AARCH64_MAP_H
+
+#include "capstone/capstone.h"
+#include "../../MCInst.h"
+#include "../../SStream.h"
+
+typedef enum {
+#include "AArch64GenCSOpGroup.inc"
+} aarch64_op_group;
+
+// return name of register in friendly string
+const char *AArch64_reg_name(csh handle, unsigned int reg);
+
+// given internal insn id, return public instruction info
+void AArch64_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
+
+const char *AArch64_insn_name(csh handle, unsigned int id);
+
+const char *AArch64_group_name(csh handle, unsigned int id);
+
+void AArch64_reg_access(const cs_insn *insn, cs_regs regs_read,
+			uint8_t *regs_read_count, cs_regs regs_write,
+			uint8_t *regs_write_count);
+
+void AArch64_add_cs_detail(MCInst *MI, int /* aarch64_op_group */ op_group,
+			   va_list args);
+
+static inline void add_cs_detail(MCInst *MI,
+				 int /* aarch64_op_group */ op_group, ...)
+{
+	if (!MI->flat_insn->detail)
+		return;
+	va_list args;
+	va_start(args, op_group);
+	AArch64_add_cs_detail(MI, op_group, args);
+	va_end(args);
+}
+
+void AArch64_init_mri(MCRegisterInfo *MRI);
+
+void AArch64_init_cs_detail(MCInst *MI);
+
+void AArch64_set_instr_map_data(MCInst *MI);
+
+bool AArch64_getInstruction(csh handle, const uint8_t *code, size_t code_len,
+			    MCInst *instr, uint16_t *size, uint64_t address,
+			    void *info);
+
+void AArch64_printer(MCInst *MI, SStream *O, void * /* MCRegisterInfo* */ info);
+
+void AArch64_set_detail_op_reg(MCInst *MI, unsigned OpNum, aarch64_reg Reg);
+void AArch64_set_detail_op_imm(MCInst *MI, unsigned OpNum,
+			       aarch64_op_type ImmType, int64_t Imm);
+void AArch64_set_detail_op_imm_range(MCInst *MI, unsigned OpNum,
+				     uint32_t FirstImm, uint32_t offset);
+void AArch64_set_detail_op_mem(MCInst *MI, unsigned OpNum, uint64_t Val);
+void AArch64_set_detail_op_mem_offset(MCInst *MI, unsigned OpNum, uint64_t Val);
+void AArch64_set_detail_shift_ext(MCInst *MI, unsigned OpNum, bool SignExtend,
+				  bool DoShift, unsigned ExtWidth,
+				  char SrcRegKind);
+void AArch64_set_detail_op_float(MCInst *MI, unsigned OpNum, float Val);
+void AArch64_set_detail_op_sys(MCInst *MI, unsigned OpNum, aarch64_sysop sys_op,
+			       aarch64_op_type type);
+void AArch64_set_detail_op_sme(MCInst *MI, unsigned OpNum,
+			       aarch64_sme_op_part part,
+			       AArch64Layout_VectorLayout vas, ...);
+void AArch64_set_detail_op_pred(MCInst *MI, unsigned OpNum);
+void AArch64_insert_detail_op_reg_at(MCInst *MI, unsigned index,
+				     aarch64_reg Reg, cs_ac_type access);
+void AArch64_insert_detail_op_float_at(MCInst *MI, unsigned index, double val,
+				       cs_ac_type access);
+void AArch64_insert_detail_op_imm_at(MCInst *MI, unsigned index, int64_t Imm);
+void AArch64_insert_detail_op_sys(MCInst *MI, unsigned index, aarch64_sysop sys_op,
+			       aarch64_op_type type);
+void AArch64_insert_detail_op_sme(MCInst *MI, unsigned index, aarch64_op_sme sme_op);
+void AArch64_add_vas(MCInst *MI, const SStream *OS);
+
+#endif

thirdparty/capstone/arch/AArch64/AArch64Module.c

@@ -0,0 +1,46 @@
+/* Capstone Disassembly Engine */
+/* By Dang Hoang Vu <danghvu@gmail.com> 2013 */
+
+#ifdef CAPSTONE_HAS_AARCH64
+
+#include "../../utils.h"
+#include "../../MCRegisterInfo.h"
+#include "AArch64InstPrinter.h"
+#include "AArch64Mapping.h"
+#include "AArch64Module.h"
+
+cs_err AArch64_global_init(cs_struct *ud)
+{
+	MCRegisterInfo *mri;
+	mri = cs_mem_malloc(sizeof(*mri));
+
+	AArch64_init_mri(mri);
+	ud->printer = AArch64_printer;
+	ud->printer_info = mri;
+	ud->getinsn_info = mri;
+	ud->disasm = AArch64_getInstruction;
+	ud->reg_name = AArch64_reg_name;
+	ud->insn_id = AArch64_get_insn_id;
+	ud->insn_name = AArch64_insn_name;
+	ud->group_name = AArch64_group_name;
+	ud->post_printer = NULL;
+#ifndef CAPSTONE_DIET
+	ud->reg_access = AArch64_reg_access;
+#endif
+
+	return CS_ERR_OK;
+}
+
+cs_err AArch64_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+	if (type == CS_OPT_SYNTAX)
+		handle->syntax |= (int)value;
+
+	if (type == CS_OPT_MODE) {
+		handle->mode |= (cs_mode)value;
+	}
+
+	return CS_ERR_OK;
+}
+
+#endif

thirdparty/capstone/arch/AArch64/AArch64Module.h

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