/src/capstonenext/arch/ARM/ARMBaseInfo.h

Source (jump to first uncovered line)
//===-- ARMBaseInfo.h - Top level definitions for ARM ---*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains small standalone helper functions and enum definitions for
// the ARM target useful for the compiler back-end and the MC libraries.
// As such, it deliberately does not include references to LLVM core
// code gen types, passes, etc..
//
//===----------------------------------------------------------------------===//

#ifndef CS_ARM_BASEINFO_H
#define CS_ARM_BASEINFO_H

#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "../../MCInstPrinter.h"
#include "../../cs_priv.h"
#include "capstone/arm.h"

#define GET_INSTRINFO_ENUM
#include "ARMGenInstrInfo.inc"

// System Registers
typedef struct MClassSysReg {
  const char *Name;
  arm_sysop_reg sysreg;
  uint16_t M1Encoding12;
  uint16_t M2M3Encoding8;
  uint16_t Encoding;
  int FeaturesRequired[2];
} ARMSysReg_MClassSysReg;

// return true if FeaturesRequired are all present in ActiveFeatures
static inline bool hasRequiredFeatures(const ARMSysReg_MClassSysReg *TheReg,
               int ActiveFeatures)
{
  return (TheReg->FeaturesRequired[0] == ActiveFeatures ||
    TheReg->FeaturesRequired[1] == ActiveFeatures);
}

// returns true if TestFeatures are all present in FeaturesRequired
static inline bool
MClassSysReg_isInRequiredFeatures(const ARMSysReg_MClassSysReg *TheReg,
          int TestFeatures)
{
  return (TheReg->FeaturesRequired[0] == TestFeatures ||
    TheReg->FeaturesRequired[1] == TestFeatures);
}

#define GET_SUBTARGETINFO_ENUM
#include "ARMGenSubtargetInfo.inc"

// lookup system register using 12-bit SYSm value.
// Note: the search is uniqued using M1 mask
const ARMSysReg_MClassSysReg *
ARMSysReg_lookupMClassSysRegBy12bitSYSmValue(unsigned SYSm);
// returns APSR with _<bits> qualifier.
// Note: ARMv7-M deprecates using MSR APSR without a _<bits> qualifier
const ARMSysReg_MClassSysReg *
ARMSysReg_lookupMClassSysRegAPSRNonDeprecated(unsigned SYSm);
// lookup system registers using 8-bit SYSm value
const ARMSysReg_MClassSysReg *
ARMSysReg_lookupMClassSysRegBy8bitSYSmValue(unsigned SYSm);
// end namespace ARMSysReg

// Banked Registers
typedef struct BankedReg {
  const char *Name;
  arm_sysop_reg sysreg;
  uint16_t Encoding;
} ARMBankedReg_BankedReg;

#define GET_BANKEDREG_DECL
#define GET_MCLASSSYSREG_DECL
#include "ARMGenSystemRegister.inc"

typedef enum IMod { ARM_PROC_IE = 2, ARM_PROC_ID = 3 } ARM_PROC_IMod;

typedef enum IFlags {
  ARM_PROC_F = 1,
  ARM_PROC_I = 2,
  ARM_PROC_A = 4
} ARM_PROC_IFlags;

inline static const char *ARM_PROC_IFlagsToString(unsigned val)
{
  switch (val) {
  default:
    // llvm_unreachable("Unknown iflags operand");
  case ARM_PROC_F:
    return "f";
  case ARM_PROC_I:
    return "i";
  case ARM_PROC_A:
    return "a";
  }
}

inline static const char *ARM_PROC_IModToString(unsigned val)
{
  switch (val) {
  default:
    CS_ASSERT_RET_VAL("Unknown imod operand", NULL);
  case ARM_PROC_IE:
    return "ie";
  case ARM_PROC_ID:
    return "id";
  }
}

inline static const char *ARM_MB_MemBOptToString(unsigned val, bool HasV8)
{
  switch (val) {
  default:
    CS_ASSERT_RET_VAL("Unknown memory operation", NULL);
  case ARM_MB_SY:
    return "sy";
  case ARM_MB_ST:
    return "st";
  case ARM_MB_LD:
    return HasV8 ? "ld" : "#0xd";
  case ARM_MB_RESERVED_12:
    return "#0xc";
  case ARM_MB_ISH:
    return "ish";
  case ARM_MB_ISHST:
    return "ishst";
  case ARM_MB_ISHLD:
    return HasV8 ? "ishld" : "#0x9";
  case ARM_MB_RESERVED_8:
    return "#0x8";
  case ARM_MB_NSH:
    return "nsh";
  case ARM_MB_NSHST:
    return "nshst";
  case ARM_MB_NSHLD:
    return HasV8 ? "nshld" : "#0x5";
  case ARM_MB_RESERVED_4:
    return "#0x4";
  case ARM_MB_OSH:
    return "osh";
  case ARM_MB_OSHST:
    return "oshst";
  case ARM_MB_OSHLD:
    return HasV8 ? "oshld" : "#0x1";
  case ARM_MB_RESERVED_0:
    return "#0x0";
  }
}

