1 //===--- AMDGPU.h - Declare AMDGPU target feature support -------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares AMDGPU TargetInfo objects.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
15 #define LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
16 
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 
23 namespace clang {
24 namespace targets {
25 
26 class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
27 
28   static const Builtin::Info BuiltinInfo[];
29   static const char *const GCCRegNames[];
30 
31   struct LLVM_LIBRARY_VISIBILITY AddrSpace {
32     unsigned Generic, Global, Local, Constant, Private;
33     AddrSpace(bool IsGenericZero_ = false) {
34       if (IsGenericZero_) {
35         Generic = 0;
36         Global = 1;
37         Local = 3;
38         Constant = 2;
39         Private = 5;
40       } else {
41         Generic = 4;
42         Global = 1;
43         Local = 3;
44         Constant = 2;
45         Private = 0;
46       }
47     }
48   };
49 
50   /// \brief The GPU profiles supported by the AMDGPU target.
51   enum GPUKind {
52     GK_NONE,
53     GK_R600,
54     GK_R600_DOUBLE_OPS,
55     GK_R700,
56     GK_R700_DOUBLE_OPS,
57     GK_EVERGREEN,
58     GK_EVERGREEN_DOUBLE_OPS,
59     GK_NORTHERN_ISLANDS,
60     GK_CAYMAN,
61     GK_GFX6,
62     GK_GFX7,
63     GK_GFX8,
64     GK_GFX9
65   } GPU;
66 
67   bool hasFP64 : 1;
68   bool hasFMAF : 1;
69   bool hasLDEXPF : 1;
70   const AddrSpace AS;
71 
72   static bool hasFullSpeedFMAF32(StringRef GPUName) {
73     return parseAMDGCNName(GPUName) >= GK_GFX9;
74   }
75 
76   static bool isAMDGCN(const llvm::Triple &TT) {
77     return TT.getArch() == llvm::Triple::amdgcn;
78   }
79 
80   static bool isGenericZero(const llvm::Triple &TT) {
81     return TT.getEnvironmentName() == "amdgiz" ||
82            TT.getEnvironmentName() == "amdgizcl";
83   }
84 
85 public:
86   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
87 
88   void setAddressSpaceMap(bool DefaultIsPrivate);
89 
90   void adjust(LangOptions &Opts) override;
91 
92   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
93     if (GPU <= GK_CAYMAN)
94       return 32;
95 
96     if (AddrSpace == AS.Private || AddrSpace == AS.Local) {
97       return 32;
98     }
99     return 64;
100   }
101 
102   uint64_t getPointerAlignV(unsigned AddrSpace) const override {
103     return getPointerWidthV(AddrSpace);
104   }
105 
106   uint64_t getMaxPointerWidth() const override {
107     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
108   }
109 
110   const char *getClobbers() const override { return ""; }
111 
112   ArrayRef<const char *> getGCCRegNames() const override;
113 
114   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
115     return None;
116   }
117 
118   /// Accepted register names: (n, m is unsigned integer, n < m)
119   /// v
120   /// s
121   /// {vn}, {v[n]}
122   /// {sn}, {s[n]}
123   /// {S} , where S is a special register name
124   ////{v[n:m]}
125   /// {s[n:m]}
126   bool validateAsmConstraint(const char *&Name,
127                              TargetInfo::ConstraintInfo &Info) const override {
128     static const ::llvm::StringSet<> SpecialRegs({
129         "exec", "vcc", "flat_scratch", "m0", "scc", "tba", "tma",
130         "flat_scratch_lo", "flat_scratch_hi", "vcc_lo", "vcc_hi", "exec_lo",
131         "exec_hi", "tma_lo", "tma_hi", "tba_lo", "tba_hi",
132     });
133 
134     StringRef S(Name);
135     bool HasLeftParen = false;
136     if (S.front() == '{') {
137       HasLeftParen = true;
138       S = S.drop_front();
139     }
140     if (S.empty())
141       return false;
142     if (S.front() != 'v' && S.front() != 's') {
143       if (!HasLeftParen)
144         return false;
145       auto E = S.find('}');
146       if (!SpecialRegs.count(S.substr(0, E)))
147         return false;
148       S = S.drop_front(E + 1);
149       if (!S.empty())
150         return false;
151       // Found {S} where S is a special register.
152       Info.setAllowsRegister();
153       Name = S.data() - 1;
154       return true;
155     }
156     S = S.drop_front();
157     if (!HasLeftParen) {
158       if (!S.empty())
159         return false;
160       // Found s or v.
161       Info.setAllowsRegister();
162       Name = S.data() - 1;
163       return true;
164     }
165     bool HasLeftBracket = false;
166     if (!S.empty() && S.front() == '[') {
167       HasLeftBracket = true;
168       S = S.drop_front();
169     }
170     unsigned long long N;
171     if (S.empty() || consumeUnsignedInteger(S, 10, N))
172       return false;
173     if (!S.empty() && S.front() == ':') {
174       if (!HasLeftBracket)
175         return false;
176       S = S.drop_front();
177       unsigned long long M;
178       if (consumeUnsignedInteger(S, 10, M) || N >= M)
179         return false;
180     }
181     if (HasLeftBracket) {
182       if (S.empty() || S.front() != ']')
183         return false;
184       S = S.drop_front();
185     }
186     if (S.empty() || S.front() != '}')
187       return false;
188     S = S.drop_front();
189     if (!S.empty())
190       return false;
191     // Found {vn}, {sn}, {v[n]}, {s[n]}, {v[n:m]}, or {s[n:m]}.
192     Info.setAllowsRegister();
193     Name = S.data() - 1;
194     return true;
195   }
196 
197   bool
198   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
199                  StringRef CPU,
200                  const std::vector<std::string> &FeatureVec) const override;
201 
202   void adjustTargetOptions(const CodeGenOptions &CGOpts,
203                            TargetOptions &TargetOpts) const override;
204 
205   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
206 
207   void getTargetDefines(const LangOptions &Opts,
208                         MacroBuilder &Builder) const override;
209 
210   BuiltinVaListKind getBuiltinVaListKind() const override {
211     return TargetInfo::CharPtrBuiltinVaList;
212   }
213 
214   static GPUKind parseR600Name(StringRef Name);
215 
216   static GPUKind parseAMDGCNName(StringRef Name);
217 
218   bool isValidCPUName(StringRef Name) const override {
219     if (getTriple().getArch() == llvm::Triple::amdgcn)
220       return GK_NONE != parseAMDGCNName(Name);
221     else
222       return GK_NONE != parseR600Name(Name);
223   }
224 
225   bool setCPU(const std::string &Name) override {
226     if (getTriple().getArch() == llvm::Triple::amdgcn)
227       GPU = parseAMDGCNName(Name);
228     else
229       GPU = parseR600Name(Name);
230 
231     return GPU != GK_NONE;
232   }
233 
234   void setSupportedOpenCLOpts() override {
235     auto &Opts = getSupportedOpenCLOpts();
236     Opts.support("cl_clang_storage_class_specifiers");
237     Opts.support("cl_khr_icd");
238 
239     if (hasFP64)
240       Opts.support("cl_khr_fp64");
241     if (GPU >= GK_EVERGREEN) {
242       Opts.support("cl_khr_byte_addressable_store");
243       Opts.support("cl_khr_global_int32_base_atomics");
244       Opts.support("cl_khr_global_int32_extended_atomics");
245       Opts.support("cl_khr_local_int32_base_atomics");
246       Opts.support("cl_khr_local_int32_extended_atomics");
247     }
248     if (GPU >= GK_GFX6) {
249       Opts.support("cl_khr_fp16");
250       Opts.support("cl_khr_int64_base_atomics");
251       Opts.support("cl_khr_int64_extended_atomics");
252       Opts.support("cl_khr_mipmap_image");
253       Opts.support("cl_khr_subgroups");
254       Opts.support("cl_khr_3d_image_writes");
255       Opts.support("cl_amd_media_ops");
256       Opts.support("cl_amd_media_ops2");
257     }
258   }
259 
260   LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const override {
261     switch (TK) {
262     case OCLTK_Image:
263       return LangAS::opencl_constant;
264 
265     case OCLTK_ClkEvent:
266     case OCLTK_Queue:
267     case OCLTK_ReserveID:
268       return LangAS::opencl_global;
269 
270     default:
271       return TargetInfo::getOpenCLTypeAddrSpace(TK);
272     }
273   }
274 
275   llvm::Optional<LangAS> getConstantAddressSpace() const override {
276     return getLangASFromTargetAS(AS.Constant);
277   }
278 
279   /// \returns Target specific vtbl ptr address space.
280   unsigned getVtblPtrAddressSpace() const override { return AS.Constant; }
281 
282   /// \returns If a target requires an address within a target specific address
283   /// space \p AddressSpace to be converted in order to be used, then return the
284   /// corresponding target specific DWARF address space.
285   ///
286   /// \returns Otherwise return None and no conversion will be emitted in the
287   /// DWARF.
288   Optional<unsigned>
289   getDWARFAddressSpace(unsigned AddressSpace) const override {
290     const unsigned DWARF_Private = 1;
291     const unsigned DWARF_Local = 2;
292     if (AddressSpace == AS.Private) {
293       return DWARF_Private;
294     } else if (AddressSpace == AS.Local) {
295       return DWARF_Local;
296     } else {
297       return None;
298     }
299   }
300 
301   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
302     switch (CC) {
303     default:
304       return CCCR_Warning;
305     case CC_C:
306     case CC_OpenCLKernel:
307       return CCCR_OK;
308     }
309   }
310 
311   // In amdgcn target the null pointer in global, constant, and generic
312   // address space has value 0 but in private and local address space has
313   // value ~0.
314   uint64_t getNullPointerValue(LangAS AS) const override {
315     return AS == LangAS::opencl_local ? ~0 : 0;
316   }
317 };
318 
319 } // namespace targets
320 } // namespace clang
321 
322 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_AMDGPU_H
323