Home | History | Annotate | Line # | Download | only in Basic 
      1 //===--- TargetBuiltins.h - Target specific builtin IDs ---------*- C++ -*-===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 ///
      9 /// \file
     10 /// Enumerates target-specific builtins in their own namespaces within
     11 /// namespace ::clang.
     12 ///
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_CLANG_BASIC_TARGETBUILTINS_H
     16 #define LLVM_CLANG_BASIC_TARGETBUILTINS_H
     17 
     18 #include <algorithm>
     19 #include <stdint.h>
     20 #include "clang/Basic/Builtins.h"
     21 #include "llvm/Support/MathExtras.h"
     22 #undef PPC
     23 
     24 namespace clang {
     25 
     26   namespace NEON {
     27   enum {
     28     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
     29 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     30 #include "clang/Basic/BuiltinsNEON.def"
     31     FirstTSBuiltin
     32   };
     33   }
     34 
     35   /// ARM builtins
     36   namespace ARM {
     37     enum {
     38       LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
     39       LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
     40 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     41 #include "clang/Basic/BuiltinsARM.def"
     42       LastTSBuiltin
     43     };
     44   }
     45 
     46   namespace SVE {
     47   enum {
     48     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
     49 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     50 #include "clang/Basic/BuiltinsSVE.def"
     51     FirstTSBuiltin,
     52   };
     53   }
     54 
     55   /// AArch64 builtins
     56   namespace AArch64 {
     57   enum {
     58     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
     59     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
     60     FirstSVEBuiltin = NEON::FirstTSBuiltin,
     61     LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
     62   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     63   #include "clang/Basic/BuiltinsAArch64.def"
     64     LastTSBuiltin
     65   };
     66   }
     67 
     68   /// BPF builtins
     69   namespace BPF {
     70   enum {
     71     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
     72   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     73   #include "clang/Basic/BuiltinsBPF.def"
     74     LastTSBuiltin
     75   };
     76   }
     77 
     78   /// PPC builtins
     79   namespace PPC {
     80     enum {
     81         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
     82 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     83 #include "clang/Basic/BuiltinsPPC.def"
     84         LastTSBuiltin
     85     };
     86   }
     87 
     88   /// NVPTX builtins
     89   namespace NVPTX {
     90     enum {
     91         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
     92 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
     93 #include "clang/Basic/BuiltinsNVPTX.def"
     94         LastTSBuiltin
     95     };
     96   }
     97 
     98   /// AMDGPU builtins
     99   namespace AMDGPU {
    100   enum {
    101     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
    102   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    103   #include "clang/Basic/BuiltinsAMDGPU.def"
    104     LastTSBuiltin
    105   };
    106   }
    107 
    108   /// X86 builtins
    109   namespace X86 {
    110   enum {
    111     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
    112 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    113 #include "clang/Basic/BuiltinsX86.def"
    114     FirstX86_64Builtin,
    115     LastX86CommonBuiltin = FirstX86_64Builtin - 1,
    116 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    117 #include "clang/Basic/BuiltinsX86_64.def"
    118     LastTSBuiltin
    119   };
    120   }
    121 
    122   /// VE builtins
    123   namespace VE {
    124   enum { LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, LastTSBuiltin };
    125   }
    126 
    127   /// RISCV builtins
    128   namespace RISCV {
    129   enum {
    130     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
    131 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    132 #include "clang/Basic/BuiltinsRISCV.def"
    133     LastTSBuiltin
    134   };
    135   } // namespace RISCV
    136 
    137   /// Flags to identify the types for overloaded Neon builtins.
    138   ///
    139   /// These must be kept in sync with the flags in utils/TableGen/NeonEmitter.h.
    140   class NeonTypeFlags {
    141     enum {
    142       EltTypeMask = 0xf,
    143       UnsignedFlag = 0x10,
    144       QuadFlag = 0x20
    145     };
    146     uint32_t Flags;
    147 
    148   public:
    149     enum EltType {
    150       Int8,
    151       Int16,
    152       Int32,
    153       Int64,
    154       Poly8,
    155       Poly16,
    156       Poly64,
    157       Poly128,
    158       Float16,
    159       Float32,
    160       Float64,
    161       BFloat16
    162     };
    163 
    164     NeonTypeFlags(unsigned F) : Flags(F) {}
    165     NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
    166       if (IsUnsigned)
    167         Flags |= UnsignedFlag;
    168       if (IsQuad)
    169         Flags |= QuadFlag;
    170     }
    171 
    172     EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
    173     bool isPoly() const {
    174       EltType ET = getEltType();
    175       return ET == Poly8 || ET == Poly16 || ET == Poly64;
    176     }
    177     bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
    178     bool isQuad() const { return (Flags & QuadFlag) != 0; }
    179   };
    180 
    181   /// Flags to identify the types for overloaded SVE builtins.
    182   class SVETypeFlags {
    183     uint64_t Flags;
    184     unsigned EltTypeShift;
    185     unsigned MemEltTypeShift;
    186     unsigned MergeTypeShift;
    187     unsigned SplatOperandMaskShift;
    188 
    189   public:
    190 #define LLVM_GET_SVE_TYPEFLAGS
    191 #include "clang/Basic/arm_sve_typeflags.inc"
    192 #undef LLVM_GET_SVE_TYPEFLAGS
    193 
    194     enum EltType {
    195 #define LLVM_GET_SVE_ELTTYPES
    196 #include "clang/Basic/arm_sve_typeflags.inc"
    197 #undef LLVM_GET_SVE_ELTTYPES
    198     };
    199 
    200     enum MemEltType {
    201 #define LLVM_GET_SVE_MEMELTTYPES
    202 #include "clang/Basic/arm_sve_typeflags.inc"
    203 #undef LLVM_GET_SVE_MEMELTTYPES
    204     };
    205 
    206     enum MergeType {
    207 #define LLVM_GET_SVE_MERGETYPES
    208 #include "clang/Basic/arm_sve_typeflags.inc"
    209 #undef LLVM_GET_SVE_MERGETYPES
    210     };
    211 
    212     enum ImmCheckType {
    213 #define LLVM_GET_SVE_IMMCHECKTYPES
    214 #include "clang/Basic/arm_sve_typeflags.inc"
    215 #undef LLVM_GET_SVE_IMMCHECKTYPES
    216     };
    217 
    218     SVETypeFlags(uint64_t F) : Flags(F) {
    219       EltTypeShift = llvm::countTrailingZeros(EltTypeMask);
    220       MemEltTypeShift = llvm::countTrailingZeros(MemEltTypeMask);
    221       MergeTypeShift = llvm::countTrailingZeros(MergeTypeMask);
    222       SplatOperandMaskShift = llvm::countTrailingZeros(SplatOperandMask);
    223     }
    224 
    225     EltType getEltType() const {
    226       return (EltType)((Flags & EltTypeMask) >> EltTypeShift);
    227     }
    228 
    229     MemEltType getMemEltType() const {
    230       return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift);
    231     }
    232 
    233     MergeType getMergeType() const {
    234       return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift);
    235     }
    236 
    237     unsigned getSplatOperand() const {
    238       return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1;
    239     }
    240 
    241     bool hasSplatOperand() const {
    242       return Flags & SplatOperandMask;
    243     }
    244 
    245     bool isLoad() const { return Flags & IsLoad; }
    246     bool isStore() const { return Flags & IsStore; }
    247     bool isGatherLoad() const { return Flags & IsGatherLoad; }
    248     bool isScatterStore() const { return Flags & IsScatterStore; }
    249     bool isStructLoad() const { return Flags & IsStructLoad; }
    250     bool isStructStore() const { return Flags & IsStructStore; }
    251     bool isZExtReturn() const { return Flags & IsZExtReturn; }
    252     bool isByteIndexed() const { return Flags & IsByteIndexed; }
    253     bool isOverloadNone() const { return Flags & IsOverloadNone; }
    254     bool isOverloadWhile() const { return Flags & IsOverloadWhile; }
    255     bool isOverloadDefault() const { return !(Flags & OverloadKindMask); }
    256     bool isOverloadWhileRW() const { return Flags & IsOverloadWhileRW; }
    257     bool isOverloadCvt() const { return Flags & IsOverloadCvt; }
    258     bool isPrefetch() const { return Flags & IsPrefetch; }
    259     bool isReverseCompare() const { return Flags & ReverseCompare; }
    260     bool isAppendSVALL() const { return Flags & IsAppendSVALL; }
    261     bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; }
    262     bool isGatherPrefetch() const { return Flags & IsGatherPrefetch; }
    263     bool isReverseUSDOT() const { return Flags & ReverseUSDOT; }
    264     bool isUndef() const { return Flags & IsUndef; }
    265     bool isTupleCreate() const { return Flags & IsTupleCreate; }
    266     bool isTupleGet() const { return Flags & IsTupleGet; }
    267     bool isTupleSet() const { return Flags & IsTupleSet; }
    268 
    269     uint64_t getBits() const { return Flags; }
    270     bool isFlagSet(uint64_t Flag) const { return Flags & Flag; }
    271   };
    272 
    273   /// Hexagon builtins
    274   namespace Hexagon {
    275     enum {
    276         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
    277 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    278 #include "clang/Basic/BuiltinsHexagon.def"
    279         LastTSBuiltin
    280     };
    281   }
    282 
    283   /// MIPS builtins
    284   namespace Mips {
    285     enum {
    286         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
    287 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    288 #include "clang/Basic/BuiltinsMips.def"
    289         LastTSBuiltin
    290     };
    291   }
    292 
    293   /// XCore builtins
    294   namespace XCore {
    295     enum {
    296         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
    297 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    298 #include "clang/Basic/BuiltinsXCore.def"
    299         LastTSBuiltin
    300     };
    301   }
    302 
    303   /// SystemZ builtins
    304   namespace SystemZ {
    305     enum {
    306         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
    307 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    308 #include "clang/Basic/BuiltinsSystemZ.def"
    309         LastTSBuiltin
    310     };
    311   }
    312 
    313   /// WebAssembly builtins
    314   namespace WebAssembly {
    315     enum {
    316       LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
    317 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
    318 #include "clang/Basic/BuiltinsWebAssembly.def"
    319       LastTSBuiltin
    320     };
    321   }
    322 
    323   static constexpr uint64_t LargestBuiltinID = std::max<uint64_t>(
    324       {ARM::LastTSBuiltin, AArch64::LastTSBuiltin, BPF::LastTSBuiltin,
    325        PPC::LastTSBuiltin, NVPTX::LastTSBuiltin, AMDGPU::LastTSBuiltin,
    326        X86::LastTSBuiltin, VE::LastTSBuiltin, RISCV::LastTSBuiltin,
    327        Hexagon::LastTSBuiltin, Mips::LastTSBuiltin, XCore::LastTSBuiltin,
    328        SystemZ::LastTSBuiltin, WebAssembly::LastTSBuiltin});
    329 
    330 } // end namespace clang.
    331 
    332 #endif
    333