typedef enum TraceSyncBOpt { ARM_TSB_CSYNC = 0 } ARM_TSB_TraceSyncBOpt;

inline static const char *ARM_TSB_TraceSyncBOptToString(unsigned val)
{
  switch (val) {
  default:
    CS_ASSERT_RET_VAL("Unknown trace synchronization barrier operation", NULL);
  case ARM_TSB_CSYNC:
    return "csync";
  }
}

typedef enum InstSyncBOpt {
  ARM_ISB_RESERVED_0 = 0,
  ARM_ISB_RESERVED_1 = 1,
  ARM_ISB_RESERVED_2 = 2,
  ARM_ISB_RESERVED_3 = 3,
  ARM_ISB_RESERVED_4 = 4,
  ARM_ISB_RESERVED_5 = 5,
  ARM_ISB_RESERVED_6 = 6,
  ARM_ISB_RESERVED_7 = 7,
  ARM_ISB_RESERVED_8 = 8,
  ARM_ISB_RESERVED_9 = 9,
  ARM_ISB_RESERVED_10 = 10,
  ARM_ISB_RESERVED_11 = 11,
  ARM_ISB_RESERVED_12 = 12,
  ARM_ISB_RESERVED_13 = 13,
  ARM_ISB_RESERVED_14 = 14,
  ARM_ISB_SY = 15
} ARM_ISB_InstSyncBOpt;

inline static const char *ARM_ISB_InstSyncBOptToString(unsigned val)
{
  switch (val) {
  default:
    CS_ASSERT_RET_VAL("Unknown memory operation", NULL);
  case ARM_ISB_RESERVED_0:
    return "#0x0";
  case ARM_ISB_RESERVED_1:
    return "#0x1";
  case ARM_ISB_RESERVED_2:
    return "#0x2";
  case ARM_ISB_RESERVED_3:
    return "#0x3";
  case ARM_ISB_RESERVED_4:
    return "#0x4";
  case ARM_ISB_RESERVED_5:
    return "#0x5";
  case ARM_ISB_RESERVED_6:
    return "#0x6";
  case ARM_ISB_RESERVED_7:
    return "#0x7";
  case ARM_ISB_RESERVED_8:
    return "#0x8";
  case ARM_ISB_RESERVED_9:
    return "#0x9";
  case ARM_ISB_RESERVED_10:
    return "#0xa";
  case ARM_ISB_RESERVED_11:
    return "#0xb";
  case ARM_ISB_RESERVED_12:
    return "#0xc";
  case ARM_ISB_RESERVED_13:
    return "#0xd";
  case ARM_ISB_RESERVED_14:
    return "#0xe";
  case ARM_ISB_SY:
    return "sy";
  }
}

#define GET_REGINFO_ENUM
#include "ARMGenRegisterInfo.inc"

/// isARMLowRegister - Returns true if the register is a low register (r0-r7).
///
static inline bool isARMLowRegister(unsigned Reg)
{
  switch (Reg) {
  case ARM_R0:
  case ARM_R1:
  case ARM_R2:
  case ARM_R3:
  case ARM_R4:
  case ARM_R5:
  case ARM_R6:
  case ARM_R7:
    return true;
  default:
    return false;
  }
}

/// ARMII - This namespace holds all of the target specific flags that
/// instruction info tracks.
///
/// ARM Index Modes
typedef enum IndexMode {
  ARMII_IndexModeNone = 0,
  ARMII_IndexModePre = 1,
  ARMII_IndexModePost = 2,
  ARMII_IndexModeUpd = 3
} ARMII_IndexMode;

