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#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
31#include "clang/Basic/BuiltinsNEON.def"
32 FirstTSBuiltin
33 };
34 }
35
36 /// ARM builtins
37 namespace ARM {
38 enum {
39 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
40 LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
41#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
42#include "clang/Basic/BuiltinsARM.def"
43 LastTSBuiltin
44 };
45 }
46
47 namespace SVE {
48 enum {
49 LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
50#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
51#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
52#include "clang/Basic/BuiltinsSVE.def"
53 FirstTSBuiltin,
54 };
55 }
56
57 namespace SME {
58 enum {
59 LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
60#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
61#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
62#include "clang/Basic/BuiltinsSME.def"
63 FirstTSBuiltin,
64 };
65 }
66
67 /// AArch64 builtins
68 namespace AArch64 {
69 enum {
70 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
71 LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
72 FirstSVEBuiltin = NEON::FirstTSBuiltin,
73 LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
74 FirstSMEBuiltin = SVE::FirstTSBuiltin,
75 LastSMEBuiltin = SME::FirstTSBuiltin - 1,
76 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
77 #include "clang/Basic/BuiltinsAArch64.def"
78 LastTSBuiltin
79 };
80 }
81
82 /// BPF builtins
83 namespace BPF {
84 enum {
85 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
86 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
87 #include "clang/Basic/BuiltinsBPF.inc"
88 LastTSBuiltin
89 };
90 }
91
92 /// PPC builtins
93 namespace PPC {
94 enum {
95 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
96#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
97#include "clang/Basic/BuiltinsPPC.def"
98 LastTSBuiltin
99 };
100 }
101
102 /// NVPTX builtins
103 namespace NVPTX {
104 enum {
105 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
106#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
107#include "clang/Basic/BuiltinsNVPTX.def"
108 LastTSBuiltin
109 };
110 }
111
112 /// AMDGPU builtins
113 namespace AMDGPU {
114 enum {
115 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
116 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
117 #include "clang/Basic/BuiltinsAMDGPU.def"
118 LastTSBuiltin
119 };
120 }
121
122 /// X86 builtins
123 namespace X86 {
124 enum {
125 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
126#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
127#include "clang/Basic/BuiltinsX86.def"
128 FirstX86_64Builtin,
129 LastX86CommonBuiltin = FirstX86_64Builtin - 1,
130#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
131#include "clang/Basic/BuiltinsX86_64.def"
132 LastTSBuiltin
133 };
134 }
135
136 /// VE builtins
137 namespace VE {
138 enum {
139 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
140#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
141#include "clang/Basic/BuiltinsVE.def"
142 LastTSBuiltin
143 };
144 }
145
146 namespace RISCVVector {
147 enum {
148 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
149#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
150#include "clang/Basic/BuiltinsRISCVVector.def"
151 FirstTSBuiltin,
152 };
153 }
154
155 /// RISCV builtins
156 namespace RISCV {
157 enum {
158 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
159 FirstRVVBuiltin = clang::Builtin::FirstTSBuiltin,
160 LastRVVBuiltin = RISCVVector::FirstTSBuiltin - 1,
161#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
162#include "clang/Basic/BuiltinsRISCV.inc"
163 LastTSBuiltin
164 };
165 } // namespace RISCV
166
167 /// LoongArch builtins
168 namespace LoongArch {
169 enum {
170 LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
171#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
172#include "clang/Basic/BuiltinsLoongArch.def"
173 LastTSBuiltin
174 };
175 } // namespace LoongArch
176
177 /// Flags to identify the types for overloaded Neon builtins.
178 ///
179 /// These must be kept in sync with the flags in utils/TableGen/NeonEmitter.h.
180 class NeonTypeFlags {
181 enum {
182 EltTypeMask = 0xf,
183 UnsignedFlag = 0x10,
184 QuadFlag = 0x20
185 };
186 uint32_t Flags;
187
188 public:
189 enum EltType {
190 Int8,
191 Int16,
192 Int32,
193 Int64,
194 Poly8,
195 Poly16,
196 Poly64,
197 Poly128,
198 Float16,
199 Float32,
200 Float64,
201 BFloat16
202 };
203
204 NeonTypeFlags(unsigned F) : Flags(F) {}
205 NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
206 if (IsUnsigned)
207 Flags |= UnsignedFlag;
208 if (IsQuad)
209 Flags |= QuadFlag;
210 }
211
212 EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
213 bool isPoly() const {
214 EltType ET = getEltType();
215 return ET == Poly8 || ET == Poly16 || ET == Poly64;
216 }
217 bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
218 bool isQuad() const { return (Flags & QuadFlag) != 0; }
219 };
220
221 /// Flags to identify the types for overloaded SVE builtins.
222 class SVETypeFlags {
223 uint64_t Flags;
224 unsigned EltTypeShift;
225 unsigned MemEltTypeShift;
226 unsigned MergeTypeShift;
227 unsigned SplatOperandMaskShift;
228
229 public:
230#define LLVM_GET_SVE_TYPEFLAGS
231#include "clang/Basic/arm_sve_typeflags.inc"
232#undef LLVM_GET_SVE_TYPEFLAGS
233
234 enum EltType {
235#define LLVM_GET_SVE_ELTTYPES
236#include "clang/Basic/arm_sve_typeflags.inc"
237#undef LLVM_GET_SVE_ELTTYPES
238 };
239
240 enum MemEltType {
241#define LLVM_GET_SVE_MEMELTTYPES
242#include "clang/Basic/arm_sve_typeflags.inc"
243#undef LLVM_GET_SVE_MEMELTTYPES
244 };
245
246 enum MergeType {
247#define LLVM_GET_SVE_MERGETYPES
248#include "clang/Basic/arm_sve_typeflags.inc"
249#undef LLVM_GET_SVE_MERGETYPES
250 };
251
252 enum ImmCheckType {
253#define LLVM_GET_SVE_IMMCHECKTYPES
254#include "clang/Basic/arm_sve_typeflags.inc"
255#undef LLVM_GET_SVE_IMMCHECKTYPES
256 };
257
258 SVETypeFlags(uint64_t F) : Flags(F) {
259 EltTypeShift = llvm::countr_zero(EltTypeMask);
260 MemEltTypeShift = llvm::countr_zero(MemEltTypeMask);
261 MergeTypeShift = llvm::countr_zero(MergeTypeMask);
262 SplatOperandMaskShift = llvm::countr_zero(SplatOperandMask);
263 }
264
265 EltType getEltType() const {
266 return (EltType)((Flags & EltTypeMask) >> EltTypeShift);
267 }
268
269 MemEltType getMemEltType() const {
270 return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift);
271 }
272
273 MergeType getMergeType() const {
274 return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift);
275 }
276
277 unsigned getSplatOperand() const {
278 return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1;
279 }
280
281 bool hasSplatOperand() const {
282 return Flags & SplatOperandMask;
283 }
284
285 bool isLoad() const { return Flags & IsLoad; }
286 bool isStore() const { return Flags & IsStore; }
287 bool isGatherLoad() const { return Flags & IsGatherLoad; }
288 bool isScatterStore() const { return Flags & IsScatterStore; }
289 bool isStructLoad() const { return Flags & IsStructLoad; }
290 bool isStructStore() const { return Flags & IsStructStore; }
291 bool isZExtReturn() const { return Flags & IsZExtReturn; }
292 bool isByteIndexed() const { return Flags & IsByteIndexed; }
293 bool isOverloadNone() const { return Flags & IsOverloadNone; }
294 bool isOverloadWhileOrMultiVecCvt() const {
295 return Flags & IsOverloadWhileOrMultiVecCvt;
296 }
297 bool isOverloadDefault() const { return !(Flags & OverloadKindMask); }
298 bool isOverloadWhileRW() const { return Flags & IsOverloadWhileRW; }
299 bool isOverloadCvt() const { return Flags & IsOverloadCvt; }
300 bool isPrefetch() const { return Flags & IsPrefetch; }
301 bool isReverseCompare() const { return Flags & ReverseCompare; }
302 bool isAppendSVALL() const { return Flags & IsAppendSVALL; }
303 bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; }
304 bool isGatherPrefetch() const { return Flags & IsGatherPrefetch; }
305 bool isReverseUSDOT() const { return Flags & ReverseUSDOT; }
306 bool isReverseMergeAnyBinOp() const { return Flags & ReverseMergeAnyBinOp; }
307 bool isReverseMergeAnyAccOp() const { return Flags & ReverseMergeAnyAccOp; }
308 bool isUndef() const { return Flags & IsUndef; }
309 bool isTupleCreate() const { return Flags & IsTupleCreate; }
310 bool isTupleGet() const { return Flags & IsTupleGet; }
311 bool isTupleSet() const { return Flags & IsTupleSet; }
312 bool isReadZA() const { return Flags & IsReadZA; }
313 bool isWriteZA() const { return Flags & IsWriteZA; }
314 bool isReductionQV() const { return Flags & IsReductionQV; }
315 uint64_t getBits() const { return Flags; }
316 bool isFlagSet(uint64_t Flag) const { return Flags & Flag; }
317 };
318
319 /// Hexagon builtins
320 namespace Hexagon {
321 enum {
322 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
323#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
324#include "clang/Basic/BuiltinsHexagon.def"
325 LastTSBuiltin
326 };
327 }
328
329 /// MIPS builtins
330 namespace Mips {
331 enum {
332 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
333#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
334#include "clang/Basic/BuiltinsMips.def"
335 LastTSBuiltin
336 };
337 }
338
339 /// XCore builtins
340 namespace XCore {
341 enum {
342 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
343#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
344#include "clang/Basic/BuiltinsXCore.def"
345 LastTSBuiltin
346 };
347 }
348
349 /// SystemZ builtins
350 namespace SystemZ {
351 enum {
352 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
353#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
354#include "clang/Basic/BuiltinsSystemZ.def"
355 LastTSBuiltin
356 };
357 }
358
359 /// WebAssembly builtins
360 namespace WebAssembly {
361 enum {
362 LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
363#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
364#include "clang/Basic/BuiltinsWebAssembly.def"
365 LastTSBuiltin
366 };
367 }
368
369 static constexpr uint64_t LargestBuiltinID = std::max<uint64_t>(
370 {ARM::LastTSBuiltin, AArch64::LastTSBuiltin, BPF::LastTSBuiltin,
371 PPC::LastTSBuiltin, NVPTX::LastTSBuiltin, AMDGPU::LastTSBuiltin,
372 X86::LastTSBuiltin, VE::LastTSBuiltin, RISCV::LastTSBuiltin,
373 Hexagon::LastTSBuiltin, Mips::LastTSBuiltin, XCore::LastTSBuiltin,
374 SystemZ::LastTSBuiltin, WebAssembly::LastTSBuiltin});
375
376} // end namespace clang.
377
378#endif
379

source code of clang/include/clang/Basic/TargetBuiltins.h