/* 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 */

//===- ARMDisassembler.cpp - Disassembler for ARM/Thumb ISA ---------------===//

//

// 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

//

//===----------------------------------------------------------------------===//

#include <capstone/platform.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdlib.h>

#include <capstone/platform.h>

#include <capstone/platform.h>

#include "../../LEB128.h"

#include "../../MCDisassembler.h"

#include "../../MCFixedLenDisassembler.h"

#include "../../MCInst.h"

#include "../../MCInstrDesc.h"

#include "../../MCRegisterInfo.h"

#include "../../MathExtras.h"

#include "../../cs_priv.h"

#include "../../utils.h"

#include "ARMAddressingModes.h"

#include "ARMBaseInfo.h"

#include "ARMDisassemblerExtension.h"

#include "ARMLinkage.h"

#include "ARMMapping.h"

#define GET_INSTRINFO_MC_DESC

#include "ARMGenInstrInfo.inc"

#define CONCAT(a, b) CONCAT_(a, b)

#define CONCAT_(a, b) a##_##b

// end anonymous namespace

// Forward declare these because the autogenerated code will reference them.

// Definitions are further down.

static DecodeStatus DecodeGPRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeCLRMGPRRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodetGPROddRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodetGPREvenRegisterClass(MCInst *Inst, unsigned RegNo,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus

DecodeGPRwithAPSR_NZCVnospRegisterClass(MCInst *Inst, unsigned RegNo,

          uint64_t Address, const void *Decoder);

static DecodeStatus DecodeGPRnopcRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeGPRnospRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeGPRwithAPSRRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeGPRwithZRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeGPRwithZRnospRegisterClass(MCInst *Inst,

                 unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodetGPRRegisterClass(MCInst *Inst, unsigned RegNo,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodetcGPRRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecoderGPRRegisterClass(MCInst *Inst, unsigned RegNo,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeGPRPairRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeGPRPairnospRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeGPRspRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeHPRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeSPRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeDPRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeDPR_8RegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeSPR_8RegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeDPR_VFP2RegisterClass(MCInst *Inst, unsigned RegNo,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeQPRRegisterClass(MCInst *Inst, unsigned RegNo,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeMQPRRegisterClass(MCInst *Inst, unsigned RegNo,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeMQQPRRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeMQQQQPRRegisterClass(MCInst *Inst, unsigned RegNo,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeDPairRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeDPairSpacedRegisterClass(MCInst *Inst, unsigned RegNo,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodePredicateOperand(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeCCOutOperand(MCInst *Inst, unsigned Val,

               uint64_t Address, const void *Decoder);

static DecodeStatus DecodeRegListOperand(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeSPRRegListOperand(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeDPRRegListOperand(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeBitfieldMaskOperand(MCInst *Inst, unsigned Insn,

                uint64_t Address,

                const void *Decoder);

static DecodeStatus DecodeCopMemInstruction(MCInst *Inst, unsigned Insn,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeAddrMode2IdxInstruction(MCInst *Inst, unsigned Insn,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeAddrMode3Instruction(MCInst *Inst, unsigned Insn,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeTSBInstruction(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeSORegImmOperand(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeSORegRegOperand(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeMemMultipleWritebackInstruction(MCInst *Inst,

                unsigned Insn,

                uint64_t Adddress,

                const void *Decoder);

static DecodeStatus DecodeT2MOVTWInstruction(MCInst *Inst, unsigned Insn,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,

                uint64_t Address,

                const void *Decoder);

static DecodeStatus DecodeSMLAInstruction(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeHINTInstruction(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeCPSInstruction(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeTSTInstruction(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeSETPANInstruction(MCInst *Inst, unsigned Insn,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeT2CPSInstruction(MCInst *Inst, unsigned Insn,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeT2HintSpaceInstruction(MCInst *Inst, unsigned Insn,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeAddrModeImm12Operand(MCInst *Inst, unsigned Val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeAddrMode5Operand(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeAddrMode5FP16Operand(MCInst *Inst, unsigned Val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeAddrMode7Operand(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeT2BInstruction(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeBranchImmInstruction(MCInst *Inst, unsigned Insn,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeAddrMode6Operand(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeVLDST1Instruction(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeVLDST2Instruction(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeVLDST4Instruction(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeVLDInstruction(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeVSTInstruction(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeVLD1DupInstruction(MCInst *Inst, unsigned Val,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeVLD2DupInstruction(MCInst *Inst, unsigned Val,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeVLD3DupInstruction(MCInst *Inst, unsigned Val,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeVLD4DupInstruction(MCInst *Inst, unsigned Val,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeVMOVModImmInstruction(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeMVEModImmInstruction(MCInst *Inst, unsigned Val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeMVEVADCInstruction(MCInst *Inst, unsigned Insn,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeVSHLMaxInstruction(MCInst *Inst, unsigned Val,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeShiftRight8Imm(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeShiftRight16Imm(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeShiftRight32Imm(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeShiftRight64Imm(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeTBLInstruction(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodePostIdxReg(MCInst *Inst, unsigned Insn,

             uint64_t Address, const void *Decoder);

static DecodeStatus DecodeMveAddrModeRQ(MCInst *Inst, unsigned Insn,

          uint64_t Address, const void *Decoder);

#define DECLARE_DecodeMveAddrModeQ(shift) \

  static DecodeStatus CONCAT(DecodeMveAddrModeQ, shift)( \

    MCInst * Inst, unsigned Insn, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMveAddrModeQ(2);

DECLARE_DecodeMveAddrModeQ(3);

static DecodeStatus DecodeCoprocessor(MCInst *Inst, unsigned Insn,

              uint64_t Address, const void *Decoder);

static DecodeStatus DecodeMemBarrierOption(MCInst *Inst, unsigned Insn,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeInstSyncBarrierOption(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeMSRMask(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeBankedReg(MCInst *Inst, unsigned Insn,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeDoubleRegLoad(MCInst *Inst, unsigned Insn,

          uint64_t Address, const void *Decoder);

static DecodeStatus DecodeDoubleRegStore(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeLDRPreImm(MCInst *Inst, unsigned Insn,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeLDRPreReg(MCInst *Inst, unsigned Insn,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeSTRPreImm(MCInst *Inst, unsigned Insn,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeSTRPreReg(MCInst *Inst, unsigned Insn,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeVLD1LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVLD2LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVLD3LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVLD4LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVST1LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVST2LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVST3LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVST4LN(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeVMOVSRR(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeVMOVRRS(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeSwap(MCInst *Inst, unsigned Insn, uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeVCVTD(MCInst *Inst, unsigned Insn, uint64_t Address,

        const void *Decoder);

static DecodeStatus DecodeVCVTQ(MCInst *Inst, unsigned Insn, uint64_t Address,

        const void *Decoder);

static DecodeStatus DecodeVCVTImmOperand(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeNEONComplexLane64Instruction(MCInst *Inst,

                   unsigned Val,

                   uint64_t Address,

                   const void *Decoder);

static DecodeStatus DecodeThumbAddSpecialReg(MCInst *Inst, uint16_t Insn,

               uint64_t Address,

               const void *Decoder);

static DecodeStatus DecodeThumbBROperand(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2BROperand(MCInst *Inst, unsigned Val,

              uint64_t Address, const void *Decoder);

static DecodeStatus DecodeThumbCmpBROperand(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeThumbAddrModeRR(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbAddrModeIS(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbAddrModePC(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbAddrModeSP(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeT2AddrModeSOReg(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeT2LoadShift(MCInst *Inst, unsigned Val,

              uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2LoadImm8(MCInst *Inst, unsigned Insn,

             uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2LoadImm12(MCInst *Inst, unsigned Insn,

              uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2LoadT(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeT2LoadLabel(MCInst *Inst, unsigned Insn,

              uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2Imm8S4(MCInst *Inst, unsigned Val, uint64_t Address,

           const void *Decoder);

static DecodeStatus DecodeT2Imm7S4(MCInst *Inst, unsigned Val, uint64_t Address,

           const void *Decoder);

static DecodeStatus DecodeT2AddrModeImm8s4(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeT2AddrModeImm7s4(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeT2AddrModeImm0_1020s4(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeT2Imm8(MCInst *Inst, unsigned Val, uint64_t Address,

         const void *Decoder);

#define DECLARE_DecodeT2Imm7(shift) \

  static DecodeStatus CONCAT(DecodeT2Imm7, shift)(MCInst * Inst, \

              unsigned Val, \

              uint64_t Address, \

              const void *Decoder);

DECLARE_DecodeT2Imm7(0);

DECLARE_DecodeT2Imm7(1);

DECLARE_DecodeT2Imm7(2);

static DecodeStatus DecodeT2AddrModeImm8(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

#define DECLARE_DecodeTAddrModeImm7(shift) \

  static DecodeStatus CONCAT(DecodeTAddrModeImm7, shift)( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeTAddrModeImm7(0);

DECLARE_DecodeTAddrModeImm7(1);

#define DECLARE_DecodeT2AddrModeImm7(shift, WriteBack) \

  static DecodeStatus CONCAT(DecodeT2AddrModeImm7, \

           CONCAT(shift, WriteBack))( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeT2AddrModeImm7(0, 0);

DECLARE_DecodeT2AddrModeImm7(1, 0);

DECLARE_DecodeT2AddrModeImm7(2, 0);

DECLARE_DecodeT2AddrModeImm7(0, 1);

DECLARE_DecodeT2AddrModeImm7(1, 1);

DECLARE_DecodeT2AddrModeImm7(2, 1);

static DecodeStatus DecodeThumbAddSPImm(MCInst *Inst, uint16_t Val,

          uint64_t Address, const void *Decoder);

static DecodeStatus DecodeThumbAddSPReg(MCInst *Inst, uint16_t Insn,

          uint64_t Address, const void *Decoder);

static DecodeStatus DecodeThumbCPS(MCInst *Inst, uint16_t Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeQADDInstruction(MCInst *Inst, unsigned Insn,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbBLXOffset(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2AddrModeImm12(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbTableBranch(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeThumb2BCCInstruction(MCInst *Inst, unsigned Val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeT2SOImm(MCInst *Inst, unsigned Val, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeThumbBCCTargetOperand(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeThumbBLTargetOperand(MCInst *Inst, unsigned Val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeIT(MCInst *Inst, unsigned Val, uint64_t Address,

           const void *Decoder);

static DecodeStatus DecodeT2LDRDPreInstruction(MCInst *Inst, unsigned Insn,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeT2STRDPreInstruction(MCInst *Inst, unsigned Insn,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodeT2Adr(MCInst *Inst, unsigned Val, uint64_t Address,

        const void *Decoder);

static DecodeStatus DecodeT2LdStPre(MCInst *Inst, unsigned Val,

            uint64_t Address, const void *Decoder);

static DecodeStatus DecodeT2ShifterImmOperand(MCInst *Inst, unsigned Val,

                uint64_t Address,

                const void *Decoder);

static DecodeStatus DecodeLDR(MCInst *Inst, unsigned Val, uint64_t Address,

            const void *Decoder);

static DecodeStatus DecoderForMRRC2AndMCRR2(MCInst *Inst, unsigned Val,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeForVMRSandVMSR(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

#define DECLARE_DecodeBFLabelOperand(isSigned, isNeg, zeroPermitted, size) \

  static DecodeStatus CONCAT( \

    DecodeBFLabelOperand, \

    CONCAT(isSigned, CONCAT(isNeg, CONCAT(zeroPermitted, size))))( \

    MCInst * Inst, unsigned val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeBFLabelOperand(false, false, false, 4);

DECLARE_DecodeBFLabelOperand(true, false, true, 18);

DECLARE_DecodeBFLabelOperand(true, false, true, 12);

DECLARE_DecodeBFLabelOperand(true, false, true, 16);

DECLARE_DecodeBFLabelOperand(false, true, true, 11);

DECLARE_DecodeBFLabelOperand(false, false, true, 11);

static DecodeStatus DecodeBFAfterTargetOperand(MCInst *Inst, unsigned val,

                 uint64_t Address,

                 const void *Decoder);

static DecodeStatus DecodePredNoALOperand(MCInst *Inst, unsigned Val,

            uint64_t Address,

            const void *Decoder);

static DecodeStatus DecodeLOLoop(MCInst *Inst, unsigned Insn, uint64_t Address,

         const void *Decoder);

static DecodeStatus DecodeLongShiftOperand(MCInst *Inst, unsigned Val,

             uint64_t Address,

             const void *Decoder);

static DecodeStatus DecodeVSCCLRM(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeVPTMaskOperand(MCInst *Inst, unsigned Val,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeVpredROperand(MCInst *Inst, unsigned Val,

          uint64_t Address, const void *Decoder);

static DecodeStatus DecodeRestrictedIPredicateOperand(MCInst *Inst,

                  unsigned Val,

                  uint64_t Address,

                  const void *Decoder);

static DecodeStatus DecodeRestrictedSPredicateOperand(MCInst *Inst,

                  unsigned Val,

                  uint64_t Address,

                  const void *Decoder);

static DecodeStatus DecodeRestrictedUPredicateOperand(MCInst *Inst,

                  unsigned Val,

                  uint64_t Address,

                  const void *Decoder);

static DecodeStatus DecodeRestrictedFPPredicateOperand(MCInst *Inst,

                   unsigned Val,

                   uint64_t Address,

                   const void *Decoder);

#define DECLARE_DecodeVSTRVLDR_SYSREG(Writeback) \

  static DecodeStatus CONCAT(DecodeVSTRVLDR_SYSREG, Writeback)( \

    MCInst * Inst, unsigned Insn, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeVSTRVLDR_SYSREG(false);

DECLARE_DecodeVSTRVLDR_SYSREG(true);

#define DECLARE_DecodeMVE_MEM_1_pre(shift) \

  static DecodeStatus CONCAT(DecodeMVE_MEM_1_pre, shift)( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMVE_MEM_1_pre(0);

DECLARE_DecodeMVE_MEM_1_pre(1);

#define DECLARE_DecodeMVE_MEM_2_pre(shift) \

  static DecodeStatus CONCAT(DecodeMVE_MEM_2_pre, shift)( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMVE_MEM_2_pre(0);

DECLARE_DecodeMVE_MEM_2_pre(1);

DECLARE_DecodeMVE_MEM_2_pre(2);

#define DECLARE_DecodeMVE_MEM_3_pre(shift) \

  static DecodeStatus CONCAT(DecodeMVE_MEM_3_pre, shift)( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMVE_MEM_3_pre(2);

DECLARE_DecodeMVE_MEM_3_pre(3);

#define DECLARE_DecodePowerTwoOperand(MinLog, MaxLog) \

  static DecodeStatus CONCAT(DecodePowerTwoOperand, \

           CONCAT(MinLog, MaxLog))( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodePowerTwoOperand(0, 3);

#define DECLARE_DecodeMVEPairVectorIndexOperand(start) \

  static DecodeStatus CONCAT(DecodeMVEPairVectorIndexOperand, start)( \

    MCInst * Inst, unsigned Val, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMVEPairVectorIndexOperand(2);

DECLARE_DecodeMVEPairVectorIndexOperand(0);

static DecodeStatus DecodeMVEVMOVQtoDReg(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeMVEVMOVDRegtoQ(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeMVEVCVTt1fp(MCInst *Inst, unsigned Insn,

              uint64_t Address, const void *Decoder);

typedef DecodeStatus OperandDecoder(MCInst *Inst, unsigned Val,

            uint64_t Address, const void *Decoder);

#define DECLARE_DecodeMVEVCMP(scalar, predicate_decoder) \

  static DecodeStatus CONCAT(DecodeMVEVCMP, \

           CONCAT(scalar, predicate_decoder))( \

    MCInst * Inst, unsigned Insn, uint64_t Address, \

    const void *Decoder);

DECLARE_DecodeMVEVCMP(false, DecodeRestrictedIPredicateOperand);

DECLARE_DecodeMVEVCMP(false, DecodeRestrictedUPredicateOperand);

DECLARE_DecodeMVEVCMP(false, DecodeRestrictedSPredicateOperand);

DECLARE_DecodeMVEVCMP(true, DecodeRestrictedIPredicateOperand);

DECLARE_DecodeMVEVCMP(true, DecodeRestrictedUPredicateOperand);

DECLARE_DecodeMVEVCMP(true, DecodeRestrictedSPredicateOperand);

DECLARE_DecodeMVEVCMP(false, DecodeRestrictedFPPredicateOperand);

DECLARE_DecodeMVEVCMP(true, DecodeRestrictedFPPredicateOperand);

static DecodeStatus DecodeMveVCTP(MCInst *Inst, unsigned Insn, uint64_t Address,

          const void *Decoder);

static DecodeStatus DecodeMVEVPNOT(MCInst *Inst, unsigned Insn,

           uint64_t Address, const void *Decoder);

static DecodeStatus DecodeMVEOverlappingLongShift(MCInst *Inst, unsigned Insn,

              uint64_t Address,

              const void *Decoder);

static DecodeStatus DecodeT2AddSubSPImm(MCInst *Inst, unsigned Insn,

          uint64_t Address, const void *Decoder);

#include "ARMGenDisassemblerTables.inc"

// Post-decoding checks

static DecodeStatus checkDecodedInstruction(MCInst *MI, uint32_t Insn,

              DecodeStatus Result)

{

  switch (MCInst_getOpcode(MI)) {

  case ARM_HVC: {

    // HVC is undefined if condition = 0xf otherwise upredictable

    // if condition != 0xe

    uint32_t Cond = (Insn >> 28) & 0xF;

    if (Cond == 0xF)

      return MCDisassembler_Fail;

    if (Cond != 0xE)

      return MCDisassembler_SoftFail;

    return Result;

  }

  case ARM_t2ADDri:

  case ARM_t2ADDri12:

  case ARM_t2ADDrr:

  case ARM_t2ADDrs:

  case ARM_t2SUBri:

  case ARM_t2SUBri12:

  case ARM_t2SUBrr:

  case ARM_t2SUBrs:

    if (MCOperand_getReg(MCInst_getOperand(MI, (0))) == ARM_SP &&

        MCOperand_getReg(MCInst_getOperand(MI, (1))) != ARM_SP)

      return MCDisassembler_SoftFail;

    return Result;

  default:

    return Result;

  }

}

static DecodeStatus getARMInstruction(csh ud, const uint8_t *Bytes,

              size_t BytesLen, MCInst *MI,

              uint16_t *Size, uint64_t Address,

              void *Info)

{

  // We want to read exactly 4 bytes of data.

  if (BytesLen < 4) {

    *Size = 0;

    return MCDisassembler_Fail;

  }

  // Encoded as a 32-bit word in the stream.

  uint32_t Insn = readBytes32(MI, Bytes);

  // Calling the auto-generated decoder function.

  DecodeStatus Result =

    decodeInstruction_4(DecoderTableARM32, MI, Insn, Address, NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    return checkDecodedInstruction(MI, Insn, Result);

  }

  typedef struct DecodeTable {

    const uint8_t *P;

    bool DecodePred;

  } DecodeTable;

  const DecodeTable Tables[] = {

    { DecoderTableVFP32, false },

    { DecoderTableVFPV832, false },

    { DecoderTableNEONData32, true },

    { DecoderTableNEONLoadStore32, true },

    { DecoderTableNEONDup32, true },

    { DecoderTablev8NEON32, false },

    { DecoderTablev8Crypto32, false },

  };

  for (int i = 0; i < (sizeof(Tables) / sizeof(Tables[0])); ++i) {

    MCInst_clear(MI);

    DecodeTable Table = Tables[i];

    Result = decodeInstruction_4(Table.P, MI, Insn, Address, NULL);

    if (Result != MCDisassembler_Fail) {

      *Size = 4;

      // Add a fake predicate operand, because we share these instruction

      // definitions with Thumb2 where these instructions are predicable.

      if (Table.DecodePred &&

          !DecodePredicateOperand(MI, 0xE, Address, Table.P))

        return MCDisassembler_Fail;

      return Result;

    }

  }

  Result = decodeInstruction_4(DecoderTableCoProc32, MI, Insn, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    return checkDecodedInstruction(MI, Insn, Result);

  }

  *Size = 4;

  return MCDisassembler_Fail;

}

/// tryAddingSymbolicOperand - trys to add a symbolic operand in place of the

/// immediate Value in the MCInst.  The immediate Value has had any PC

/// adjustment made by the caller.  If the instruction is a branch instruction

/// then isBranch is true, else false.  If the getOpInfo() function was set as

/// part of the setupForSymbolicDisassembly() call then that function is called

/// to get any symbolic information at the Address for this instruction.  If

/// that returns non-zero then the symbolic information it returns is used to

/// create an MCExpr and that is added as an operand to the MCInst.  If

/// getOpInfo() returns zero and isBranch is true then a symbol look up for

/// Value is done and if a symbol is found an MCExpr is created with that, else

/// an MCExpr with Value is created.  This function returns true if it adds an

/// operand to the MCInst and false otherwise.

static bool tryAddingSymbolicOperand(uint64_t Address, int32_t Value,

             bool isBranch, uint64_t InstSize,

             MCInst *MI, const void *Decoder)

{

  // FIXME: Does it make sense for value to be negative?

  // return Decoder->tryAddingSymbolicOperand(MI, (uint32_t)Value, Address,

  //         isBranch, /*Offset=*/0, /*OpSize=*/0,

  //         InstSize);

  return false;

}

/// tryAddingPcLoadReferenceComment - trys to add a comment as to what is being

/// referenced by a load instruction with the base register that is the Pc.

/// These can often be values in a literal pool near the Address of the

/// instruction.  The Address of the instruction and its immediate Value are

/// used as a possible literal pool entry.  The SymbolLookUp call back will

/// return the name of a symbol referenced by the literal pool's entry if

/// the referenced address is that of a symbol.  Or it will return a pointer to

/// a literal 'C' string if the referenced address of the literal pool's entry

/// is an address into a section with 'C' string literals.

static void tryAddingPcLoadReferenceComment(uint64_t Address, int Value,

              const void *Decoder)

{

  // Decoder->tryAddingPcLoadReferenceComment(Value, Address);

}

// Thumb1 instructions don't have explicit S bits.  Rather, they

// implicitly set CPSR.  Since it's not represented in the encoding, the

// auto-generated decoder won't inject the CPSR operand.  We need to fix

// that as a post-pass.

static void AddThumb1SBit(MCInst *MI, bool InITBlock)

{

  const MCInstrDesc *Desc = MCInstrDesc_get(

    MCInst_getOpcode(MI), ARMDescs.Insts, ARR_SIZE(ARMDescs.Insts));

  const MCOperandInfo *OpInfo = Desc->OpInfo;

  unsigned short NumOps = Desc->NumOperands;

  unsigned i;

  for (i = 0; i < NumOps; ++i) {

    if (i == MCInst_getNumOperands(MI))

      break;

    if (MCOperandInfo_isOptionalDef(&OpInfo[i]) &&

        OpInfo[i].RegClass == ARM_CCRRegClassID) {

      if (i > 0 && MCOperandInfo_isPredicate(&OpInfo[i - 1]))

        continue;

      MCInst_insert0(MI, i,

               MCOperand_CreateReg1(

                 MI, (InITBlock ? 0 : ARM_CPSR)));

      return;

    }

  }

  MCInst_insert0(MI, i,

           MCOperand_CreateReg1(MI, (InITBlock ? 0 : ARM_CPSR)));

}

static bool isVectorPredicable(unsigned Opcode)

{

  const MCInstrDesc *Desc = MCInstrDesc_get(Opcode, ARMDescs.Insts,

              ARR_SIZE(ARMDescs.Insts));

  const MCOperandInfo *OpInfo = Desc->OpInfo;

  unsigned short NumOps = Desc->NumOperands;

  for (unsigned i = 0; i < NumOps; ++i) {

    if (ARM_isVpred(OpInfo[i].OperandType))

      return true;

  }

  return false;

}

// Most Thumb instructions don't have explicit predicates in the

// encoding, but rather get their predicates from IT context.  We need

// to fix up the predicate operands using this context information as a

// post-pass.

DecodeStatus AddThumbPredicate(MCInst *MI)

{

  DecodeStatus S = MCDisassembler_Success;

  // A few instructions actually have predicates encoded in them.  Don't

  // try to overwrite it if we're seeing one of those.

  switch (MCInst_getOpcode(MI)) {

  case ARM_tBcc:

  case ARM_t2Bcc:

  case ARM_tCBZ:

  case ARM_tCBNZ:

  case ARM_tCPS:

  case ARM_t2CPS3p:

  case ARM_t2CPS2p:

  case ARM_t2CPS1p:

  case ARM_t2CSEL:

  case ARM_t2CSINC:

  case ARM_t2CSINV:

  case ARM_t2CSNEG:

  case ARM_tMOVSr:

  case ARM_tSETEND:

    // Some instructions (mostly conditional branches) are not

    // allowed in IT blocks.

    if (ITBlock_instrInITBlock(&(MI->csh->ITBlock)))

      S = MCDisassembler_SoftFail;

    else

      return MCDisassembler_Success;

    break;

  case ARM_t2HINT:

    if (MCOperand_getImm(MCInst_getOperand(MI, (0))) == 0x10 &&

        (ARM_getFeatureBits(MI->csh->mode, ARM_FeatureRAS)) != 0)

      S = MCDisassembler_SoftFail;

    break;

  case ARM_tB:

  case ARM_t2B:

  case ARM_t2TBB:

  case ARM_t2TBH:

    // Some instructions (mostly unconditional branches) can

    // only appears at the end of, or outside of, an IT.

    if (ITBlock_instrInITBlock(&(MI->csh->ITBlock)) &&

        !ITBlock_instrLastInITBlock(&(MI->csh->ITBlock)))

      S = MCDisassembler_SoftFail;

    break;

  default:

    break;

  }

  // Warn on non-VPT predicable instruction in a VPT block and a VPT

  // predicable instruction in an IT block

  if ((!isVectorPredicable(MCInst_getOpcode(MI)) &&

       VPTBlock_instrInVPTBlock(&(MI->csh->VPTBlock))) ||

      (isVectorPredicable(MCInst_getOpcode(MI)) &&

       ITBlock_instrInITBlock(&(MI->csh->ITBlock))))

    S = MCDisassembler_SoftFail;

  // If we're in an IT/VPT block, base the predicate on that.  Otherwise,

  // assume a predicate of AL.

  unsigned CC = ARMCC_AL;

  unsigned VCC = ARMVCC_None;

  if (ITBlock_instrInITBlock(&(MI->csh->ITBlock))) {

    CC = ITBlock_getITCC(&(MI->csh->ITBlock));

    ITBlock_advanceITState(&(MI->csh->ITBlock));

  } else if (VPTBlock_instrInVPTBlock(&(MI->csh->VPTBlock))) {

    VCC = VPTBlock_getVPTPred(&(MI->csh->VPTBlock));

    VPTBlock_advanceVPTState(&(MI->csh->VPTBlock));

  }

  const MCInstrDesc *Desc = MCInstrDesc_get(

    MCInst_getOpcode(MI), ARMDescs.Insts, ARR_SIZE(ARMDescs.Insts));

  const MCOperandInfo *OpInfo = Desc->OpInfo;

  unsigned short NumOps = Desc->NumOperands;

  unsigned i;

  for (i = 0; i < NumOps; ++i) {

    if (MCOperandInfo_isPredicate(&OpInfo[i]) ||

        i == MCInst_getNumOperands(MI))

      break;

  }

  if (MCInst_isPredicable(Desc)) {

    MCInst_insert0(MI, i, MCOperand_CreateImm1(MI, (CC)));

    if (CC == ARMCC_AL)

      MCInst_insert0(MI, i + 1,

               MCOperand_CreateReg1(MI, (0)));

    else

      MCInst_insert0(MI, i + 1,

               MCOperand_CreateReg1(MI, (ARM_CPSR)));

  } else if (CC != ARMCC_AL) {

    Check(&S, MCDisassembler_SoftFail);

  }

  unsigned VCCPos;

  for (VCCPos = 0; VCCPos < NumOps; ++VCCPos) {

    if (ARM_isVpred(OpInfo[VCCPos].OperandType) ||

        VCCPos == MCInst_getNumOperands(MI))

      break;

  }

  if (isVectorPredicable(MCInst_getOpcode(MI))) {

    MCInst_insert0(MI, VCCPos, MCOperand_CreateImm1(MI, (VCC)));

    if (VCC == ARMVCC_None)

      MCInst_insert0(MI, VCCPos + 1,

               MCOperand_CreateReg1(MI, (0)));

    else

      MCInst_insert0(MI, VCCPos + 1,

               MCOperand_CreateReg1(MI, (ARM_P0)));

    MCInst_insert0(MI, VCCPos + 2, MCOperand_CreateReg1(MI, (0)));

    if (OpInfo[VCCPos].OperandType == ARM_OP_VPRED_R) {

      int TiedOp = MCOperandInfo_getOperandConstraint(

        Desc, VCCPos + 3, MCOI_TIED_TO);

      CS_ASSERT_RET_VAL(

        TiedOp >= 0 &&

          "Inactive register in vpred_r is not tied to an output!",

        MCDisassembler_Fail);

      // Copy the operand to ensure it's not invalidated when MI grows.

      MCOperand Op = *MCInst_getOperand(MI, TiedOp);

      MCInst_insert0(MI, VCCPos + 3, &Op);

    }

  } else if (VCC != ARMVCC_None) {

    Check(&S, MCDisassembler_SoftFail);

  }

  return S;

}

// Thumb VFP instructions are a special case.  Because we share their

// encodings between ARM and Thumb modes, and they are predicable in ARM

// mode, the auto-generated decoder will give them an (incorrect)

// predicate operand.  We need to rewrite these operands based on the IT

// context as a post-pass.

static void UpdateThumbVFPPredicate(DecodeStatus S, MCInst *MI)

{

  unsigned CC;

  CC = ITBlock_getITCC(&(MI->csh->ITBlock));

  if (CC == 0xF)

    CC = ARMCC_AL;

  if (ITBlock_instrInITBlock(&(MI->csh->ITBlock)))

    ITBlock_advanceITState(&(MI->csh->ITBlock));

  else if (VPTBlock_instrInVPTBlock(&(MI->csh->VPTBlock))) {

    CC = VPTBlock_getVPTPred(&(MI->csh->VPTBlock));

    VPTBlock_advanceVPTState(&(MI->csh->VPTBlock));

  }

  const MCInstrDesc *Desc = MCInstrDesc_get(

    MCInst_getOpcode(MI), ARMDescs.Insts, ARR_SIZE(ARMDescs.Insts));

  const MCOperandInfo *OpInfo = Desc->OpInfo;

  unsigned short NumOps = Desc->NumOperands;

  for (unsigned i = 0; i < NumOps; ++i) {

    if (MCOperandInfo_isPredicate(&OpInfo[i])) {

      if (CC != ARMCC_AL && !MCInst_isPredicable(Desc))

        Check(&S, MCDisassembler_SoftFail);

      MCOperand_setImm(MCInst_getOperand(MI, i), CC);

      if (CC == ARMCC_AL)

        MCOperand_setReg(MCInst_getOperand(MI, i + 1),

             0);

      else

        MCOperand_setReg(MCInst_getOperand(MI, i + 1),

             ARM_CPSR);

      return;

    }

  }

}

static DecodeStatus getThumbInstruction(csh ud, const uint8_t *Bytes,

          size_t BytesLen, MCInst *MI,

          uint16_t *Size, uint64_t Address,

          void *Info)

{

  // We want to read exactly 2 bytes of data.

  if (BytesLen < 2) {

    *Size = 0;

    return MCDisassembler_Fail;

  }

  uint16_t Insn16 = readBytes16(MI, Bytes);

  DecodeStatus Result = decodeInstruction_2(DecoderTableThumb16, MI,

              Insn16, Address, NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 2;

    Check(&Result, AddThumbPredicate(MI));

    return Result;

  }

  Result = decodeInstruction_2(DecoderTableThumbSBit16, MI, Insn16,

             Address, NULL);

  if (Result) {

    *Size = 2;

    bool InITBlock = ITBlock_instrInITBlock(&(MI->csh->ITBlock));

    Check(&Result, AddThumbPredicate(MI));

    AddThumb1SBit(MI, InITBlock);

    return Result;

  }

  Result = decodeInstruction_2(DecoderTableThumb216, MI, Insn16, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 2;

    // Nested IT blocks are UNPREDICTABLE.  Must be checked before we add

    // the Thumb predicate.

    if (MCInst_getOpcode(MI) == ARM_t2IT &&

        ITBlock_instrInITBlock(&(MI->csh->ITBlock)))

      Result = MCDisassembler_SoftFail;

    Check(&Result, AddThumbPredicate(MI));

    // If we find an IT instruction, we need to parse its condition

    // code and mask operands so that we can apply them correctly

    // to the subsequent instructions.

    if (MCInst_getOpcode(MI) == ARM_t2IT) {

      unsigned Firstcond =

        MCOperand_getImm(MCInst_getOperand(MI, (0)));

      unsigned Mask =

        MCOperand_getImm(MCInst_getOperand(MI, (1)));

      ITBlock_setITState(&(MI->csh->ITBlock), (char)Firstcond,

             (char)Mask);

      // An IT instruction that would give a 'NV' predicate is

      // unpredictable. if (Firstcond == ARMCC_AL && !isPowerOf2_32(Mask))

      //  SStream_concat0(CS, "unpredictable IT predicate sequence");

    }

    return Result;

  }

  // We want to read exactly 4 bytes of data.

  if (BytesLen < 4) {

    *Size = 0;

    return MCDisassembler_Fail;

  }

  uint32_t Insn32 = (uint32_t)Insn16 << 16 | readBytes16(MI, Bytes + 2);

  Result = decodeInstruction_4(DecoderTableMVE32, MI, Insn32, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    // Nested VPT blocks are UNPREDICTABLE. Must be checked before we add

    // the VPT predicate.

    if (isVPTOpcode(MCInst_getOpcode(MI)) &&

        VPTBlock_instrInVPTBlock(&(MI->csh->VPTBlock)))

      Result = MCDisassembler_SoftFail;

    Check(&Result, AddThumbPredicate(MI));

    if (isVPTOpcode(MCInst_getOpcode(MI))) {

      unsigned Mask =

        MCOperand_getImm(MCInst_getOperand(MI, (0)));

      VPTBlock_setVPTState(&(MI->csh->VPTBlock), Mask);

    }

    return Result;

  }

  Result = decodeInstruction_4(DecoderTableThumb32, MI, Insn32, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    bool InITBlock = ITBlock_instrInITBlock(&(MI->csh->ITBlock));

    Check(&Result, AddThumbPredicate(MI));

    AddThumb1SBit(MI, InITBlock);

    return Result;

  }

  Result = decodeInstruction_4(DecoderTableThumb232, MI, Insn32, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    Check(&Result, AddThumbPredicate(MI));

    return checkDecodedInstruction(MI, Insn32, Result);

  }

  if (fieldFromInstruction_4(Insn32, 28, 4) == 0xE) {

    Result = decodeInstruction_4(DecoderTableVFP32, MI, Insn32,

               Address, NULL);

    if (Result != MCDisassembler_Fail) {

      *Size = 4;

      UpdateThumbVFPPredicate(Result, MI);

      return Result;

    }

  }

  Result = decodeInstruction_4(DecoderTableVFPV832, MI, Insn32, Address,

             NULL);

  if (Result != MCDisassembler_Fail) {

    *Size = 4;

    return Result;

  }

  if (fieldFromInstruction_4(Insn32, 28, 4) == 0xE) {

    Result = decodeInstruction_4(DecoderTableNEONDup32, MI, Insn32,

               Address, NULL);

    if (Result != MCDisassembler_Fail) {

      *Size = 4;

      Check(&Result, AddThumbPredicate(MI));

      return Result;

    }

  }