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