contrib/llvm/include/llvm/Support/TargetParser.h

   1 //===-- TargetParser - Parser for target features ---------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements a target parser to recognise hardware features such as
  11 // FPU/CPU/ARCH names as well as specific support such as HDIV, etc.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_SUPPORT_TARGETPARSER_H
  16 #define LLVM_SUPPORT_TARGETPARSER_H
  17
  18 // FIXME: vector is used because that's what clang uses for subtarget feature
  19 // lists, but SmallVector would probably be better
  20 #include "llvm/ADT/Triple.h"
  21 #include <vector>
  22
  23 namespace llvm {
  24 class StringRef;
  25
  26 // Target specific information into their own namespaces. These should be
  27 // generated from TableGen because the information is already there, and there
  28 // is where new information about targets will be added.
  29 // FIXME: To TableGen this we need to make some table generated files available
  30 // even if the back-end is not compiled with LLVM, plus we need to create a new
  31 // back-end to TableGen to create these clean tables.
  32 namespace ARM {
  33
  34 // FPU Version
  35 enum class FPUVersion {
  36   NONE,
  37   VFPV2,
  38   VFPV3,
  39   VFPV3_FP16,
  40   VFPV4,
  41   VFPV5
  42 };
  43
  44 // An FPU name restricts the FPU in one of three ways:
  45 enum class FPURestriction {
  46   None = 0, ///< No restriction
  47   D16,      ///< Only 16 D registers
  48   SP_D16    ///< Only single-precision instructions, with 16 D registers
  49 };
  50
  51 // An FPU name implies one of three levels of Neon support:
  52 enum class NeonSupportLevel {
  53   None = 0, ///< No Neon
  54   Neon,     ///< Neon
  55   Crypto    ///< Neon with Crypto
  56 };
  57
  58 // FPU names.
  59 enum FPUKind {
  60 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) KIND,
  61 #include "ARMTargetParser.def"
  62   FK_LAST
  63 };
  64
  65 // Arch names.
  66 enum class ArchKind {
  67 #define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
  68 #include "ARMTargetParser.def"
  69 };
  70
  71 // Arch extension modifiers for CPUs.
  72 enum ArchExtKind : unsigned {
  73   AEK_INVALID =     0,
  74   AEK_NONE =        1,
  75   AEK_CRC =         1 << 1,
  76   AEK_CRYPTO =      1 << 2,
  77   AEK_FP =          1 << 3,
  78   AEK_HWDIVTHUMB =  1 << 4,
  79   AEK_HWDIVARM =    1 << 5,
  80   AEK_MP =          1 << 6,
  81   AEK_SIMD =        1 << 7,
  82   AEK_SEC =         1 << 8,
  83   AEK_VIRT =        1 << 9,
  84   AEK_DSP =         1 << 10,
  85   AEK_FP16 =        1 << 11,
  86   AEK_RAS =         1 << 12,
  87   AEK_SVE =         1 << 13,
  88   AEK_DOTPROD =     1 << 14,
  89   AEK_SHA2    =     1 << 15,
  90   AEK_AES     =     1 << 16,
  91   // Unsupported extensions.
  92   AEK_OS = 0x8000000,
  93   AEK_IWMMXT = 0x10000000,
  94   AEK_IWMMXT2 = 0x20000000,
  95   AEK_MAVERICK = 0x40000000,
  96   AEK_XSCALE = 0x80000000,
  97 };
  98
  99 // ISA kinds.
 100 enum class ISAKind { INVALID = 0, ARM, THUMB, AARCH64 };
 101
 102 // Endianness
 103 // FIXME: BE8 vs. BE32?
 104 enum class EndianKind { INVALID = 0, LITTLE, BIG };
 105
 106 // v6/v7/v8 Profile
 107 enum class ProfileKind { INVALID = 0, A, R, M };
 108
 109 StringRef getCanonicalArchName(StringRef Arch);
 110
 111 // Information by ID
 112 StringRef getFPUName(unsigned FPUKind);
 113 FPUVersion getFPUVersion(unsigned FPUKind);
 114 NeonSupportLevel getFPUNeonSupportLevel(unsigned FPUKind);
 115 FPURestriction getFPURestriction(unsigned FPUKind);
 116
 117 // FIXME: These should be moved to TargetTuple once it exists
 118 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
 119 bool getHWDivFeatures(unsigned HWDivKind, std::vector<StringRef> &Features);
 120 bool getExtensionFeatures(unsigned Extensions,
 121                           std::vector<StringRef> &Features);
 122
 123 StringRef getArchName(ArchKind AK);
 124 unsigned getArchAttr(ArchKind AK);
 125 StringRef getCPUAttr(ArchKind AK);
 126 StringRef getSubArch(ArchKind AK);
 127 StringRef getArchExtName(unsigned ArchExtKind);
 128 StringRef getArchExtFeature(StringRef ArchExt);
 129 StringRef getHWDivName(unsigned HWDivKind);
 130
 131 // Information by Name
 132 unsigned  getDefaultFPU(StringRef CPU, ArchKind AK);
 133 unsigned  getDefaultExtensions(StringRef CPU, ArchKind AK);
 134 StringRef getDefaultCPU(StringRef Arch);
 135
 136 // Parser
 137 unsigned parseHWDiv(StringRef HWDiv);
 138 unsigned parseFPU(StringRef FPU);
 139 ArchKind parseArch(StringRef Arch);
 140 unsigned parseArchExt(StringRef ArchExt);
 141 ArchKind parseCPUArch(StringRef CPU);
 142 void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values);
 143 ISAKind parseArchISA(StringRef Arch);
 144 EndianKind parseArchEndian(StringRef Arch);
 145 ProfileKind parseArchProfile(StringRef Arch);
 146 unsigned parseArchVersion(StringRef Arch);
 147
 148 StringRef computeDefaultTargetABI(const Triple &TT, StringRef CPU);
 149
 150 } // namespace ARM
 151
 152 // FIXME:This should be made into class design,to avoid dupplication.
 153 namespace AArch64 {
 154
 155 // Arch names.
 156 enum class ArchKind {
 157 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
 158 #include "AArch64TargetParser.def"
 159 };
 160
 161 // Arch extension modifiers for CPUs.
 162 enum ArchExtKind : unsigned {
 163   AEK_INVALID =     0,
 164   AEK_NONE =        1,
 165   AEK_CRC =         1 << 1,
 166   AEK_CRYPTO =      1 << 2,
 167   AEK_FP =          1 << 3,
 168   AEK_SIMD =        1 << 4,
 169   AEK_FP16 =        1 << 5,
 170   AEK_PROFILE =     1 << 6,
 171   AEK_RAS =         1 << 7,
 172   AEK_LSE =         1 << 8,
 173   AEK_SVE =         1 << 9,
 174   AEK_DOTPROD =     1 << 10,
 175   AEK_RCPC =        1 << 11,
 176   AEK_RDM =         1 << 12,
 177   AEK_SM4 =         1 << 13,
 178   AEK_SHA3 =        1 << 14,
 179   AEK_SHA2 =        1 << 15,
 180   AEK_AES =         1 << 16,
 181 };
 182
 183 StringRef getCanonicalArchName(StringRef Arch);
 184
 185 // Information by ID
 186 StringRef getFPUName(unsigned FPUKind);
 187 ARM::FPUVersion getFPUVersion(unsigned FPUKind);
 188 ARM::NeonSupportLevel getFPUNeonSupportLevel(unsigned FPUKind);
 189 ARM::FPURestriction getFPURestriction(unsigned FPUKind);
 190
 191 // FIXME: These should be moved to TargetTuple once it exists
 192 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
 193 bool getExtensionFeatures(unsigned Extensions,
 194                                    std::vector<StringRef> &Features);
 195 bool getArchFeatures(ArchKind AK, std::vector<StringRef> &Features);
 196
 197 StringRef getArchName(ArchKind AK);
 198 unsigned getArchAttr(ArchKind AK);
 199 StringRef getCPUAttr(ArchKind AK);
 200 StringRef getSubArch(ArchKind AK);
 201 StringRef getArchExtName(unsigned ArchExtKind);
 202 StringRef getArchExtFeature(StringRef ArchExt);
 203 unsigned checkArchVersion(StringRef Arch);
 204
 205 // Information by Name
 206 unsigned  getDefaultFPU(StringRef CPU, ArchKind AK);
 207 unsigned  getDefaultExtensions(StringRef CPU, ArchKind AK);
 208 StringRef getDefaultCPU(StringRef Arch);
 209 AArch64::ArchKind getCPUArchKind(StringRef CPU);
 210
 211 // Parser
 212 unsigned parseFPU(StringRef FPU);
 213 AArch64::ArchKind parseArch(StringRef Arch);
 214 ArchExtKind parseArchExt(StringRef ArchExt);
 215 ArchKind parseCPUArch(StringRef CPU);
 216 void fillValidCPUArchList(SmallVectorImpl<StringRef> &Values);
 217 ARM::ISAKind parseArchISA(StringRef Arch);
 218 ARM::EndianKind parseArchEndian(StringRef Arch);
 219 ARM::ProfileKind parseArchProfile(StringRef Arch);
 220 unsigned parseArchVersion(StringRef Arch);
 221
 222 bool isX18ReservedByDefault(const Triple &TT);
 223
 224 } // namespace AArch64
 225
 226 namespace X86 {
 227
 228 // This should be kept in sync with libcc/compiler-rt as its included by clang
 229 // as a proxy for what's in libgcc/compiler-rt.
 230 enum ProcessorVendors : unsigned {
 231   VENDOR_DUMMY,
 232 #define X86_VENDOR(ENUM, STRING) \
 233   ENUM,
 234 #include "llvm/Support/X86TargetParser.def"
 235   VENDOR_OTHER
 236 };
 237
 238 // This should be kept in sync with libcc/compiler-rt as its included by clang
 239 // as a proxy for what's in libgcc/compiler-rt.
 240 enum ProcessorTypes : unsigned {
 241   CPU_TYPE_DUMMY,
 242 #define X86_CPU_TYPE(ARCHNAME, ENUM) \
 243   ENUM,
 244 #include "llvm/Support/X86TargetParser.def"
 245   CPU_TYPE_MAX
 246 };
 247
 248 // This should be kept in sync with libcc/compiler-rt as its included by clang
 249 // as a proxy for what's in libgcc/compiler-rt.
 250 enum ProcessorSubtypes : unsigned {
 251   CPU_SUBTYPE_DUMMY,
 252 #define X86_CPU_SUBTYPE(ARCHNAME, ENUM) \
 253   ENUM,
 254 #include "llvm/Support/X86TargetParser.def"
 255   CPU_SUBTYPE_MAX
 256 };
 257
 258 // This should be kept in sync with libcc/compiler-rt as it should be used
 259 // by clang as a proxy for what's in libgcc/compiler-rt.
 260 enum ProcessorFeatures {
 261 #define X86_FEATURE(VAL, ENUM) \
 262   ENUM = VAL,
 263 #include "llvm/Support/X86TargetParser.def"
 264
 265 };
 266
 267 } // namespace X86
 268
 269 } // namespace llvm
 270
 271 #endif