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 /// Flags to identify the types for overloaded Neon builtins. 128 /// 129 /// These must be kept in sync with the flags in utils/TableGen/NeonEmitter.h. 130 class NeonTypeFlags { 131 enum { 132 EltTypeMask = 0xf, 133 UnsignedFlag = 0x10, 134 QuadFlag = 0x20 135 }; 136 uint32_t Flags; 137 138 public: 139 enum EltType { 140 Int8, 141 Int16, 142 Int32, 143 Int64, 144 Poly8, 145 Poly16, 146 Poly64, 147 Poly128, 148 Float16, 149 Float32, 150 Float64, 151 BFloat16 152 }; 153 NeonTypeFlags(unsigned F)154 NeonTypeFlags(unsigned F) : Flags(F) {} NeonTypeFlags(EltType ET,bool IsUnsigned,bool IsQuad)155 NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) { 156 if (IsUnsigned) 157 Flags |= UnsignedFlag; 158 if (IsQuad) 159 Flags |= QuadFlag; 160 } 161 getEltType()162 EltType getEltType() const { return (EltType)(Flags & EltTypeMask); } isPoly()163 bool isPoly() const { 164 EltType ET = getEltType(); 165 return ET == Poly8 || ET == Poly16 || ET == Poly64; 166 } isUnsigned()167 bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; } isQuad()168 bool isQuad() const { return (Flags & QuadFlag) != 0; } 169 }; 170 171 /// Flags to identify the types for overloaded SVE builtins. 172 class SVETypeFlags { 173 uint64_t Flags; 174 unsigned EltTypeShift; 175 unsigned MemEltTypeShift; 176 unsigned MergeTypeShift; 177 unsigned SplatOperandMaskShift; 178 179 public: 180 #define LLVM_GET_SVE_TYPEFLAGS 181 #include "clang/Basic/arm_sve_typeflags.inc" 182 #undef LLVM_GET_SVE_TYPEFLAGS 183 184 enum EltType { 185 #define LLVM_GET_SVE_ELTTYPES 186 #include "clang/Basic/arm_sve_typeflags.inc" 187 #undef LLVM_GET_SVE_ELTTYPES 188 }; 189 190 enum MemEltType { 191 #define LLVM_GET_SVE_MEMELTTYPES 192 #include "clang/Basic/arm_sve_typeflags.inc" 193 #undef LLVM_GET_SVE_MEMELTTYPES 194 }; 195 196 enum MergeType { 197 #define LLVM_GET_SVE_MERGETYPES 198 #include "clang/Basic/arm_sve_typeflags.inc" 199 #undef LLVM_GET_SVE_MERGETYPES 200 }; 201 202 enum ImmCheckType { 203 #define LLVM_GET_SVE_IMMCHECKTYPES 204 #include "clang/Basic/arm_sve_typeflags.inc" 205 #undef LLVM_GET_SVE_IMMCHECKTYPES 206 }; 207 SVETypeFlags(uint64_t F)208 SVETypeFlags(uint64_t F) : Flags(F) { 209 EltTypeShift = llvm::countTrailingZeros(EltTypeMask); 210 MemEltTypeShift = llvm::countTrailingZeros(MemEltTypeMask); 211 MergeTypeShift = llvm::countTrailingZeros(MergeTypeMask); 212 SplatOperandMaskShift = llvm::countTrailingZeros(SplatOperandMask); 213 } 214 getEltType()215 EltType getEltType() const { 216 return (EltType)((Flags & EltTypeMask) >> EltTypeShift); 217 } 218 getMemEltType()219 MemEltType getMemEltType() const { 220 return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift); 221 } 222 getMergeType()223 MergeType getMergeType() const { 224 return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift); 225 } 226 getSplatOperand()227 unsigned getSplatOperand() const { 228 return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1; 229 } 230 hasSplatOperand()231 bool hasSplatOperand() const { 232 return Flags & SplatOperandMask; 233 } 234 isLoad()235 bool isLoad() const { return Flags & IsLoad; } isStore()236 bool isStore() const { return Flags & IsStore; } isGatherLoad()237 bool isGatherLoad() const { return Flags & IsGatherLoad; } isScatterStore()238 bool isScatterStore() const { return Flags & IsScatterStore; } isStructLoad()239 bool isStructLoad() const { return Flags & IsStructLoad; } isStructStore()240 bool isStructStore() const { return Flags & IsStructStore; } isZExtReturn()241 bool isZExtReturn() const { return Flags & IsZExtReturn; } isByteIndexed()242 bool isByteIndexed() const { return Flags & IsByteIndexed; } isOverloadNone()243 bool isOverloadNone() const { return Flags & IsOverloadNone; } isOverloadWhile()244 bool isOverloadWhile() const { return Flags & IsOverloadWhile; } isOverloadDefault()245 bool isOverloadDefault() const { return !(Flags & OverloadKindMask); } isOverloadWhileRW()246 bool isOverloadWhileRW() const { return Flags & IsOverloadWhileRW; } isOverloadCvt()247 bool isOverloadCvt() const { return Flags & IsOverloadCvt; } isPrefetch()248 bool isPrefetch() const { return Flags & IsPrefetch; } isReverseCompare()249 bool isReverseCompare() const { return Flags & ReverseCompare; } isAppendSVALL()250 bool isAppendSVALL() const { return Flags & IsAppendSVALL; } isInsertOp1SVALL()251 bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; } isGatherPrefetch()252 bool isGatherPrefetch() const { return Flags & IsGatherPrefetch; } isReverseUSDOT()253 bool isReverseUSDOT() const { return Flags & ReverseUSDOT; } isUndef()254 bool isUndef() const { return Flags & IsUndef; } isTupleCreate()255 bool isTupleCreate() const { return Flags & IsTupleCreate; } isTupleGet()256 bool isTupleGet() const { return Flags & IsTupleGet; } isTupleSet()257 bool isTupleSet() const { return Flags & IsTupleSet; } 258 getBits()259 uint64_t getBits() const { return Flags; } isFlagSet(uint64_t Flag)260 bool isFlagSet(uint64_t Flag) const { return Flags & Flag; } 261 }; 262 263 /// Hexagon builtins 264 namespace Hexagon { 265 enum { 266 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1, 267 #define BUILTIN(ID, TYPE, ATTRS) BI##ID, 268 #include "clang/Basic/BuiltinsHexagon.def" 269 LastTSBuiltin 270 }; 271 } 272 273 /// MIPS builtins 274 namespace Mips { 275 enum { 276 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1, 277 #define BUILTIN(ID, TYPE, ATTRS) BI##ID, 278 #include "clang/Basic/BuiltinsMips.def" 279 LastTSBuiltin 280 }; 281 } 282 283 /// XCore builtins 284 namespace XCore { 285 enum { 286 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1, 287 #define BUILTIN(ID, TYPE, ATTRS) BI##ID, 288 #include "clang/Basic/BuiltinsXCore.def" 289 LastTSBuiltin 290 }; 291 } 292 293 /// Le64 builtins 294 namespace Le64 { 295 enum { 296 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, 297 #define BUILTIN(ID, TYPE, ATTRS) BI##ID, 298 #include "clang/Basic/BuiltinsLe64.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 {NEON::FirstTSBuiltin, ARM::LastTSBuiltin, SVE::FirstTSBuiltin, 325 AArch64::LastTSBuiltin, BPF::LastTSBuiltin, PPC::LastTSBuiltin, 326 NVPTX::LastTSBuiltin, AMDGPU::LastTSBuiltin, X86::LastTSBuiltin, 327 Hexagon::LastTSBuiltin, Mips::LastTSBuiltin, XCore::LastTSBuiltin, 328 Le64::LastTSBuiltin, SystemZ::LastTSBuiltin, 329 WebAssembly::LastTSBuiltin}); 330 331 } // end namespace clang. 332 333 #endif 334