xref: /freebsd/contrib/llvm-project/clang/include/clang/Basic/TargetBuiltins.h (revision 700637cbb5e582861067a11aaca4d053546871d2) 
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 GET_NEON_BUILTIN_ENUMERATORS
30 #include "clang/Basic/arm_neon.inc"
31     FirstFp16Builtin,
32     LastNeonBuiltin = FirstFp16Builtin - 1,
33 #include "clang/Basic/arm_fp16.inc"
34 #undef GET_NEON_BUILTIN_ENUMERATORS
35     FirstTSBuiltin
36   };
37   }
38 
39   /// ARM builtins
40   namespace ARM {
41   enum {
42     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
43     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
44 #define GET_MVE_BUILTIN_ENUMERATORS
45 #include "clang/Basic/arm_mve_builtins.inc"
46 #undef GET_MVE_BUILTIN_ENUMERATORS
47     FirstCDEBuiltin,
48     LastMVEBuiltin = FirstCDEBuiltin - 1,
49 #define GET_CDE_BUILTIN_ENUMERATORS
50 #include "clang/Basic/arm_cde_builtins.inc"
51 #undef GET_CDE_BUILTIN_ENUMERATORS
52     FirstARMBuiltin,
53     LastCDEBuiltin = FirstARMBuiltin - 1,
54 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
55 #include "clang/Basic/BuiltinsARM.def"
56     LastTSBuiltin
57   };
58   }
59 
60   namespace SVE {
61   enum {
62     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
63 #define GET_SVE_BUILTIN_ENUMERATORS
64 #include "clang/Basic/arm_sve_builtins.inc"
65 #undef GET_SVE_BUILTIN_ENUMERATORS
66     FirstNeonBridgeBuiltin,
67     LastSveBuiltin = FirstNeonBridgeBuiltin - 1,
68 #define GET_SVE_BUILTINS
69 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
70 #include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
71 #undef TARGET_BUILTIN
72 #undef GET_SVE_BUILTINS
73     FirstTSBuiltin,
74   };
75   }
76 
77   namespace SME {
78   enum {
79     LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
80 #define GET_SME_BUILTIN_ENUMERATORS
81 #include "clang/Basic/arm_sme_builtins.inc"
82 #undef GET_SME_BUILTIN_ENUMERATORS
83     FirstTSBuiltin,
84   };
85   }
86 
87   /// AArch64 builtins
88   namespace AArch64 {
89   enum {
90     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
91     LastNEONBuiltin = NEON::FirstTSBuiltin - 1,
92     FirstSVEBuiltin = NEON::FirstTSBuiltin,
93     LastSVEBuiltin = SVE::FirstTSBuiltin - 1,
94     FirstSMEBuiltin = SVE::FirstTSBuiltin,
95     LastSMEBuiltin = SME::FirstTSBuiltin - 1,
96   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
97   #include "clang/Basic/BuiltinsAArch64.def"
98     LastTSBuiltin
99   };
100   }
101 
102   /// BPF builtins
103   namespace BPF {
104   enum {
105     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
106 #define GET_BUILTIN_ENUMERATORS
107 #include "clang/Basic/BuiltinsBPF.inc"
108 #undef GET_BUILTIN_ENUMERATORS
109     LastTSBuiltin
110   };
111   }
112 
113   /// PPC builtins
114   namespace PPC {
115     enum {
116         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
117 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
118 #include "clang/Basic/BuiltinsPPC.def"
119         LastTSBuiltin
120     };
121   }
122 
123   /// NVPTX builtins
124   namespace NVPTX {
125   enum {
126     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
127 #define GET_BUILTIN_ENUMERATORS
128 #include "clang/Basic/BuiltinsNVPTX.inc"
129 #undef GET_BUILTIN_ENUMERATORS
130     LastTSBuiltin
131   };
132   }
133 
134   /// AMDGPU builtins
135   namespace AMDGPU {
136   enum {
137     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
138   #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
139   #include "clang/Basic/BuiltinsAMDGPU.def"
140     LastTSBuiltin
141   };
142   }
143 
144   /// DirectX builtins
145   namespace DirectX {
146   enum {
147     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
148 #define GET_BUILTIN_ENUMERATORS
149 #include "clang/Basic/BuiltinsDirectX.inc"
150 #undef GET_BUILTIN_ENUMERATORS
151     LastTSBuiltin
152   };
153   } // namespace DirectX
154 
155   /// SPIRV builtins
156   namespace SPIRV {
157   enum {
158     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
159 #define GET_BUILTIN_ENUMERATORS
160 #include "clang/Basic/BuiltinsSPIRVCommon.inc"
161 #undef GET_BUILTIN_ENUMERATORS
162     FirstVKBuiltin,
163     LastCoreBuiltin = FirstVKBuiltin - 1,
164 #define GET_BUILTIN_ENUMERATORS
165 #include "clang/Basic/BuiltinsSPIRVVK.inc"
166 #undef GET_BUILTIN_ENUMERATORS
167     FirstCLBuiltin,
168     LastVKBuiltin = FirstCLBuiltin - 1,
169 #define GET_BUILTIN_ENUMERATORS
170 #include "clang/Basic/BuiltinsSPIRVCL.inc"
171 #undef GET_BUILTIN_ENUMERATORS
172     LastTSBuiltin
173   };
174   } // namespace SPIRV
175 
176   /// X86 builtins
177   namespace X86 {
178   enum {
179     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
180 #define GET_BUILTIN_ENUMERATORS
181 #include "clang/Basic/BuiltinsX86.inc"
182 #undef GET_BUILTIN_ENUMERATORS
183     FirstX86_64Builtin,
184     LastX86CommonBuiltin = FirstX86_64Builtin - 1,
185 #define GET_BUILTIN_ENUMERATORS
186 #include "clang/Basic/BuiltinsX86_64.inc"
187 #undef GET_BUILTIN_ENUMERATORS
188     LastTSBuiltin
189   };
190   }
191 
192   /// VE builtins
193   namespace VE {
194   enum {
195     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
196 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
197 #include "clang/Basic/BuiltinsVE.def"
198     LastTSBuiltin
199   };
200   }
201 
202   namespace RISCVVector {
203   enum {
204     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
205 #define GET_RISCVV_BUILTIN_ENUMERATORS
206 #include "clang/Basic/riscv_vector_builtins.inc"
207     FirstSiFiveBuiltin,
208     LastRVVBuiltin = FirstSiFiveBuiltin - 1,
209 #include "clang/Basic/riscv_sifive_vector_builtins.inc"
210     FirstAndesBuiltin,
211     LastSiFiveBuiltin = FirstAndesBuiltin - 1,
212 #include "clang/Basic/riscv_andes_vector_builtins.inc"
213 #undef GET_RISCVV_BUILTIN_ENUMERATORS
214     FirstTSBuiltin,
215   };
216   }
217 
218   /// RISCV builtins
219   namespace RISCV {
220   enum {
221     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
222     FirstRVVBuiltin = clang::Builtin::FirstTSBuiltin,
223     LastRVVBuiltin = RISCVVector::FirstTSBuiltin - 1,
224 #define GET_BUILTIN_ENUMERATORS
225 #include "clang/Basic/BuiltinsRISCV.inc"
226 #undef GET_BUILTIN_ENUMERATORS
227     LastTSBuiltin
228   };
229   } // namespace RISCV
230 
231   /// LoongArch builtins
232   namespace LoongArch {
233   enum {
234     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
235 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
236 #include "clang/Basic/BuiltinsLoongArchBase.def"
237     FirstLSXBuiltin,
238     LastBaseBuiltin = FirstLSXBuiltin - 1,
239 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
240 #include "clang/Basic/BuiltinsLoongArchLSX.def"
241     FirstLASXBuiltin,
242     LastLSXBuiltin = FirstLASXBuiltin - 1,
243 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BI##ID,
244 #include "clang/Basic/BuiltinsLoongArchLASX.def"
245     LastTSBuiltin
246   };
247   } // namespace LoongArch
248 
249   /// Flags to identify the types for overloaded Neon builtins.
250   ///
251   /// These must be kept in sync with the flags in utils/TableGen/NeonEmitter.h.
252   class NeonTypeFlags {
253     enum {
254       EltTypeMask = 0xf,
255       UnsignedFlag = 0x10,
256       QuadFlag = 0x20
257     };
258     uint32_t Flags;
259 
260   public:
261     enum EltType {
262       Int8,
263       Int16,
264       Int32,
265       Int64,
266       Poly8,
267       Poly16,
268       Poly64,
269       Poly128,
270       Float16,
271       Float32,
272       Float64,
273       BFloat16,
274       MFloat8
275     };
276 
NeonTypeFlags(unsigned F)277     NeonTypeFlags(unsigned F) : Flags(F) {}
NeonTypeFlags(EltType ET,bool IsUnsigned,bool IsQuad)278     NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
279       if (IsUnsigned)
280         Flags |= UnsignedFlag;
281       if (IsQuad)
282         Flags |= QuadFlag;
283     }
284 
getEltType()285     EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
isPoly()286     bool isPoly() const {
287       EltType ET = getEltType();
288       return ET == Poly8 || ET == Poly16 || ET == Poly64;
289     }
isFloatingPoint()290     bool isFloatingPoint() const {
291       EltType ET = getEltType();
292       return ET == Float16 || ET == Float32 || ET == Float64 || ET == BFloat16;
293     }
isUnsigned()294     bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
isQuad()295     bool isQuad() const { return (Flags & QuadFlag) != 0; }
getEltSizeInBits()296     unsigned getEltSizeInBits() const {
297       switch (getEltType()) {
298       case Int8:
299       case Poly8:
300       case MFloat8:
301         return 8;
302       case Int16:
303       case Float16:
304       case Poly16:
305       case BFloat16:
306         return 16;
307       case Int32:
308       case Float32:
309         return 32;
310       case Int64:
311       case Float64:
312       case Poly64:
313         return 64;
314       case Poly128:
315         return 128;
316       }
317       llvm_unreachable("Invalid NeonTypeFlag!");
318     }
319   };
320 
321   // Shared between SVE/SME and NEON
322   enum ImmCheckType {
323 #define LLVM_GET_ARM_INTRIN_IMMCHECKTYPES
324 #include "clang/Basic/arm_immcheck_types.inc"
325 #undef LLVM_GET_ARM_INTRIN_IMMCHECKTYPES
326   };
327 
328   /// Flags to identify the types for overloaded SVE builtins.
329   class SVETypeFlags {
330     uint64_t Flags;
331     unsigned EltTypeShift;
332     unsigned MemEltTypeShift;
333     unsigned MergeTypeShift;
334     unsigned SplatOperandMaskShift;
335 
336   public:
337 #define LLVM_GET_SVE_TYPEFLAGS
338 #include "clang/Basic/arm_sve_typeflags.inc"
339 #undef LLVM_GET_SVE_TYPEFLAGS
340 
341     enum EltType {
342 #define LLVM_GET_SVE_ELTTYPES
343 #include "clang/Basic/arm_sve_typeflags.inc"
344 #undef LLVM_GET_SVE_ELTTYPES
345     };
346 
347     enum MemEltType {
348 #define LLVM_GET_SVE_MEMELTTYPES
349 #include "clang/Basic/arm_sve_typeflags.inc"
350 #undef LLVM_GET_SVE_MEMELTTYPES
351     };
352 
353     enum MergeType {
354 #define LLVM_GET_SVE_MERGETYPES
355 #include "clang/Basic/arm_sve_typeflags.inc"
356 #undef LLVM_GET_SVE_MERGETYPES
357     };
358 
SVETypeFlags(uint64_t F)359     SVETypeFlags(uint64_t F) : Flags(F) {
360       EltTypeShift = llvm::countr_zero(EltTypeMask);
361       MemEltTypeShift = llvm::countr_zero(MemEltTypeMask);
362       MergeTypeShift = llvm::countr_zero(MergeTypeMask);
363       SplatOperandMaskShift = llvm::countr_zero(SplatOperandMask);
364     }
365 
getEltType()366     EltType getEltType() const {
367       return (EltType)((Flags & EltTypeMask) >> EltTypeShift);
368     }
369 
getMemEltType()370     MemEltType getMemEltType() const {
371       return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift);
372     }
373 
getMergeType()374     MergeType getMergeType() const {
375       return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift);
376     }
377 
getSplatOperand()378     unsigned getSplatOperand() const {
379       return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1;
380     }
381 
hasSplatOperand()382     bool hasSplatOperand() const {
383       return Flags & SplatOperandMask;
384     }
385 
isLoad()386     bool isLoad() const { return Flags & IsLoad; }
isStore()387     bool isStore() const { return Flags & IsStore; }
isGatherLoad()388     bool isGatherLoad() const { return Flags & IsGatherLoad; }
isScatterStore()389     bool isScatterStore() const { return Flags & IsScatterStore; }
isStructLoad()390     bool isStructLoad() const { return Flags & IsStructLoad; }
isStructStore()391     bool isStructStore() const { return Flags & IsStructStore; }
isZExtReturn()392     bool isZExtReturn() const { return Flags & IsZExtReturn; }
isByteIndexed()393     bool isByteIndexed() const { return Flags & IsByteIndexed; }
isOverloadNone()394     bool isOverloadNone() const { return Flags & IsOverloadNone; }
isOverloadWhileOrMultiVecCvt()395     bool isOverloadWhileOrMultiVecCvt() const {
396       return Flags & IsOverloadWhileOrMultiVecCvt;
397     }
isOverloadDefault()398     bool isOverloadDefault() const { return !(Flags & OverloadKindMask); }
isOverloadWhileRW()399     bool isOverloadWhileRW() const { return Flags & IsOverloadWhileRW; }
isOverloadCvt()400     bool isOverloadCvt() const { return Flags & IsOverloadCvt; }
isPrefetch()401     bool isPrefetch() const { return Flags & IsPrefetch; }
isReverseCompare()402     bool isReverseCompare() const { return Flags & ReverseCompare; }
isAppendSVALL()403     bool isAppendSVALL() const { return Flags & IsAppendSVALL; }
isInsertOp1SVALL()404     bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; }
isGatherPrefetch()405     bool isGatherPrefetch() const { return Flags & IsGatherPrefetch; }
isReverseUSDOT()406     bool isReverseUSDOT() const { return Flags & ReverseUSDOT; }
isReverseMergeAnyBinOp()407     bool isReverseMergeAnyBinOp() const { return Flags & ReverseMergeAnyBinOp; }
isReverseMergeAnyAccOp()408     bool isReverseMergeAnyAccOp() const { return Flags & ReverseMergeAnyAccOp; }
isUndef()409     bool isUndef() const { return Flags & IsUndef; }
isTupleCreate()410     bool isTupleCreate() const { return Flags & IsTupleCreate; }
isTupleGet()411     bool isTupleGet() const { return Flags & IsTupleGet; }
isTupleSet()412     bool isTupleSet() const { return Flags & IsTupleSet; }
isReadZA()413     bool isReadZA() const { return Flags & IsReadZA; }
isWriteZA()414     bool isWriteZA() const { return Flags & IsWriteZA; }
setsFPMR()415     bool setsFPMR() const { return Flags & SetsFPMR; }
isReductionQV()416     bool isReductionQV() const { return Flags & IsReductionQV; }
getBits()417     uint64_t getBits() const { return Flags; }
isFlagSet(uint64_t Flag)418     bool isFlagSet(uint64_t Flag) const { return Flags & Flag; }
419   };
420 
421   /// Hexagon builtins
422   namespace Hexagon {
423   enum {
424     LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1,
425 #define GET_BUILTIN_ENUMERATORS
426 #include "clang/Basic/BuiltinsHexagon.inc"
427 #undef GET_BUILTIN_ENUMERATORS
428     LastTSBuiltin
429   };
430   }
431 
432   /// MIPS builtins
433   namespace Mips {
434     enum {
435         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
436 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
437 #include "clang/Basic/BuiltinsMips.def"
438         LastTSBuiltin
439     };
440   }
441 
442   /// XCore builtins
443   namespace XCore {
444     enum {
445         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
446 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
447 #include "clang/Basic/BuiltinsXCore.def"
448         LastTSBuiltin
449     };
450   }
451 
452   /// SystemZ builtins
453   namespace SystemZ {
454     enum {
455         LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
456 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
457 #include "clang/Basic/BuiltinsSystemZ.def"
458         LastTSBuiltin
459     };
460   }
461 
462   /// WebAssembly builtins
463   namespace WebAssembly {
464     enum {
465       LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
466 #define BUILTIN(ID, TYPE, ATTRS) BI##ID,
467 #include "clang/Basic/BuiltinsWebAssembly.def"
468       LastTSBuiltin
469     };
470   }
471 
472   static constexpr uint64_t LargestBuiltinID = std::max<uint64_t>(
473       {ARM::LastTSBuiltin, AArch64::LastTSBuiltin, BPF::LastTSBuiltin,
474        PPC::LastTSBuiltin, NVPTX::LastTSBuiltin, AMDGPU::LastTSBuiltin,
475        X86::LastTSBuiltin, VE::LastTSBuiltin, RISCV::LastTSBuiltin,
476        Hexagon::LastTSBuiltin, Mips::LastTSBuiltin, XCore::LastTSBuiltin,
477        SystemZ::LastTSBuiltin, WebAssembly::LastTSBuiltin});
478 
479 } // end namespace clang.
480 
481 #endif
482