Coverage Report

Created: 2022-01-22 13:19

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