Coverage Report

Created: 2020-11-24 06:42

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Basic/Targets/AMDGPU.h
Line
Count
Source (jump to first uncovered line)
1
//===--- AMDGPU.h - Declare AMDGPU target feature support -------*- 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
// This file declares AMDGPU TargetInfo objects.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
14
#define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
15
16
#include "clang/Basic/TargetID.h"
17
#include "clang/Basic/TargetInfo.h"
18
#include "clang/Basic/TargetOptions.h"
19
#include "llvm/ADT/StringSet.h"
20
#include "llvm/ADT/Triple.h"
21
#include "llvm/Support/Compiler.h"
22
#include "llvm/Support/TargetParser.h"
23
24
namespace clang {
25
namespace targets {
26
27
class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
28
29
  static const Builtin::Info BuiltinInfo[];
30
  static const char *const GCCRegNames[];
31
32
  enum AddrSpace {
33
    Generic = 0,
34
    Global = 1,
35
    Local = 3,
36
    Constant = 4,
37
    Private = 5
38
  };
39
  static const LangASMap AMDGPUDefIsGenMap;
40
  static const LangASMap AMDGPUDefIsPrivMap;
41
42
  llvm::AMDGPU::GPUKind GPUKind;
43
  unsigned GPUFeatures;
44
  unsigned WavefrontSize;
45
46
  /// Target ID is device name followed by optional feature name postfixed
47
  /// by plus or minus sign delimitted by colon, e.g. gfx908:xnack+:sram-ecc-.
48
  /// If the target ID contains feature+, map it to true.
49
  /// If the target ID contains feature-, map it to false.
50
  /// If the target ID does not contain a feature (default), do not map it.
51
  llvm::StringMap<bool> OffloadArchFeatures;
52
  std::string TargetID;
53
54
694
  bool hasFP64() const {
55
694
    return getTriple().getArch() == llvm::Triple::amdgcn ||
56
133
           !!(GPUFeatures & llvm::AMDGPU::FEATURE_FP64);
57
694
  }
58
59
  /// Has fast fma f32
60
346
  bool hasFastFMAF() const {
61
346
    return !!(GPUFeatures & llvm::AMDGPU::FEATURE_FAST_FMA_F32);
62
346
  }
63
64
  /// Has fast fma f64
65
346
  bool hasFastFMA() const {
66
346
    return getTriple().getArch() == llvm::Triple::amdgcn;
67
346
  }
68
69
346
  bool hasFMAF() const {
70
346
    return getTriple().getArch() == llvm::Triple::amdgcn ||
71
66
           !!(GPUFeatures & llvm::AMDGPU::FEATURE_FMA);
72
346
  }
73
74
0
  bool hasFullRateDenormalsF32() const {
75
0
    return !!(GPUFeatures & llvm::AMDGPU::FEATURE_FAST_DENORMAL_F32);
76
0
  }
77
78
346
  bool hasLDEXPF() const {
79
346
    return getTriple().getArch() == llvm::Triple::amdgcn ||
80
66
           !!(GPUFeatures & llvm::AMDGPU::FEATURE_LDEXP);
81
346
  }
82
83
3.14k
  static bool isAMDGCN(const llvm::Triple &TT) {
84
3.14k
    return TT.getArch() == llvm::Triple::amdgcn;
85
3.14k
  }
86
87
1.05k
  static bool isR600(const llvm::Triple &TT) {
88
1.05k
    return TT.getArch() == llvm::Triple::r600;
89
1.05k
  }
90
91
public:
92
  AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
93
94
  void setAddressSpaceMap(bool DefaultIsPrivate);
95
96
  void adjust(LangOptions &Opts) override;
97
98
1.05k
  uint64_t getPointerWidthV(unsigned AddrSpace) const override {
99
1.05k
    if (isR600(getTriple()))
100
50
      return 32;
101
102
1.00k
    if (AddrSpace == Private || 
AddrSpace == Local870
)
103
546
      return 32;
104
105
460
    return 64;
106
460
  }
107
108
517
  uint64_t getPointerAlignV(unsigned AddrSpace) const override {
109
517
    return getPointerWidthV(AddrSpace);
110
517
  }
111
112
2.72k
  uint64_t getMaxPointerWidth() const override {
113
2.51k
    return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 
32217
;
114
2.72k
  }
115
116
9
  const char *getClobbers() const override { return ""; }
117
118
  ArrayRef<const char *> getGCCRegNames() const override;
119
120
70
  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
121
70
    return None;
122
70
  }
123
124
  /// Accepted register names: (n, m is unsigned integer, n < m)
125
  /// v
126
  /// s
127
  /// a
128
  /// {vn}, {v[n]}
129
  /// {sn}, {s[n]}
130
  /// {an}, {a[n]}
131
  /// {S} , where S is a special register name
132
  ////{v[n:m]}
133
  /// {s[n:m]}
134
  /// {a[n:m]}
135
  bool validateAsmConstraint(const char *&Name,
136
130
                             TargetInfo::ConstraintInfo &Info) const override {
137
130
    static const ::llvm::StringSet<> SpecialRegs({
138
130
        "exec", "vcc", "flat_scratch", "m0", "scc", "tba", "tma",
139
130
        "flat_scratch_lo", "flat_scratch_hi", "vcc_lo", "vcc_hi", "exec_lo",
140
130
        "exec_hi", "tma_lo", "tma_hi", "tba_lo", "tba_hi",
141
130
    });
142
143
130
    switch (*Name) {
144
5
    case 'I':
145
5
      Info.setRequiresImmediate(-16, 64);
146
5
      return true;
147
5
    case 'J':
148
5
      Info.setRequiresImmediate(-32768, 32767);
149
5
      return true;
150
3
    case 'A':
151
3
    case 'B':
152
3
    case 'C':
153
3
      Info.setRequiresImmediate();
154
3
      return true;
155
117
    default:
156
117
      break;
157
117
    }
158
159
117
    StringRef S(Name);
160
161
117
    if (S == "DA" || 
S == "DB"114
) {
162
6
      Name++;
163
6
      Info.setRequiresImmediate();
164
6
      return true;
165
6
    }
166
167
111
    bool HasLeftParen = false;
168
111
    if (S.front() == '{') {
169
57
      HasLeftParen = true;
170
57
      S = S.drop_front();
171
57
    }
172
111
    if (S.empty())
173
1
      return false;
174
110
    if (S.front() != 'v' && 
S.front() != 's'47
&&
S.front() != 'a'26
) {
175
5
      if (!HasLeftParen)
176
0
        return false;
177
5
      auto E = S.find('}');
178
5
      if (!SpecialRegs.count(S.substr(0, E)))
179
2
        return false;
180
3
      S = S.drop_front(E + 1);
181
3
      if (!S.empty())
182
2
        return false;
183
      // Found {S} where S is a special register.
184
1
      Info.setAllowsRegister();
185
1
      Name = S.data() - 1;
186
1
      return true;
187
1
    }
188
105
    S = S.drop_front();
189
105
    if (!HasLeftParen) {
190
54
      if (!S.empty())
191
4
        return false;
192
      // Found s, v or a.
193
50
      Info.setAllowsRegister();
194
50
      Name = S.data() - 1;
195
50
      return true;
196
50
    }
197
51
    bool HasLeftBracket = false;
198
51
    if (!S.empty() && 
S.front() == '['50
) {
199
27
      HasLeftBracket = true;
200
27
      S = S.drop_front();
201
27
    }
202
51
    unsigned long long N;
203
51
    if (S.empty() || 
consumeUnsignedInteger(S, 10, N)50
)
204
7
      return false;
205
44
    if (!S.empty() && 
S.front() == ':'43
) {
206
20
      if (!HasLeftBracket)
207
0
        return false;
208
20
      S = S.drop_front();
209
20
      unsigned long long M;
210
20
      if (consumeUnsignedInteger(S, 10, M) || 
N >= M18
)
211
3
        return false;
212
41
    }
213
41
    if (HasLeftBracket) {
214
22
      if (S.empty() || S.front() != ']')
215
2
        return false;
216
20
      S = S.drop_front();
217
20
    }
218
39
    if (S.empty() || 
S.front() != '}'36
)
219
5
      return false;
220
34
    S = S.drop_front();
221
34
    if (!S.empty())
222
2
      return false;
223
    // Found {vn}, {sn}, {an}, {v[n]}, {s[n]}, {a[n]}, {v[n:m]}, {s[n:m]}
224
    // or {a[n:m]}.
225
32
    Info.setAllowsRegister();
226
32
    Name = S.data() - 1;
227
32
    return true;
228
32
  }
229
230
  // \p Constraint will be left pointing at the last character of
231
  // the constraint.  In practice, it won't be changed unless the
232
  // constraint is longer than one character.
233
16
  std::string convertConstraint(const char *&Constraint) const override {
234
235
16
    StringRef S(Constraint);
236
16
    if (S == "DA" || 
S == "DB"15
) {
237
2
      return std::string("^") + std::string(Constraint++, 2);
238
2
    }
239
240
14
    const char *Begin = Constraint;
241
14
    TargetInfo::ConstraintInfo Info("", "");
242
14
    if (validateAsmConstraint(Constraint, Info))
243
14
      return std::string(Begin).substr(0, Constraint - Begin + 1);
244
245
0
    Constraint = Begin;
246
0
    return std::string(1, *Constraint);
247
0
  }
248
249
  bool
250
  initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
251
                 StringRef CPU,
252
                 const std::vector<std::string> &FeatureVec) const override;
