clang 17.0.0git
AMDGPU.cpp
Go to the documentation of this file.
1//===--- AMDGPU.cpp - Implement AMDGPU target feature support -------------===//
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 implements AMDGPU TargetInfo objects.
10//
11//===----------------------------------------------------------------------===//
12
13#include "AMDGPU.h"
20
21using namespace clang;
22using namespace clang::targets;
23
24namespace clang {
25namespace targets {
26
27// If you edit the description strings, make sure you update
28// getPointerWidthV().
29
30static const char *const DataLayoutStringR600 =
31 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
32 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1";
33
34static const char *const DataLayoutStringAMDGCN =
35 "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32"
36 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
37 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1"
38 "-ni:7";
39
40const LangASMap AMDGPUTargetInfo::AMDGPUDefIsGenMap = {
41 Generic, // Default
42 Global, // opencl_global
43 Local, // opencl_local
44 Constant, // opencl_constant
45 Private, // opencl_private
46 Generic, // opencl_generic
47 Global, // opencl_global_device
48 Global, // opencl_global_host
49 Global, // cuda_device
50 Constant, // cuda_constant
51 Local, // cuda_shared
52 Global, // sycl_global
53 Global, // sycl_global_device
54 Global, // sycl_global_host
55 Local, // sycl_local
56 Private, // sycl_private
57 Generic, // ptr32_sptr
58 Generic, // ptr32_uptr
59 Generic, // ptr64
60 Generic, // hlsl_groupshared
61};
62
63const LangASMap AMDGPUTargetInfo::AMDGPUDefIsPrivMap = {
64 Private, // Default
65 Global, // opencl_global
66 Local, // opencl_local
67 Constant, // opencl_constant
68 Private, // opencl_private
69 Generic, // opencl_generic
70 Global, // opencl_global_device
71 Global, // opencl_global_host
72 Global, // cuda_device
73 Constant, // cuda_constant
74 Local, // cuda_shared
75 // SYCL address space values for this map are dummy
76 Generic, // sycl_global
77 Generic, // sycl_global_device
78 Generic, // sycl_global_host
79 Generic, // sycl_local
80 Generic, // sycl_private
81 Generic, // ptr32_sptr
82 Generic, // ptr32_uptr
83 Generic, // ptr64
84 Generic, // hlsl_groupshared
85
86};
87} // namespace targets
88} // namespace clang
89
90static constexpr Builtin::Info BuiltinInfo[] = {
91#define BUILTIN(ID, TYPE, ATTRS) \
92 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
93#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
94 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
95#include "clang/Basic/BuiltinsAMDGPU.def"
96};
97
98const char *const AMDGPUTargetInfo::GCCRegNames[] = {
99 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8",
100 "v9", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17",
101 "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26",
102 "v27", "v28", "v29", "v30", "v31", "v32", "v33", "v34", "v35",
103 "v36", "v37", "v38", "v39", "v40", "v41", "v42", "v43", "v44",
104 "v45", "v46", "v47", "v48", "v49", "v50", "v51", "v52", "v53",
105 "v54", "v55", "v56", "v57", "v58", "v59", "v60", "v61", "v62",
106 "v63", "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71",
107 "v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79", "v80",
108 "v81", "v82", "v83", "v84", "v85", "v86", "v87", "v88", "v89",
109 "v90", "v91", "v92", "v93", "v94", "v95", "v96", "v97", "v98",
110 "v99", "v100", "v101", "v102", "v103", "v104", "v105", "v106", "v107",
111 "v108", "v109", "v110", "v111", "v112", "v113", "v114", "v115", "v116",
112 "v117", "v118", "v119", "v120", "v121", "v122", "v123", "v124", "v125",
113 "v126", "v127", "v128", "v129", "v130", "v131", "v132", "v133", "v134",
114 "v135", "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143",
115 "v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151", "v152",
116 "v153", "v154", "v155", "v156", "v157", "v158", "v159", "v160", "v161",
117 "v162", "v163", "v164", "v165", "v166", "v167", "v168", "v169", "v170",
118 "v171", "v172", "v173", "v174", "v175", "v176", "v177", "v178", "v179",
119 "v180", "v181", "v182", "v183", "v184", "v185", "v186", "v187", "v188",
120 "v189", "v190", "v191", "v192", "v193", "v194", "v195", "v196", "v197",
121 "v198", "v199", "v200", "v201", "v202", "v203", "v204", "v205", "v206",
122 "v207", "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215",
123 "v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223", "v224",
124 "v225", "v226", "v227", "v228", "v229", "v230", "v231", "v232", "v233",
125 "v234", "v235", "v236", "v237", "v238", "v239", "v240", "v241", "v242",
126 "v243", "v244", "v245", "v246", "v247", "v248", "v249", "v250", "v251",
127 "v252", "v253", "v254", "v255", "s0", "s1", "s2", "s3", "s4",
128 "s5", "s6", "s7", "s8", "s9", "s10", "s11", "s12", "s13",
129 "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22",
130 "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
131 "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39", "s40",
132 "s41", "s42", "s43", "s44", "s45", "s46", "s47", "s48", "s49",
133 "s50", "s51", "s52", "s53", "s54", "s55", "s56", "s57", "s58",
134 "s59", "s60", "s61", "s62", "s63", "s64", "s65", "s66", "s67",
135 "s68", "s69", "s70", "s71", "s72", "s73", "s74", "s75", "s76",
136 "s77", "s78", "s79", "s80", "s81", "s82", "s83", "s84", "s85",
137 "s86", "s87", "s88", "s89", "s90", "s91", "s92", "s93", "s94",
138 "s95", "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
139 "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111", "s112",
140 "s113", "s114", "s115", "s116", "s117", "s118", "s119", "s120", "s121",
141 "s122", "s123", "s124", "s125", "s126", "s127", "exec", "vcc", "scc",
142 "m0", "flat_scratch", "exec_lo", "exec_hi", "vcc_lo", "vcc_hi",
143 "flat_scratch_lo", "flat_scratch_hi",
144 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8",
145 "a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "a17",
146 "a18", "a19", "a20", "a21", "a22", "a23", "a24", "a25", "a26",
147 "a27", "a28", "a29", "a30", "a31", "a32", "a33", "a34", "a35",
148 "a36", "a37", "a38", "a39", "a40", "a41", "a42", "a43", "a44",
149 "a45", "a46", "a47", "a48", "a49", "a50", "a51", "a52", "a53",
150 "a54", "a55", "a56", "a57", "a58", "a59", "a60", "a61", "a62",
151 "a63", "a64", "a65", "a66", "a67", "a68", "a69", "a70", "a71",
152 "a72", "a73", "a74", "a75", "a76", "a77", "a78", "a79", "a80",
153 "a81", "a82", "a83", "a84", "a85", "a86", "a87", "a88", "a89",
154 "a90", "a91", "a92", "a93", "a94", "a95", "a96", "a97", "a98",
155 "a99", "a100", "a101", "a102", "a103", "a104", "a105", "a106", "a107",
156 "a108", "a109", "a110", "a111", "a112", "a113", "a114", "a115", "a116",
157 "a117", "a118", "a119", "a120", "a121", "a122", "a123", "a124", "a125",
158 "a126", "a127", "a128", "a129", "a130", "a131", "a132", "a133", "a134",
159 "a135", "a136", "a137", "a138", "a139", "a140", "a141", "a142", "a143",
160 "a144", "a145", "a146", "a147", "a148", "a149", "a150", "a151", "a152",
161 "a153", "a154", "a155", "a156", "a157", "a158", "a159", "a160", "a161",
162 "a162", "a163", "a164", "a165", "a166", "a167", "a168", "a169", "a170",
163 "a171", "a172", "a173", "a174", "a175", "a176", "a177", "a178", "a179",
164 "a180", "a181", "a182", "a183", "a184", "a185", "a186", "a187", "a188",
165 "a189", "a190", "a191", "a192", "a193", "a194", "a195", "a196", "a197",
166 "a198", "a199", "a200", "a201", "a202", "a203", "a204", "a205", "a206",
167 "a207", "a208", "a209", "a210", "a211", "a212", "a213", "a214", "a215",
168 "a216", "a217", "a218", "a219", "a220", "a221", "a222", "a223", "a224",
169 "a225", "a226", "a227", "a228", "a229", "a230", "a231", "a232", "a233",
170 "a234", "a235", "a236", "a237", "a238", "a239", "a240", "a241", "a242",
171 "a243", "a244", "a245", "a246", "a247", "a248", "a249", "a250", "a251",
172 "a252", "a253", "a254", "a255"
173};
174
176 return llvm::ArrayRef(GCCRegNames);
177}
178
180 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
181 const std::vector<std::string> &FeatureVec) const {
182 const bool IsNullCPU = CPU.empty();
183 bool IsWave32Capable = false;
184
185 using namespace llvm::AMDGPU;
186
187 // XXX - What does the member GPU mean if device name string passed here?
188 if (isAMDGCN(getTriple())) {
189 switch (llvm::AMDGPU::parseArchAMDGCN(CPU)) {
190 case GK_GFX1103:
191 case GK_GFX1102:
192 case GK_GFX1101:
193 case GK_GFX1100:
194 IsWave32Capable = true;
195 Features["ci-insts"] = true;
196 Features["dot5-insts"] = true;
197 Features["dot7-insts"] = true;
198 Features["dot8-insts"] = true;
199 Features["dot9-insts"] = true;
200 Features["dot10-insts"] = true;
201 Features["dl-insts"] = true;
202 Features["16-bit-insts"] = true;
203 Features["dpp"] = true;
204 Features["gfx8-insts"] = true;
205 Features["gfx9-insts"] = true;
206 Features["gfx10-insts"] = true;
207 Features["gfx10-3-insts"] = true;
208 Features["gfx11-insts"] = true;
209 break;
210 case GK_GFX1036:
211 case GK_GFX1035:
212 case GK_GFX1034:
213 case GK_GFX1033:
214 case GK_GFX1032:
215 case GK_GFX1031:
216 case GK_GFX1030:
217 IsWave32Capable = true;
218 Features["ci-insts"] = true;
219 Features["dot1-insts"] = true;
220 Features["dot2-insts"] = true;
221 Features["dot5-insts"] = true;
222 Features["dot6-insts"] = true;
223 Features["dot7-insts"] = true;
224 Features["dot10-insts"] = true;
225 Features["dl-insts"] = true;
226 Features["16-bit-insts"] = true;
227 Features["dpp"] = true;
228 Features["gfx8-insts"] = true;
229 Features["gfx9-insts"] = true;
230 Features["gfx10-insts"] = true;
231 Features["gfx10-3-insts"] = true;
232 Features["s-memrealtime"] = true;
233 Features["s-memtime-inst"] = true;
234 break;
235 case GK_GFX1012:
236 case GK_GFX1011:
237 Features["dot1-insts"] = true;
238 Features["dot2-insts"] = true;
239 Features["dot5-insts"] = true;
240 Features["dot6-insts"] = true;
241 Features["dot7-insts"] = true;
242 Features["dot10-insts"] = true;
243 [[fallthrough]];
244 case GK_GFX1013:
245 case GK_GFX1010:
246 IsWave32Capable = true;
247 Features["dl-insts"] = true;
248 Features["ci-insts"] = true;
249 Features["16-bit-insts"] = true;
250 Features["dpp"] = true;
251 Features["gfx8-insts"] = true;
252 Features["gfx9-insts"] = true;
253 Features["gfx10-insts"] = true;
254 Features["s-memrealtime"] = true;
255 Features["s-memtime-inst"] = true;
256 break;
257 case GK_GFX940:
258 Features["gfx940-insts"] = true;
259 Features["fp8-insts"] = true;
260 [[fallthrough]];
261 case GK_GFX90A:
262 Features["gfx90a-insts"] = true;
263 [[fallthrough]];
264 case GK_GFX908:
265 Features["dot3-insts"] = true;
266 Features["dot4-insts"] = true;
267 Features["dot5-insts"] = true;
268 Features["dot6-insts"] = true;
269 Features["mai-insts"] = true;
270 [[fallthrough]];
271 case GK_GFX906:
272 Features["dl-insts"] = true;
273 Features["dot1-insts"] = true;
274 Features["dot2-insts"] = true;
275 Features["dot7-insts"] = true;
276 Features["dot10-insts"] = true;
277 [[fallthrough]];
278 case GK_GFX90C:
279 case GK_GFX909:
280 case GK_GFX904:
281 case GK_GFX902:
282 case GK_GFX900:
283 Features["gfx9-insts"] = true;
284 [[fallthrough]];
285 case GK_GFX810:
286 case GK_GFX805:
287 case GK_GFX803:
288 case GK_GFX802:
289 case GK_GFX801:
290 Features["gfx8-insts"] = true;
291 Features["16-bit-insts"] = true;
292 Features["dpp"] = true;
293 Features["s-memrealtime"] = true;
294 [[fallthrough]];
295 case GK_GFX705:
296 case GK_GFX704:
297 case GK_GFX703:
298 case GK_GFX702:
299 case GK_GFX701:
300 case GK_GFX700:
301 Features["ci-insts"] = true;
302 [[fallthrough]];
303 case GK_GFX602:
304 case GK_GFX601:
305 case GK_GFX600:
306 Features["s-memtime-inst"] = true;
307 break;
308 case GK_NONE:
309 break;
310 default:
311 llvm_unreachable("Unhandled GPU!");
312 }
313 } else {
314 if (CPU.empty())
315 CPU = "r600";
316
317 switch (llvm::AMDGPU::parseArchR600(CPU)) {
318 case GK_CAYMAN:
319 case GK_CYPRESS:
320 case GK_RV770:
321 case GK_RV670:
322 // TODO: Add fp64 when implemented.
323 break;
324 case GK_TURKS:
325 case GK_CAICOS:
326 case GK_BARTS:
327 case GK_SUMO:
328 case GK_REDWOOD:
329 case GK_JUNIPER:
330 case GK_CEDAR:
331 case GK_RV730:
332 case GK_RV710:
333 case GK_RS880:
334 case GK_R630:
335 case GK_R600:
336 break;
337 default:
338 llvm_unreachable("Unhandled GPU!");
339 }
340 }
341
342 if (!TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec))
343 return false;
344
345 // FIXME: Not diagnosing wavefrontsize32 on wave64 only targets.
346 const bool HaveWave32 =
347 (IsWave32Capable || IsNullCPU) && Features.count("wavefrontsize32");
348 const bool HaveWave64 = Features.count("wavefrontsize64");
349
350 // TODO: Should move this logic into TargetParser
351 if (HaveWave32 && HaveWave64) {
352 Diags.Report(diag::err_invalid_feature_combination)
353 << "'wavefrontsize32' and 'wavefrontsize64' are mutually exclusive";
354 return false;
355 }
356
357 // Don't assume any wavesize with an unknown subtarget.
358 if (!IsNullCPU) {
359 // Default to wave32 if available, or wave64 if not
360 if (!HaveWave32 && !HaveWave64) {
361 StringRef DefaultWaveSizeFeature =
362 IsWave32Capable ? "wavefrontsize32" : "wavefrontsize64";
363 Features.insert(std::make_pair(DefaultWaveSizeFeature, true));
364 }
365 }
366
367 return true;
368}
369
371 SmallVectorImpl<StringRef> &Values) const {
372 if (isAMDGCN(getTriple()))
373 llvm::AMDGPU::fillValidArchListAMDGCN(Values);
374 else
375 llvm::AMDGPU::fillValidArchListR600(Values);
376}
377
378void AMDGPUTargetInfo::setAddressSpaceMap(bool DefaultIsPrivate) {
379 AddrSpaceMap = DefaultIsPrivate ? &AMDGPUDefIsPrivMap : &AMDGPUDefIsGenMap;
380}
381
382AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple,
383 const TargetOptions &Opts)
384 : TargetInfo(Triple),
385 GPUKind(isAMDGCN(Triple) ?
386 llvm::AMDGPU::parseArchAMDGCN(Opts.CPU) :
387 llvm::AMDGPU::parseArchR600(Opts.CPU)),
388 GPUFeatures(isAMDGCN(Triple) ?
389 llvm::AMDGPU::getArchAttrAMDGCN(GPUKind) :
390 llvm::AMDGPU::getArchAttrR600(GPUKind)) {
393
394 setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D ||
395 !isAMDGCN(Triple));
397
398 if (isAMDGCN(Triple)) {
399 // __bf16 is always available as a load/store only type on AMDGCN.
401 BFloat16Format = &llvm::APFloat::BFloat();
402 }
403
404 HasLegalHalfType = true;
405 HasFloat16 = true;
406 WavefrontSize = GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32 ? 32 : 64;
408
409 // Set pointer width and alignment for the generic address space.
411 if (getMaxPointerWidth() == 64) {
412 LongWidth = LongAlign = 64;
416 }
417
419}
420
422 TargetInfo::adjust(Diags, Opts);
423 // ToDo: There are still a few places using default address space as private
424 // address space in OpenCL, which needs to be cleaned up, then Opts.OpenCL
425 // can be removed from the following line.
426 setAddressSpaceMap(/*DefaultIsPrivate=*/Opts.OpenCL ||
427 !isAMDGCN(getTriple()));
428}
429
433}
434
436 MacroBuilder &Builder) const {
437 Builder.defineMacro("__AMD__");
438 Builder.defineMacro("__AMDGPU__");
439
440 if (isAMDGCN(getTriple()))
441 Builder.defineMacro("__AMDGCN__");
442 else
443 Builder.defineMacro("__R600__");
444
445 if (GPUKind != llvm::AMDGPU::GK_NONE) {
446 StringRef CanonName = isAMDGCN(getTriple()) ?
447 getArchNameAMDGCN(GPUKind) : getArchNameR600(GPUKind);
448 Builder.defineMacro(Twine("__") + Twine(CanonName) + Twine("__"));
449 // Emit macros for gfx family e.g. gfx906 -> __GFX9__, gfx1030 -> __GFX10___
450 if (isAMDGCN(getTriple())) {
451 assert(CanonName.startswith("gfx") && "Invalid amdgcn canonical name");
452 Builder.defineMacro(Twine("__") + Twine(CanonName.drop_back(2).upper()) +
453 Twine("__"));
454 }
455 if (isAMDGCN(getTriple())) {
456 Builder.defineMacro("__amdgcn_processor__",
457 Twine("\"") + Twine(CanonName) + Twine("\""));
458 Builder.defineMacro("__amdgcn_target_id__",
459 Twine("\"") + Twine(*getTargetID()) + Twine("\""));
460 for (auto F : getAllPossibleTargetIDFeatures(getTriple(), CanonName)) {
461 auto Loc = OffloadArchFeatures.find(F);
462 if (Loc != OffloadArchFeatures.end()) {
463 std::string NewF = F.str();
464 std::replace(NewF.begin(), NewF.end(), '-', '_');
465 Builder.defineMacro(Twine("__amdgcn_feature_") + Twine(NewF) +
466 Twine("__"),
467 Loc->second ? "1" : "0");
468 }
469 }
470 }
471 }
472
474 Builder.defineMacro("__AMDGCN_UNSAFE_FP_ATOMICS__");
475
476 // TODO: __HAS_FMAF__, __HAS_LDEXPF__, __HAS_FP64__ are deprecated and will be
477 // removed in the near future.
478 if (hasFMAF())
479 Builder.defineMacro("__HAS_FMAF__");
480 if (hasFastFMAF())
481 Builder.defineMacro("FP_FAST_FMAF");
482 if (hasLDEXPF())
483 Builder.defineMacro("__HAS_LDEXPF__");
484 if (hasFP64())
485 Builder.defineMacro("__HAS_FP64__");
486 if (hasFastFMA())
487 Builder.defineMacro("FP_FAST_FMA");
488
489 Builder.defineMacro("__AMDGCN_WAVEFRONT_SIZE", Twine(WavefrontSize));
490}
491
493 assert(HalfFormat == Aux->HalfFormat);
494 assert(FloatFormat == Aux->FloatFormat);
495 assert(DoubleFormat == Aux->DoubleFormat);
496
497 // On x86_64 long double is 80-bit extended precision format, which is
498 // not supported by AMDGPU. 128-bit floating point format is also not
499 // supported by AMDGPU. Therefore keep its own format for these two types.
500 auto SaveLongDoubleFormat = LongDoubleFormat;
501 auto SaveFloat128Format = Float128Format;
502 auto SaveLongDoubleWidth = LongDoubleWidth;
503 auto SaveLongDoubleAlign = LongDoubleAlign;
504 copyAuxTarget(Aux);
505 LongDoubleFormat = SaveLongDoubleFormat;
506 Float128Format = SaveFloat128Format;
507 LongDoubleWidth = SaveLongDoubleWidth;
508 LongDoubleAlign = SaveLongDoubleAlign;
509 // For certain builtin types support on the host target, claim they are
510 // support to pass the compilation of the host code during the device-side
511 // compilation.
512 // FIXME: As the side effect, we also accept `__float128` uses in the device
513 // code. To rejct these builtin types supported in the host target but not in
514 // the device target, one approach would support `device_builtin` attribute
515 // so that we could tell the device builtin types from the host ones. The
516 // also solves the different representations of the same builtin type, such
517 // as `size_t` in the MSVC environment.
518 if (Aux->hasFloat128Type()) {
519 HasFloat128 = true;
521 }
522}
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
Definition: AMDGPU.cpp:90
static constexpr Builtin::Info BuiltinInfo[]
Definition: Builtins.cpp:32
Defines enum values for all the target-independent builtin functions.
Defines the clang::LangOptions interface.
Defines the clang::MacroBuilder utility class.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1542
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
Exposes information about the current target.
Definition: TargetInfo.h:206
void copyAuxTarget(const TargetInfo *Aux)
Copy type and layout related info.
Definition: TargetInfo.cpp:986
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1195
const LangASMap * AddrSpaceMap
Definition: TargetInfo.h:234
void resetDataLayout(StringRef DL, const char *UserLabelPrefix="")
Definition: TargetInfo.cpp:187
unsigned char MaxAtomicPromoteWidth
Definition: TargetInfo.h:227
bool UseAddrSpaceMapMangling
Specify if mangling based on address space map should be used or not for language specific address sp...
Definition: TargetInfo.h:337
virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:389
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
Definition: TargetInfo.h:646
virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const
Initialize the map with the default set of target features for the CPU this should include all legal ...
Definition: TargetInfo.cpp:519
unsigned char MaxAtomicInlineWidth
Definition: TargetInfo.h:227
unsigned AllowAMDGPUUnsafeFPAtomics
Definition: TargetInfo.h:251
Options for controlling the target.
Definition: TargetOptions.h:26
bool AllowAMDGPUUnsafeFPAtomics
If enabled, allow AMDGPU unsafe floating point atomics.
Definition: TargetOptions.h:79
void setAuxTarget(const TargetInfo *Aux) override
Definition: AMDGPU.cpp:492
ArrayRef< const char * > getGCCRegNames() const override
Definition: AMDGPU.cpp:175
AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: AMDGPU.cpp:382
uint64_t getPointerWidthV(LangAS AS) const override
Definition: AMDGPU.h:98
void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values to setCPU.
Definition: AMDGPU.cpp:370
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
Definition: AMDGPU.cpp:179
void setAddressSpaceMap(bool DefaultIsPrivate)
Definition: AMDGPU.cpp:378
void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override
Set forced language options.
Definition: AMDGPU.cpp:421
std::optional< std::string > getTargetID() const override
Returns the target ID if supported.
Definition: AMDGPU.h:456
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
Definition: AMDGPU.cpp:435
uint64_t getMaxPointerWidth() const override
Return the maximum width of pointers on this target.
Definition: AMDGPU.h:113
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
Definition: AMDGPU.cpp:430
static const char *const DataLayoutStringR600
Definition: AMDGPU.cpp:30
static const char *const DataLayoutStringAMDGCN
Definition: AMDGPU.cpp:34
unsigned[(unsigned) LangAS::FirstTargetAddressSpace] LangASMap
The type of a lookup table which maps from language-specific address spaces to target-specific ones.
Definition: AddressSpaces.h:70
llvm::SmallVector< llvm::StringRef, 4 > getAllPossibleTargetIDFeatures(const llvm::Triple &T, llvm::StringRef Processor)
Get all feature strings that can be used in target ID for Processor.
Definition: TargetID.cpp:38
YAML serialization mapping.
Definition: Dominators.h:30
const llvm::fltSemantics * DoubleFormat
Definition: TargetInfo.h:132
const llvm::fltSemantics * LongDoubleFormat
Definition: TargetInfo.h:132
const llvm::fltSemantics * Float128Format
Definition: TargetInfo.h:132
const llvm::fltSemantics * FloatFormat
Definition: TargetInfo.h:131
const llvm::fltSemantics * HalfFormat
Definition: TargetInfo.h:131
const llvm::fltSemantics * BFloat16Format
Definition: TargetInfo.h:131