/* Capstone Disassembly Engine */

/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */

/*    Rot127 <unisono@quyllur.org>, 2022-2023 */

#include "ARMDisassemblerExtension.h"

#include "ARMBaseInfo.h"

bool ITBlock_push_back(ARM_ITBlock *it, char v)

{

  if (it->size >= sizeof(it->ITStates)) {

    // TODO: consider warning user.

    it->size = 0;

  }

  it->ITStates[it->size] = v;

  it->size++;

  return true;

}

// Returns true if the current instruction is in an IT block

bool ITBlock_instrInITBlock(ARM_ITBlock *it)

{

  return (it->size > 0);

}

// Returns true if current instruction is the last instruction in an IT block

bool ITBlock_instrLastInITBlock(ARM_ITBlock *it)

{

  return (it->size == 1);

}

// Returns the condition code for instruction in IT block

unsigned ITBlock_getITCC(ARM_ITBlock *it)

{

  unsigned CC = ARMCC_AL;

  if (ITBlock_instrInITBlock(it))

    CC = it->ITStates[it->size - 1];

  return CC;

}

// Advances the IT block state to the next T or E

void ITBlock_advanceITState(ARM_ITBlock *it)

{

  it->size--;

}

// Called when decoding an IT instruction. Sets the IT state for the following

// instructions that for the IT block. Firstcond and Mask correspond to the

// fields in the IT instruction encoding.

void ITBlock_setITState(ARM_ITBlock *it, char Firstcond, char Mask)

{

  // (3 - the number of trailing zeros) is the number of then / else.

  unsigned NumTZ = CountTrailingZeros_8(Mask);

  unsigned char CCBits = (unsigned char)(Firstcond & 0xf);

  assert(NumTZ <= 3 && "Invalid IT mask!");

  // push condition codes onto the stack the correct order for the pops

  for (unsigned Pos = NumTZ + 1; Pos <= 3; ++Pos) {

    unsigned Else = (Mask >> Pos) & 1;

    ITBlock_push_back(it, CCBits ^ Else);

  }

  ITBlock_push_back(it, CCBits);

}

bool VPTBlock_push_back(ARM_VPTBlock *it, char v)

{

  if (it->size >= sizeof(it->VPTStates)) {

    // TODO: consider warning user.

    it->size = 0;

  }

  it->VPTStates[it->size] = v;

  it->size++;

  return true;

}

bool VPTBlock_instrInVPTBlock(ARM_VPTBlock *VPT)

{

  return VPT->size > 0;

}

unsigned VPTBlock_getVPTPred(ARM_VPTBlock *VPT)

{

  unsigned Pred = ARMVCC_None;

  if (VPTBlock_instrInVPTBlock(VPT))

    Pred = VPT->VPTStates[VPT->size - 1];

  return Pred;

}

void VPTBlock_advanceVPTState(ARM_VPTBlock *VPT)

{

  VPT->size--;

}

void VPTBlock_setVPTState(ARM_VPTBlock *VPT, char Mask)

{

  // (3 - the number of trailing zeros) is the number of then / else.

  unsigned NumTZ = CountTrailingZeros_8(Mask);

  assert(NumTZ <= 3 && "Invalid VPT mask!");

  // push predicates onto the stack the correct order for the pops

  for (unsigned Pos = NumTZ + 1; Pos <= 3; ++Pos) {

    bool T = ((Mask >> Pos) & 1) == 0;

    if (T)

      VPTBlock_push_back(VPT, ARMVCC_Then);

    else

      VPTBlock_push_back(VPT, ARMVCC_Else);

  }

  VPTBlock_push_back(VPT, ARMVCC_Then);

}

/// ThumbDisassembler - Thumb disassembler for all Thumb platforms.

bool Check(DecodeStatus *Out, DecodeStatus In)

{

  switch (In) {

  case MCDisassembler_Success:

    // Out stays the same.

    return true;

  case MCDisassembler_SoftFail:

    *Out = In;

    return true;

  case MCDisassembler_Fail:

    *Out = In;

    return false;

  default: // never reached

    return false;

  }

}

// Imported from ARMBaseInstrInfo.h

//

/// isValidCoprocessorNumber - decide whether an explicit coprocessor

/// number is legal in generic instructions like CDP. The answer can

/// vary with the subtarget.

bool isValidCoprocessorNumber(MCInst *Inst, unsigned Num)