253
254
  ArrayRef<Builtin::Info> getTargetBuiltins() const override;
255
256
113
  bool useFP16ConversionIntrinsics() const override { return false; }
257
258
  void getTargetDefines(const LangOptions &Opts,
259
                        MacroBuilder &Builder) const override;
260
261
241
  BuiltinVaListKind getBuiltinVaListKind() const override {
262
241
    return TargetInfo::CharPtrBuiltinVaList;
263
241
  }
264
265
17
  bool isValidCPUName(StringRef Name) const override {
266
17
    if (getTriple().getArch() == llvm::Triple::amdgcn)
267
17
      return llvm::AMDGPU::parseArchAMDGCN(Name) != llvm::AMDGPU::GK_NONE;
268
0
    return llvm::AMDGPU::parseArchR600(Name) != llvm::AMDGPU::GK_NONE;
269
0
  }
270
271
  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
272
273
195
  bool setCPU(const std::string &Name) override {
274
195
    if (getTriple().getArch() == llvm::Triple::amdgcn) {
275
134
      GPUKind = llvm::AMDGPU::parseArchAMDGCN(Name);
276
134
      GPUFeatures = llvm::AMDGPU::getArchAttrAMDGCN(GPUKind);
277
61
    } else {
278
61
      GPUKind = llvm::AMDGPU::parseArchR600(Name);
279
61
      GPUFeatures = llvm::AMDGPU::getArchAttrR600(GPUKind);
280
61
    }
281
282
195
    return GPUKind != llvm::AMDGPU::GK_NONE;
283
195
  }
