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