{

  // In Armv7 and Armv8-M CP10 and CP11 clash with VFP/NEON, however, the

  // coprocessor is still valid for CDP/MCR/MRC and friends. Allowing it is

  // useful for code which is shared with older architectures which do not

  // know the new VFP/NEON mnemonics.

  // Armv8-A disallows everything *other* than 111x (CP14 and CP15).

  if (ARM_getFeatureBits(Inst->csh->mode, ARM_HasV8Ops) &&

      (Num & 0xE) != 0xE)

    return false;

  // Armv8.1-M disallows 100x (CP8,CP9) and 111x (CP14,CP15)

  // which clash with MVE.

  if (ARM_getFeatureBits(Inst->csh->mode, ARM_HasV8_1MMainlineOps) &&

      ((Num & 0xE) == 0x8 || (Num & 0xE) == 0xE))

    return false;

  return true;

}

// Imported from ARMMCTargetDesc.h

bool ARM_isVpred(arm_op_type op)

{

  return op == ARM_OP_VPRED_R || op == ARM_OP_VPRED_N;

}

// Imported from ARMBaseInstrInfo.h

//

// This table shows the VPT instruction variants, i.e. the different

// mask field encodings, see also B5.6. Predication/conditional execution in

// the ArmARM.

bool isVPTOpcode(int Opc)

{

  return Opc == ARM_MVE_VPTv16i8 || Opc == ARM_MVE_VPTv16u8 ||

         Opc == ARM_MVE_VPTv16s8 || Opc == ARM_MVE_VPTv8i16 ||

         Opc == ARM_MVE_VPTv8u16 || Opc == ARM_MVE_VPTv8s16 ||

         Opc == ARM_MVE_VPTv4i32 || Opc == ARM_MVE_VPTv4u32 ||

         Opc == ARM_MVE_VPTv4s32 || Opc == ARM_MVE_VPTv4f32 ||

         Opc == ARM_MVE_VPTv8f16 || Opc == ARM_MVE_VPTv16i8r ||

         Opc == ARM_MVE_VPTv16u8r || Opc == ARM_MVE_VPTv16s8r ||

         Opc == ARM_MVE_VPTv8i16r || Opc == ARM_MVE_VPTv8u16r ||

         Opc == ARM_MVE_VPTv8s16r || Opc == ARM_MVE_VPTv4i32r ||

         Opc == ARM_MVE_VPTv4u32r || Opc == ARM_MVE_VPTv4s32r ||

         Opc == ARM_MVE_VPTv4f32r || Opc == ARM_MVE_VPTv8f16r ||

         Opc == ARM_MVE_VPST;

}

// Imported from ARMMCTargetDesc.cpp

bool ARM_isCDECoproc(size_t Coproc, const MCInst *MI)

{

  // Unfortunately we don't have ARMTargetInfo in the disassembler, so we have

  // to rely on feature bits.

  if (Coproc >= 8)

    return false;

  return ARM_getFeatureBits(MI->csh->mode,

          ARM_FeatureCoprocCDE0 + Coproc);

}

// Hacky: enable all features for disassembler

bool ARM_getFeatureBits(unsigned int mode, unsigned int feature)

{

  if (feature == ARM_ModeThumb) {

    if (mode & CS_MODE_THUMB)

      return true;

    return false;

  }

  if (feature == ARM_FeatureDFB)

    return false;

  if (feature == ARM_FeatureRAS)

    return false;

  if (feature == ARM_FeatureMClass && (mode & CS_MODE_MCLASS) == 0)

    return false;

  if ((feature == ARM_HasMVEIntegerOps || feature == ARM_HasMVEFloatOps ||

       feature == ARM_FeatureMVEVectorCostFactor1 ||

       feature == ARM_FeatureMVEVectorCostFactor2 ||

       feature == ARM_FeatureMVEVectorCostFactor4) &&

      (mode & CS_MODE_MCLASS) == 0)

    return false;

  if ((feature == ARM_HasV8Ops || feature == ARM_HasV8_1MMainlineOps ||

       feature == ARM_HasV8_1aOps || feature == ARM_HasV8_2aOps ||

       feature == ARM_HasV8_3aOps || feature == ARM_HasV8_4aOps ||

       feature == ARM_HasV8_5aOps || feature == ARM_HasV8_6aOps ||

       feature == ARM_HasV8_7aOps || feature == ARM_HasV8_8aOps ||

       feature == ARM_HasV8_9aOps) &&

      (mode & CS_MODE_V8) == 0)

    return false;

  if (feature >= ARM_FeatureCoprocCDE0 &&

      feature <= ARM_FeatureCoprocCDE7)

    // We currently have no way to detect CDE (Custom-Datapath-Extension)

    // coprocessors.

    return false;

  // we support everything

  return true;

}