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