Coverage Report

Created: 2021-08-24 07:12

/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
  /// 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
15.5k
    NeonTypeFlags(unsigned F) : Flags(F) {}
165
69
    NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
166
69
      if (IsUnsigned)
167
0
        Flags |= UnsignedFlag;
168
69
      if (IsQuad)
169
39
        Flags |= QuadFlag;
170
69
    }
171
172
12.0k
    EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
173
18
    bool isPoly() const {
174
18
      EltType ET = getEltType();
175
18
      return ET == Poly8 || ET == Poly16 || 
ET == Poly6416
;
176
18
    }
177
8.75k
    bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
178
16.3k
    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
28.5k
    SVETypeFlags(uint64_t F) : Flags(F) {
219
28.5k
      EltTypeShift = llvm::countTrailingZeros(EltTypeMask);
220
28.5k
      MemEltTypeShift = llvm::countTrailingZeros(MemEltTypeMask);
221
28.5k
      MergeTypeShift = llvm::countTrailingZeros(MergeTypeMask);
222
28.5k
      SplatOperandMaskShift = llvm::countTrailingZeros(SplatOperandMask);
223
28.5k
    }
224
225
41.4k
    EltType getEltType() const {
226
41.4k
      return (EltType)((Flags & EltTypeMask) >> EltTypeShift);
227
41.4k
    }
228
229
3.12k
    MemEltType getMemEltType() const {
230
3.12k
      return (MemEltType)((Flags & MemEltTypeMask) >> MemEltTypeShift);
231
3.12k
    }
232
233
67.9k
    MergeType getMergeType() const {
234
67.9k
      return (MergeType)((Flags & MergeTypeMask) >> MergeTypeShift);
235
67.9k
    }
236
237
6.19k
    unsigned getSplatOperand() const {
238
6.19k
      return ((Flags & SplatOperandMask) >> SplatOperandMaskShift) - 1;
239
6.19k
    }
240
241
22.6k
    bool hasSplatOperand() const {
242
22.6k
      return Flags & SplatOperandMask;
243
22.6k
    }
244
245
28.3k
    bool isLoad() const { return Flags & IsLoad; }
246
27.2k
    bool isStore() const { return Flags & IsStore; }
247
26.9k
    bool isGatherLoad() const { return Flags & IsGatherLoad; }
248
24.8k
    bool isScatterStore() const { return Flags & IsScatterStore; }
249
23.7k
    bool isStructLoad() const { return Flags & IsStructLoad; }
250
23.4k
    bool isStructStore() const { return Flags & IsStructStore; }
251
3.20k
    bool isZExtReturn() const { return Flags & IsZExtReturn; }
252
2.82k
    bool isByteIndexed() const { return Flags & IsByteIndexed; }
253
22.6k
    bool isOverloadNone() const { return Flags & IsOverloadNone; }
254
21.6k
    bool isOverloadWhile() const { return Flags & IsOverloadWhile; }
255
20.5k
    bool isOverloadDefault() const { return !(Flags & OverloadKindMask); }
256
21.3k
    bool isOverloadWhileRW() const { return Flags & IsOverloadWhileRW; }
257
21.2k
    bool isOverloadCvt() const { return Flags & IsOverloadCvt; }
258
24.1k
    bool isPrefetch() const { return Flags & IsPrefetch; }
259
22.6k
    bool isReverseCompare() const { return Flags & ReverseCompare; }
260
22.6k
    bool isAppendSVALL() const { return Flags & IsAppendSVALL; }
261
22.6k
    bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; }
262
23.8k
    bool isGatherPrefetch() const { return Flags & IsGatherPrefetch; }
263
22.6k
    bool isReverseUSDOT() const { return Flags & ReverseUSDOT; }
264
23.0k
    bool isUndef() const { return Flags & IsUndef; }
265
20.9k
    bool isTupleCreate() const { return Flags & IsTupleCreate; }
266
20.7k
    bool isTupleGet() const { return Flags & IsTupleGet; }
267
21.0k
    bool isTupleSet() const { return Flags & IsTupleSet; }
268
269
0
    uint64_t getBits() const { return Flags; }
270
0
    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