LLVM 24.0.0git
AMDGPUTargetParser.cpp
Go to the documentation of this file.
1//===-- AMDGPUTargetParser - Parser for AMDGPU features ---------*- 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 implements a target parser to recognise AMDGPU hardware features.
10//
11//===----------------------------------------------------------------------===//
12
16#include "llvm/ADT/Twine.h"
19#include <algorithm>
20#include <array>
21#include <cassert>
22
23using namespace llvm;
24using namespace AMDGPU;
25
26namespace {
27constexpr unsigned NumAMDGPUSubArches =
29
30// A legacy GPU name (e.g. "tahiti") mapped to the GPUKind it aliases.
31struct GPUNameAlias {
32 StringTable::Offset AltName;
33 GPUKind Kind;
34};
35
36// Per-GPU data for the AMDGCN GPUKinds, from the generated table below.
37struct GPUInfo {
38 StringTable::Offset Name;
39 Triple::SubArchType SubArch;
40 AMDGPUFeatureBitset Features;
41 IsaVersion Version;
42 StringTable::Offset FamilyName;
43 uint8_t MaxWavesPerEU;
44 uint32_t MaxHWAddressableLocalMemorySize;
45 uint8_t LDSBankCount;
46 uint8_t BufferResourceNumRecordsWidth;
47};
48
49// Per-GPU data for the R600 GPUKinds.
50struct R600Info {
51 StringTable::Offset Name;
52 R600FeatureBitset Features;
53};
54
55#define GET_AMDGPU_NAME_TABLE
56#define GET_AMDGPU_GPU_TABLE
57#define GET_AMDGPU_GPU_ALIAS_TABLE
58#define GET_AMDGPU_MAJOR_SUBARCH
59#define GET_AMDGPU_SUBARCH_NAME
60#define GET_AMDGPU_FEATURE_NAME_TABLE
61#include "llvm/TargetParser/AMDGPUTargetParserDef.inc"
62
63#define GET_R600_NAME_TABLE
64#define GET_R600_GPU_TABLE
65#define GET_R600_GPU_ALIAS_TABLE
66#define GET_R600_FEATURE_NAME_TABLE
67#include "llvm/TargetParser/R600TargetParserDef.inc"
68
69// The string tables holding GPU-name-derived strings as offsets. R600 and
70// AMDGPU come from separate generated headers, each with its own pool.
71constexpr StringTable AMDGPUNameStrTab = AMDGPUNameTable;
72constexpr StringTable R600NameStrTab = R600NameTable;
73
74// Look up the GPUInfo row for an AMDGCN GPUKind, or nullptr for GK_NONE / a
75// non-AMDGCN (R600) kind.
76const GPUInfo *getAMDGPUInfo(GPUKind AK) {
77 if (AK < AMDGPUFirstGPUKind)
78 return nullptr;
79 unsigned Idx = AK - AMDGPUFirstGPUKind;
80 if (Idx >= std::size(AMDGPUGPUTable))
81 return nullptr;
82 return &AMDGPUGPUTable[Idx];
83}
84
85// Look up the R600Info row for an R600 GPUKind, or nullptr for a non-R600 kind.
86const R600Info *getR600Info(GPUKind AK) {
87 if (AK < R600FirstGPUKind)
88 return nullptr;
89 unsigned Idx = AK - R600FirstGPUKind;
90 if (Idx >= std::size(R600GPUTable))
91 return nullptr;
92 return &R600GPUTable[Idx];
93}
94
95// Scan a name -> GPUKind table (canonical names, then aliases) for \p CPU.
96template <typename InfoT, size_t N, size_t M>
97GPUKind parseArchImpl(StringRef CPU, const InfoT (&Table)[N], GPUKind FirstKind,
98 const StringTable &StrTab,
99 const GPUNameAlias (&Aliases)[M]) {
100 for (unsigned I = 0; I != N; ++I) {
101 if (CPU == StrTab[Table[I].Name])
102 return static_cast<GPUKind>(FirstKind + I);
103 }
104
105 for (const GPUNameAlias &A : Aliases) {
106 if (CPU == StrTab[A.AltName])
107 return A.Kind;
108 }
109
110 return GK_NONE;
111}
112
113// Reverse map: SubArch -> GPUKind, indexed by (SubArch - FirstAMDGPUSubArch).
114// Subarches with no GPU (incl. the NoSubArch pseudo targets) map to GK_NONE.
115constexpr std::array<GPUKind, NumAMDGPUSubArches> AMDGPUSubArchToGPUKind = [] {
116 std::array<GPUKind, NumAMDGPUSubArches> Map{};
117
118 for (unsigned I = 0; I < std::size(AMDGPUGPUTable); ++I) {
119 Triple::SubArchType SubArch = AMDGPUGPUTable[I].SubArch;
120 if (SubArch != Triple::NoSubArch) {
122 static_cast<GPUKind>(AMDGPUFirstGPUKind + I);
123 }
124 }
125 return Map;
126}();
127
128/// SubArch -> major-family, indexed by (SubArch - FirstAMDGPUSubArch).
129constexpr std::array<Triple::SubArchType, NumAMDGPUSubArches>
130 AMDGPUMajorFamilies = [] {
131 std::array<Triple::SubArchType, NumAMDGPUSubArches> Map{};
132
133 for (unsigned I = 0; I < NumAMDGPUSubArches; ++I) {
134 Map[I] =
136 }
137
138 for (const AMDGPUMajorSubArchEntry &Entry : AMDGPUMajorSubArch)
139 Map[Entry.SubArch - Triple::FirstAMDGPUSubArch] = Entry.Major;
140 return Map;
141 }();
142
143// SubArch -> name-offset, indexed by (SubArch - FirstAMDGPUSubArch). Unmapped
144// subarches keep offset 0 (the empty string).
145constexpr std::array<StringTable::Offset, NumAMDGPUSubArches>
146 AMDGPUSubArchNameOffsets = [] {
147 std::array<StringTable::Offset, NumAMDGPUSubArches> Map{};
148 for (const AMDGPUSubArchNameEntry &Entry : AMDGPUSubArchNames)
149 Map[Entry.SubArch - Triple::FirstAMDGPUSubArch] = Entry.NameOffset;
150 return Map;
151 }();
152
153// SubArch -> triple-name-offset (e.g. "amdgpu9.00"), like
154// AMDGPUSubArchNameOffsets.
155constexpr std::array<StringTable::Offset, NumAMDGPUSubArches>
156 AMDGPUSubArchTripleNameOffsets = [] {
157 std::array<StringTable::Offset, NumAMDGPUSubArches> Map{};
158 for (const AMDGPUSubArchNameEntry &Entry : AMDGPUSubArchNames)
159 Map[Entry.SubArch - Triple::FirstAMDGPUSubArch] =
160 Entry.TripleNameOffset;
161 return Map;
162 }();
163} // namespace
164
166 const GPUInfo *Info = getAMDGPUInfo(AK);
167 return Info ? AMDGPUNameStrTab[Info->FamilyName] : "";
168}
169
171 const GPUInfo *Info = getAMDGPUInfo(AK);
172 return Info ? Info->SubArch : Triple::SubArchType::NoSubArch;
173}
174
178
181 if (SubArch < Triple::FirstAMDGPUSubArch ||
183 return GK_NONE;
184 return AMDGPUSubArchToGPUKind[SubArch - Triple::FirstAMDGPUSubArch];
185}
186
192
194 if (A == B || A == Triple::NoSubArch || B == Triple::NoSubArch)
195 return true;
196
199
200 // One side is the major-family subarch covering the other's family.
201 if (A == MajorA)
202 return MajorA == MajorB;
203 if (B == MajorB)
204 return MajorA == MajorB;
205
206 return false;
207}
208
210 // An unrecognized GPU is never valid.
211 if (AK == GK_NONE)
212 return false;
213 // A legacy triple without a subarch accepts any known GPU.
214 if (SubArch == Triple::NoSubArch)
215 return true;
216
217 // Reject the dummy "generic" targets
218 Triple::SubArchType GPUSubArch = getSubArch(AK);
219 if (GPUSubArch == Triple::NoSubArch)
220 return false;
221
222 return isSubArchCompatible(GPUSubArch, SubArch);
223}
224
228
230 const GPUInfo *Info = getAMDGPUInfo(AK);
231 return Info && Info->SubArch == Triple::NoSubArch;
232}
233
237
239 // Tolerate subarch mismatch if one entry is none. This is a hack for bitcode
240 // libraries.
241 // There's a missing enum entry for an unknown subarch. Make sure the
242 // subarch is really empty.
243 if (A.getSubArch() == Triple::NoSubArch)
244 return A.getArchName().size() == 6;
245
246 if (B.getSubArch() == Triple::NoSubArch)
247 return B.getArchName().size() == 6;
248
249 return isSubArchCompatible(A.getSubArch(), B.getSubArch());
250}
251
252std::string AMDGPU::mergeSubArch(const Triple &A, const Triple &B) {
253 if (A.getSubArch() == Triple::NoSubArch)
254 return B.str();
255 if (B.getSubArch() == Triple::NoSubArch)
256 return A.str();
257
258 Triple::SubArchType MajorA = AMDGPU::getMajorSubArch(A.getSubArch());
259 Triple::SubArchType MajorB = AMDGPU::getMajorSubArch(B.getSubArch());
260
261 // With a compatible major arch, return the specific subarch.
262 if (A.getSubArch() == MajorA) {
263 if (MajorA == MajorB)
264 return B.str();
265 }
266
267 if (B.getSubArch() == MajorB) {
268 if (MajorA == MajorB)
269 return A.str();
270 }
271
272 // Invalid case.
273 return B.str();
274}
275
277 const GPUInfo *Info = getAMDGPUInfo(AK);
278 return Info ? AMDGPUNameStrTab[Info->Name] : "";
279}
280
282 if (SubArch < Triple::FirstAMDGPUSubArch ||
284 return "";
285 return AMDGPUNameStrTab[AMDGPUSubArchNameOffsets[SubArch -
287}
288
290 if (SubArch == Triple::NoSubArch)
291 return AMDGPUNameStrTab[AMDGPUNoSubArchNameOffset];
292
294 SubArch <= Triple::LastAMDGPUSubArch &&
295 "expected an AMDGPU subarch or NoSubArch");
296 return AMDGPUNameStrTab
297 [AMDGPUSubArchTripleNameOffsets[SubArch - Triple::FirstAMDGPUSubArch]];
298}
299
301 const R600Info *Info = getR600Info(AK);
302 return Info ? R600NameStrTab[Info->Name] : "";
303}
304
306 return parseArchImpl(CPU, AMDGPUGPUTable, AMDGPUFirstGPUKind,
307 AMDGPUNameStrTab, AMDGPUGPUAliases);
308}
309
311 return parseArchImpl(CPU, R600GPUTable, R600FirstGPUKind, R600NameStrTab,
312 R600GPUAliases);
313}
314
316 static constexpr AMDGPUFeatureBitset Empty{};
317 const GPUInfo *Info = getAMDGPUInfo(AK);
318 return Info ? Info->Features : Empty;
319}
320
325
327 static constexpr R600FeatureBitset Empty{};
328 const R600Info *Info = getR600Info(AK);
329 return Info ? Info->Features : Empty;
330}
331
334 for (unsigned I = 0; I != NUM_FEATURES; ++I) {
335 if (Features.test(I))
336 Names.push_back(AMDGPUNameStrTab[AMDGPUFeatureNames[I]]);
337 }
338}
339
341 Triple::SubArchType SubArch) {
342 // XXX: Should this only report unique canonical names?
343 // An alias shares its GPU's GPUKind, so it is filtered alongside it.
344 for (unsigned I = 0; I != std::size(AMDGPUGPUTable); ++I) {
345 GPUKind Kind = static_cast<GPUKind>(AMDGPUFirstGPUKind + I);
346 if (AMDGPUGPUTable[I].SubArch != Triple::NoSubArch &&
347 isCPUValidForSubArch(SubArch, Kind))
348 Values.push_back(AMDGPUNameStrTab[AMDGPUGPUTable[I].Name]);
349 }
350
351 for (const GPUNameAlias &A : AMDGPUGPUAliases) {
352 if (isCPUValidForSubArch(SubArch, A.Kind))
353 Values.push_back(AMDGPUNameStrTab[A.AltName]);
354 }
355}
356
358 for (const R600Info &Info : R600GPUTable)
359 Values.push_back(R600NameStrTab[Info.Name]);
360 for (const GPUNameAlias &A : R600GPUAliases)
361 Values.push_back(R600NameStrTab[A.AltName]);
362}
363
365 const GPUInfo *Info = getAMDGPUInfo(parseArchAMDGCN(GPU));
366 return Info ? Info->Version : IsaVersion{0, 0, 0};
367}
368
370 const GPUInfo *Info = getAMDGPUInfo(getGPUKindFromSubArch(SubArch));
371 return Info ? Info->Version : IsaVersion{0, 0, 0};
372}
373
376 if (Version.Major >= 8)
377 return 800;
378 return 512;
379}
380
383 if (Version.Major >= 8)
384 return 800;
385 return 512;
386}
387
389 if (getFeatureBitset(AK).test(FEAT_SGPR_INIT_BUG))
391
393 if (Version.Major >= 10)
394 return 106;
395 if (Version.Major >= 8)
396 return 102;
397 return 104;
398}
399
401 if (getFeatureBitset(getGPUKindFromSubArch(SubArch)).test(FEAT_SGPR_INIT_BUG))
403
405 if (Version.Major >= 10)
406 return 106;
407 if (Version.Major >= 8)
408 return 102;
409 return 104;
410}
411
414 if (Version.Major >= 10)
415 return getAddressableNumSGPRs(AK);
416 if (Version.Major >= 8)
417 return 16;
418 return 8;
419}
420
423 if (Version.Major >= 10)
424 return getAddressableNumSGPRs(SubArch);
425 if (Version.Major >= 8)
426 return 16;
427 return 8;
428}
429
430unsigned AMDGPU::getVGPRAllocGranule(GPUKind AK, bool IsWave32) {
431 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
432 if (Features.test(FEAT_GFX90A_INSTS))
433 return 8;
434 if (Features.test(FEAT_1536_PHYSICAL_VGPRS))
435 return IsWave32 ? 24 : 12;
436 if (Features.test(FEAT_GFX10_3_INSTS))
437 return IsWave32 ? 16 : 8;
438 return IsWave32 ? 8 : 4;
439}
440
442 bool IsWave32) {
443 return getVGPRAllocGranule(getGPUKindFromSubArch(SubArch), IsWave32);
444}
445
446unsigned AMDGPU::getTotalNumVGPRs(GPUKind AK, bool IsWave32) {
447 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
448 if (Features.test(FEAT_GFX90A_INSTS))
449 return 512;
450 if (!Features.test(FEAT_GFX10_INSTS))
451 return 256;
452 if (Features.test(FEAT_1536_PHYSICAL_VGPRS))
453 return IsWave32 ? 1536 : 768;
454 return IsWave32 ? 1024 : 512;
455}
456
457unsigned AMDGPU::getTotalNumVGPRs(Triple::SubArchType SubArch, bool IsWave32) {
458 return getTotalNumVGPRs(getGPUKindFromSubArch(SubArch), IsWave32);
459}
460
461unsigned AMDGPU::getAddressableNumVGPRs(GPUKind AK, bool IsWave32) {
462 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
463 // The unified register file makes the AGPRs addressable as VGPRs.
464 if (Features.test(FEAT_GFX90A_INSTS))
465 return 512;
466
467 // VGPR operand fields are 8 bits; VGPR MSBs add 2 more per operand.
468 constexpr unsigned OperandBits = 8;
469 constexpr unsigned MSBBits = 2;
470 unsigned Bits = OperandBits;
471 if (Features.test(FEAT_VGPR_MSBS))
472 Bits += MSBBits;
473 return std::min(1u << Bits, getTotalNumVGPRs(AK, IsWave32));
474}
475
477 bool IsWave32) {
478 return getAddressableNumVGPRs(getGPUKindFromSubArch(SubArch), IsWave32);
479}
480
482 const GPUInfo *Info = getAMDGPUInfo(AK);
483 return Info ? Info->MaxHWAddressableLocalMemorySize : 32768;
484}
485
486unsigned
490
491unsigned AMDGPU::getLocalMemorySize(GPUKind AK, bool FullSIMDMode) {
492 // gfx6 and gfx10/11/12 address half of the physical block.
494 if (getFeatureBitset(AK).test(FEAT_HALF_ADDRESSABLE_PHYSICAL_LOCAL_MEMORY))
495 Size *= 2;
496
497 // In half-SIMD mode the work-group reaches only half of the block.
498 if (!FullSIMDMode)
499 Size /= 2;
500
501 return Size;
502}
503
505 bool FullSIMDMode) {
506 return getLocalMemorySize(getGPUKindFromSubArch(SubArch), FullSIMDMode);
507}
508
509unsigned AMDGPU::getAddressableLocalMemorySize(GPUKind AK, bool FullSIMDMode) {
510 return std::min(getMaxHWAddressableLocalMemorySize(AK),
511 getLocalMemorySize(AK, FullSIMDMode));
512}
513
515 bool FullSIMDMode) {
517 FullSIMDMode);
518}
519
521 const GPUInfo *Info = getAMDGPUInfo(AK);
522 return Info ? Info->LDSBankCount : 32;
523}
524
528
530 const GPUInfo *Info = getAMDGPUInfo(AK);
531 if (!Info || Info->BufferResourceNumRecordsWidth == 0)
532 return std::nullopt;
533 return Info->BufferResourceNumRecordsWidth;
534}
535
536std::optional<unsigned>
540
542 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
543 if (Features.none())
544 return 256;
545 assert((Features.test(FEAT_LDS_ALLOC_GRANULARITY_256) ||
546 Features.test(FEAT_LDS_ALLOC_GRANULARITY_512) ||
547 Features.test(FEAT_LDS_ALLOC_GRANULARITY_1024) ||
548 Features.test(FEAT_LDS_ALLOC_GRANULARITY_1280) ||
549 Features.test(FEAT_LDS_ALLOC_GRANULARITY_2048)) &&
550 "missing LDS allocation granularity feature");
551 if (Features.test(FEAT_LDS_ALLOC_GRANULARITY_256))
552 return 256;
553 if (Features.test(FEAT_LDS_ALLOC_GRANULARITY_512))
554 return 512;
555 if (Features.test(FEAT_LDS_ALLOC_GRANULARITY_1024))
556 return 1024;
557 if (Features.test(FEAT_LDS_ALLOC_GRANULARITY_1280))
558 return 1280;
559 if (Features.test(FEAT_LDS_ALLOC_GRANULARITY_2048))
560 return 2048;
561
562 return 256;
563}
564
568
570 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
571 if (Features.test(FEAT_LDS_ENCODING_GRANULARITY_256))
572 return 256;
573 if (Features.test(FEAT_LDS_ENCODING_GRANULARITY_512))
574 return 512;
575 if (Features.test(FEAT_LDS_ENCODING_GRANULARITY_1024))
576 return 1024;
577 if (Features.test(FEAT_LDS_ENCODING_GRANULARITY_1280))
578 return 1280;
579 if (Features.test(FEAT_LDS_ENCODING_GRANULARITY_2048))
580 return 2048;
581
582 return 0;
583}
584
588
590 const GPUInfo *Info = getAMDGPUInfo(AK);
591 return Info ? Info->MaxWavesPerEU : 10;
592}
593
597
599 assert(T.isAMDGPU());
600 auto ProcKind = T.isAMDGCN() ? parseArchAMDGCN(Arch) : parseArchR600(Arch);
601 if (ProcKind == GK_NONE)
602 return StringRef();
603
604 return T.isAMDGCN() ? getArchNameAMDGCN(ProcKind) : getArchNameR600(ProcKind);
605}
606
607// Capability features clang queries via the feature bitset but must not
608// serialize into the target-feature string.
609//
610// FIXME: This is hacky, we shouldn't have mismatches between the bitset and
611// feature string map.
613 FEAT_FAST_FMAF,
614 FEAT_FAST_DENORMAL_F32,
615 FEAT_SUPPORTS_WAVE32,
616 FEAT_SUPPORTS_WGP,
617 FEAT_XNACK_SUPPORT,
618 FEAT_SRAMECC_SUPPORT,
619 FEAT_XNACK_ON_OFF_MODES,
620 FEAT_SRAMECC_ON_OFF_MODES,
621 FEAT_APERTURE_REGS,
622 FEAT_GET_DOORBELL_ID,
623 FEAT_AGPR_ALLOC,
624 FEAT_1536_PHYSICAL_VGPRS,
625 FEAT_HALF_ADDRESSABLE_PHYSICAL_LOCAL_MEMORY,
626 FEAT_VGPR_MSBS,
627 FEAT_LDS_ALLOC_GRANULARITY_256,
628 FEAT_LDS_ALLOC_GRANULARITY_512,
629 FEAT_LDS_ALLOC_GRANULARITY_1024,
630 FEAT_LDS_ALLOC_GRANULARITY_1280,
631 FEAT_LDS_ALLOC_GRANULARITY_2048,
632 FEAT_LDS_ENCODING_GRANULARITY_256,
633 FEAT_LDS_ENCODING_GRANULARITY_512,
634 FEAT_LDS_ENCODING_GRANULARITY_1024,
635 FEAT_LDS_ENCODING_GRANULARITY_1280,
636 FEAT_LDS_ENCODING_GRANULARITY_2048};
637
638// Add a GPU's features (minus the frontend-only ones) to \p Features. With \p
639// Overwrite false, existing entries are kept so user -mattr overrides win.
640static void addGPUFeatures(const GPUInfo &Info, bool Overwrite,
641 StringMap<bool> &Features) {
643 getFeatureNames(Info.Features & ~FrontendOnlyFeatures, Names);
644 for (StringRef Name : Names) {
645 if (Overwrite)
646 Features[Name] = true;
647 else
648 Features.insert({Name, true});
649 }
650}
651
652/// Add a GPU's default features to \p Features (preserving user overrides) and
653/// validate any requested wavesize.
654static std::pair<FeatureError, StringRef>
656 StringMap<bool> &Features) {
657 // With no explicit GPU, the triple's subarch identifies the target.
658 GPUKind Kind = GPU.empty() && T.getSubArch() != Triple::NoSubArch
659 ? getGPUKindFromSubArch(T.getSubArch())
660 : parseArchAMDGCN(GPU);
661 const GPUInfo *Info = getAMDGPUInfo(Kind);
662
663 // A bare subarch triple (no -target-cpu) still pins down the target, so it is
664 // not a null GPU. The target's native wavesize (if single-mode) is in the
665 // feature bitset; a dual-mode GPU has neither wave bit set.
666 const bool IsNullGPU = T.getSubArch() == Triple::NoSubArch && GPU.empty();
667 const bool TargetHasWave32 =
668 Info && Info->Features.test(FEAT_WAVEFRONTSIZE32);
669 const bool TargetHasWave64 =
670 Info && Info->Features.test(FEAT_WAVEFRONTSIZE64);
671
672 auto Wave32Itr = Features.find("wavefrontsize32");
673 auto Wave64Itr = Features.find("wavefrontsize64");
674 const bool EnableWave32 =
675 Wave32Itr != Features.end() && Wave32Itr->getValue();
676 const bool EnableWave64 =
677 Wave64Itr != Features.end() && Wave64Itr->getValue();
678 const bool DisableWave32 =
679 Wave32Itr != Features.end() && !Wave32Itr->getValue();
680 const bool DisableWave64 =
681 Wave64Itr != Features.end() && !Wave64Itr->getValue();
682
683 if (EnableWave32 && EnableWave64)
685 "'+wavefrontsize32' and '+wavefrontsize64' are mutually exclusive"};
686 if (DisableWave32 && DisableWave64)
688 "'-wavefrontsize32' and '-wavefrontsize64' are mutually exclusive"};
689
690 if (!IsNullGPU) {
691 if (TargetHasWave64) {
692 if (EnableWave32)
693 return {AMDGPU::UNSUPPORTED_TARGET_FEATURE, "+wavefrontsize32"};
694 if (DisableWave64)
695 return {AMDGPU::UNSUPPORTED_TARGET_FEATURE, "-wavefrontsize64"};
696 }
697
698 if (TargetHasWave32) {
699 if (EnableWave64)
700 return {AMDGPU::UNSUPPORTED_TARGET_FEATURE, "+wavefrontsize64"};
701 if (DisableWave32)
702 return {AMDGPU::UNSUPPORTED_TARGET_FEATURE, "-wavefrontsize32"};
703 }
704 }
705
706 // Don't assume any wavesize with an unknown subtarget.
707 // Default to wave32 if target supports both.
708 if (!IsNullGPU && !EnableWave32 && !EnableWave64 && !TargetHasWave32 &&
709 !TargetHasWave64)
710 Features.insert({"wavefrontsize32", true});
711
712 // Merge the target defaults, keeping any user -mattr overrides.
713 if (Info)
714 addGPUFeatures(*Info, /*Overwrite=*/false, Features);
715
716 return {NO_ERROR, StringRef()};
717}
718
719/// Fills Features map with default values for given target GPU.
720/// \p Features contains overriding target features and this function returns
721/// default target features with entries overridden by \p Features.
722std::pair<FeatureError, StringRef>
724 StringMap<bool> &Features) {
725 // XXX - What does the member GPU mean if device name string passed here?
726 if (T.isSPIRV() && T.getOS() == Triple::OSType::AMDHSA) {
727 // AMDGCN SPIRV must support the union of all AMDGCN features.
730 for (StringRef G : GPUs)
731 if (const GPUInfo *Info = getAMDGPUInfo(parseArchAMDGCN(G)))
732 addGPUFeatures(*Info, /*Overwrite=*/true, Features);
733 Features["wavefrontsize32"] = true;
734 Features["wavefrontsize64"] = true;
735 } else if (T.isAMDGCN()) {
736 return fillAMDGCNFeatureMap(GPU, T, Features);
737 } else {
738 if (GPU.empty())
739 GPU = "r600";
740
741 switch (llvm::AMDGPU::parseArchR600(GPU)) {
742 case GK_CAYMAN:
743 case GK_CYPRESS:
744 case GK_RV770:
745 case GK_RV670:
746 // TODO: Add fp64 when implemented.
747 break;
748 case GK_TURKS:
749 case GK_CAICOS:
750 case GK_BARTS:
751 case GK_SUMO:
752 case GK_REDWOOD:
753 case GK_JUNIPER:
754 case GK_CEDAR:
755 case GK_RV730:
756 case GK_RV710:
757 case GK_RS880:
758 case GK_R630:
759 case GK_R600:
760 break;
761 default:
762 llvm_unreachable("Unhandled GPU!");
763 }
764 }
765 return {NO_ERROR, StringRef()};
766}
767
768TargetID::TargetID(GPUKind Arch, const Triple &TT, TargetIDSetting XnackSetting,
769 TargetIDSetting SramEccSetting)
770 : Arch(Arch),
771 TargetTripleString(TT.normalize(Triple::CanonicalForm::FOUR_IDENT)),
772 XnackSetting(XnackSetting), SramEccSetting(SramEccSetting),
773 IsAMDHSA(TT.getOS() == Triple::AMDHSA) {}
774
775// Parse a feature modifier sign ("+"/"-"). Returns "Unsupported" if \p Sign is
776// neither (i.e. the modifier is malformed).
778 if (Sign == "+")
779 return TargetIDSetting::On;
780 if (Sign == "-")
781 return TargetIDSetting::Off;
782
783 return TargetIDSetting::Unsupported;
784}
785
786// Derive the architecture from the processor name in \p TargetIDStr. "generic"
787// and the empty processor name act as a wildcard.
788static GPUKind getGPUKindFromTargetID(const Triple &TT, StringRef TargetIDStr) {
789 StringRef CPUName = TargetIDStr.split(':').first;
790 return (CPUName.empty() || CPUName == "generic")
791 ? getGPUKindFromSubArch(TT.getSubArch())
792 : parseArchAMDGCN(CPUName);
793}
794
795// Compute the default xnack/sramecc settings for processor \p Arch, before any
796// explicit feature modifiers are applied.
798 TargetIDSetting &XnackSetting,
799 TargetIDSetting &SramEccSetting) {
800 const AMDGPUFeatureBitset &Features = getFeatureBitset(Arch);
801 // Features with on/off modes default to Any; supported without on/off modes
802 // is hardwired On; unsupported is Unsupported.
803 if (!Features.test(FEAT_XNACK_SUPPORT))
804 XnackSetting = TargetIDSetting::Unsupported;
805 else if (Features.test(FEAT_XNACK_ON_OFF_MODES))
806 XnackSetting = TargetIDSetting::Any;
807 else
808 XnackSetting = TargetIDSetting::On;
809 if (!Features.test(FEAT_SRAMECC_SUPPORT))
810 SramEccSetting = TargetIDSetting::Unsupported;
811 else if (Features.test(FEAT_SRAMECC_ON_OFF_MODES))
812 SramEccSetting = TargetIDSetting::Any;
813 else
814 SramEccSetting = TargetIDSetting::On;
815}
816
817// Compute the xnack/sramecc settings for processor \p Arch from the
818// processor+features string \p TargetIDStr
819// (e.g. "gfx90a:xnack+:sramecc-"). Returns false if a modifier names an unknown
820// or repeated feature, names one the processor does not support, or has a
821// malformed sign.
822static bool computeTargetIDFeatures(GPUKind Arch, StringRef TargetIDStr,
823 TargetIDSetting &XnackSetting,
824 TargetIDSetting &SramEccSetting) {
825 const AMDGPUFeatureBitset &Features = getFeatureBitset(Arch);
826 getDefaultTargetIDFeatures(Arch, XnackSetting, SramEccSetting);
827
828 // The first component is the processor; the rest are feature modifiers of the
829 // form "<feature><+|->".
831 TargetIDStr.split(Split, ':');
832 bool SeenXnack = false;
833 bool SeenSramEcc = false;
834 bool Valid = true;
835 for (unsigned I = 1, E = Split.size(); I != E; ++I) {
836 StringRef FeatureString = Split[I];
837 if (FeatureString.consume_front("xnack")) {
839 // An xnack modifier is only valid with on/off modes: rejected when xnack
840 // is unsupported or hardwired on (e.g. gfx1250).
841 if (SeenXnack || !Features.test(FEAT_XNACK_ON_OFF_MODES) ||
842 Sign == TargetIDSetting::Unsupported)
843 Valid = false;
844 else
845 XnackSetting = Sign;
846 SeenXnack = true;
847 } else if (FeatureString.consume_front("sramecc")) {
849 if (SeenSramEcc || !Features.test(FEAT_SRAMECC_ON_OFF_MODES) ||
850 Sign == TargetIDSetting::Unsupported)
851 Valid = false;
852 else
853 SramEccSetting = Sign;
854 SeenSramEcc = true;
855 } else {
856 // Unknown feature name.
857 Valid = false;
858 }
859 }
860 return Valid;
861}
862
863TargetID::TargetID(const Triple &TT, StringRef TargetIDStr)
864 : TargetID(getGPUKindFromTargetID(TT, TargetIDStr), TT,
866 // Derive the feature settings from the string. Validity is not checked here;
867 // parseTargetIDString validates untrusted input.
868 computeTargetIDFeatures(Arch, TargetIDStr, XnackSetting, SramEccSetting);
869}
870
872 StringRef FeatureString) {
873 GPUKind Arch = parseArchAMDGCN(CPU);
874 TargetIDSetting XnackSetting, SramEccSetting;
875 getDefaultTargetIDFeatures(Arch, XnackSetting, SramEccSetting);
876
877 // Apply the +/-xnack and +/-sramecc modifiers from the feature string, only
878 // for targets that can toggle the corresponding mode.
879 bool XnackToggleable = XnackSetting == TargetIDSetting::Any;
880 bool SramEccToggleable = SramEccSetting == TargetIDSetting::Any;
882 FeatureString.split(Features, ',', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
883 for (StringRef Feature : Features) {
885 getTargetIDSettingFromFeatureString(Feature.take_front());
886 if (Sign == TargetIDSetting::Unsupported)
887 continue;
888 StringRef Name = Feature.drop_front();
889 if (Name == "xnack" && XnackToggleable)
890 XnackSetting = Sign;
891 else if (Name == "sramecc" && SramEccToggleable)
892 SramEccSetting = Sign;
893 }
894
895 return TargetID(Arch, TT, XnackSetting, SramEccSetting);
896}
897
898std::optional<TargetID> TargetID::parse(const Triple &TT,
899 StringRef ProcAndFeatures) {
900 if (!TT.isAMDGCN())
901 return std::nullopt;
902
903 // Filter out unrecognized subarch suffixes.
904 if (TT.getSubArch() == Triple::NoSubArch && TT.getArchName() != "amdgcn")
905 return std::nullopt;
906
907 // A named processor (i.e. not the empty/generic wildcard, which is resolved
908 // from the triple's subarch) must be a recognized GPU that is consistent with
909 // the triple's subarch.
910 StringRef CPUName = ProcAndFeatures.split(':').first;
911 if (!CPUName.empty() && CPUName != "generic" &&
912 !isCPUValidForSubArch(TT.getSubArch(), CPUName))
913 return std::nullopt;
914
915 // Parse the processor and its feature modifiers, then construct directly from
916 // the resulting fields.
917 GPUKind Arch = getGPUKindFromTargetID(TT, ProcAndFeatures);
918 TargetIDSetting XnackSetting, SramEccSetting;
919 if (!computeTargetIDFeatures(Arch, ProcAndFeatures, XnackSetting,
920 SramEccSetting))
921 return std::nullopt;
922
923 return TargetID(Arch, TT, XnackSetting, SramEccSetting);
924}
925
926std::optional<TargetID>
928 // Split on '-' to get arch-vendor-os-environment-processor:features. There is
929 // a single dash separator after the 4-component triple, so the
930 // processor+features field must be present (even if empty).
932 TargetIDDirective.split(Parts, '-', /*MaxSplit=*/4);
933 if (Parts.size() < 5)
934 return std::nullopt;
935
936 return parse(Triple(Parts[0], Parts[1], Parts[2], Parts[3]), Parts[4]);
937}
938
939// Returns true if \p Arch hardwires xnack on (supports xnack but has no on/off
940// modes, e.g. gfx1250), so xnack is not a selectable target-id modifier.
941static bool isXnackHardwiredOn(GPUKind Arch) {
942 const AMDGPUFeatureBitset &Features = getFeatureBitset(Arch);
943 return Features.test(FEAT_XNACK_SUPPORT) &&
944 !Features.test(FEAT_XNACK_ON_OFF_MODES);
945}
946
947static bool isSramEccHardwiredOn(GPUKind Arch) {
948 const AMDGPUFeatureBitset &Features = getFeatureBitset(Arch);
949 return Features.test(FEAT_SRAMECC_SUPPORT) &&
950 !Features.test(FEAT_SRAMECC_ON_OFF_MODES);
951}
952
953// Append the explicit (On/Off) sramecc/xnack feature modifiers in canonical
954// order, e.g. ":sramecc-:xnack+". Hardwired-on features are never emitted.
956 TargetIDSetting Xnack,
957 bool SramEccHardwiredOn,
958 bool XnackHardwiredOn) {
959 if (!SramEccHardwiredOn) {
960 if (SramEcc == TargetIDSetting::Off)
961 OS << ":sramecc-";
962 else if (SramEcc == TargetIDSetting::On)
963 OS << ":sramecc+";
964 }
965
966 if (XnackHardwiredOn)
967 return;
968
969 if (Xnack == TargetIDSetting::Off)
970 OS << ":xnack-";
971 else if (Xnack == TargetIDSetting::On)
972 OS << ":xnack+";
973}
974
975void TargetID::print(raw_ostream &StreamRep) const {
976 StreamRep << TargetTripleString << '-' << getArchNameAMDGCN(Arch);
977
978 if (IsAMDHSA) {
981 }
982}
983
984std::string TargetID::toString() const {
985 std::string Str;
986 raw_string_ostream OS(Str);
987 OS << *this;
988 return Str;
989}
990
996
998 std::string Str;
999 raw_string_ostream OS(Str);
1001 return Str;
1002}
1003
1005 return Arch == Other.Arch && XnackSetting == Other.XnackSetting &&
1006 SramEccSetting == Other.SramEccSetting && IsAMDHSA == Other.IsAMDHSA &&
1007 TargetTripleString == Other.TargetTripleString;
1008}
1009
1011 TargetIDSetting Requested) {
1012 return Provided == TargetIDSetting::Any ||
1013 Provided == TargetIDSetting::Unsupported || Provided == Requested;
1014}
1015
1017 // The processor and feature settings must match exactly
1018 if (Arch != Other.Arch || XnackSetting != Other.XnackSetting ||
1019 SramEccSetting != Other.SramEccSetting)
1020 return false;
1021
1023 .isCompatibleWith(Triple(Other.getTargetTripleString()));
1024}
1025
1027 // A major-family/generic processor (e.g. amdgpu9) provides for a specific
1028 // member of its family (e.g. gfx900), but not the reverse. Otherwise the
1029 // processors must match.
1030 if (Arch != Other.Arch && Arch != GK_NONE && Other.Arch != GK_NONE) {
1031 Triple::SubArchType ThisSubArch = getSubArch(Arch);
1032 if (ThisSubArch != getMajorSubArch(ThisSubArch) ||
1033 ThisSubArch != getMajorSubArch(getSubArch(Other.Arch)))
1034 return false;
1035 }
1036
1037 if (!featureProvidesFor(XnackSetting, Other.XnackSetting) ||
1038 !featureProvidesFor(SramEccSetting, Other.SramEccSetting))
1039 return false;
1040
1042 .isCompatibleWith(Triple(Other.getTargetTripleString()));
1043}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GPUKind getGPUKindFromTargetID(const Triple &TT, StringRef TargetIDStr)
static std::pair< FeatureError, StringRef > fillAMDGCNFeatureMap(StringRef GPU, const Triple &T, StringMap< bool > &Features)
Add a GPU's default features to Features (preserving user overrides) and validate any requested waves...
static bool computeTargetIDFeatures(GPUKind Arch, StringRef TargetIDStr, TargetIDSetting &XnackSetting, TargetIDSetting &SramEccSetting)
static bool isSramEccHardwiredOn(GPUKind Arch)
static void getDefaultTargetIDFeatures(GPUKind Arch, TargetIDSetting &XnackSetting, TargetIDSetting &SramEccSetting)
static TargetIDSetting getTargetIDSettingFromFeatureString(StringRef Sign)
static bool featureProvidesFor(TargetIDSetting Provided, TargetIDSetting Requested)
static bool isXnackHardwiredOn(GPUKind Arch)
static void addGPUFeatures(const GPUInfo &Info, bool Overwrite, StringMap< bool > &Features)
static void printFeatureModifiers(raw_ostream &OS, TargetIDSetting SramEcc, TargetIDSetting Xnack, bool SramEccHardwiredOn, bool XnackHardwiredOn)
static const AMDGPUFeatureBitset FrontendOnlyFeatures
#define X(NUM, ENUM, NAME)
Definition ELF.h:665
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define I(x, y, z)
Definition MD5.cpp:57
#define G(x, y, z)
Definition MD5.cpp:55
#define T
modulo schedule test
This file defines the SmallVector class.
LocallyHashedType DenseMapInfo< LocallyHashedType >::Empty
static TargetID createFromSubtargetFeatures(const Triple &TT, StringRef CPU, StringRef FeatureString)
Construct a TargetID for triple TT and processor CPU, taking the xnack/sramecc modes from the subtarg...
void printCanonicalTargetIDString(raw_ostream &OS) const
Print the canonical processor name followed by any explicit xnack and sramecc feature modifiers (e....
static std::optional< TargetID > parseTargetIDString(StringRef TargetIDDirective)
Parse and validate a TargetID from a full "<triple>-<processor>:<features>" directive string.
void print(raw_ostream &OS) const
TargetIDSetting getXnackSetting() const
bool isEquivalent(const TargetID &Other) const
Returns true if Other denotes the same target as *this, i.e.
bool operator==(const TargetID &Other) const
bool providesFor(const TargetID &Other) const
Returns true if a device image for *this can provide the device code for a request for Other.
StringRef getTargetTripleString() const
std::string getCanonicalFeatureString() const
TargetID(GPUKind Arch, const Triple &TT, TargetIDSetting XnackSetting, TargetIDSetting SramEccSetting)
static std::optional< TargetID > parse(const Triple &TT, StringRef ProcAndFeatures)
Parse and validate a TargetID for triple TT from the processor+features string ProcAndFeatures (e....
std::string toString() const
TargetIDSetting getSramEccSetting() const
constexpr bool none() const
Definition Bitset.h:120
constexpr bool test(unsigned I) const
Definition Bitset.h:109
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:129
iterator end()
Definition StringMap.h:214
iterator find(StringRef Key)
Definition StringMap.h:227
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition StringMap.h:311
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:736
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:661
A table of densely packed, null-terminated strings indexed by offset.
Definition StringTable.h:34
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
@ FirstAMDGPUSubArch
Definition Triple.h:281
@ LastAMDGPUSubArch
Definition Triple.h:282
LLVM_ABI bool isCompatibleWith(const Triple &Other) const
Test whether target triples are compatible.
Definition Triple.cpp:2294
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI StringRef getArchNameR600(GPUKind AK)
LLVM_ABI void fillValidArchListAMDGCN(SmallVectorImpl< StringRef > &Values, Triple::SubArchType SubArch=Triple::NoSubArch)
Append the valid AMDGCN GPU names to Values.
LLVM_ABI unsigned getLDSEncodingGranule(GPUKind AK)
LLVM_ABI unsigned getLDSAllocGranule(GPUKind AK)
LLVM_ABI unsigned getMaxWavesPerEU(GPUKind AK)
LLVM_ABI StringRef getCanonicalArchName(const Triple &T, StringRef Arch)
LLVM_ABI unsigned getAddressableLocalMemorySize(GPUKind AK, bool FullSIMDMode)
LLVM_ABI void fillValidArchListR600(SmallVectorImpl< StringRef > &Values)
LLVM_ABI std::string mergeSubArch(const Triple &A, const Triple &B)
Returns the effective triple appropriate to use when linking B into A by merging the subarches in cas...
LLVM_ABI bool isCPUValidForSubArch(Triple::SubArchType SubArch, GPUKind AK)
Return true if the GPU AK is usable with the triple subarch SubArch.
LLVM_ABI bool isSubArchCompatible(const Triple &A, const Triple &B)
Return true if subarch A is compatible with subarch B, i.e.
LLVM_ABI unsigned getLDSBankCount(GPUKind AK)
LLVM_ABI unsigned getMaxHWAddressableLocalMemorySize(GPUKind AK)
LDS size queries.
LLVM_ABI StringRef getArchFamilyNameAMDGCN(GPUKind AK)
LLVM_ABI StringRef getSubArchName(Triple::SubArchType SubArch)
Returns the triple subarch name for an AMDGPU subarch, e.g.
LLVM_ABI unsigned getAddressableNumSGPRs(GPUKind AK)
LLVM_ABI IsaVersion getIsaVersion(StringRef GPU)
LLVM_ABI unsigned getTotalNumVGPRs(GPUKind AK, bool IsWave32)
LLVM_ABI unsigned getTotalNumSGPRs(GPUKind AK)
LLVM_ABI std::optional< unsigned > getBufferResourceNumRecordsWidth(GPUKind AK)
GPUKind
GPU kinds supported by the AMDGPU target.
Bitset< NUM_FEATURES > AMDGPUFeatureBitset
LLVM_ABI Triple::SubArchType getSubArchFromGPUName(StringRef CPU)
Returns the preferred subarch for a GPU name CPU, or NoSubArch if unrecognized.
LLVM_ABI unsigned getLocalMemorySize(GPUKind AK, bool FullSIMDMode)
LLVM_ABI unsigned getSGPRAllocGranule(GPUKind AK)
LLVM_ABI Triple::SubArchType getSubArch(GPUKind AK)
LLVM_ABI StringRef getArchNameFromSubArch(Triple::SubArchType SubArch)
Returns the canonical GPU name for an AMDGPU subarch, e.g.
LLVM_ABI unsigned getVGPRAllocGranule(GPUKind AK, bool IsWave32)
LLVM_ABI GPUKind parseArchAMDGCN(StringRef CPU)
LLVM_ABI bool isPseudoTarget(GPUKind AK)
Return true if AK is a pseudo target (e.g.
LLVM_ABI GPUKind getGPUKindFromSubArch(Triple::SubArchType SubArch)
AMDGPU::TargetID TargetID
LLVM_ABI std::pair< FeatureError, StringRef > fillAMDGPUFeatureMap(StringRef GPU, const Triple &T, StringMap< bool > &Features)
Fills Features map with default values for given target GPU.
LLVM_ABI unsigned getAddressableNumVGPRs(GPUKind AK, bool IsWave32)
LLVM_ABI void getFeatureNames(const AMDGPUFeatureBitset &Features, SmallVectorImpl< StringRef > &Names)
Appends the feature name of each bit set in Features to Names.
LLVM_ABI StringRef getArchNameAMDGCN(GPUKind AK)
LLVM_ABI Triple::SubArchType getMajorSubArch(Triple::SubArchType SubArch)
LLVM_ABI const AMDGPUFeatureBitset & getFeatureBitset(GPUKind AK)
Returns AK's feature bitset, or an empty bitset if unknown.
LLVM_ABI const R600FeatureBitset & getFeatureBitsetR600(GPUKind AK)
Returns R600 GPU AK's feature bitset, or an empty bitset if unknown.
Bitset< R600_NUM_FEATURES > R600FeatureBitset
LLVM_ABI GPUKind parseArchR600(StringRef CPU)
This is an optimization pass for GlobalISel generic memory operations.
RelativeUniformCounterPtr Values
Definition InstrProf.h:91
#define N
Instruction set architecture version.