284
285
348
  void setSupportedOpenCLOpts() override {
286
348
    auto &Opts = getSupportedOpenCLOpts();
287
348
    Opts.support("cl_clang_storage_class_specifiers");
288
289
348
    bool IsAMDGCN = isAMDGCN(getTriple());
290
291
348
    if (hasFP64())
292
281
      Opts.support("cl_khr_fp64");
293
294
348
    if (IsAMDGCN || 
GPUKind >= llvm::AMDGPU::GK_CEDAR67
) {
295
322
      Opts.support("cl_khr_byte_addressable_store");
296
322
      Opts.support("cl_khr_global_int32_base_atomics");
297
322
      Opts.support("cl_khr_global_int32_extended_atomics");
298
322
      Opts.support("cl_khr_local_int32_base_atomics");
299
322
      Opts.support("cl_khr_local_int32_extended_atomics");
300
322
    }
301
302
348
    if (IsAMDGCN) {
303
281
      Opts.support("cl_khr_fp16");
304
281
      Opts.support("cl_khr_int64_base_atomics");
305
281
      Opts.support("cl_khr_int64_extended_atomics");
306
281
      Opts.support("cl_khr_mipmap_image");
307
281
      Opts.support("cl_khr_mipmap_image_writes");
308
281
      Opts.support("cl_khr_subgroups");
309
281
      Opts.support("cl_khr_3d_image_writes");
310
281
      Opts.support("cl_amd_media_ops");
311
281
      Opts.support("cl_amd_media_ops2");
312
281
    }
313
348
  }
314
315
40
  LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const override {
316
40
    switch (TK) {
317
18
    case OCLTK_Image:
318
18
      return LangAS::opencl_constant;
319
320
12
    case OCLTK_ClkEvent:
321
12
    case OCLTK_Queue:
322
12
    case OCLTK_ReserveID:
323
12
      return LangAS::opencl_global;
324
325
10
    default:
326
10
      return TargetInfo::getOpenCLTypeAddrSpace(TK);
327
40
    }
328
40
  }
