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
24namespace 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