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
13#include "llvm/TargetParser/AMDGPUTargetParser.h"
14#include "llvm/ADT/SmallVector.h"
15#include "llvm/ADT/StringTable.h"
16#include "llvm/ADT/Twine.h"
17#include "llvm/Support/raw_ostream.h"
18#include "llvm/TargetParser/Triple.h"
19#include <algorithm>
20#include <array>
21#include <cassert>
22
23using namespace llvm;
24using namespace AMDGPU;
25
26namespace {
27constexpr unsigned NumAMDGPUSubArches =
28 Triple::LastAMDGPUSubArch - Triple::FirstAMDGPUSubArch + 1;
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) {
121 Map[SubArch - Triple::FirstAMDGPUSubArch] =
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] =
135 static_cast<Triple::SubArchType>(Triple::FirstAMDGPUSubArch + 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
165StringRef llvm::AMDGPU::getArchFamilyNameAMDGCN(GPUKind AK) {
166 const GPUInfo *Info = getAMDGPUInfo(AK);
167 return Info ? AMDGPUNameStrTab[Info->FamilyName] : "";
168}
169
170Triple::SubArchType llvm::AMDGPU::getSubArch(GPUKind AK) {
171 const GPUInfo *Info = getAMDGPUInfo(AK);
172 return Info ? Info->SubArch : Triple::SubArchType::NoSubArch;
173}
174
175Triple::SubArchType llvm::AMDGPU::getSubArchFromGPUName(StringRef CPU) {
176 return getSubArch(AK: parseArchAMDGCN(CPU));
177}
178
179AMDGPU::GPUKind
180llvm::AMDGPU::getGPUKindFromSubArch(Triple::SubArchType SubArch) {
181 if (SubArch < Triple::FirstAMDGPUSubArch ||
182 SubArch > Triple::LastAMDGPUSubArch)
183 return GK_NONE;
184 return AMDGPUSubArchToGPUKind[SubArch - Triple::FirstAMDGPUSubArch];
185}
186
187Triple::SubArchType AMDGPU::getMajorSubArch(Triple::SubArchType X) {
188 if (X < Triple::FirstAMDGPUSubArch || X > Triple::LastAMDGPUSubArch)
189 return Triple::NoSubArch;
190 return AMDGPUMajorFamilies[X - Triple::FirstAMDGPUSubArch];
191}
192
193bool AMDGPU::isSubArchCompatible(Triple::SubArchType A, Triple::SubArchType B) {
194 if (A == B || A == Triple::NoSubArch || B == Triple::NoSubArch)
195 return true;
196
197 Triple::SubArchType MajorA = AMDGPU::getMajorSubArch(X: A);
198 Triple::SubArchType MajorB = AMDGPU::getMajorSubArch(X: B);
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
209bool AMDGPU::isCPUValidForSubArch(Triple::SubArchType SubArch, GPUKind AK) {
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(A: GPUSubArch, B: SubArch);
223}
224
225bool AMDGPU::isCPUValidForSubArch(Triple::SubArchType SubArch, StringRef CPU) {
226 return isCPUValidForSubArch(SubArch, AK: parseArchAMDGCN(CPU));
227}
228
229bool AMDGPU::isPseudoTarget(GPUKind AK) {
230 const GPUInfo *Info = getAMDGPUInfo(AK);
231 return Info && Info->SubArch == Triple::NoSubArch;
232}
233
234bool AMDGPU::isPseudoTarget(StringRef CPU) {
235 return isPseudoTarget(AK: parseArchAMDGCN(CPU));
236}
237
238bool AMDGPU::isSubArchCompatible(const Triple &A, const Triple &B) {
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: A.getSubArch(), B: 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(X: A.getSubArch());
259 Triple::SubArchType MajorB = AMDGPU::getMajorSubArch(X: 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
276StringRef llvm::AMDGPU::getArchNameAMDGCN(GPUKind AK) {
277 const GPUInfo *Info = getAMDGPUInfo(AK);
278 return Info ? AMDGPUNameStrTab[Info->Name] : "";
279}
280
281StringRef llvm::AMDGPU::getArchNameFromSubArch(Triple::SubArchType SubArch) {
282 if (SubArch < Triple::FirstAMDGPUSubArch ||
283 SubArch > Triple::LastAMDGPUSubArch)
284 return "";
285 return AMDGPUNameStrTab[AMDGPUSubArchNameOffsets[SubArch -
286 Triple::FirstAMDGPUSubArch]];
287}
288
289StringRef llvm::AMDGPU::getSubArchName(Triple::SubArchType SubArch) {
290 if (SubArch == Triple::NoSubArch)
291 return AMDGPUNameStrTab[AMDGPUNoSubArchNameOffset];
292
293 assert(SubArch >= Triple::FirstAMDGPUSubArch &&
294 SubArch <= Triple::LastAMDGPUSubArch &&
295 "expected an AMDGPU subarch or NoSubArch");
296 return AMDGPUNameStrTab
297 [AMDGPUSubArchTripleNameOffsets[SubArch - Triple::FirstAMDGPUSubArch]];
298}
299
300StringRef llvm::AMDGPU::getArchNameR600(GPUKind AK) {
301 const R600Info *Info = getR600Info(AK);
302 return Info ? R600NameStrTab[Info->Name] : "";
303}
304
305AMDGPU::GPUKind llvm::AMDGPU::parseArchAMDGCN(StringRef CPU) {
306 return parseArchImpl(CPU, Table: AMDGPUGPUTable, FirstKind: AMDGPUFirstGPUKind,
307 StrTab: AMDGPUNameStrTab, Aliases: AMDGPUGPUAliases);
308}
309
310AMDGPU::GPUKind llvm::AMDGPU::parseArchR600(StringRef CPU) {
311 return parseArchImpl(CPU, Table: R600GPUTable, FirstKind: R600FirstGPUKind, StrTab: R600NameStrTab,
312 Aliases: R600GPUAliases);
313}
314
315const AMDGPUFeatureBitset &AMDGPU::getFeatureBitset(GPUKind AK) {
316 static constexpr AMDGPUFeatureBitset Empty{};
317 const GPUInfo *Info = getAMDGPUInfo(AK);
318 return Info ? Info->Features : Empty;
319}
320
321const AMDGPUFeatureBitset &
322AMDGPU::getFeatureBitset(Triple::SubArchType SubArch) {
323 return getFeatureBitset(AK: getGPUKindFromSubArch(SubArch));
324}
325
326const R600FeatureBitset &AMDGPU::getFeatureBitsetR600(GPUKind AK) {
327 static constexpr R600FeatureBitset Empty{};
328 const R600Info *Info = getR600Info(AK);
329 return Info ? Info->Features : Empty;
330}
331
332void AMDGPU::getFeatureNames(const AMDGPUFeatureBitset &Features,
333 SmallVectorImpl<StringRef> &Names) {
334 for (unsigned I = 0; I != NUM_FEATURES; ++I) {
335 if (Features.test(I))
336 Names.push_back(Elt: AMDGPUNameStrTab[AMDGPUFeatureNames[I]]);
337 }
338}
339
340void AMDGPU::fillValidArchListAMDGCN(SmallVectorImpl<StringRef> &Values,
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, AK: Kind))
348 Values.push_back(Elt: AMDGPUNameStrTab[AMDGPUGPUTable[I].Name]);
349 }
350
351 for (const GPUNameAlias &A : AMDGPUGPUAliases) {
352 if (isCPUValidForSubArch(SubArch, AK: A.Kind))
353 Values.push_back(Elt: AMDGPUNameStrTab[A.AltName]);
354 }
355}
356
357void AMDGPU::fillValidArchListR600(SmallVectorImpl<StringRef> &Values) {
358 for (const R600Info &Info : R600GPUTable)
359 Values.push_back(Elt: R600NameStrTab[Info.Name]);
360 for (const GPUNameAlias &A : R600GPUAliases)
361 Values.push_back(Elt: R600NameStrTab[A.AltName]);
362}
363
364AMDGPU::IsaVersion AMDGPU::getIsaVersion(StringRef GPU) {
365 const GPUInfo *Info = getAMDGPUInfo(AK: parseArchAMDGCN(CPU: GPU));
366 return Info ? Info->Version : IsaVersion{.Major: 0, .Minor: 0, .Stepping: 0};
367}
368
369AMDGPU::IsaVersion AMDGPU::getIsaVersion(Triple::SubArchType SubArch) {
370 const GPUInfo *Info = getAMDGPUInfo(AK: getGPUKindFromSubArch(SubArch));
371 return Info ? Info->Version : IsaVersion{.Major: 0, .Minor: 0, .Stepping: 0};
372}
373
374unsigned AMDGPU::getTotalNumSGPRs(GPUKind AK) {
375 IsaVersion Version = getIsaVersion(SubArch: getSubArch(AK));
376 if (Version.Major >= 8)
377 return 800;
378 return 512;
379}
380
381unsigned AMDGPU::getTotalNumSGPRs(Triple::SubArchType SubArch) {
382 IsaVersion Version = getIsaVersion(SubArch);
383 if (Version.Major >= 8)
384 return 800;
385 return 512;
386}
387
388unsigned AMDGPU::getAddressableNumSGPRs(GPUKind AK) {
389 if (getFeatureBitset(AK).test(I: FEAT_SGPR_INIT_BUG))
390 return FIXED_NUM_SGPRS_FOR_INIT_BUG;
391
392 IsaVersion Version = getIsaVersion(SubArch: getSubArch(AK));
393 if (Version.Major >= 10)
394 return 106;
395 if (Version.Major >= 8)
396 return 102;
397 return 104;
398}
399
400unsigned AMDGPU::getAddressableNumSGPRs(Triple::SubArchType SubArch) {
401 if (getFeatureBitset(AK: getGPUKindFromSubArch(SubArch)).test(I: FEAT_SGPR_INIT_BUG))
402 return FIXED_NUM_SGPRS_FOR_INIT_BUG;
403
404 IsaVersion Version = getIsaVersion(SubArch);
405 if (Version.Major >= 10)
406 return 106;
407 if (Version.Major >= 8)
408 return 102;
409 return 104;
410}
411
412unsigned AMDGPU::getSGPRAllocGranule(GPUKind AK) {
413 IsaVersion Version = getIsaVersion(SubArch: getSubArch(AK));
414 if (Version.Major >= 10)
415 return getAddressableNumSGPRs(AK);
416 if (Version.Major >= 8)
417 return 16;
418 return 8;
419}
420
421unsigned AMDGPU::getSGPRAllocGranule(Triple::SubArchType SubArch) {
422 IsaVersion Version = getIsaVersion(SubArch);
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(I: FEAT_GFX90A_INSTS))
433 return 8;
434 if (Features.test(I: FEAT_1536_PHYSICAL_VGPRS))
435 return IsWave32 ? 24 : 12;
436 if (Features.test(I: FEAT_GFX10_3_INSTS))
437 return IsWave32 ? 16 : 8;
438 return IsWave32 ? 8 : 4;
439}
440
441unsigned AMDGPU::getVGPRAllocGranule(Triple::SubArchType SubArch,
442 bool IsWave32) {
443 return getVGPRAllocGranule(AK: getGPUKindFromSubArch(SubArch), IsWave32);
444}
445
446unsigned AMDGPU::getTotalNumVGPRs(GPUKind AK, bool IsWave32) {
447 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
448 if (Features.test(I: FEAT_GFX90A_INSTS))
449 return 512;
450 if (!Features.test(I: FEAT_GFX10_INSTS))
451 return 256;
452 if (Features.test(I: 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(AK: 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(I: 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(I: FEAT_VGPR_MSBS))
472 Bits += MSBBits;
473 return std::min(a: 1u << Bits, b: getTotalNumVGPRs(AK, IsWave32));
474}
475
476unsigned AMDGPU::getAddressableNumVGPRs(Triple::SubArchType SubArch,
477 bool IsWave32) {
478 return getAddressableNumVGPRs(AK: getGPUKindFromSubArch(SubArch), IsWave32);
479}
480
481unsigned AMDGPU::getMaxHWAddressableLocalMemorySize(GPUKind AK) {
482 const GPUInfo *Info = getAMDGPUInfo(AK);
483 return Info ? Info->MaxHWAddressableLocalMemorySize : 32768;
484}
485
486unsigned
487AMDGPU::getMaxHWAddressableLocalMemorySize(Triple::SubArchType SubArch) {
488 return getMaxHWAddressableLocalMemorySize(AK: getGPUKindFromSubArch(SubArch));
489}
490
491unsigned AMDGPU::getLocalMemorySize(GPUKind AK, bool FullSIMDMode) {
492 // gfx6 and gfx10/11/12 address half of the physical block.
493 unsigned Size = getMaxHWAddressableLocalMemorySize(AK);
494 if (getFeatureBitset(AK).test(I: 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
504unsigned AMDGPU::getLocalMemorySize(Triple::SubArchType SubArch,
505 bool FullSIMDMode) {
506 return getLocalMemorySize(AK: getGPUKindFromSubArch(SubArch), FullSIMDMode);
507}
508
509unsigned AMDGPU::getAddressableLocalMemorySize(GPUKind AK, bool FullSIMDMode) {
510 return std::min(a: getMaxHWAddressableLocalMemorySize(AK),
511 b: getLocalMemorySize(AK, FullSIMDMode));
512}
513
514unsigned AMDGPU::getAddressableLocalMemorySize(Triple::SubArchType SubArch,
515 bool FullSIMDMode) {
516 return getAddressableLocalMemorySize(AK: getGPUKindFromSubArch(SubArch),
517 FullSIMDMode);
518}
519
520unsigned AMDGPU::getLDSBankCount(GPUKind AK) {
521 const GPUInfo *Info = getAMDGPUInfo(AK);
522 return Info ? Info->LDSBankCount : 32;
523}
524
525unsigned AMDGPU::getLDSBankCount(Triple::SubArchType SubArch) {
526 return getLDSBankCount(AK: getGPUKindFromSubArch(SubArch));
527}
528
529std::optional<unsigned> AMDGPU::getBufferResourceNumRecordsWidth(GPUKind AK) {
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>
537AMDGPU::getBufferResourceNumRecordsWidth(Triple::SubArchType SubArch) {
538 return getBufferResourceNumRecordsWidth(AK: getGPUKindFromSubArch(SubArch));
539}
540
541unsigned AMDGPU::getLDSAllocGranule(GPUKind AK) {
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(I: FEAT_LDS_ALLOC_GRANULARITY_256))
552 return 256;
553 if (Features.test(I: FEAT_LDS_ALLOC_GRANULARITY_512))
554 return 512;
555 if (Features.test(I: FEAT_LDS_ALLOC_GRANULARITY_1024))
556 return 1024;
557 if (Features.test(I: FEAT_LDS_ALLOC_GRANULARITY_1280))
558 return 1280;
559 if (Features.test(I: FEAT_LDS_ALLOC_GRANULARITY_2048))
560 return 2048;
561
562 return 256;
563}
564
565unsigned AMDGPU::getLDSAllocGranule(Triple::SubArchType SubArch) {
566 return getLDSAllocGranule(AK: getGPUKindFromSubArch(SubArch));
567}
568
569unsigned AMDGPU::getLDSEncodingGranule(GPUKind AK) {
570 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK);
571 if (Features.test(I: FEAT_LDS_ENCODING_GRANULARITY_256))
572 return 256;
573 if (Features.test(I: FEAT_LDS_ENCODING_GRANULARITY_512))
574 return 512;
575 if (Features.test(I: FEAT_LDS_ENCODING_GRANULARITY_1024))
576 return 1024;
577 if (Features.test(I: FEAT_LDS_ENCODING_GRANULARITY_1280))
578 return 1280;
579 if (Features.test(I: FEAT_LDS_ENCODING_GRANULARITY_2048))
580 return 2048;
581
582 return 0;
583}
584
585unsigned AMDGPU::getLDSEncodingGranule(Triple::SubArchType SubArch) {
586 return getLDSEncodingGranule(AK: getGPUKindFromSubArch(SubArch));
587}
588
589unsigned AMDGPU::getMaxWavesPerEU(GPUKind AK) {
590 const GPUInfo *Info = getAMDGPUInfo(AK);
591 return Info ? Info->MaxWavesPerEU : 10;
592}
593
594unsigned AMDGPU::getMaxWavesPerEU(Triple::SubArchType SubArch) {
595 return getMaxWavesPerEU(AK: getGPUKindFromSubArch(SubArch));
596}
597
598StringRef AMDGPU::getCanonicalArchName(const Triple &T, StringRef Arch) {
599 assert(T.isAMDGPU());
600 auto ProcKind = T.isAMDGCN() ? parseArchAMDGCN(CPU: Arch) : parseArchR600(CPU: Arch);
601 if (ProcKind == GK_NONE)
602 return StringRef();
603
604 return T.isAMDGCN() ? getArchNameAMDGCN(AK: ProcKind) : getArchNameR600(AK: 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.
612static const AMDGPUFeatureBitset FrontendOnlyFeatures = {
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) {
642 SmallVector<StringRef, NUM_FEATURES> Names;
643 getFeatureNames(Features: Info.Features & ~FrontendOnlyFeatures, Names);
644 for (StringRef Name : Names) {
645 if (Overwrite)
646 Features[Name] = true;
647 else
648 Features.insert(KV: {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>
655fillAMDGCNFeatureMap(StringRef GPU, const Triple &T,
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(SubArch: T.getSubArch())
660 : parseArchAMDGCN(CPU: GPU);
661 const GPUInfo *Info = getAMDGPUInfo(AK: 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(I: FEAT_WAVEFRONTSIZE32);
669 const bool TargetHasWave64 =
670 Info && Info->Features.test(I: FEAT_WAVEFRONTSIZE64);
671
672 auto Wave32Itr = Features.find(Key: "wavefrontsize32");
673 auto Wave64Itr = Features.find(Key: "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)
684 return {AMDGPU::INVALID_FEATURE_COMBINATION,
685 "'+wavefrontsize32' and '+wavefrontsize64' are mutually exclusive"};
686 if (DisableWave32 && DisableWave64)
687 return {AMDGPU::INVALID_FEATURE_COMBINATION,
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(KV: {"wavefrontsize32", true});
711
712 // Merge the target defaults, keeping any user -mattr overrides.
713 if (Info)
714 addGPUFeatures(Info: *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>
723AMDGPU::fillAMDGPUFeatureMap(StringRef GPU, const Triple &T,
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.
728 SmallVector<StringRef> GPUs;
729 fillValidArchListAMDGCN(Values&: GPUs);
730 for (StringRef G : GPUs)
731 if (const GPUInfo *Info = getAMDGPUInfo(AK: parseArchAMDGCN(CPU: G)))
732 addGPUFeatures(Info: *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(CPU: 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(Form: 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).
777static TargetIDSetting getTargetIDSettingFromFeatureString(StringRef Sign) {
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(Separator: ':').first;
790 return (CPUName.empty() || CPUName == "generic")
791 ? getGPUKindFromSubArch(SubArch: TT.getSubArch())
792 : parseArchAMDGCN(CPU: CPUName);
793}
794
795// Compute the default xnack/sramecc settings for processor \p Arch, before any
796// explicit feature modifiers are applied.
797static void getDefaultTargetIDFeatures(GPUKind Arch,
798 TargetIDSetting &XnackSetting,
799 TargetIDSetting &SramEccSetting) {
800 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK: 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(I: FEAT_XNACK_SUPPORT))
804 XnackSetting = TargetIDSetting::Unsupported;
805 else if (Features.test(I: FEAT_XNACK_ON_OFF_MODES))
806 XnackSetting = TargetIDSetting::Any;
807 else
808 XnackSetting = TargetIDSetting::On;
809 if (!Features.test(I: FEAT_SRAMECC_SUPPORT))
810 SramEccSetting = TargetIDSetting::Unsupported;
811 else if (Features.test(I: 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(AK: Arch);
826 getDefaultTargetIDFeatures(Arch, XnackSetting, SramEccSetting);
827
828 // The first component is the processor; the rest are feature modifiers of the
829 // form "<feature><+|->".
830 SmallVector<StringRef, 3> Split;
831 TargetIDStr.split(A&: Split, Separator: ':');
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(Prefix: "xnack")) {
838 TargetIDSetting Sign = getTargetIDSettingFromFeatureString(Sign: FeatureString);
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(I: 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(Prefix: "sramecc")) {
848 TargetIDSetting Sign = getTargetIDSettingFromFeatureString(Sign: FeatureString);
849 if (SeenSramEcc || !Features.test(I: 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,
865 TargetIDSetting::Unsupported, TargetIDSetting::Unsupported) {
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
871TargetID TargetID::createFromSubtargetFeatures(const Triple &TT, StringRef CPU,
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;
881 SmallVector<StringRef, 4> Features;
882 FeatureString.split(A&: Features, Separator: ',', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
883 for (StringRef Feature : Features) {
884 TargetIDSetting Sign =
885 getTargetIDSettingFromFeatureString(Sign: 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(Separator: ':').first;
911 if (!CPUName.empty() && CPUName != "generic" &&
912 !isCPUValidForSubArch(SubArch: TT.getSubArch(), CPU: 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, TargetIDStr: ProcAndFeatures);
918 TargetIDSetting XnackSetting, SramEccSetting;
919 if (!computeTargetIDFeatures(Arch, TargetIDStr: ProcAndFeatures, XnackSetting,
920 SramEccSetting))
921 return std::nullopt;
922
923 return TargetID(Arch, TT, XnackSetting, SramEccSetting);
924}
925
926std::optional<TargetID>
927TargetID::parseTargetIDString(StringRef TargetIDDirective) {
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).
931 SmallVector<StringRef, 5> Parts;
932 TargetIDDirective.split(A&: Parts, Separator: '-', /*MaxSplit=*/4);
933 if (Parts.size() < 5)
934 return std::nullopt;
935
936 return parse(TT: Triple(Parts[0], Parts[1], Parts[2], Parts[3]), ProcAndFeatures: 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(AK: Arch);
943 return Features.test(I: FEAT_XNACK_SUPPORT) &&
944 !Features.test(I: FEAT_XNACK_ON_OFF_MODES);
945}
946
947static bool isSramEccHardwiredOn(GPUKind Arch) {
948 const AMDGPUFeatureBitset &Features = getFeatureBitset(AK: Arch);
949 return Features.test(I: FEAT_SRAMECC_SUPPORT) &&
950 !Features.test(I: 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.
955static void printFeatureModifiers(raw_ostream &OS, TargetIDSetting SramEcc,
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(AK: Arch);
977
978 if (IsAMDHSA) {
979 printFeatureModifiers(OS&: StreamRep, SramEcc: getSramEccSetting(), Xnack: getXnackSetting(),
980 SramEccHardwiredOn: isSramEccHardwiredOn(Arch), XnackHardwiredOn: isXnackHardwiredOn(Arch));
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
991void TargetID::printCanonicalTargetIDString(raw_ostream &OS) const {
992 OS << getArchNameAMDGCN(AK: Arch);
993 printFeatureModifiers(OS, SramEcc: getSramEccSetting(), Xnack: getXnackSetting(),
994 SramEccHardwiredOn: isSramEccHardwiredOn(Arch), XnackHardwiredOn: isXnackHardwiredOn(Arch));
995}
996
997std::string TargetID::getCanonicalFeatureString() const {
998 std::string Str;
999 raw_string_ostream OS(Str);
1000 printCanonicalTargetIDString(OS);
1001 return Str;
1002}
1003
1004bool TargetID::operator==(const TargetID &Other) const {
1005 return Arch == Other.Arch && XnackSetting == Other.XnackSetting &&
1006 SramEccSetting == Other.SramEccSetting && IsAMDHSA == Other.IsAMDHSA &&
1007 TargetTripleString == Other.TargetTripleString;
1008}
1009
1010static bool featureProvidesFor(TargetIDSetting Provided,
1011 TargetIDSetting Requested) {
1012 return Provided == TargetIDSetting::Any ||
1013 Provided == TargetIDSetting::Unsupported || Provided == Requested;
1014}
1015
1016bool TargetID::isEquivalent(const TargetID &Other) const {
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
1022 return Triple(getTargetTripleString())
1023 .isCompatibleWith(Other: Triple(Other.getTargetTripleString()));
1024}
1025
1026bool TargetID::providesFor(const TargetID &Other) const {
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(AK: Arch);
1032 if (ThisSubArch != getMajorSubArch(X: ThisSubArch) ||
1033 ThisSubArch != getMajorSubArch(X: getSubArch(AK: Other.Arch)))
1034 return false;
1035 }
1036
1037 if (!featureProvidesFor(Provided: XnackSetting, Requested: Other.XnackSetting) ||
1038 !featureProvidesFor(Provided: SramEccSetting, Requested: Other.SramEccSetting))
1039 return false;
1040
1041 return Triple(getTargetTripleString())
1042 .isCompatibleWith(Other: Triple(Other.getTargetTripleString()));
1043}
1044