/// ARM Addressing Modes
typedef enum AddrMode {
  ARMII_AddrModeNone = 0,
  ARMII_AddrMode1 = 1,
  ARMII_AddrMode2 = 2,
  ARMII_AddrMode3 = 3,
  ARMII_AddrMode4 = 4,
  ARMII_AddrMode5 = 5,
  ARMII_AddrMode6 = 6,
  ARMII_AddrModeT1_1 = 7,
  ARMII_AddrModeT1_2 = 8,
  ARMII_AddrModeT1_4 = 9,
  ARMII_AddrModeT1_s = 10,     // i8 * 4 for pc and sp relative data
  ARMII_AddrModeT2_i12 = 11,
  ARMII_AddrModeT2_i8 = 12,    // +/- i8
  ARMII_AddrModeT2_i8pos = 13, // + i8
  ARMII_AddrModeT2_i8neg = 14, // - i8
  ARMII_AddrModeT2_so = 15,
  ARMII_AddrModeT2_pc = 16,    // +/- i12 for pc relative data
  ARMII_AddrModeT2_i8s4 = 17,  // i8 * 4
  ARMII_AddrMode_i12 = 18,
  ARMII_AddrMode5FP16 = 19,    // i8 * 2
  ARMII_AddrModeT2_ldrex = 20, // i8 * 4, with unscaled offset in MCInst
  ARMII_AddrModeT2_i7s4 = 21,  // i7 * 4
  ARMII_AddrModeT2_i7s2 = 22,  // i7 * 2
  ARMII_AddrModeT2_i7 = 23,    // i7 * 1
} ARMII_AddrMode;

inline static const char *ARMII_AddrModeToString(ARMII_AddrMode addrmode)
{
  switch (addrmode) {
  case ARMII_AddrModeNone:
    return "AddrModeNone";
  case ARMII_AddrMode1:
    return "AddrMode1";
  case ARMII_AddrMode2:
    return "AddrMode2";
  case ARMII_AddrMode3:
    return "AddrMode3";
  case ARMII_AddrMode4:
    return "AddrMode4";
  case ARMII_AddrMode5:
    return "AddrMode5";
  case ARMII_AddrMode5FP16:
    return "AddrMode5FP16";
  case ARMII_AddrMode6:
    return "AddrMode6";
  case ARMII_AddrModeT1_1:
    return "AddrModeT1_1";
  case ARMII_AddrModeT1_2:
    return "AddrModeT1_2";
  case ARMII_AddrModeT1_4:
    return "AddrModeT1_4";
  case ARMII_AddrModeT1_s:
    return "AddrModeT1_s";
  case ARMII_AddrModeT2_i12:
    return "AddrModeT2_i12";
  case ARMII_AddrModeT2_i8:
    return "AddrModeT2_i8";
  case ARMII_AddrModeT2_i8pos:
    return "AddrModeT2_i8pos";
  case ARMII_AddrModeT2_i8neg:
    return "AddrModeT2_i8neg";
  case ARMII_AddrModeT2_so:
    return "AddrModeT2_so";
  case ARMII_AddrModeT2_pc:
    return "AddrModeT2_pc";
  case ARMII_AddrModeT2_i8s4:
    return "AddrModeT2_i8s4";
  case ARMII_AddrMode_i12:
    return "AddrMode_i12";
  case ARMII_AddrModeT2_ldrex:
    return "AddrModeT2_ldrex";
  case ARMII_AddrModeT2_i7s4:
    return "AddrModeT2_i7s4";
  case ARMII_AddrModeT2_i7s2:
    return "AddrModeT2_i7s2";
  case ARMII_AddrModeT2_i7:
    return "AddrModeT2_i7";
  }
}

/// Target Operand Flag enum.
typedef enum TOF {
  //===------------------------------------------------------------------===//
  // ARM Specific MachineOperand flags.

  ARMII_MO_NO_FLAG = 0,

  /// MO_LO16 - On a symbol operand, this represents a relocation containing
  /// lower 16 bit of the address. Used only via movw instruction.
  ARMII_MO_LO16 = 0x1,

  /// MO_HI16 - On a symbol operand, this represents a relocation containing
  /// higher 16 bit of the address. Used only via movt instruction.
  ARMII_MO_HI16 = 0x2,

  /// MO_OPTION_MASK - Most flags are mutually exclusive; this mask selects
  /// just that part of the flag set.
  ARMII_MO_OPTION_MASK = 0x3,

  /// MO_COFFSTUB - On a symbol operand "FOO", this indicates that the
  /// reference is actually to the ".refptr.FOO" symbol.  This is used for
  /// stub symbols on windows.
  ARMII_MO_COFFSTUB = 0x4,

  /// MO_GOT - On a symbol operand, this represents a GOT relative relocation.
  ARMII_MO_GOT = 0x8,

  /// MO_SBREL - On a symbol operand, this represents a static base relative
  /// relocation. Used in movw and movt instructions.
  ARMII_MO_SBREL = 0x10,

  /// MO_DLLIMPORT - On a symbol operand, this represents that the reference
  /// to the symbol is for an import stub.  This is used for DLL import
  /// storage class indication on Windows.
  ARMII_MO_DLLIMPORT = 0x20,

  /// MO_SECREL - On a symbol operand this indicates that the immediate is
  /// the offset from beginning of section.
  ///
  /// This is the TLS offset for the COFF/Windows TLS mechanism.
  ARMII_MO_SECREL = 0x40,

  /// MO_NONLAZY - This is an independent flag, on a symbol operand "FOO" it
  /// represents a symbol which, if indirect, will get special Darwin mangling
  /// as a non-lazy-ptr indirect symbol (i.e. "L_FOO$non_lazy_ptr"). Can be
  /// combined with MO_LO16, MO_HI16 or MO_NO_FLAG (in a constant-pool, for
  /// example).
  ARMII_MO_NONLAZY = 0x80,

  // It's undefined behaviour if an enum overflows the range between its
  // smallest and largest values, but since these are |ed together, it can
  // happen. Put a sentinel in (values of this enum are stored as "unsigned
  // char").
  ARMII_MO_UNUSED_MAXIMUM = 0xff
} ARMII_TOF;

