1//===-- AMDGPUPALMetadata.cpp - Accumulate and print AMDGPU PAL metadata -===//
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/// \file
10///
11/// This class has methods called by AMDGPUAsmPrinter to accumulate and print
12/// the PAL metadata.
13//
14//===----------------------------------------------------------------------===//
15//
16
17#include "AMDGPUPALMetadata.h"
18#include "AMDGPUPTNote.h"
19#include "SIDefines.h"
20#include "llvm/ADT/Enum.h"
21#include "llvm/BinaryFormat/ELF.h"
22#include "llvm/IR/Constants.h"
23#include "llvm/IR/Module.h"
24#include "llvm/MC/MCExpr.h"
25#include "llvm/Support/AMDGPUMetadata.h"
26#include "llvm/Support/EndianStream.h"
27#include "llvm/Support/VersionTuple.h"
28
29using namespace llvm;
30using namespace llvm::AMDGPU;
31
32// Return the PAL metadata hardware shader stage name.
33static const char *getStageName(CallingConv::ID CC) {
34 switch (CC) {
35 case CallingConv::AMDGPU_PS:
36 return ".ps";
37 case CallingConv::AMDGPU_VS:
38 return ".vs";
39 case CallingConv::AMDGPU_GS:
40 return ".gs";
41 case CallingConv::AMDGPU_ES:
42 return ".es";
43 case CallingConv::AMDGPU_HS:
44 return ".hs";
45 case CallingConv::AMDGPU_LS:
46 return ".ls";
47 case CallingConv::AMDGPU_Gfx:
48 case CallingConv::AMDGPU_Gfx_WholeWave:
49 llvm_unreachable("Callable shader has no hardware stage");
50 default:
51 return ".cs";
52 }
53}
54
55// Read the PAL metadata from IR metadata, where it was put by the frontend.
56void AMDGPUPALMetadata::readFromIR(Module &M) {
57 auto *NamedMD = M.getNamedMetadata(Name: "amdgpu.pal.metadata.msgpack");
58 if (NamedMD && NamedMD->getNumOperands()) {
59 // This is the new msgpack format for metadata. It is a NamedMD containing
60 // an MDTuple containing an MDString containing the msgpack data.
61 BlobType = ELF::NT_AMDGPU_METADATA;
62 auto *MDN = dyn_cast<MDTuple>(Val: NamedMD->getOperand(i: 0));
63 if (MDN && MDN->getNumOperands()) {
64 if (auto *MDS = dyn_cast<MDString>(Val: MDN->getOperand(I: 0)))
65 setFromMsgPackBlob(MDS->getString());
66 }
67 return;
68 }
69 BlobType = ELF::NT_AMD_PAL_METADATA;
70 NamedMD = M.getNamedMetadata(Name: "amdgpu.pal.metadata");
71 if (!NamedMD || !NamedMD->getNumOperands()) {
72 // Emit msgpack metadata by default
73 BlobType = ELF::NT_AMDGPU_METADATA;
74 return;
75 }
76 // This is the old reg=value pair format for metadata. It is a NamedMD
77 // containing an MDTuple containing a number of MDNodes each of which is an
78 // integer value, and each two integer values forms a key=value pair that we
79 // store as Registers[key]=value in the map.
80 auto *Tuple = dyn_cast<MDTuple>(Val: NamedMD->getOperand(i: 0));
81 if (!Tuple)
82 return;
83 for (unsigned I = 0, E = Tuple->getNumOperands() & -2; I != E; I += 2) {
84 auto *Key = mdconst::dyn_extract<ConstantInt>(MD: Tuple->getOperand(I));
85 auto *Val = mdconst::dyn_extract<ConstantInt>(MD: Tuple->getOperand(I: I + 1));
86 if (!Key || !Val)
87 continue;
88 setRegister(Reg: Key->getZExtValue(), Val: Val->getZExtValue());
89 }
90}
91
92// Set PAL metadata from a binary blob from the applicable .note record.
93// Returns false if bad format. Blob must remain valid for the lifetime of the
94// Metadata.
95bool AMDGPUPALMetadata::setFromBlob(unsigned Type, StringRef Blob) {
96 BlobType = Type;
97 if (Type == ELF::NT_AMD_PAL_METADATA)
98 return setFromLegacyBlob(Blob);
99 return setFromMsgPackBlob(Blob);
100}
101
102// Set PAL metadata from legacy (array of key=value pairs) blob.
103bool AMDGPUPALMetadata::setFromLegacyBlob(StringRef Blob) {
104 const auto *Data = reinterpret_cast<const uint32_t *>(Blob.data());
105 for (unsigned I = 0; I != Blob.size() / sizeof(uint32_t) / 2; ++I)
106 setRegister(Reg: Data[I * 2], Val: Data[I * 2 + 1]);
107 return true;
108}
109
110// Set PAL metadata from msgpack blob.
111bool AMDGPUPALMetadata::setFromMsgPackBlob(StringRef Blob) {
112 return MsgPackDoc.readFromBlob(Blob, /*Multi=*/false);
113}
114
115// Given the calling convention, calculate the register number for rsrc1. In
116// principle the register number could change in future hardware, but we know
117// it is the same for gfx6-9 (except that LS and ES don't exist on gfx9), so
118// we can use fixed values.
119static unsigned getRsrc1Reg(CallingConv::ID CC) {
120 switch (CC) {
121 default:
122 return PALMD::R_2E12_COMPUTE_PGM_RSRC1;
123 case CallingConv::AMDGPU_LS:
124 return PALMD::R_2D4A_SPI_SHADER_PGM_RSRC1_LS;
125 case CallingConv::AMDGPU_HS:
126 return PALMD::R_2D0A_SPI_SHADER_PGM_RSRC1_HS;
127 case CallingConv::AMDGPU_ES:
128 return PALMD::R_2CCA_SPI_SHADER_PGM_RSRC1_ES;
129 case CallingConv::AMDGPU_GS:
130 return PALMD::R_2C8A_SPI_SHADER_PGM_RSRC1_GS;
131 case CallingConv::AMDGPU_VS:
132 return PALMD::R_2C4A_SPI_SHADER_PGM_RSRC1_VS;
133 case CallingConv::AMDGPU_PS:
134 return PALMD::R_2C0A_SPI_SHADER_PGM_RSRC1_PS;
135 }
136}
137
138// Calculate the PAL metadata key for *S_SCRATCH_SIZE. It can be used
139// with a constant offset to access any non-register shader-specific PAL
140// metadata key.
141static unsigned getScratchSizeKey(CallingConv::ID CC) {
142 switch (CC) {
143 case CallingConv::AMDGPU_PS:
144 return PALMD::Key::PS_SCRATCH_SIZE;
145 case CallingConv::AMDGPU_VS:
146 return PALMD::Key::VS_SCRATCH_SIZE;
147 case CallingConv::AMDGPU_GS:
148 return PALMD::Key::GS_SCRATCH_SIZE;
149 case CallingConv::AMDGPU_ES:
150 return PALMD::Key::ES_SCRATCH_SIZE;
151 case CallingConv::AMDGPU_HS:
152 return PALMD::Key::HS_SCRATCH_SIZE;
153 case CallingConv::AMDGPU_LS:
154 return PALMD::Key::LS_SCRATCH_SIZE;
155 default:
156 return PALMD::Key::CS_SCRATCH_SIZE;
157 }
158}
159
160// Set the rsrc1 register in the metadata for a particular shader stage.
161// In fact this ORs the value into any previous setting of the register.
162void AMDGPUPALMetadata::setRsrc1(CallingConv::ID CC, unsigned Val) {
163 setRegister(Reg: getRsrc1Reg(CC), Val);
164}
165
166void AMDGPUPALMetadata::setRsrc1(CallingConv::ID CC, const MCExpr *Val,
167 MCContext &Ctx) {
168 setRegister(Reg: getRsrc1Reg(CC), Val, Ctx);
169}
170
171// Set the rsrc2 register in the metadata for a particular shader stage.
172// In fact this ORs the value into any previous setting of the register.
173void AMDGPUPALMetadata::setRsrc2(CallingConv::ID CC, unsigned Val) {
174 setRegister(Reg: getRsrc1Reg(CC) + 1, Val);
175}
176
177void AMDGPUPALMetadata::setRsrc2(CallingConv::ID CC, const MCExpr *Val,
178 MCContext &Ctx) {
179 setRegister(Reg: getRsrc1Reg(CC) + 1, Val, Ctx);
180}
181
182// Set the SPI_PS_INPUT_ENA register in the metadata.
183// In fact this ORs the value into any previous setting of the register.
184void AMDGPUPALMetadata::setSpiPsInputEna(unsigned Val) {
185 setRegister(Reg: PALMD::R_A1B3_SPI_PS_INPUT_ENA, Val);
186}
187
188// Set the SPI_PS_INPUT_ADDR register in the metadata.
189// In fact this ORs the value into any previous setting of the register.
190void AMDGPUPALMetadata::setSpiPsInputAddr(unsigned Val) {
191 setRegister(Reg: PALMD::R_A1B4_SPI_PS_INPUT_ADDR, Val);
192}
193
194// Get a register from the metadata, or 0 if not currently set.
195unsigned AMDGPUPALMetadata::getRegister(unsigned Reg) {
196 auto Regs = getRegisters();
197 auto It = Regs.find(Key: MsgPackDoc.getNode(V: Reg));
198 if (It == Regs.end())
199 return 0;
200 auto N = It->second;
201 if (N.getKind() != msgpack::Type::UInt)
202 return 0;
203 return N.getUInt();
204}
205
206// Set a register in the metadata.
207// In fact this ORs the value into any previous setting of the register.
208void AMDGPUPALMetadata::setRegister(unsigned Reg, unsigned Val) {
209 if (!isLegacy()) {
210 // In the new MsgPack format, ignore register numbered >= 0x10000000. It
211 // is a PAL ABI pseudo-register in the old non-MsgPack format.
212 if (Reg >= 0x10000000)
213 return;
214 }
215 auto &N = getRegisters()[MsgPackDoc.getNode(V: Reg)];
216 if (N.getKind() == msgpack::Type::UInt)
217 Val |= N.getUInt();
218 N = N.getDocument()->getNode(V: Val);
219}
220
221// Set a register in the metadata.
222// In fact this ORs the value into any previous setting of the register.
223void AMDGPUPALMetadata::setRegister(unsigned Reg, const MCExpr *Val,
224 MCContext &Ctx) {
225 if (!isLegacy()) {
226 // In the new MsgPack format, ignore register numbered >= 0x10000000. It
227 // is a PAL ABI pseudo-register in the old non-MsgPack format.
228 if (Reg >= 0x10000000)
229 return;
230 }
231 auto &N = getRegisters()[MsgPackDoc.getNode(V: Reg)];
232 auto [ExprIt, Inserted] = REM.try_emplace(Key: Reg);
233
234 if (!Inserted) {
235 Val = MCBinaryExpr::createOr(LHS: Val, RHS: ExprIt->getSecond(), Ctx);
236 // This conditional may be redundant most of the time, but the alternate
237 // setRegister(unsigned, unsigned) could've been called while the
238 // conditional returns true (i.e., Reg exists in REM).
239 if (N.getKind() == msgpack::Type::UInt) {
240 const MCExpr *NExpr = MCConstantExpr::create(Value: N.getUInt(), Ctx);
241 Val = MCBinaryExpr::createOr(LHS: Val, RHS: NExpr, Ctx);
242 }
243 } else if (N.getKind() == msgpack::Type::UInt) {
244 const MCExpr *NExpr = MCConstantExpr::create(Value: N.getUInt(), Ctx);
245 Val = MCBinaryExpr::createOr(LHS: Val, RHS: NExpr, Ctx);
246 } else {
247 // Default to uint64_t 0 so additional calls to setRegister will allow
248 // propagate ORs.
249 N = (uint64_t)0;
250 }
251 ExprIt->second = Val;
252 DelayedExprs.assignDocNode(DN&: N, Type: msgpack::Type::UInt, ExprValue: Val);
253}
254
255// Set the entry point name for one shader.
256void AMDGPUPALMetadata::setEntryPoint(unsigned CC, StringRef Name) {
257 if (isLegacy())
258 return;
259 // Msgpack format.
260 // Entry point is updated to .entry_point_symbol and is set to the function
261 // name
262 getHwStage(CC)[".entry_point_symbol"] =
263 MsgPackDoc.getNode(V: Name, /*Copy=*/true);
264
265 // For PAL version 3.6 and above, entry_point is no longer required.
266 if (getPALVersion() < VersionTuple(3, 6)) {
267 // Set .entry_point which is defined to be _amdgpu_<stage>_main and
268 // _amdgpu_cs_main for non-shader functions.
269 SmallString<16> EPName("_amdgpu_");
270 raw_svector_ostream EPNameOS(EPName);
271 EPNameOS << getStageName(CC) + 1 << "_main";
272 getHwStage(CC)[".entry_point"] =
273 MsgPackDoc.getNode(V: EPNameOS.str(), /*Copy=*/true);
274 }
275}
276
277// Set the number of used vgprs in the metadata. This is an optional
278// advisory record for logging etc; wave dispatch actually uses the rsrc1
279// register for the shader stage to determine the number of vgprs to
280// allocate.
281void AMDGPUPALMetadata::setNumUsedVgprs(CallingConv::ID CC, unsigned Val) {
282 if (isLegacy()) {
283 // Old non-msgpack format.
284 unsigned NumUsedVgprsKey = getScratchSizeKey(CC) +
285 PALMD::Key::VS_NUM_USED_VGPRS -
286 PALMD::Key::VS_SCRATCH_SIZE;
287 setRegister(Reg: NumUsedVgprsKey, Val);
288 return;
289 }
290 // Msgpack format.
291 getHwStage(CC)[".vgpr_count"] = MsgPackDoc.getNode(V: Val);
292}
293
294void AMDGPUPALMetadata::setNumUsedVgprs(CallingConv::ID CC, const MCExpr *Val,
295 MCContext &Ctx) {
296 if (isLegacy()) {
297 // Old non-msgpack format.
298 unsigned NumUsedVgprsKey = getScratchSizeKey(CC) +
299 PALMD::Key::VS_NUM_USED_VGPRS -
300 PALMD::Key::VS_SCRATCH_SIZE;
301 setRegister(Reg: NumUsedVgprsKey, Val, Ctx);
302 return;
303 }
304 // Msgpack format.
305 setHwStage(CC, field: ".vgpr_count", Type: msgpack::Type::UInt, Val);
306}
307
308// Set the number of used agprs in the metadata.
309void AMDGPUPALMetadata::setNumUsedAgprs(CallingConv::ID CC, unsigned Val) {
310 getHwStage(CC)[".agpr_count"] = Val;
311}
312
313void AMDGPUPALMetadata::setNumUsedAgprs(unsigned CC, const MCExpr *Val) {
314 setHwStage(CC, field: ".agpr_count", Type: msgpack::Type::UInt, Val);
315}
316
317// Set the number of used sgprs in the metadata. This is an optional advisory
318// record for logging etc; wave dispatch actually uses the rsrc1 register for
319// the shader stage to determine the number of sgprs to allocate.
320void AMDGPUPALMetadata::setNumUsedSgprs(CallingConv::ID CC, unsigned Val) {
321 if (isLegacy()) {
322 // Old non-msgpack format.
323 unsigned NumUsedSgprsKey = getScratchSizeKey(CC) +
324 PALMD::Key::VS_NUM_USED_SGPRS -
325 PALMD::Key::VS_SCRATCH_SIZE;
326 setRegister(Reg: NumUsedSgprsKey, Val);
327 return;
328 }
329 // Msgpack format.
330 getHwStage(CC)[".sgpr_count"] = MsgPackDoc.getNode(V: Val);
331}
332
333void AMDGPUPALMetadata::setNumUsedSgprs(unsigned CC, const MCExpr *Val,
334 MCContext &Ctx) {
335 if (isLegacy()) {
336 // Old non-msgpack format.
337 unsigned NumUsedSgprsKey = getScratchSizeKey(CC) +
338 PALMD::Key::VS_NUM_USED_SGPRS -
339 PALMD::Key::VS_SCRATCH_SIZE;
340 setRegister(Reg: NumUsedSgprsKey, Val, Ctx);
341 return;
342 }
343 // Msgpack format.
344 setHwStage(CC, field: ".sgpr_count", Type: msgpack::Type::UInt, Val);
345}
346
347// Set the scratch size in the metadata.
348void AMDGPUPALMetadata::setScratchSize(CallingConv::ID CC, unsigned Val) {
349 if (isLegacy()) {
350 // Old non-msgpack format.
351 setRegister(Reg: getScratchSizeKey(CC), Val);
352 return;
353 }
354 // Msgpack format.
355 getHwStage(CC)[".scratch_memory_size"] = MsgPackDoc.getNode(V: Val);
356}
357
358void AMDGPUPALMetadata::setScratchSize(unsigned CC, const MCExpr *Val,
359 MCContext &Ctx) {
360 if (isLegacy()) {
361 // Old non-msgpack format.
362 setRegister(Reg: getScratchSizeKey(CC), Val, Ctx);
363 return;
364 }
365 // Msgpack format.
366 setHwStage(CC, field: ".scratch_memory_size", Type: msgpack::Type::UInt, Val);
367}
368
369void AMDGPUPALMetadata::setBackendStackSize(unsigned CC, const MCExpr *Val) {
370 setHwStage(CC, field: ".backend_stack_size", Type: msgpack::Type::UInt, Val);
371}
372
373void AMDGPUPALMetadata::setFunctionStackFrameSize(StringRef FnName,
374 uint64_t Val) {
375 auto Node = getShaderFunction(Name: FnName);
376 Node[".stack_frame_size_in_bytes"] = MsgPackDoc.getNode(V: Val);
377}
378
379void AMDGPUPALMetadata::setFunctionBackendStackSize(StringRef FnName,
380 const MCExpr *Val) {
381 msgpack::MapDocNode Node = getShaderFunction(Name: FnName);
382 DelayedExprs.assignDocNode(DN&: Node[".backend_stack_size"], Type: msgpack::Type::UInt,
383 ExprValue: Val);
384}
385
386// Set the amount of LDS used in bytes in the metadata.
387void AMDGPUPALMetadata::setFunctionLdsSize(StringRef FnName, unsigned Val) {
388 auto Node = getShaderFunction(Name: FnName);
389 Node[".lds_size"] = MsgPackDoc.getNode(V: Val);
390}
391
392// Set the number of used vgprs in the metadata.
393void AMDGPUPALMetadata::setFunctionNumUsedVgprs(StringRef FnName,
394 unsigned Val) {
395 auto Node = getShaderFunction(Name: FnName);
396 Node[".vgpr_count"] = MsgPackDoc.getNode(V: Val);
397}
398
399void AMDGPUPALMetadata::setFunctionNumUsedVgprs(StringRef FnName,
400 const MCExpr *Val) {
401 auto Node = getShaderFunction(Name: FnName);
402 DelayedExprs.assignDocNode(DN&: Node[".vgpr_count"], Type: msgpack::Type::UInt, ExprValue: Val);
403}
404
405// Set the number of used vgprs in the metadata.
406void AMDGPUPALMetadata::setFunctionNumUsedSgprs(StringRef FnName,
407 unsigned Val) {
408 auto Node = getShaderFunction(Name: FnName);
409 Node[".sgpr_count"] = MsgPackDoc.getNode(V: Val);
410}
411
412void AMDGPUPALMetadata::setFunctionNumUsedSgprs(StringRef FnName,
413 const MCExpr *Val) {
414 auto Node = getShaderFunction(Name: FnName);
415 DelayedExprs.assignDocNode(DN&: Node[".sgpr_count"], Type: msgpack::Type::UInt, ExprValue: Val);
416}
417
418// Set the hardware register bit in PAL metadata to enable wave32 on the
419// shader of the given calling convention.
420void AMDGPUPALMetadata::setWave32(unsigned CC) {
421 switch (CC) {
422 case CallingConv::AMDGPU_HS:
423 setRegister(Reg: PALMD::R_A2D5_VGT_SHADER_STAGES_EN, S_028B54_HS_W32_EN(1));
424 break;
425 case CallingConv::AMDGPU_GS:
426 setRegister(Reg: PALMD::R_A2D5_VGT_SHADER_STAGES_EN, S_028B54_GS_W32_EN(1));
427 break;
428 case CallingConv::AMDGPU_VS:
429 setRegister(Reg: PALMD::R_A2D5_VGT_SHADER_STAGES_EN, S_028B54_VS_W32_EN(1));
430 break;
431 case CallingConv::AMDGPU_PS:
432 setRegister(Reg: PALMD::R_A1B6_SPI_PS_IN_CONTROL, S_0286D8_PS_W32_EN(1));
433 break;
434 case CallingConv::AMDGPU_CS:
435 setRegister(Reg: PALMD::R_2E00_COMPUTE_DISPATCH_INITIATOR,
436 S_00B800_CS_W32_EN(1));
437 break;
438 }
439}
440
441// Convert a register number to name, for display by toString().
442// Returns nullptr if none.
443static StringRef getRegisterName(unsigned RegNum) {
444 // Table of registers.
445 constexpr EnumStringDef<uint16_t> RegInfoTableDefs[] = {
446 // Registers that code generation sets/modifies metadata for.
447 {.Names: {"SPI_SHADER_PGM_RSRC1_VS"}, .Value: PALMD::R_2C4A_SPI_SHADER_PGM_RSRC1_VS},
448 {.Names: {"SPI_SHADER_PGM_RSRC2_VS"}, .Value: PALMD::R_2C4A_SPI_SHADER_PGM_RSRC1_VS + 1},
449 {.Names: {"SPI_SHADER_PGM_RSRC1_LS"}, .Value: PALMD::R_2D4A_SPI_SHADER_PGM_RSRC1_LS},
450 {.Names: {"SPI_SHADER_PGM_RSRC2_LS"}, .Value: PALMD::R_2D4A_SPI_SHADER_PGM_RSRC1_LS + 1},
451 {.Names: {"SPI_SHADER_PGM_RSRC1_HS"}, .Value: PALMD::R_2D0A_SPI_SHADER_PGM_RSRC1_HS},
452 {.Names: {"SPI_SHADER_PGM_RSRC2_HS"}, .Value: PALMD::R_2D0A_SPI_SHADER_PGM_RSRC1_HS + 1},
453 {.Names: {"SPI_SHADER_PGM_RSRC1_ES"}, .Value: PALMD::R_2CCA_SPI_SHADER_PGM_RSRC1_ES},
454 {.Names: {"SPI_SHADER_PGM_RSRC2_ES"}, .Value: PALMD::R_2CCA_SPI_SHADER_PGM_RSRC1_ES + 1},
455 {.Names: {"SPI_SHADER_PGM_RSRC1_GS"}, .Value: PALMD::R_2C8A_SPI_SHADER_PGM_RSRC1_GS},
456 {.Names: {"SPI_SHADER_PGM_RSRC2_GS"}, .Value: PALMD::R_2C8A_SPI_SHADER_PGM_RSRC1_GS + 1},
457 {.Names: {"COMPUTE_DISPATCH_INITIATOR"},
458 .Value: PALMD::R_2E00_COMPUTE_DISPATCH_INITIATOR},
459 {.Names: {"COMPUTE_PGM_RSRC1"}, .Value: PALMD::R_2E12_COMPUTE_PGM_RSRC1},
460 {.Names: {"COMPUTE_PGM_RSRC2"}, .Value: PALMD::R_2E12_COMPUTE_PGM_RSRC1 + 1},
461 {.Names: {"SPI_SHADER_PGM_RSRC1_PS"}, .Value: PALMD::R_2C0A_SPI_SHADER_PGM_RSRC1_PS},
462 {.Names: {"SPI_SHADER_PGM_RSRC2_PS"}, .Value: PALMD::R_2C0A_SPI_SHADER_PGM_RSRC1_PS + 1},
463 {.Names: {"SPI_PS_INPUT_ENA"}, .Value: PALMD::R_A1B3_SPI_PS_INPUT_ENA},
464 {.Names: {"SPI_PS_INPUT_ADDR"}, .Value: PALMD::R_A1B4_SPI_PS_INPUT_ADDR},
465 {.Names: {"SPI_PS_IN_CONTROL"}, .Value: PALMD::R_A1B6_SPI_PS_IN_CONTROL},
466 {.Names: {"VGT_SHADER_STAGES_EN"}, .Value: PALMD::R_A2D5_VGT_SHADER_STAGES_EN},
467
468 // Registers not known to code generation.
469 {.Names: {"SPI_SHADER_PGM_RSRC3_PS"}, .Value: 0x2c07},
470 {.Names: {"SPI_SHADER_PGM_RSRC3_VS"}, .Value: 0x2c46},
471 {.Names: {"SPI_SHADER_PGM_RSRC3_GS"}, .Value: 0x2c87},
472 {.Names: {"SPI_SHADER_PGM_RSRC3_ES"}, .Value: 0x2cc7},
473 {.Names: {"SPI_SHADER_PGM_RSRC3_HS"}, .Value: 0x2d07},
474 {.Names: {"SPI_SHADER_PGM_RSRC3_LS"}, .Value: 0x2d47},
475
476 {.Names: {"SPI_SHADER_POS_FORMAT"}, .Value: 0xa1c3},
477 {.Names: {"SPI_VS_OUT_CONFIG"}, .Value: 0xa1b1},
478 {.Names: {"PA_CL_VS_OUT_CNTL"}, .Value: 0xa207},
479 {.Names: {"PA_CL_CLIP_CNTL"}, .Value: 0xa204},
480 {.Names: {"PA_CL_VTE_CNTL"}, .Value: 0xa206},
481 {.Names: {"PA_SU_VTX_CNTL"}, .Value: 0xa2f9},
482 {.Names: {"PA_SC_MODE_CNTL_1"}, .Value: 0xa293},
483 {.Names: {"VGT_PRIMITIVEID_EN"}, .Value: 0xa2a1},
484 {.Names: {"SPI_SHADER_PGM_RSRC4_GS"}, .Value: 0x2c81},
485 {.Names: {"COMPUTE_TMPRING_SIZE"}, .Value: 0x2e18},
486 {.Names: {"SPI_INTERP_CONTROL_0"}, .Value: 0xa1b5},
487 {.Names: {"SPI_TMPRING_SIZE"}, .Value: 0xa1ba},
488 {.Names: {"SPI_SHADER_Z_FORMAT"}, .Value: 0xa1c4},
489 {.Names: {"SPI_SHADER_COL_FORMAT"}, .Value: 0xa1c5},
490 {.Names: {"DB_SHADER_CONTROL"}, .Value: 0xa203},
491 {.Names: {"CB_SHADER_MASK"}, .Value: 0xa08f},
492 {.Names: {"SPI_PS_INPUT_CNTL_0"}, .Value: 0xa191},
493 {.Names: {"SPI_PS_INPUT_CNTL_1"}, .Value: 0xa192},
494 {.Names: {"SPI_PS_INPUT_CNTL_2"}, .Value: 0xa193},
495 {.Names: {"SPI_PS_INPUT_CNTL_3"}, .Value: 0xa194},
496 {.Names: {"SPI_PS_INPUT_CNTL_4"}, .Value: 0xa195},
497 {.Names: {"SPI_PS_INPUT_CNTL_5"}, .Value: 0xa196},
498 {.Names: {"SPI_PS_INPUT_CNTL_6"}, .Value: 0xa197},
499 {.Names: {"SPI_PS_INPUT_CNTL_7"}, .Value: 0xa198},
500 {.Names: {"SPI_PS_INPUT_CNTL_8"}, .Value: 0xa199},
501 {.Names: {"SPI_PS_INPUT_CNTL_9"}, .Value: 0xa19a},
502 {.Names: {"SPI_PS_INPUT_CNTL_10"}, .Value: 0xa19b},
503 {.Names: {"SPI_PS_INPUT_CNTL_11"}, .Value: 0xa19c},
504 {.Names: {"SPI_PS_INPUT_CNTL_12"}, .Value: 0xa19d},
505 {.Names: {"SPI_PS_INPUT_CNTL_13"}, .Value: 0xa19e},
506 {.Names: {"SPI_PS_INPUT_CNTL_14"}, .Value: 0xa19f},
507 {.Names: {"SPI_PS_INPUT_CNTL_15"}, .Value: 0xa1a0},
508 {.Names: {"SPI_PS_INPUT_CNTL_16"}, .Value: 0xa1a1},
509 {.Names: {"SPI_PS_INPUT_CNTL_17"}, .Value: 0xa1a2},
510 {.Names: {"SPI_PS_INPUT_CNTL_18"}, .Value: 0xa1a3},
511 {.Names: {"SPI_PS_INPUT_CNTL_19"}, .Value: 0xa1a4},
512 {.Names: {"SPI_PS_INPUT_CNTL_20"}, .Value: 0xa1a5},
513 {.Names: {"SPI_PS_INPUT_CNTL_21"}, .Value: 0xa1a6},
514 {.Names: {"SPI_PS_INPUT_CNTL_22"}, .Value: 0xa1a7},
515 {.Names: {"SPI_PS_INPUT_CNTL_23"}, .Value: 0xa1a8},
516 {.Names: {"SPI_PS_INPUT_CNTL_24"}, .Value: 0xa1a9},
517 {.Names: {"SPI_PS_INPUT_CNTL_25"}, .Value: 0xa1aa},
518 {.Names: {"SPI_PS_INPUT_CNTL_26"}, .Value: 0xa1ab},
519 {.Names: {"SPI_PS_INPUT_CNTL_27"}, .Value: 0xa1ac},
520 {.Names: {"SPI_PS_INPUT_CNTL_28"}, .Value: 0xa1ad},
521 {.Names: {"SPI_PS_INPUT_CNTL_29"}, .Value: 0xa1ae},
522 {.Names: {"SPI_PS_INPUT_CNTL_30"}, .Value: 0xa1af},
523 {.Names: {"SPI_PS_INPUT_CNTL_31"}, .Value: 0xa1b0},
524
525 {.Names: {"VGT_GS_MAX_VERT_OUT"}, .Value: 0xa2ce},
526 {.Names: {"VGT_ESGS_RING_ITEMSIZE"}, .Value: 0xa2ab},
527 {.Names: {"VGT_GS_MODE"}, .Value: 0xa290},
528 {.Names: {"VGT_GS_ONCHIP_CNTL"}, .Value: 0xa291},
529 {.Names: {"VGT_GS_VERT_ITEMSIZE"}, .Value: 0xa2d7},
530 {.Names: {"VGT_GS_VERT_ITEMSIZE_1"}, .Value: 0xa2d8},
531 {.Names: {"VGT_GS_VERT_ITEMSIZE_2"}, .Value: 0xa2d9},
532 {.Names: {"VGT_GS_VERT_ITEMSIZE_3"}, .Value: 0xa2da},
533 {.Names: {"VGT_GSVS_RING_OFFSET_1"}, .Value: 0xa298},
534 {.Names: {"VGT_GSVS_RING_OFFSET_2"}, .Value: 0xa299},
535 {.Names: {"VGT_GSVS_RING_OFFSET_3"}, .Value: 0xa29a},
536
537 {.Names: {"VGT_GS_INSTANCE_CNT"}, .Value: 0xa2e4},
538 {.Names: {"VGT_GS_PER_VS"}, .Value: 0xa297},
539 {.Names: {"VGT_GS_OUT_PRIM_TYPE"}, .Value: 0xa29b},
540 {.Names: {"VGT_GSVS_RING_ITEMSIZE"}, .Value: 0xa2ac},
541
542 {.Names: {"VGT_REUSE_OFF"}, .Value: 0xa2ad},
543 {.Names: {"SPI_BARYC_CNTL"}, .Value: 0xa1b8},
544
545 {.Names: {"SPI_SHADER_USER_DATA_VS_0"}, .Value: 0x2c4c},
546 {.Names: {"SPI_SHADER_USER_DATA_VS_1"}, .Value: 0x2c4d},
547 {.Names: {"SPI_SHADER_USER_DATA_VS_2"}, .Value: 0x2c4e},
548 {.Names: {"SPI_SHADER_USER_DATA_VS_3"}, .Value: 0x2c4f},
549 {.Names: {"SPI_SHADER_USER_DATA_VS_4"}, .Value: 0x2c50},
550 {.Names: {"SPI_SHADER_USER_DATA_VS_5"}, .Value: 0x2c51},
551 {.Names: {"SPI_SHADER_USER_DATA_VS_6"}, .Value: 0x2c52},
552 {.Names: {"SPI_SHADER_USER_DATA_VS_7"}, .Value: 0x2c53},
553 {.Names: {"SPI_SHADER_USER_DATA_VS_8"}, .Value: 0x2c54},
554 {.Names: {"SPI_SHADER_USER_DATA_VS_9"}, .Value: 0x2c55},
555 {.Names: {"SPI_SHADER_USER_DATA_VS_10"}, .Value: 0x2c56},
556 {.Names: {"SPI_SHADER_USER_DATA_VS_11"}, .Value: 0x2c57},
557 {.Names: {"SPI_SHADER_USER_DATA_VS_12"}, .Value: 0x2c58},
558 {.Names: {"SPI_SHADER_USER_DATA_VS_13"}, .Value: 0x2c59},
559 {.Names: {"SPI_SHADER_USER_DATA_VS_14"}, .Value: 0x2c5a},
560 {.Names: {"SPI_SHADER_USER_DATA_VS_15"}, .Value: 0x2c5b},
561 {.Names: {"SPI_SHADER_USER_DATA_VS_16"}, .Value: 0x2c5c},
562 {.Names: {"SPI_SHADER_USER_DATA_VS_17"}, .Value: 0x2c5d},
563 {.Names: {"SPI_SHADER_USER_DATA_VS_18"}, .Value: 0x2c5e},
564 {.Names: {"SPI_SHADER_USER_DATA_VS_19"}, .Value: 0x2c5f},
565 {.Names: {"SPI_SHADER_USER_DATA_VS_20"}, .Value: 0x2c60},
566 {.Names: {"SPI_SHADER_USER_DATA_VS_21"}, .Value: 0x2c61},
567 {.Names: {"SPI_SHADER_USER_DATA_VS_22"}, .Value: 0x2c62},
568 {.Names: {"SPI_SHADER_USER_DATA_VS_23"}, .Value: 0x2c63},
569 {.Names: {"SPI_SHADER_USER_DATA_VS_24"}, .Value: 0x2c64},
570 {.Names: {"SPI_SHADER_USER_DATA_VS_25"}, .Value: 0x2c65},
571 {.Names: {"SPI_SHADER_USER_DATA_VS_26"}, .Value: 0x2c66},
572 {.Names: {"SPI_SHADER_USER_DATA_VS_27"}, .Value: 0x2c67},
573 {.Names: {"SPI_SHADER_USER_DATA_VS_28"}, .Value: 0x2c68},
574 {.Names: {"SPI_SHADER_USER_DATA_VS_29"}, .Value: 0x2c69},
575 {.Names: {"SPI_SHADER_USER_DATA_VS_30"}, .Value: 0x2c6a},
576 {.Names: {"SPI_SHADER_USER_DATA_VS_31"}, .Value: 0x2c6b},
577
578 {.Names: {"SPI_SHADER_USER_DATA_GS_0"}, .Value: 0x2c8c},
579 {.Names: {"SPI_SHADER_USER_DATA_GS_1"}, .Value: 0x2c8d},
580 {.Names: {"SPI_SHADER_USER_DATA_GS_2"}, .Value: 0x2c8e},
581 {.Names: {"SPI_SHADER_USER_DATA_GS_3"}, .Value: 0x2c8f},
582 {.Names: {"SPI_SHADER_USER_DATA_GS_4"}, .Value: 0x2c90},
583 {.Names: {"SPI_SHADER_USER_DATA_GS_5"}, .Value: 0x2c91},
584 {.Names: {"SPI_SHADER_USER_DATA_GS_6"}, .Value: 0x2c92},
585 {.Names: {"SPI_SHADER_USER_DATA_GS_7"}, .Value: 0x2c93},
586 {.Names: {"SPI_SHADER_USER_DATA_GS_8"}, .Value: 0x2c94},
587 {.Names: {"SPI_SHADER_USER_DATA_GS_9"}, .Value: 0x2c95},
588 {.Names: {"SPI_SHADER_USER_DATA_GS_10"}, .Value: 0x2c96},
589 {.Names: {"SPI_SHADER_USER_DATA_GS_11"}, .Value: 0x2c97},
590 {.Names: {"SPI_SHADER_USER_DATA_GS_12"}, .Value: 0x2c98},
591 {.Names: {"SPI_SHADER_USER_DATA_GS_13"}, .Value: 0x2c99},
592 {.Names: {"SPI_SHADER_USER_DATA_GS_14"}, .Value: 0x2c9a},
593 {.Names: {"SPI_SHADER_USER_DATA_GS_15"}, .Value: 0x2c9b},
594 {.Names: {"SPI_SHADER_USER_DATA_GS_16"}, .Value: 0x2c9c},
595 {.Names: {"SPI_SHADER_USER_DATA_GS_17"}, .Value: 0x2c9d},
596 {.Names: {"SPI_SHADER_USER_DATA_GS_18"}, .Value: 0x2c9e},
597 {.Names: {"SPI_SHADER_USER_DATA_GS_19"}, .Value: 0x2c9f},
598 {.Names: {"SPI_SHADER_USER_DATA_GS_20"}, .Value: 0x2ca0},
599 {.Names: {"SPI_SHADER_USER_DATA_GS_21"}, .Value: 0x2ca1},
600 {.Names: {"SPI_SHADER_USER_DATA_GS_22"}, .Value: 0x2ca2},
601 {.Names: {"SPI_SHADER_USER_DATA_GS_23"}, .Value: 0x2ca3},
602 {.Names: {"SPI_SHADER_USER_DATA_GS_24"}, .Value: 0x2ca4},
603 {.Names: {"SPI_SHADER_USER_DATA_GS_25"}, .Value: 0x2ca5},
604 {.Names: {"SPI_SHADER_USER_DATA_GS_26"}, .Value: 0x2ca6},
605 {.Names: {"SPI_SHADER_USER_DATA_GS_27"}, .Value: 0x2ca7},
606 {.Names: {"SPI_SHADER_USER_DATA_GS_28"}, .Value: 0x2ca8},
607 {.Names: {"SPI_SHADER_USER_DATA_GS_29"}, .Value: 0x2ca9},
608 {.Names: {"SPI_SHADER_USER_DATA_GS_30"}, .Value: 0x2caa},
609 {.Names: {"SPI_SHADER_USER_DATA_GS_31"}, .Value: 0x2cab},
610
611 {.Names: {"SPI_SHADER_USER_DATA_ES_0"}, .Value: 0x2ccc},
612 {.Names: {"SPI_SHADER_USER_DATA_ES_1"}, .Value: 0x2ccd},
613 {.Names: {"SPI_SHADER_USER_DATA_ES_2"}, .Value: 0x2cce},
614 {.Names: {"SPI_SHADER_USER_DATA_ES_3"}, .Value: 0x2ccf},
615 {.Names: {"SPI_SHADER_USER_DATA_ES_4"}, .Value: 0x2cd0},
616 {.Names: {"SPI_SHADER_USER_DATA_ES_5"}, .Value: 0x2cd1},
617 {.Names: {"SPI_SHADER_USER_DATA_ES_6"}, .Value: 0x2cd2},
618 {.Names: {"SPI_SHADER_USER_DATA_ES_7"}, .Value: 0x2cd3},
619 {.Names: {"SPI_SHADER_USER_DATA_ES_8"}, .Value: 0x2cd4},
620 {.Names: {"SPI_SHADER_USER_DATA_ES_9"}, .Value: 0x2cd5},
621 {.Names: {"SPI_SHADER_USER_DATA_ES_10"}, .Value: 0x2cd6},
622 {.Names: {"SPI_SHADER_USER_DATA_ES_11"}, .Value: 0x2cd7},
623 {.Names: {"SPI_SHADER_USER_DATA_ES_12"}, .Value: 0x2cd8},
624 {.Names: {"SPI_SHADER_USER_DATA_ES_13"}, .Value: 0x2cd9},
625 {.Names: {"SPI_SHADER_USER_DATA_ES_14"}, .Value: 0x2cda},
626 {.Names: {"SPI_SHADER_USER_DATA_ES_15"}, .Value: 0x2cdb},
627 {.Names: {"SPI_SHADER_USER_DATA_ES_16"}, .Value: 0x2cdc},
628 {.Names: {"SPI_SHADER_USER_DATA_ES_17"}, .Value: 0x2cdd},
629 {.Names: {"SPI_SHADER_USER_DATA_ES_18"}, .Value: 0x2cde},
630 {.Names: {"SPI_SHADER_USER_DATA_ES_19"}, .Value: 0x2cdf},
631 {.Names: {"SPI_SHADER_USER_DATA_ES_20"}, .Value: 0x2ce0},
632 {.Names: {"SPI_SHADER_USER_DATA_ES_21"}, .Value: 0x2ce1},
633 {.Names: {"SPI_SHADER_USER_DATA_ES_22"}, .Value: 0x2ce2},
634 {.Names: {"SPI_SHADER_USER_DATA_ES_23"}, .Value: 0x2ce3},
635 {.Names: {"SPI_SHADER_USER_DATA_ES_24"}, .Value: 0x2ce4},
636 {.Names: {"SPI_SHADER_USER_DATA_ES_25"}, .Value: 0x2ce5},
637 {.Names: {"SPI_SHADER_USER_DATA_ES_26"}, .Value: 0x2ce6},
638 {.Names: {"SPI_SHADER_USER_DATA_ES_27"}, .Value: 0x2ce7},
639 {.Names: {"SPI_SHADER_USER_DATA_ES_28"}, .Value: 0x2ce8},
640 {.Names: {"SPI_SHADER_USER_DATA_ES_29"}, .Value: 0x2ce9},
641 {.Names: {"SPI_SHADER_USER_DATA_ES_30"}, .Value: 0x2cea},
642 {.Names: {"SPI_SHADER_USER_DATA_ES_31"}, .Value: 0x2ceb},
643
644 {.Names: {"SPI_SHADER_USER_DATA_PS_0"}, .Value: 0x2c0c},
645 {.Names: {"SPI_SHADER_USER_DATA_PS_1"}, .Value: 0x2c0d},
646 {.Names: {"SPI_SHADER_USER_DATA_PS_2"}, .Value: 0x2c0e},
647 {.Names: {"SPI_SHADER_USER_DATA_PS_3"}, .Value: 0x2c0f},
648 {.Names: {"SPI_SHADER_USER_DATA_PS_4"}, .Value: 0x2c10},
649 {.Names: {"SPI_SHADER_USER_DATA_PS_5"}, .Value: 0x2c11},
650 {.Names: {"SPI_SHADER_USER_DATA_PS_6"}, .Value: 0x2c12},
651 {.Names: {"SPI_SHADER_USER_DATA_PS_7"}, .Value: 0x2c13},
652 {.Names: {"SPI_SHADER_USER_DATA_PS_8"}, .Value: 0x2c14},
653 {.Names: {"SPI_SHADER_USER_DATA_PS_9"}, .Value: 0x2c15},
654 {.Names: {"SPI_SHADER_USER_DATA_PS_10"}, .Value: 0x2c16},
655 {.Names: {"SPI_SHADER_USER_DATA_PS_11"}, .Value: 0x2c17},
656 {.Names: {"SPI_SHADER_USER_DATA_PS_12"}, .Value: 0x2c18},
657 {.Names: {"SPI_SHADER_USER_DATA_PS_13"}, .Value: 0x2c19},
658 {.Names: {"SPI_SHADER_USER_DATA_PS_14"}, .Value: 0x2c1a},
659 {.Names: {"SPI_SHADER_USER_DATA_PS_15"}, .Value: 0x2c1b},
660 {.Names: {"SPI_SHADER_USER_DATA_PS_16"}, .Value: 0x2c1c},
661 {.Names: {"SPI_SHADER_USER_DATA_PS_17"}, .Value: 0x2c1d},
662 {.Names: {"SPI_SHADER_USER_DATA_PS_18"}, .Value: 0x2c1e},
663 {.Names: {"SPI_SHADER_USER_DATA_PS_19"}, .Value: 0x2c1f},
664 {.Names: {"SPI_SHADER_USER_DATA_PS_20"}, .Value: 0x2c20},
665 {.Names: {"SPI_SHADER_USER_DATA_PS_21"}, .Value: 0x2c21},
666 {.Names: {"SPI_SHADER_USER_DATA_PS_22"}, .Value: 0x2c22},
667 {.Names: {"SPI_SHADER_USER_DATA_PS_23"}, .Value: 0x2c23},
668 {.Names: {"SPI_SHADER_USER_DATA_PS_24"}, .Value: 0x2c24},
669 {.Names: {"SPI_SHADER_USER_DATA_PS_25"}, .Value: 0x2c25},
670 {.Names: {"SPI_SHADER_USER_DATA_PS_26"}, .Value: 0x2c26},
671 {.Names: {"SPI_SHADER_USER_DATA_PS_27"}, .Value: 0x2c27},
672 {.Names: {"SPI_SHADER_USER_DATA_PS_28"}, .Value: 0x2c28},
673 {.Names: {"SPI_SHADER_USER_DATA_PS_29"}, .Value: 0x2c29},
674 {.Names: {"SPI_SHADER_USER_DATA_PS_30"}, .Value: 0x2c2a},
675 {.Names: {"SPI_SHADER_USER_DATA_PS_31"}, .Value: 0x2c2b},
676
677 {.Names: {"COMPUTE_USER_DATA_0"}, .Value: 0x2e40},
678 {.Names: {"COMPUTE_USER_DATA_1"}, .Value: 0x2e41},
679 {.Names: {"COMPUTE_USER_DATA_2"}, .Value: 0x2e42},
680 {.Names: {"COMPUTE_USER_DATA_3"}, .Value: 0x2e43},
681 {.Names: {"COMPUTE_USER_DATA_4"}, .Value: 0x2e44},
682 {.Names: {"COMPUTE_USER_DATA_5"}, .Value: 0x2e45},
683 {.Names: {"COMPUTE_USER_DATA_6"}, .Value: 0x2e46},
684 {.Names: {"COMPUTE_USER_DATA_7"}, .Value: 0x2e47},
685 {.Names: {"COMPUTE_USER_DATA_8"}, .Value: 0x2e48},
686 {.Names: {"COMPUTE_USER_DATA_9"}, .Value: 0x2e49},
687 {.Names: {"COMPUTE_USER_DATA_10"}, .Value: 0x2e4a},
688 {.Names: {"COMPUTE_USER_DATA_11"}, .Value: 0x2e4b},
689 {.Names: {"COMPUTE_USER_DATA_12"}, .Value: 0x2e4c},
690 {.Names: {"COMPUTE_USER_DATA_13"}, .Value: 0x2e4d},
691 {.Names: {"COMPUTE_USER_DATA_14"}, .Value: 0x2e4e},
692 {.Names: {"COMPUTE_USER_DATA_15"}, .Value: 0x2e4f},
693 {.Names: {"COMPUTE_USER_DATA_16"}, .Value: 0x2e50},
694 {.Names: {"COMPUTE_USER_DATA_17"}, .Value: 0x2e51},
695 {.Names: {"COMPUTE_USER_DATA_18"}, .Value: 0x2e52},
696 {.Names: {"COMPUTE_USER_DATA_19"}, .Value: 0x2e53},
697 {.Names: {"COMPUTE_USER_DATA_20"}, .Value: 0x2e54},
698 {.Names: {"COMPUTE_USER_DATA_21"}, .Value: 0x2e55},
699 {.Names: {"COMPUTE_USER_DATA_22"}, .Value: 0x2e56},
700 {.Names: {"COMPUTE_USER_DATA_23"}, .Value: 0x2e57},
701 {.Names: {"COMPUTE_USER_DATA_24"}, .Value: 0x2e58},
702 {.Names: {"COMPUTE_USER_DATA_25"}, .Value: 0x2e59},
703 {.Names: {"COMPUTE_USER_DATA_26"}, .Value: 0x2e5a},
704 {.Names: {"COMPUTE_USER_DATA_27"}, .Value: 0x2e5b},
705 {.Names: {"COMPUTE_USER_DATA_28"}, .Value: 0x2e5c},
706 {.Names: {"COMPUTE_USER_DATA_29"}, .Value: 0x2e5d},
707 {.Names: {"COMPUTE_USER_DATA_30"}, .Value: 0x2e5e},
708 {.Names: {"COMPUTE_USER_DATA_31"}, .Value: 0x2e5f},
709
710 {.Names: {"COMPUTE_NUM_THREAD_X"}, .Value: 0x2e07},
711 {.Names: {"COMPUTE_NUM_THREAD_Y"}, .Value: 0x2e08},
712 {.Names: {"COMPUTE_NUM_THREAD_Z"}, .Value: 0x2e09},
713 {.Names: {"VGT_TF_PARAM"}, .Value: 0xa2db},
714 {.Names: {"VGT_LS_HS_CONFIG"}, .Value: 0xa2d6},
715 {.Names: {"VGT_HOS_MIN_TESS_LEVEL"}, .Value: 0xa287},
716 {.Names: {"VGT_HOS_MAX_TESS_LEVEL"}, .Value: 0xa286},
717 {.Names: {"PA_SC_AA_CONFIG"}, .Value: 0xa2f8},
718 {.Names: {"PA_SC_SHADER_CONTROL"}, .Value: 0xa310},
719 {.Names: {"PA_SC_CONSERVATIVE_RASTERIZATION_CNTL"}, .Value: 0xa313},
720
721 {.Names: {"SPI_SHADER_USER_DATA_HS_0"}, .Value: 0x2d0c},
722 {.Names: {"SPI_SHADER_USER_DATA_HS_1"}, .Value: 0x2d0d},
723 {.Names: {"SPI_SHADER_USER_DATA_HS_2"}, .Value: 0x2d0e},
724 {.Names: {"SPI_SHADER_USER_DATA_HS_3"}, .Value: 0x2d0f},
725 {.Names: {"SPI_SHADER_USER_DATA_HS_4"}, .Value: 0x2d10},
726 {.Names: {"SPI_SHADER_USER_DATA_HS_5"}, .Value: 0x2d11},
727 {.Names: {"SPI_SHADER_USER_DATA_HS_6"}, .Value: 0x2d12},
728 {.Names: {"SPI_SHADER_USER_DATA_HS_7"}, .Value: 0x2d13},
729 {.Names: {"SPI_SHADER_USER_DATA_HS_8"}, .Value: 0x2d14},
730 {.Names: {"SPI_SHADER_USER_DATA_HS_9"}, .Value: 0x2d15},
731 {.Names: {"SPI_SHADER_USER_DATA_HS_10"}, .Value: 0x2d16},
732 {.Names: {"SPI_SHADER_USER_DATA_HS_11"}, .Value: 0x2d17},
733 {.Names: {"SPI_SHADER_USER_DATA_HS_12"}, .Value: 0x2d18},
734 {.Names: {"SPI_SHADER_USER_DATA_HS_13"}, .Value: 0x2d19},
735 {.Names: {"SPI_SHADER_USER_DATA_HS_14"}, .Value: 0x2d1a},
736 {.Names: {"SPI_SHADER_USER_DATA_HS_15"}, .Value: 0x2d1b},
737 {.Names: {"SPI_SHADER_USER_DATA_HS_16"}, .Value: 0x2d1c},
738 {.Names: {"SPI_SHADER_USER_DATA_HS_17"}, .Value: 0x2d1d},
739 {.Names: {"SPI_SHADER_USER_DATA_HS_18"}, .Value: 0x2d1e},
740 {.Names: {"SPI_SHADER_USER_DATA_HS_19"}, .Value: 0x2d1f},
741 {.Names: {"SPI_SHADER_USER_DATA_HS_20"}, .Value: 0x2d20},
742 {.Names: {"SPI_SHADER_USER_DATA_HS_21"}, .Value: 0x2d21},
743 {.Names: {"SPI_SHADER_USER_DATA_HS_22"}, .Value: 0x2d22},
744 {.Names: {"SPI_SHADER_USER_DATA_HS_23"}, .Value: 0x2d23},
745 {.Names: {"SPI_SHADER_USER_DATA_HS_24"}, .Value: 0x2d24},
746 {.Names: {"SPI_SHADER_USER_DATA_HS_25"}, .Value: 0x2d25},
747 {.Names: {"SPI_SHADER_USER_DATA_HS_26"}, .Value: 0x2d26},
748 {.Names: {"SPI_SHADER_USER_DATA_HS_27"}, .Value: 0x2d27},
749 {.Names: {"SPI_SHADER_USER_DATA_HS_28"}, .Value: 0x2d28},
750 {.Names: {"SPI_SHADER_USER_DATA_HS_29"}, .Value: 0x2d29},
751 {.Names: {"SPI_SHADER_USER_DATA_HS_30"}, .Value: 0x2d2a},
752 {.Names: {"SPI_SHADER_USER_DATA_HS_31"}, .Value: 0x2d2b},
753
754 {.Names: {"SPI_SHADER_USER_DATA_LS_0"}, .Value: 0x2d4c},
755 {.Names: {"SPI_SHADER_USER_DATA_LS_1"}, .Value: 0x2d4d},
756 {.Names: {"SPI_SHADER_USER_DATA_LS_2"}, .Value: 0x2d4e},
757 {.Names: {"SPI_SHADER_USER_DATA_LS_3"}, .Value: 0x2d4f},
758 {.Names: {"SPI_SHADER_USER_DATA_LS_4"}, .Value: 0x2d50},
759 {.Names: {"SPI_SHADER_USER_DATA_LS_5"}, .Value: 0x2d51},
760 {.Names: {"SPI_SHADER_USER_DATA_LS_6"}, .Value: 0x2d52},
761 {.Names: {"SPI_SHADER_USER_DATA_LS_7"}, .Value: 0x2d53},
762 {.Names: {"SPI_SHADER_USER_DATA_LS_8"}, .Value: 0x2d54},
763 {.Names: {"SPI_SHADER_USER_DATA_LS_9"}, .Value: 0x2d55},
764 {.Names: {"SPI_SHADER_USER_DATA_LS_10"}, .Value: 0x2d56},
765 {.Names: {"SPI_SHADER_USER_DATA_LS_11"}, .Value: 0x2d57},
766 {.Names: {"SPI_SHADER_USER_DATA_LS_12"}, .Value: 0x2d58},
767 {.Names: {"SPI_SHADER_USER_DATA_LS_13"}, .Value: 0x2d59},
768 {.Names: {"SPI_SHADER_USER_DATA_LS_14"}, .Value: 0x2d5a},
769 {.Names: {"SPI_SHADER_USER_DATA_LS_15"}, .Value: 0x2d5b},
770
771 {.Names: {"IA_MULTI_VGT_PARAM"}, .Value: 0xa2aa},
772 {.Names: {"VGT_GS_MAX_PRIMS_PER_SUBGROUP"}, .Value: 0xa2a5},
773 {.Names: {"VGT_STRMOUT_BUFFER_CONFIG"}, .Value: 0xa2e6},
774 {.Names: {"VGT_STRMOUT_CONFIG"}, .Value: 0xa2e5},
775 {.Names: {"VGT_STRMOUT_VTX_STRIDE_0"}, .Value: 0xa2b5},
776 {.Names: {"VGT_STRMOUT_VTX_STRIDE_1"}, .Value: 0xa2b9},
777 {.Names: {"VGT_STRMOUT_VTX_STRIDE_2"}, .Value: 0xa2bd},
778 {.Names: {"VGT_STRMOUT_VTX_STRIDE_3"}, .Value: 0xa2c1},
779 {.Names: {"VGT_VERTEX_REUSE_BLOCK_CNTL"}, .Value: 0xa316},
780
781 {.Names: {"COMPUTE_PGM_RSRC3"}, .Value: 0x2e28},
782 {.Names: {"COMPUTE_SHADER_CHKSUM"}, .Value: 0x2e2a},
783 {.Names: {"COMPUTE_USER_ACCUM_0"}, .Value: 0x2e24},
784 {.Names: {"COMPUTE_USER_ACCUM_1"}, .Value: 0x2e25},
785 {.Names: {"COMPUTE_USER_ACCUM_2"}, .Value: 0x2e26},
786 {.Names: {"COMPUTE_USER_ACCUM_3"}, .Value: 0x2e27},
787 {.Names: {"GE_MAX_OUTPUT_PER_SUBGROUP"}, .Value: 0xa1ff},
788 {.Names: {"GE_NGG_SUBGRP_CNTL"}, .Value: 0xa2d3},
789 {.Names: {"GE_STEREO_CNTL"}, .Value: 0xc25f},
790 {.Names: {"GE_USER_VGPR_EN"}, .Value: 0xc262},
791 {.Names: {"IA_MULTI_VGT_PARAM_PIPED"}, .Value: 0xc258},
792 {.Names: {"PA_STEREO_CNTL"}, .Value: 0xa210},
793 {.Names: {"SPI_SHADER_IDX_FORMAT"}, .Value: 0xa1c2},
794 {.Names: {"SPI_SHADER_PGM_CHKSUM_GS"}, .Value: 0x2c80},
795 {.Names: {"SPI_SHADER_PGM_CHKSUM_HS"}, .Value: 0x2d00},
796 {.Names: {"SPI_SHADER_PGM_CHKSUM_PS"}, .Value: 0x2c06},
797 {.Names: {"SPI_SHADER_PGM_CHKSUM_VS"}, .Value: 0x2c45},
798 {.Names: {"SPI_SHADER_PGM_LO_GS"}, .Value: 0x2c88},
799 {.Names: {"SPI_SHADER_USER_ACCUM_ESGS_0"}, .Value: 0x2cb2},
800 {.Names: {"SPI_SHADER_USER_ACCUM_ESGS_1"}, .Value: 0x2cb3},
801 {.Names: {"SPI_SHADER_USER_ACCUM_ESGS_2"}, .Value: 0x2cb4},
802 {.Names: {"SPI_SHADER_USER_ACCUM_ESGS_3"}, .Value: 0x2cb5},
803 {.Names: {"SPI_SHADER_USER_ACCUM_LSHS_0"}, .Value: 0x2d32},
804 {.Names: {"SPI_SHADER_USER_ACCUM_LSHS_1"}, .Value: 0x2d33},
805 {.Names: {"SPI_SHADER_USER_ACCUM_LSHS_2"}, .Value: 0x2d34},
806 {.Names: {"SPI_SHADER_USER_ACCUM_LSHS_3"}, .Value: 0x2d35},
807 {.Names: {"SPI_SHADER_USER_ACCUM_PS_0"}, .Value: 0x2c32},
808 {.Names: {"SPI_SHADER_USER_ACCUM_PS_1"}, .Value: 0x2c33},
809 {.Names: {"SPI_SHADER_USER_ACCUM_PS_2"}, .Value: 0x2c34},
810 {.Names: {"SPI_SHADER_USER_ACCUM_PS_3"}, .Value: 0x2c35},
811 {.Names: {"SPI_SHADER_USER_ACCUM_VS_0"}, .Value: 0x2c72},
812 {.Names: {"SPI_SHADER_USER_ACCUM_VS_1"}, .Value: 0x2c73},
813 {.Names: {"SPI_SHADER_USER_ACCUM_VS_2"}, .Value: 0x2c74},
814 {.Names: {"SPI_SHADER_USER_ACCUM_VS_3"}, .Value: 0x2c75},
815 };
816 static constexpr auto RegInfoTable = BUILD_ENUM_STRINGS(RegInfoTableDefs);
817 return EnumStrings(RegInfoTable).toString(Value: RegNum);
818}
819
820// Convert the accumulated PAL metadata into an asm directive.
821void AMDGPUPALMetadata::toString(std::string &String) {
822 String.clear();
823 if (!BlobType)
824 return;
825 ResolvedAll = DelayedExprs.resolveDelayedExpressions();
826 raw_string_ostream Stream(String);
827 if (isLegacy()) {
828 if (MsgPackDoc.getRoot().getKind() == msgpack::Type::Nil)
829 return;
830 // Old linear reg=val format.
831 Stream << '\t' << AMDGPU::PALMD::AssemblerDirective << ' ';
832 auto Regs = getRegisters();
833 for (auto I = Regs.begin(), E = Regs.end(); I != E; ++I) {
834 if (I != Regs.begin())
835 Stream << ',';
836 unsigned Reg = I->first.getUInt();
837 unsigned Val = I->second.getUInt();
838 Stream << "0x" << Twine::utohexstr(Val: Reg) << ",0x" << Twine::utohexstr(Val);
839 }
840 Stream << '\n';
841 return;
842 }
843
844 // New msgpack-based format -- output as YAML (with unsigned numbers in hex),
845 // but first change the registers map to use names.
846 MsgPackDoc.setHexMode();
847 auto &RegsObj = refRegisters();
848 auto OrigRegs = RegsObj.getMap();
849 RegsObj = MsgPackDoc.getMapNode();
850 for (auto I : OrigRegs) {
851 auto Key = I.first;
852 if (StringRef RegName = getRegisterName(RegNum: Key.getUInt()); !RegName.empty()) {
853 std::string KeyName = Key.toString();
854 KeyName += " (";
855 KeyName += RegName;
856 KeyName += ')';
857 Key = MsgPackDoc.getNode(V: KeyName, /*Copy=*/true);
858 }
859 RegsObj.getMap()[Key] = I.second;
860 }
861
862 // Output as YAML.
863 Stream << '\t' << AMDGPU::PALMD::AssemblerDirectiveBegin << '\n';
864 MsgPackDoc.toYAML(OS&: Stream);
865 Stream << '\t' << AMDGPU::PALMD::AssemblerDirectiveEnd << '\n';
866
867 // Restore original registers map.
868 RegsObj = OrigRegs;
869}
870
871// Convert the accumulated PAL metadata into a binary blob for writing as
872// a .note record of the specified AMD type. Returns an empty blob if
873// there is no PAL metadata,
874void AMDGPUPALMetadata::toBlob(unsigned Type, std::string &Blob) {
875 ResolvedAll = DelayedExprs.resolveDelayedExpressions();
876 if (Type == ELF::NT_AMD_PAL_METADATA)
877 toLegacyBlob(Blob);
878 else if (Type)
879 toMsgPackBlob(Blob);
880}
881
882void AMDGPUPALMetadata::toLegacyBlob(std::string &Blob) {
883 Blob.clear();
884 auto Registers = getRegisters();
885 if (Registers.getMap().empty())
886 return;
887 raw_string_ostream OS(Blob);
888 support::endian::Writer EW(OS, llvm::endianness::little);
889 for (auto I : Registers.getMap()) {
890 EW.write(Val: uint32_t(I.first.getUInt()));
891 EW.write(Val: uint32_t(I.second.getUInt()));
892 }
893}
894
895void AMDGPUPALMetadata::toMsgPackBlob(std::string &Blob) {
896 Blob.clear();
897 MsgPackDoc.writeToBlob(Blob);
898}
899
900// Set PAL metadata from YAML text. Returns false if failed.
901bool AMDGPUPALMetadata::setFromString(StringRef S) {
902 BlobType = ELF::NT_AMDGPU_METADATA;
903 if (!MsgPackDoc.fromYAML(S))
904 return false;
905
906 // In the registers map, some keys may be of the form "0xa191
907 // (SPI_PS_INPUT_CNTL_0)", in which case the YAML input code made it a
908 // string. We need to turn it into a number.
909 auto &RegsObj = refRegisters();
910 auto OrigRegs = RegsObj;
911 RegsObj = MsgPackDoc.getMapNode();
912 Registers = RegsObj.getMap();
913 bool Ok = true;
914 for (auto I : OrigRegs.getMap()) {
915 auto Key = I.first;
916 if (Key.getKind() == msgpack::Type::String) {
917 StringRef S = Key.getString();
918 uint64_t Val;
919 if (S.consumeInteger(Radix: 0, Result&: Val)) {
920 Ok = false;
921 errs() << "Unrecognized PAL metadata register key '" << S << "'\n";
922 continue;
923 }
924 Key = MsgPackDoc.getNode(V: Val);
925 }
926 Registers.getMap()[Key] = I.second;
927 }
928 return Ok;
929}
930
931// Reference (create if necessary) the node for the registers map.
932msgpack::DocNode &AMDGPUPALMetadata::refRegisters() {
933 auto &N =
934 MsgPackDoc.getRoot()
935 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: "amdpal.pipelines")]
936 .getArray(/*Convert=*/true)[0]
937 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: ".registers")];
938 N.getMap(/*Convert=*/true);
939 return N;
940}
941
942// Get (create if necessary) the registers map.
943msgpack::MapDocNode AMDGPUPALMetadata::getRegisters() {
944 if (Registers.isEmpty())
945 Registers = refRegisters();
946 return Registers.getMap();
947}
948
949// Reference (create if necessary) the node for the shader functions map.
950msgpack::DocNode &AMDGPUPALMetadata::refShaderFunctions() {
951 auto &N =
952 MsgPackDoc.getRoot()
953 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: "amdpal.pipelines")]
954 .getArray(/*Convert=*/true)[0]
955 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: ".shader_functions")];
956 N.getMap(/*Convert=*/true);
957 return N;
958}
959
960// Get (create if necessary) the shader functions map.
961msgpack::MapDocNode AMDGPUPALMetadata::getShaderFunctions() {
962 if (ShaderFunctions.isEmpty())
963 ShaderFunctions = refShaderFunctions();
964 return ShaderFunctions.getMap();
965}
966
967// Get (create if necessary) a function in the shader functions map.
968msgpack::MapDocNode AMDGPUPALMetadata::getShaderFunction(StringRef Name) {
969 auto Functions = getShaderFunctions();
970 return Functions[Name].getMap(/*Convert=*/true);
971}
972
973msgpack::DocNode &AMDGPUPALMetadata::refComputeRegisters() {
974 auto &N =
975 MsgPackDoc.getRoot()
976 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: "amdpal.pipelines")]
977 .getArray(/*Convert=*/true)[0]
978 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: ".compute_registers")];
979 N.getMap(/*Convert=*/true);
980 return N;
981}
982
983msgpack::MapDocNode AMDGPUPALMetadata::getComputeRegisters() {
984 if (ComputeRegisters.isEmpty())
985 ComputeRegisters = refComputeRegisters();
986 return ComputeRegisters.getMap();
987}
988
989msgpack::DocNode &AMDGPUPALMetadata::refGraphicsRegisters() {
990 auto &N =
991 MsgPackDoc.getRoot()
992 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: "amdpal.pipelines")]
993 .getArray(/*Convert=*/true)[0]
994 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: ".graphics_registers")];
995 N.getMap(/*Convert=*/true);
996 return N;
997}
998
999msgpack::MapDocNode AMDGPUPALMetadata::getGraphicsRegisters() {
1000 if (GraphicsRegisters.isEmpty())
1001 GraphicsRegisters = refGraphicsRegisters();
1002 return GraphicsRegisters.getMap();
1003}
1004
1005msgpack::DocNode &AMDGPUPALMetadata::refHwStage() {
1006 auto &N =
1007 MsgPackDoc.getRoot()
1008 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: "amdpal.pipelines")]
1009 .getArray(/*Convert=*/true)[0]
1010 .getMap(/*Convert=*/true)[MsgPackDoc.getNode(V: ".hardware_stages")];
1011 N.getMap(/*Convert=*/true);
1012 return N;
1013}
1014
1015// Get (create if necessary) the .hardware_stages entry for the given calling
1016// convention.
1017msgpack::MapDocNode AMDGPUPALMetadata::getHwStage(unsigned CC) {
1018 if (HwStages.isEmpty())
1019 HwStages = refHwStage();
1020 return HwStages.getMap()[getStageName(CC)].getMap(/*Convert=*/true);
1021}
1022
1023// Get .note record vendor name of metadata blob to be emitted.
1024const char *AMDGPUPALMetadata::getVendor() const {
1025 return isLegacy() ? ElfNote::NoteNameV2 : ElfNote::NoteNameV3;
1026}
1027
1028// Get .note record type of metadata blob to be emitted:
1029// ELF::NT_AMD_PAL_METADATA (legacy key=val format), or
1030// ELF::NT_AMDGPU_METADATA (MsgPack format), or
1031// 0 (no PAL metadata).
1032unsigned AMDGPUPALMetadata::getType() const {
1033 return BlobType;
1034}
1035
1036// Return whether the blob type is legacy PAL metadata.
1037bool AMDGPUPALMetadata::isLegacy() const {
1038 return BlobType == ELF::NT_AMD_PAL_METADATA;
1039}
1040
1041// Set legacy PAL metadata format.
1042void AMDGPUPALMetadata::setLegacy() {
1043 BlobType = ELF::NT_AMD_PAL_METADATA;
1044}
1045
1046// Erase all PAL metadata.
1047void AMDGPUPALMetadata::reset() {
1048 MsgPackDoc.clear();
1049 REM.clear();
1050 DelayedExprs.clear();
1051 Registers = MsgPackDoc.getEmptyNode();
1052 HwStages = MsgPackDoc.getEmptyNode();
1053 ShaderFunctions = MsgPackDoc.getEmptyNode();
1054}
1055
1056bool AMDGPUPALMetadata::resolvedAllMCExpr() {
1057 return ResolvedAll && DelayedExprs.empty();
1058}
1059
1060unsigned AMDGPUPALMetadata::getPALVersion(unsigned idx) {
1061 assert(idx < 2 &&
1062 "illegal index to PAL version - should be 0 (major) or 1 (minor)");
1063 if (!VersionChecked) {
1064 if (Version.isEmpty()) {
1065 auto &M = MsgPackDoc.getRoot().getMap(/*Convert=*/true);
1066 auto I = M.find(Key: MsgPackDoc.getNode(V: "amdpal.version"));
1067 if (I != M.end())
1068 Version = I->second;
1069 }
1070 VersionChecked = true;
1071 }
1072 if (Version.isEmpty())
1073 // Default to 2.6 if there's no version info
1074 return idx ? 6 : 2;
1075 return Version.getArray()[idx].getUInt();
1076}
1077
1078unsigned AMDGPUPALMetadata::getPALMajorVersion() { return getPALVersion(idx: 0); }
1079
1080VersionTuple AMDGPUPALMetadata::getPALVersion() {
1081 return VersionTuple(getPALVersion(idx: 0), getPALVersion(idx: 1));
1082}
1083
1084// Set the field in a given .hardware_stages entry to a maximum value
1085void AMDGPUPALMetadata::updateHwStageMaximum(unsigned CC, StringRef field,
1086 unsigned Val) {
1087 msgpack::MapDocNode HwStageFieldMapNode = getHwStage(CC);
1088 auto &Node = HwStageFieldMapNode[field];
1089 if (Node.isEmpty())
1090 Node = Val;
1091 else
1092 Node = std::max<unsigned>(a: Node.getUInt(), b: Val);
1093}
1094
1095// Set the field in a given .hardware_stages entry
1096void AMDGPUPALMetadata::setHwStage(unsigned CC, StringRef field, unsigned Val) {
1097 getHwStage(CC)[field] = Val;
1098}
1099
1100void AMDGPUPALMetadata::setHwStage(unsigned CC, StringRef field, bool Val) {
1101 getHwStage(CC)[field] = Val;
1102}
1103
1104void AMDGPUPALMetadata::setHwStage(unsigned CC, StringRef field,
1105 msgpack::Type Type, const MCExpr *Val) {
1106 DelayedExprs.assignDocNode(DN&: getHwStage(CC)[field], Type, ExprValue: Val);
1107}
1108
1109void AMDGPUPALMetadata::setComputeRegisters(StringRef field, unsigned Val) {
1110 getComputeRegisters()[field] = Val;
1111}
1112
1113void AMDGPUPALMetadata::setComputeRegisters(StringRef field, bool Val) {
1114 getComputeRegisters()[field] = Val;
1115}
1116
1117msgpack::DocNode *AMDGPUPALMetadata::refComputeRegister(StringRef field) {
1118 auto M = getComputeRegisters();
1119 auto I = M.find(Key: field);
1120 return I == M.end() ? nullptr : &I->second;
1121}
1122
1123bool AMDGPUPALMetadata::checkComputeRegisters(StringRef field, unsigned Val) {
1124 if (auto *N = refComputeRegister(field))
1125 return N->getUInt() == Val;
1126 return false;
1127}
1128
1129bool AMDGPUPALMetadata::checkComputeRegisters(StringRef field, bool Val) {
1130 if (auto *N = refComputeRegister(field))
1131 return N->getBool() == Val;
1132 return false;
1133}
1134
1135void AMDGPUPALMetadata::setGraphicsRegisters(StringRef field, unsigned Val) {
1136 getGraphicsRegisters()[field] = Val;
1137}
1138
1139void AMDGPUPALMetadata::setGraphicsRegisters(StringRef field, bool Val) {
1140 getGraphicsRegisters()[field] = Val;
1141}
1142
1143void AMDGPUPALMetadata::setGraphicsRegisters(StringRef field1, StringRef field2,
1144 unsigned Val) {
1145 getGraphicsRegisters()[field1].getMap(Convert: true)[field2] = Val;
1146}
1147
1148void AMDGPUPALMetadata::setGraphicsRegisters(StringRef field1, StringRef field2,
1149 bool Val) {
1150 getGraphicsRegisters()[field1].getMap(Convert: true)[field2] = Val;
1151}
1152