329
330
104
  LangAS getOpenCLBuiltinAddressSpace(unsigned AS) const override {
331
104
    switch (AS) {
332
46
    case 0:
333
46
      return LangAS::opencl_generic;
334
0
    case 1:
335
0
      return LangAS::opencl_global;
336
44
    case 3:
337
44
      return LangAS::opencl_local;
338
11
    case 4:
339
11
      return LangAS::opencl_constant;
340
0
    case 5:
341
0
      return LangAS::opencl_private;
342
3
    default:
343
3
      return getLangASFromTargetAS(AS);
344
104
    }
345
104
  }
346
347
4
  LangAS getCUDABuiltinAddressSpace(unsigned AS) const override {
348
4
    return LangAS::Default;
349
4
  }
350
351
96
  llvm::Optional<LangAS> getConstantAddressSpace() const override {
352
96
    return getLangASFromTargetAS(Constant);
353
96
  }
354
355
  /// \returns Target specific vtbl ptr address space.
356
0
  unsigned getVtblPtrAddressSpace() const override {
357
0
    return static_cast<unsigned>(Constant);
358
0
  }
359
360
  /// \returns If a target requires an address within a target specific address
361
  /// space \p AddressSpace to be converted in order to be used, then return the
362
  /// corresponding target specific DWARF address space.
363
  ///
364
  /// \returns Otherwise return None and no conversion will be emitted in the
365
  /// DWARF.
366
  Optional<unsigned>
367
208
  getDWARFAddressSpace(unsigned AddressSpace) const override {
368
208
    const unsigned DWARF_Private = 1;
369
208
    const unsigned DWARF_Local = 2;
370
208
    if (AddressSpace == Private) {
371
77
      return DWARF_Private;
372
131
    } else if (AddressSpace == Local) {
373
26
      return DWARF_Local;
374
105
    } else {
375
105
      return None;
376
105
    }
377
208
  }
378
379
0
  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
380
0
    switch (CC) {
381
0
    default:
382
0
      return CCCR_Warning;
383
0
    case CC_C:
384
0
    case CC_OpenCLKernel:
385
0
      return CCCR_OK;
386
0
    }
387
0
  }
388
389
  // In amdgcn target the null pointer in global, constant, and generic
390
  // address space has value 0 but in private and local address space has
391
  // value ~0.
392
3.35k
  uint64_t getNullPointerValue(LangAS AS) const override {
393
    // FIXME: Also should handle region.
394
3.35k
    return (AS == LangAS::opencl_local || 
AS == LangAS::opencl_private2.86k
)
395
2.30k
      ? 
~01.04k
: 0;
396
3.35k
  }
397
398
  void setAuxTarget(const TargetInfo *Aux) override;
399
400
15
  bool hasExtIntType() const override { return true; }
401
402
  // Record offload arch features since they are needed for defining the
403
  // pre-defined macros.
404
  bool handleTargetFeatures(std::vector<std::string> &Features,
405
348
                            DiagnosticsEngine &Diags) override {
406
348
    auto TargetIDFeatures =
407
348
        getAllPossibleTargetIDFeatures(getTriple(), getArchNameAMDGCN(GPUKind));
408
953
    llvm::for_each(Features, [&](const auto &F) {
409
953
      assert(F.front() == '+' || F.front() == '-');
410
953
      if (F == "+wavefrontsize64")
411
8
        WavefrontSize = 64;
412
953
      bool IsOn = F.front() == '+';
413
953
      StringRef Name = StringRef(F).drop_front();
414
953
      if (llvm::find(TargetIDFeatures, Name) == TargetIDFeatures.end())
415
945
        return;
416
8
      assert(OffloadArchFeatures.find(Name) == OffloadArchFeatures.end());
417
8
      OffloadArchFeatures[Name] = IsOn;
418
8
    });
419
348
    return true;
420
348
  }
421
422
133
  Optional<std::string> getTargetID() const override {
423
133
    if (!isAMDGCN(getTriple()))
424
0
      return llvm::None;
425
    // When -target-cpu is not set, we assume generic code that it is valid
426
    // for all GPU and use an empty string as target ID to represent that.
427
133
    if (GPUKind == llvm::AMDGPU::GK_NONE)
428
0
      return std::string("");
429
133
    return getCanonicalTargetID(getArchNameAMDGCN(GPUKind),
430
133
                                OffloadArchFeatures);
431
133
  }
432
};
433
434
} // namespace targets
435
} // namespace clang
436
437
#endif // LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H