enum {
  //===------------------------------------------------------------------===//
  // Instruction Flags.

  //===------------------------------------------------------------------===//
  // This four-bit field describes the addressing mode used.
  ARMII_AddrModeMask =
    0x1f, // The AddrMode enums are declared in ARMBaseInfo.h

  // IndexMode - Unindex, pre-indexed, or post-indexed are valid for load
  // and store ops only.  Generic "updating" flag is used for ld/st multiple.
  // The index mode enums are declared in ARMBaseInfo.h
  ARMII_IndexModeShift = 5,
  ARMII_IndexModeMask = 3 << ARMII_IndexModeShift,

  //===------------------------------------------------------------------===//
  // Instruction encoding formats.
  //
  ARMII_FormShift = 7,
  ARMII_FormMask = 0x3f << ARMII_FormShift,

  // Pseudo instructions
  ARMII_Pseudo = 0 << ARMII_FormShift,

  // Multiply instructions
  ARMII_MulFrm = 1 << ARMII_FormShift,

  // Branch instructions
  ARMII_BrFrm = 2 << ARMII_FormShift,
  ARMII_BrMiscFrm = 3 << ARMII_FormShift,

  // Data Processing instructions
  ARMII_DPFrm = 4 << ARMII_FormShift,
  ARMII_DPSoRegFrm = 5 << ARMII_FormShift,

  // Load and Store
  ARMII_LdFrm = 6 << ARMII_FormShift,
  ARMII_StFrm = 7 << ARMII_FormShift,
  ARMII_LdMiscFrm = 8 << ARMII_FormShift,
  ARMII_StMiscFrm = 9 << ARMII_FormShift,
  ARMII_LdStMulFrm = 10 << ARMII_FormShift,

  ARMII_LdStExFrm = 11 << ARMII_FormShift,

  // Miscellaneous arithmetic instructions
  ARMII_ArithMiscFrm = 12 << ARMII_FormShift,
  ARMII_SatFrm = 13 << ARMII_FormShift,

  // Extend instructions
  ARMII_ExtFrm = 14 << ARMII_FormShift,

  // VFP formats
  ARMII_VFPUnaryFrm = 15 << ARMII_FormShift,
  ARMII_VFPBinaryFrm = 16 << ARMII_FormShift,
  ARMII_VFPConv1Frm = 17 << ARMII_FormShift,
  ARMII_VFPConv2Frm = 18 << ARMII_FormShift,
  ARMII_VFPConv3Frm = 19 << ARMII_FormShift,
  ARMII_VFPConv4Frm = 20 << ARMII_FormShift,
  ARMII_VFPConv5Frm = 21 << ARMII_FormShift,
  ARMII_VFPLdStFrm = 22 << ARMII_FormShift,
  ARMII_VFPLdStMulFrm = 23 << ARMII_FormShift,
  ARMII_VFPMiscFrm = 24 << ARMII_FormShift,

  // Thumb format
  ARMII_ThumbFrm = 25 << ARMII_FormShift,

  // Miscelleaneous format
  ARMII_MiscFrm = 26 << ARMII_FormShift,

