Home | History | Annotate | Download | only in Support 
      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 <vector>
     21 
     22 namespace llvm {
     23 class StringRef;
     24 
     25 // Target specific information into their own namespaces. These should be
     26 // generated from TableGen because the information is already there, and there
     27 // is where new information about targets will be added.
     28 // FIXME: To TableGen this we need to make some table generated files available
     29 // even if the back-end is not compiled with LLVM, plus we need to create a new
     30 // back-end to TableGen to create these clean tables.
     31 namespace ARM {
     32 
     33 // FPU names.
     34 enum FPUKind {
     35 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) KIND,
     36 #include "ARMTargetParser.def"
     37   FK_LAST
     38 };
     39 
     40 // FPU Version
     41 enum FPUVersion {
     42   FV_NONE = 0,
     43   FV_VFPV2,
     44   FV_VFPV3,
     45   FV_VFPV3_FP16,
     46   FV_VFPV4,
     47   FV_VFPV5
     48 };
     49 
     50 // An FPU name implies one of three levels of Neon support:
     51 enum NeonSupportLevel {
     52   NS_None = 0, ///< No Neon
     53   NS_Neon,     ///< Neon
     54   NS_Crypto    ///< Neon with Crypto
     55 };
     56 
     57 // An FPU name restricts the FPU in one of three ways:
     58 enum FPURestriction {
     59   FR_None = 0, ///< No restriction
     60   FR_D16,      ///< Only 16 D registers
     61   FR_SP_D16    ///< Only single-precision instructions, with 16 D registers
     62 };
     63 
     64 // Arch names.
     65 enum ArchKind {
     66 #define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
     67 #include "ARMTargetParser.def"
     68   AK_LAST
     69 };
     70 
     71 // Arch extension modifiers for CPUs.
     72 enum ArchExtKind : unsigned {
     73   AEK_INVALID = 0x0,
     74   AEK_NONE = 0x1,
     75   AEK_CRC = 0x2,
     76   AEK_CRYPTO = 0x4,
     77   AEK_FP = 0x8,
     78   AEK_HWDIV = 0x10,
     79   AEK_HWDIVARM = 0x20,
     80   AEK_MP = 0x40,
     81   AEK_SIMD = 0x80,
     82   AEK_SEC = 0x100,
     83   AEK_VIRT = 0x200,
     84   AEK_DSP = 0x400,
     85   AEK_FP16 = 0x800,
     86   AEK_RAS = 0x1000,
     87   // Unsupported extensions.
     88   AEK_OS = 0x8000000,
     89   AEK_IWMMXT = 0x10000000,
     90   AEK_IWMMXT2 = 0x20000000,
     91   AEK_MAVERICK = 0x40000000,
     92   AEK_XSCALE = 0x80000000,
     93 };
     94 
     95 // ISA kinds.
     96 enum ISAKind { IK_INVALID = 0, IK_ARM, IK_THUMB, IK_AARCH64 };
     97 
     98 // Endianness
     99 // FIXME: BE8 vs. BE32?
    100 enum EndianKind { EK_INVALID = 0, EK_LITTLE, EK_BIG };
    101 
    102 // v6/v7/v8 Profile
    103 enum ProfileKind { PK_INVALID = 0, PK_A, PK_R, PK_M };
    104 
    105 StringRef getCanonicalArchName(StringRef Arch);
    106 
    107 // Information by ID
    108 StringRef getFPUName(unsigned FPUKind);
    109 unsigned getFPUVersion(unsigned FPUKind);
    110 unsigned getFPUNeonSupportLevel(unsigned FPUKind);
    111 unsigned getFPURestriction(unsigned FPUKind);
    112 
    113 // FIXME: These should be moved to TargetTuple once it exists
    114 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
    115 bool getHWDivFeatures(unsigned HWDivKind, std::vector<StringRef> &Features);
    116 bool getExtensionFeatures(unsigned Extensions,
    117                           std::vector<StringRef> &Features);
    118 
    119 StringRef getArchName(unsigned ArchKind);
    120 unsigned getArchAttr(unsigned ArchKind);
    121 StringRef getCPUAttr(unsigned ArchKind);
    122 StringRef getSubArch(unsigned ArchKind);
    123 StringRef getArchExtName(unsigned ArchExtKind);
    124 StringRef getArchExtFeature(StringRef ArchExt);
    125 StringRef getHWDivName(unsigned HWDivKind);
    126 
    127 // Information by Name
    128 unsigned  getDefaultFPU(StringRef CPU, unsigned ArchKind);
    129 unsigned  getDefaultExtensions(StringRef CPU, unsigned ArchKind);
    130 StringRef getDefaultCPU(StringRef Arch);
    131 
    132 // Parser
    133 unsigned parseHWDiv(StringRef HWDiv);
    134 unsigned parseFPU(StringRef FPU);
    135 unsigned parseArch(StringRef Arch);
    136 unsigned parseArchExt(StringRef ArchExt);
    137 unsigned parseCPUArch(StringRef CPU);
    138 unsigned parseArchISA(StringRef Arch);
    139 unsigned parseArchEndian(StringRef Arch);
    140 unsigned parseArchProfile(StringRef Arch);
    141 unsigned parseArchVersion(StringRef Arch);
    142 
    143 } // namespace ARM
    144 
    145 // FIXME:This should be made into class design,to avoid dupplication.
    146 namespace AArch64 {
    147 
    148 // Arch names.
    149 enum class ArchKind {
    150 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) ID,
    151 #include "AArch64TargetParser.def"
    152   AK_LAST
    153 };
    154 
    155 // Arch extension modifiers for CPUs.
    156 enum ArchExtKind : unsigned {
    157   AEK_INVALID = 0x0,
    158   AEK_NONE = 0x1,
    159   AEK_CRC = 0x2,
    160   AEK_CRYPTO = 0x4,
    161   AEK_FP = 0x8,
    162   AEK_SIMD = 0x10,
    163   AEK_FP16 = 0x20,
    164   AEK_PROFILE = 0x40,
    165   AEK_RAS = 0x80,
    166   AEK_LSE = 0x100
    167 };
    168 
    169 StringRef getCanonicalArchName(StringRef Arch);
    170 
    171 // Information by ID
    172 StringRef getFPUName(unsigned FPUKind);
    173 unsigned getFPUVersion(unsigned FPUKind);
    174 unsigned getFPUNeonSupportLevel(unsigned FPUKind);
    175 unsigned getFPURestriction(unsigned FPUKind);
    176 
    177 // FIXME: These should be moved to TargetTuple once it exists
    178 bool getFPUFeatures(unsigned FPUKind, std::vector<StringRef> &Features);
    179 bool getExtensionFeatures(unsigned Extensions,
    180                                    std::vector<StringRef> &Features);
    181 bool getArchFeatures(unsigned ArchKind, std::vector<StringRef> &Features);
    182 
    183 StringRef getArchName(unsigned ArchKind);
    184 unsigned getArchAttr(unsigned ArchKind);
    185 StringRef getCPUAttr(unsigned ArchKind);
    186 StringRef getSubArch(unsigned ArchKind);
    187 StringRef getArchExtName(unsigned ArchExtKind);
    188 StringRef getArchExtFeature(StringRef ArchExt);
    189 unsigned checkArchVersion(StringRef Arch);
    190 
    191 // Information by Name
    192 unsigned  getDefaultFPU(StringRef CPU, unsigned ArchKind);
    193 unsigned  getDefaultExtensions(StringRef CPU, unsigned ArchKind);
    194 StringRef getDefaultCPU(StringRef Arch);
    195 
    196 // Parser
    197 unsigned parseFPU(StringRef FPU);
    198 unsigned parseArch(StringRef Arch);
    199 unsigned parseArchExt(StringRef ArchExt);
    200 unsigned parseCPUArch(StringRef CPU);
    201 unsigned parseArchISA(StringRef Arch);
    202 unsigned parseArchEndian(StringRef Arch);
    203 unsigned parseArchProfile(StringRef Arch);
    204 unsigned parseArchVersion(StringRef Arch);
    205 
    206 } // namespace AArch64
    207 } // namespace llvm
    208 
    209 #endif
    210