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