  // NEON formats
  ARMII_NGetLnFrm = 27 << ARMII_FormShift,
  ARMII_NSetLnFrm = 28 << ARMII_FormShift,
  ARMII_NDupFrm = 29 << ARMII_FormShift,
  ARMII_NLdStFrm = 30 << ARMII_FormShift,
  ARMII_N1RegModImmFrm = 31 << ARMII_FormShift,
  ARMII_N2RegFrm = 32 << ARMII_FormShift,
  ARMII_NVCVTFrm = 33 << ARMII_FormShift,
  ARMII_NVDupLnFrm = 34 << ARMII_FormShift,
  ARMII_N2RegVShLFrm = 35 << ARMII_FormShift,
  ARMII_N2RegVShRFrm = 36 << ARMII_FormShift,
  ARMII_N3RegFrm = 37 << ARMII_FormShift,
  ARMII_N3RegVShFrm = 38 << ARMII_FormShift,
  ARMII_NVExtFrm = 39 << ARMII_FormShift,
  ARMII_NVMulSLFrm = 40 << ARMII_FormShift,
  ARMII_NVTBLFrm = 41 << ARMII_FormShift,
  ARMII_N3RegCplxFrm = 43 << ARMII_FormShift,

  //===------------------------------------------------------------------===//
  // Misc flags.

  // UnaryDP - Indicates this is a unary data processing instruction, i.e.
  // it doesn't have a Rn operand.
  ARMII_UnaryDP = 1 << 13,

  // Xform16Bit - Indicates this Thumb2 instruction may be transformed into
  // a 16-bit Thumb instruction if certain conditions are met.
  ARMII_Xform16Bit = 1 << 14,

  // ThumbArithFlagSetting - The instruction is a 16-bit flag setting Thumb
  // instruction. Used by the parser to determine whether to require the 'S'
  // suffix on the mnemonic (when not in an IT block) or preclude it (when
  // in an IT block).
  ARMII_ThumbArithFlagSetting = 1 << 19,

  // Whether an instruction can be included in an MVE tail-predicated loop,
  // though extra validity checks may need to be performed too.
  ARMII_ValidForTailPredication = 1 << 20,

  // Whether an instruction writes to the top/bottom half of a vector element
  // and leaves the other half untouched.
  ARMII_RetainsPreviousHalfElement = 1 << 21,

  // Whether the instruction produces a scalar result from vector operands.
  ARMII_HorizontalReduction = 1 << 22,

  // Whether this instruction produces a vector result that is larger than
  // its input, typically reading from the top/bottom halves of the input(s).
  ARMII_DoubleWidthResult = 1 << 23,

  // The vector element size for MVE instructions. 00 = i8, 01 = i16, 10 = i32
  // and 11 = i64. This is the largest type if multiple are present, so a
  // MVE_VMOVLs8bh is ize 01=i16, as it extends from a i8 to a i16. There are
  // some caveats so cannot be used blindly, such as exchanging VMLADAVA's and
  // complex instructions, which may use different input lanes.
  ARMII_VecSizeShift = 24,
  ARMII_VecSize = 3 << ARMII_VecSizeShift,

  //===------------------------------------------------------------------===//
  // Code domain.
  ARMII_DomainShift = 15,
  ARMII_DomainMask = 15 << ARMII_DomainShift,
  ARMII_DomainGeneral = 0 << ARMII_DomainShift,
  ARMII_DomainVFP = 1 << ARMII_DomainShift,
  ARMII_DomainNEON = 2 << ARMII_DomainShift,
  ARMII_DomainNEONA8 = 4 << ARMII_DomainShift,
  ARMII_DomainMVE = 8 << ARMII_DomainShift,

  //===------------------------------------------------------------------===//
  // Field shifts - such shifts are used to set field while generating
  // machine instructions.
  //
  // FIXME: This list will need adjusting/fixing as the MC code emitter
  // takes shape and the ARMCodeEmitter.cpp bits go away.
  ARMII_ShiftTypeShift = 4,

  ARMII_M_BitShift = 5,
  ARMII_ShiftImmShift = 5,
  ARMII_ShiftShift = 7,
  ARMII_N_BitShift = 7,
  ARMII_ImmHiShift = 8,
  ARMII_SoRotImmShift = 8,
  ARMII_RegRsShift = 8,
  ARMII_ExtRotImmShift = 10,
  ARMII_RegRdLoShift = 12,
  ARMII_RegRdShift = 12,
  ARMII_RegRdHiShift = 16,
  ARMII_RegRnShift = 16,
  ARMII_S_BitShift = 20,
  ARMII_W_BitShift = 21,
  ARMII_AM3_I_BitShift = 22,
  ARMII_D_BitShift = 22,
  ARMII_U_BitShift = 23,
  ARMII_P_BitShift = 24,
  ARMII_I_BitShift = 25,
  ARMII_CondShift = 28
};

const char *get_pred_mask(ARM_PredBlockMask pred_mask);

#endif // CS_ARM_BASEINFO_H

Coverage Report

Created: 2025-07-01 07:03