LLVM 24.0.0git
AMDGPUTargetStreamer.cpp
Go to the documentation of this file.
1//===-- AMDGPUTargetStreamer.cpp - Mips Target Streamer Methods -----------===//
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 provides AMDGPU specific target streamer methods.
10//
11//===----------------------------------------------------------------------===//
12
13#include "AMDGPUTargetStreamer.h"
14#include "AMDGPUMCExpr.h"
15#include "AMDGPUMCKernelDescriptor.h"
16#include "AMDGPUMCTargetDesc.h"
17#include "AMDGPUPTNote.h"
18#include "Utils/AMDGPUBaseInfo.h"
19#include "Utils/AMDKernelCodeTUtils.h"
20#include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
21#include "llvm/BinaryFormat/ELF.h"
22#include "llvm/MC/MCAsmInfo.h"
23#include "llvm/MC/MCAssembler.h"
24#include "llvm/MC/MCContext.h"
25#include "llvm/MC/MCELFObjectWriter.h"
26#include "llvm/MC/MCELFStreamer.h"
27#include "llvm/MC/MCSubtargetInfo.h"
28#include "llvm/MC/StringTableBuilder.h"
29#include "llvm/Support/AMDGPUMetadata.h"
30#include "llvm/Support/AMDGPUObjLinkingInfo.h"
31#include "llvm/Support/AMDHSAKernelDescriptor.h"
32#include "llvm/Support/CommandLine.h"
33#include "llvm/Support/FormattedStream.h"
34#include "llvm/TargetParser/AMDGPUTargetParser.h"
35
36using namespace llvm;
37using namespace llvm::AMDGPU;
38
39//===----------------------------------------------------------------------===//
40// AMDGPUTargetStreamer
41//===----------------------------------------------------------------------===//
42
43static cl::opt<unsigned>
44 ForceGenericVersion("amdgpu-force-generic-version",
45 cl::desc("Force a specific generic_v<N> flag to be "
46 "added. For testing purposes only."),
47 cl::ReallyHidden, cl::init(0));
48
49void AMDGPUTargetStreamer::initializeTargetID(const MCSubtargetInfo &STI,
50 bool ApplyFeatureString) {
51 assert(TargetID == std::nullopt && "TargetID can only be initialized once");
52 // Apply xnack/sramecc from subtarget features only in MC contexts
53 // (assembler), not in codegen where they come from module flags
54 TargetID = AMDGPU::createAMDGPUTargetID(
55 STI, ApplyFeatureString ? STI.getFeatureString() : "");
56}
57
58bool AMDGPUTargetStreamer::EmitHSAMetadataV3(StringRef HSAMetadataString) {
59 msgpack::Document HSAMetadataDoc;
60 if (!HSAMetadataDoc.fromYAML(HSAMetadataString))
61 return false;
62 return EmitHSAMetadata(HSAMetadataDoc, false);
63}
64
65StringRef AMDGPUTargetStreamer::getArchNameFromElfMach(unsigned ElfMach) {
66 AMDGPU::GPUKind AK;
67
68 // clang-format off
69 switch (ElfMach) {
70 case ELF::EF_AMDGPU_MACH_R600_R600: AK = GK_R600; break;
71 case ELF::EF_AMDGPU_MACH_R600_R630: AK = GK_R630; break;
72 case ELF::EF_AMDGPU_MACH_R600_RS880: AK = GK_RS880; break;
73 case ELF::EF_AMDGPU_MACH_R600_RV670: AK = GK_RV670; break;
74 case ELF::EF_AMDGPU_MACH_R600_RV710: AK = GK_RV710; break;
75 case ELF::EF_AMDGPU_MACH_R600_RV730: AK = GK_RV730; break;
76 case ELF::EF_AMDGPU_MACH_R600_RV770: AK = GK_RV770; break;
77 case ELF::EF_AMDGPU_MACH_R600_CEDAR: AK = GK_CEDAR; break;
78 case ELF::EF_AMDGPU_MACH_R600_CYPRESS: AK = GK_CYPRESS; break;
79 case ELF::EF_AMDGPU_MACH_R600_JUNIPER: AK = GK_JUNIPER; break;
80 case ELF::EF_AMDGPU_MACH_R600_REDWOOD: AK = GK_REDWOOD; break;
81 case ELF::EF_AMDGPU_MACH_R600_SUMO: AK = GK_SUMO; break;
82 case ELF::EF_AMDGPU_MACH_R600_BARTS: AK = GK_BARTS; break;
83 case ELF::EF_AMDGPU_MACH_R600_CAICOS: AK = GK_CAICOS; break;
84 case ELF::EF_AMDGPU_MACH_R600_CAYMAN: AK = GK_CAYMAN; break;
85 case ELF::EF_AMDGPU_MACH_R600_TURKS: AK = GK_TURKS; break;
86 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX600: AK = GK_GFX600; break;
87 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX601: AK = GK_GFX601; break;
88 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX602: AK = GK_GFX602; break;
89 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX700: AK = GK_GFX700; break;
90 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX701: AK = GK_GFX701; break;
91 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX702: AK = GK_GFX702; break;
92 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX703: AK = GK_GFX703; break;
93 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX704: AK = GK_GFX704; break;
94 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX705: AK = GK_GFX705; break;
95 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX801: AK = GK_GFX801; break;
96 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX802: AK = GK_GFX802; break;
97 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX803: AK = GK_GFX803; break;
98 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX805: AK = GK_GFX805; break;
99 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX810: AK = GK_GFX810; break;
100 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX900: AK = GK_GFX900; break;
101 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX902: AK = GK_GFX902; break;
102 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX904: AK = GK_GFX904; break;
103 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX906: AK = GK_GFX906; break;
104 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX908: AK = GK_GFX908; break;
105 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX909: AK = GK_GFX909; break;
106 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A: AK = GK_GFX90A; break;
107 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C: AK = GK_GFX90C; break;
108 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX942: AK = GK_GFX942; break;
109 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX950: AK = GK_GFX950; break;
110 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010: AK = GK_GFX1010; break;
111 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011: AK = GK_GFX1011; break;
112 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012: AK = GK_GFX1012; break;
113 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013: AK = GK_GFX1013; break;
114 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030: AK = GK_GFX1030; break;
115 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031: AK = GK_GFX1031; break;
116 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032: AK = GK_GFX1032; break;
117 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033: AK = GK_GFX1033; break;
118 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034: AK = GK_GFX1034; break;
119 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035: AK = GK_GFX1035; break;
120 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036: AK = GK_GFX1036; break;
121 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100: AK = GK_GFX1100; break;
122 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101: AK = GK_GFX1101; break;
123 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102: AK = GK_GFX1102; break;
124 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103: AK = GK_GFX1103; break;
125 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1150: AK = GK_GFX1150; break;
126 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1151: AK = GK_GFX1151; break;
127 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1152: AK = GK_GFX1152; break;
128 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1153: AK = GK_GFX1153; break;
129 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1154: AK = GK_GFX1154; break;
130 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1170: AK = GK_GFX1170; break;
131 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1171: AK = GK_GFX1171; break;
132 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1172: AK = GK_GFX1172; break;
133 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1200: AK = GK_GFX1200; break;
134 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1201: AK = GK_GFX1201; break;
135 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1250: AK = GK_GFX1250; break;
136 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1251: AK = GK_GFX1251; break;
137 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1310: AK = GK_GFX1310; break;
138 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC: AK = GK_GFX9_GENERIC; break;
139 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC: AK = GK_GFX9_4_GENERIC; break;
140 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC: AK = GK_GFX10_1_GENERIC; break;
141 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC: AK = GK_GFX10_3_GENERIC; break;
142 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC: AK = GK_GFX11_GENERIC; break;
143 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX11_7_GENERIC: AK = GK_GFX11_7_GENERIC; break;
144 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC: AK = GK_GFX12_GENERIC; break;
145 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX12_5_GENERIC: AK = GK_GFX12_5_GENERIC; break;
146 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX13_GENERIC: AK = GK_GFX13_GENERIC; break;
147 case ELF::EF_AMDGPU_MACH_NONE: AK = GK_NONE; break;
148 default: AK = GK_NONE; break;
149 }
150 // clang-format on
151
152 StringRef GPUName = getArchNameAMDGCN(AK);
153 if (GPUName != "")
154 return GPUName;
155 return getArchNameR600(AK);
156}
157
158unsigned AMDGPUTargetStreamer::getElfMach(StringRef GPU) {
159 AMDGPU::GPUKind AK = parseArchAMDGCN(GPU);
160 if (AK == AMDGPU::GPUKind::GK_NONE)
161 AK = parseArchR600(GPU);
162
163 // clang-format off
164 switch (AK) {
165 case GK_R600: return ELF::EF_AMDGPU_MACH_R600_R600;
166 case GK_R630: return ELF::EF_AMDGPU_MACH_R600_R630;
167 case GK_RS880: return ELF::EF_AMDGPU_MACH_R600_RS880;
168 case GK_RV670: return ELF::EF_AMDGPU_MACH_R600_RV670;
169 case GK_RV710: return ELF::EF_AMDGPU_MACH_R600_RV710;
170 case GK_RV730: return ELF::EF_AMDGPU_MACH_R600_RV730;
171 case GK_RV770: return ELF::EF_AMDGPU_MACH_R600_RV770;
172 case GK_CEDAR: return ELF::EF_AMDGPU_MACH_R600_CEDAR;
173 case GK_CYPRESS: return ELF::EF_AMDGPU_MACH_R600_CYPRESS;
174 case GK_JUNIPER: return ELF::EF_AMDGPU_MACH_R600_JUNIPER;
175 case GK_REDWOOD: return ELF::EF_AMDGPU_MACH_R600_REDWOOD;
176 case GK_SUMO: return ELF::EF_AMDGPU_MACH_R600_SUMO;
177 case GK_BARTS: return ELF::EF_AMDGPU_MACH_R600_BARTS;
178 case GK_CAICOS: return ELF::EF_AMDGPU_MACH_R600_CAICOS;
179 case GK_CAYMAN: return ELF::EF_AMDGPU_MACH_R600_CAYMAN;
180 case GK_TURKS: return ELF::EF_AMDGPU_MACH_R600_TURKS;
181 case GK_GFX600: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX600;
182 case GK_GFX601: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX601;
183 case GK_GFX602: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX602;
184 case GK_GFX700: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX700;
185 case GK_GFX701: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX701;
186 case GK_GFX702: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX702;
187 case GK_GFX703: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX703;
188 case GK_GFX704: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX704;
189 case GK_GFX705: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX705;
190 case GK_GFX801: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX801;
191 case GK_GFX802: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX802;
192 case GK_GFX803: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX803;
193 case GK_GFX805: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX805;
194 case GK_GFX810: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX810;
195 case GK_GFX900: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX900;
196 case GK_GFX902: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX902;
197 case GK_GFX904: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX904;
198 case GK_GFX906: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX906;
199 case GK_GFX908: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX908;
200 case GK_GFX909: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX909;
201 case GK_GFX90A: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A;
202 case GK_GFX90C: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C;
203 case GK_GFX942: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX942;
204 case GK_GFX950: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX950;
205 case GK_GFX1010: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010;
206 case GK_GFX1011: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011;
207 case GK_GFX1012: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012;
208 case GK_GFX1013: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013;
209 case GK_GFX1030: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030;
210 case GK_GFX1031: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031;
211 case GK_GFX1032: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032;
212 case GK_GFX1033: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033;
213 case GK_GFX1034: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034;
214 case GK_GFX1035: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035;
215 case GK_GFX1036: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036;
216 case GK_GFX1100: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100;
217 case GK_GFX1101: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101;
218 case GK_GFX1102: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102;
219 case GK_GFX1103: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103;
220 case GK_GFX1150: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1150;
221 case GK_GFX1151: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1151;
222 case GK_GFX1152: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1152;
223 case GK_GFX1153: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1153;
224 case GK_GFX1154: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1154;
225 case GK_GFX1170: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1170;
226 case GK_GFX1171: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1171;
227 case GK_GFX1172: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1172;
228 case GK_GFX1200: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1200;
229 case GK_GFX1201: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1201;
230 case GK_GFX1250: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1250;
231 case GK_GFX1251: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1251;
232 case GK_GFX1310: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1310;
233 case GK_GFX9_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_GENERIC;
234 case GK_GFX9_4_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX9_4_GENERIC;
235 case GK_GFX10_1_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_1_GENERIC;
236 case GK_GFX10_3_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX10_3_GENERIC;
237 case GK_GFX11_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX11_GENERIC;
238 case GK_GFX11_7_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX11_7_GENERIC;
239 case GK_GFX12_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX12_GENERIC;
240 case GK_GFX12_5_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX12_5_GENERIC;
241 case GK_GFX13_GENERIC: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX13_GENERIC;
242 case GK_GENERIC:
243 case GK_GENERIC_HSA:
244 case GK_NONE: return ELF::EF_AMDGPU_MACH_NONE;
245 }
246 // clang-format on
247
248 llvm_unreachable("unknown GPU");
249}
250
251//===----------------------------------------------------------------------===//
252// AMDGPUTargetAsmStreamer
253//===----------------------------------------------------------------------===//
254
258
259// A hook for emitting stuff at the end.
260// We use it for emitting the accumulated PAL metadata as directives.
261// The PAL metadata is reset after it is emitted.
262void AMDGPUTargetAsmStreamer::finish() {
263 std::string S;
264 getPALMetadata()->toString(S);
265 OS << S;
266
267 // Reset the pal metadata so its data will not affect a compilation that
268 // reuses this object.
269 getPALMetadata()->reset();
270}
271
272void AMDGPUTargetAsmStreamer::EmitDirectiveAMDGCNTarget() {
273 OS << "\t.amdgcn_target \"" << *getTargetID() << "\"\n";
274}
275
276void AMDGPUTargetAsmStreamer::EmitDirectiveAMDHSACodeObjectVersion(
277 unsigned COV) {
278 AMDGPUTargetStreamer::EmitDirectiveAMDHSACodeObjectVersion(COV);
279 OS << "\t.amdhsa_code_object_version " << COV << '\n';
280}
281
282void AMDGPUTargetAsmStreamer::EmitAMDKernelCodeT(AMDGPUMCKernelCodeT &Header) {
283 auto FoldAndPrint = [&](const MCExpr *Expr, raw_ostream &OS,
284 const MCAsmInfo *MAI) {
285 printAMDGPUMCExpr(foldAMDGPUMCExpr(Expr, getContext()), OS, MAI);
286 };
287
288 OS << "\t.amd_kernel_code_t\n";
289 Header.EmitKernelCodeT(OS, getContext(), FoldAndPrint);
290 OS << "\t.end_amd_kernel_code_t\n";
291}
292
293void AMDGPUTargetAsmStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
294 unsigned Type) {
295 switch (Type) {
296 default:
297 llvm_unreachable("Invalid AMDGPU symbol type");
298 case ELF::STT_AMDGPU_HSA_KERNEL:
299 OS << "\t.amdgpu_hsa_kernel " << SymbolName << '\n';
300 break;
301 }
302}
303
304void AMDGPUTargetAsmStreamer::emitAMDGPULDS(MCSymbol *Symbol, unsigned Size,
305 Align Alignment) {
306 OS << "\t.amdgpu_lds " << Symbol->getName() << ", " << Size << ", "
307 << Alignment.value() << '\n';
308}
309
310void AMDGPUTargetAsmStreamer::EmitMCResourceInfo(
311 const MCSymbol *NumVGPR, const MCSymbol *NumAGPR,
312 const MCSymbol *NumExplicitSGPR, const MCSymbol *NumNamedBarrier,
313 const MCSymbol *PrivateSegmentSize, const MCSymbol *UsesVCC,
314 const MCSymbol *UsesFlatScratch, const MCSymbol *HasDynamicallySizedStack,
315 const MCSymbol *HasRecursion, const MCSymbol *HasIndirectCall) {
316#define PRINT_RES_INFO(ARG) \
317 OS << "\t.set "; \
318 ARG->print(OS, &getContext().getAsmInfo()); \
319 OS << ", "; \
320 getContext().getAsmInfo().printExpr(OS, *ARG->getVariableValue()); \
321 Streamer.addBlankLine();
322
323 PRINT_RES_INFO(NumVGPR);
324 PRINT_RES_INFO(NumAGPR);
325 PRINT_RES_INFO(NumExplicitSGPR);
326 PRINT_RES_INFO(NumNamedBarrier);
327 PRINT_RES_INFO(PrivateSegmentSize);
328 PRINT_RES_INFO(UsesVCC);
329 PRINT_RES_INFO(UsesFlatScratch);
330 PRINT_RES_INFO(HasDynamicallySizedStack);
331 PRINT_RES_INFO(HasRecursion);
332 PRINT_RES_INFO(HasIndirectCall);
333#undef PRINT_RES_INFO
334}
335
336void AMDGPUTargetAsmStreamer::EmitMCResourceMaximums(
337 const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR, const MCSymbol *MaxSGPR,
338 const MCSymbol *MaxNamedBarrier) {
339#define PRINT_RES_INFO(ARG) \
340 OS << "\t.set "; \
341 ARG->print(OS, &getContext().getAsmInfo()); \
342 OS << ", "; \
343 getContext().getAsmInfo().printExpr(OS, *ARG->getVariableValue()); \
344 Streamer.addBlankLine();
345
346 PRINT_RES_INFO(MaxVGPR);
347 PRINT_RES_INFO(MaxAGPR);
348 PRINT_RES_INFO(MaxSGPR);
349 PRINT_RES_INFO(MaxNamedBarrier);
350#undef PRINT_RES_INFO
351}
352
353bool AMDGPUTargetAsmStreamer::EmitISAVersion() {
354 OS << "\t.amd_amdgpu_isa \"" << getTargetID() << "\"\n";
355 return true;
356}
357
358bool AMDGPUTargetAsmStreamer::EmitHSAMetadata(msgpack::Document &HSAMetadataDoc,
359 bool Strict) {
360 HSAMD::V3::MetadataVerifier Verifier(Strict);
361 if (!Verifier.verify(HSAMetadataDoc.getRoot()))
362 return false;
363
364 std::string HSAMetadataString;
365 raw_string_ostream StrOS(HSAMetadataString);
366 HSAMetadataDoc.toYAML(StrOS);
367
368 OS << '\t' << HSAMD::V3::AssemblerDirectiveBegin << '\n';
369 OS << StrOS.str() << '\n';
370 OS << '\t' << HSAMD::V3::AssemblerDirectiveEnd << '\n';
371 return true;
372}
373
374bool AMDGPUTargetAsmStreamer::EmitCodeEnd(const MCSubtargetInfo &STI) {
375 const uint32_t Encoded_s_code_end = 0xbf9f0000;
376 const uint32_t Encoded_s_nop = 0xbf800000;
377 uint32_t Encoded_pad = Encoded_s_code_end;
378
379 // Instruction cache line size in bytes.
380 const unsigned Log2CacheLineSize = AMDGPU::isGFX11Plus(STI) ? 7 : 6;
381 const unsigned CacheLineSize = 1u << Log2CacheLineSize;
382
383 // Extra padding amount in bytes to support prefetch mode 3.
384 unsigned FillSize = 3 * CacheLineSize;
385
386 if (AMDGPU::isGFX90A(STI)) {
387 Encoded_pad = Encoded_s_nop;
388 FillSize = 16 * CacheLineSize;
389 }
390
391 OS << "\t.p2alignl " << Log2CacheLineSize << ", " << Encoded_pad << '\n';
392 OS << "\t.fill " << (FillSize / 4) << ", 4, " << Encoded_pad << '\n';
393 return true;
394}
395
396void AMDGPUTargetAsmStreamer::EmitAmdhsaKernelDescriptor(
397 const MCSubtargetInfo &STI, StringRef KernelName,
398 const MCKernelDescriptor &KD, const MCExpr *NextVGPR,
399 const MCExpr *NextSGPR, const MCExpr *ReserveVCC,
400 const MCExpr *ReserveFlatScr) {
401 IsaVersion IVersion = getIsaVersion(STI.getCPU());
402 const MCAsmInfo &MAI = getContext().getAsmInfo();
403
404 OS << "\t.amdhsa_kernel " << KernelName << '\n';
405
406 auto PrintField = [&](const MCExpr *Expr, uint32_t Shift, uint32_t Mask,
407 StringRef Directive) {
408 OS << "\t\t" << Directive << ' ';
409 const MCExpr *ShiftedAndMaskedExpr =
410 MCKernelDescriptor::bits_get(Expr, Shift, Mask, getContext());
411 const MCExpr *New = foldAMDGPUMCExpr(ShiftedAndMaskedExpr, getContext());
412 printAMDGPUMCExpr(New, OS, &MAI);
413 OS << '\n';
414 };
415
416 auto EmitMCExpr = [&](const MCExpr *Value) {
417 const MCExpr *NewExpr = foldAMDGPUMCExpr(Value, getContext());
418 printAMDGPUMCExpr(NewExpr, OS, &MAI);
419 };
420
421 OS << "\t\t.amdhsa_group_segment_fixed_size ";
422 EmitMCExpr(KD.group_segment_fixed_size);
423 OS << '\n';
424
425 OS << "\t\t.amdhsa_private_segment_fixed_size ";
426 EmitMCExpr(KD.private_segment_fixed_size);
427 OS << '\n';
428
429 OS << "\t\t.amdhsa_kernarg_size ";
430 EmitMCExpr(KD.kernarg_size);
431 OS << '\n';
432
433 if (isGFX1250Plus(STI)) {
434 PrintField(KD.compute_pgm_rsrc2,
435 amdhsa::COMPUTE_PGM_RSRC2_GFX125_USER_SGPR_COUNT_SHIFT,
436 amdhsa::COMPUTE_PGM_RSRC2_GFX125_USER_SGPR_COUNT,
437 ".amdhsa_user_sgpr_count");
438 } else {
439 PrintField(KD.compute_pgm_rsrc2,
440 amdhsa::COMPUTE_PGM_RSRC2_GFX6_GFX120_USER_SGPR_COUNT_SHIFT,
441 amdhsa::COMPUTE_PGM_RSRC2_GFX6_GFX120_USER_SGPR_COUNT,
442 ".amdhsa_user_sgpr_count");
443 }
444
445 if (!hasArchitectedFlatScratch(STI))
446 PrintField(
447 KD.kernel_code_properties,
448 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_BUFFER_SHIFT,
449 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_BUFFER,
450 ".amdhsa_user_sgpr_private_segment_buffer");
451 PrintField(KD.kernel_code_properties,
452 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_PTR_SHIFT,
453 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_PTR,
454 ".amdhsa_user_sgpr_dispatch_ptr");
455 PrintField(KD.kernel_code_properties,
456 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_QUEUE_PTR_SHIFT,
457 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_QUEUE_PTR,
458 ".amdhsa_user_sgpr_queue_ptr");
459 PrintField(KD.kernel_code_properties,
460 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_KERNARG_SEGMENT_PTR_SHIFT,
461 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_KERNARG_SEGMENT_PTR,
462 ".amdhsa_user_sgpr_kernarg_segment_ptr");
463 PrintField(KD.kernel_code_properties,
464 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_ID_SHIFT,
465 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_ID,
466 ".amdhsa_user_sgpr_dispatch_id");
467 if (!hasArchitectedFlatScratch(STI))
468 PrintField(KD.kernel_code_properties,
469 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_FLAT_SCRATCH_INIT_SHIFT,
470 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_FLAT_SCRATCH_INIT,
471 ".amdhsa_user_sgpr_flat_scratch_init");
472 if (hasKernargPreload(STI)) {
473 PrintField(KD.kernarg_preload, amdhsa::KERNARG_PRELOAD_SPEC_LENGTH_SHIFT,
474 amdhsa::KERNARG_PRELOAD_SPEC_LENGTH,
475 ".amdhsa_user_sgpr_kernarg_preload_length");
476 PrintField(KD.kernarg_preload, amdhsa::KERNARG_PRELOAD_SPEC_OFFSET_SHIFT,
477 amdhsa::KERNARG_PRELOAD_SPEC_OFFSET,
478 ".amdhsa_user_sgpr_kernarg_preload_offset");
479 }
480 PrintField(
481 KD.kernel_code_properties,
482 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_SIZE_SHIFT,
483 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_SIZE,
484 ".amdhsa_user_sgpr_private_segment_size");
485 if (IVersion.Major >= 10)
486 PrintField(KD.kernel_code_properties,
487 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32_SHIFT,
488 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32,
489 ".amdhsa_wavefront_size32");
490 if (CodeObjectVersion >= AMDGPU::AMDHSA_COV5)
491 PrintField(KD.kernel_code_properties,
492 amdhsa::KERNEL_CODE_PROPERTY_USES_DYNAMIC_STACK_SHIFT,
493 amdhsa::KERNEL_CODE_PROPERTY_USES_DYNAMIC_STACK,
494 ".amdhsa_uses_dynamic_stack");
495 PrintField(KD.compute_pgm_rsrc2,
496 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_PRIVATE_SEGMENT_SHIFT,
497 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_PRIVATE_SEGMENT,
498 (hasArchitectedFlatScratch(STI)
499 ? ".amdhsa_enable_private_segment"
500 : ".amdhsa_system_sgpr_private_segment_wavefront_offset"));
501 PrintField(KD.compute_pgm_rsrc2,
502 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_X_SHIFT,
503 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_X,
504 ".amdhsa_system_sgpr_workgroup_id_x");
505 PrintField(KD.compute_pgm_rsrc2,
506 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Y_SHIFT,
507 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Y,
508 ".amdhsa_system_sgpr_workgroup_id_y");
509 PrintField(KD.compute_pgm_rsrc2,
510 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Z_SHIFT,
511 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Z,
512 ".amdhsa_system_sgpr_workgroup_id_z");
513 PrintField(KD.compute_pgm_rsrc2,
514 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_INFO_SHIFT,
515 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_INFO,
516 ".amdhsa_system_sgpr_workgroup_info");
517 PrintField(KD.compute_pgm_rsrc2,
518 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_VGPR_WORKITEM_ID_SHIFT,
519 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_VGPR_WORKITEM_ID,
520 ".amdhsa_system_vgpr_workitem_id");
521
522 // These directives are required.
523 OS << "\t\t.amdhsa_next_free_vgpr ";
524 EmitMCExpr(NextVGPR);
525 OS << '\n';
526
527 OS << "\t\t.amdhsa_next_free_sgpr ";
528 EmitMCExpr(NextSGPR);
529 OS << '\n';
530
531 if (AMDGPU::isGFX90A(STI)) {
532 // MCExpr equivalent of taking the (accum_offset + 1) * 4.
533 const MCExpr *accum_bits = MCKernelDescriptor::bits_get(
534 KD.compute_pgm_rsrc3,
535 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET_SHIFT,
536 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET, getContext());
537 accum_bits = MCBinaryExpr::createAdd(
538 accum_bits, MCConstantExpr::create(1, getContext()), getContext());
539 accum_bits = MCBinaryExpr::createMul(
540 accum_bits, MCConstantExpr::create(4, getContext()), getContext());
541 OS << "\t\t.amdhsa_accum_offset ";
542 const MCExpr *New = foldAMDGPUMCExpr(accum_bits, getContext());
543 printAMDGPUMCExpr(New, OS, &MAI);
544 OS << '\n';
545 }
546
547 if (isGFX1250Plus(STI))
548 PrintField(KD.compute_pgm_rsrc3,
549 amdhsa::COMPUTE_PGM_RSRC3_GFX125_NAMED_BAR_CNT_SHIFT,
550 amdhsa::COMPUTE_PGM_RSRC3_GFX125_NAMED_BAR_CNT,
551 ".amdhsa_named_barrier_count");
552
553 OS << "\t\t.amdhsa_reserve_vcc ";
554 EmitMCExpr(ReserveVCC);
555 OS << '\n';
556
557 if (IVersion.Major >= 7 && !hasArchitectedFlatScratch(STI)) {
558 OS << "\t\t.amdhsa_reserve_flat_scratch ";
559 EmitMCExpr(ReserveFlatScr);
560 OS << '\n';
561 }
562
563 switch (CodeObjectVersion) {
564 default:
565 break;
566 case AMDGPU::AMDHSA_COV4:
567 case AMDGPU::AMDHSA_COV5:
568 if (STI.hasFeature(AMDGPU::FeatureSupportsXNACK)) {
569 bool XnackOn = getTargetID()->isXnackOnOrAny() ||
570 STI.hasFeature(AMDGPU::FeatureXNACK);
571 OS << "\t\t.amdhsa_reserve_xnack_mask " << XnackOn << '\n';
572 }
573 break;
574 }
575
576 PrintField(KD.compute_pgm_rsrc1,
577 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_32_SHIFT,
578 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_32,
579 ".amdhsa_float_round_mode_32");
580 PrintField(KD.compute_pgm_rsrc1,
581 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_16_64_SHIFT,
582 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_16_64,
583 ".amdhsa_float_round_mode_16_64");
584 PrintField(KD.compute_pgm_rsrc1,
585 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_32_SHIFT,
586 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_32,
587 ".amdhsa_float_denorm_mode_32");
588 PrintField(KD.compute_pgm_rsrc1,
589 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_16_64_SHIFT,
590 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_16_64,
591 ".amdhsa_float_denorm_mode_16_64");
592 if (STI.hasFeature(AMDGPU::FeatureDX10ClampAndIEEEMode)) {
593 PrintField(KD.compute_pgm_rsrc1,
594 amdhsa::COMPUTE_PGM_RSRC1_GFX6_GFX11_ENABLE_DX10_CLAMP_SHIFT,
595 amdhsa::COMPUTE_PGM_RSRC1_GFX6_GFX11_ENABLE_DX10_CLAMP,
596 ".amdhsa_dx10_clamp");
597 PrintField(KD.compute_pgm_rsrc1,
598 amdhsa::COMPUTE_PGM_RSRC1_GFX6_GFX11_ENABLE_IEEE_MODE_SHIFT,
599 amdhsa::COMPUTE_PGM_RSRC1_GFX6_GFX11_ENABLE_IEEE_MODE,
600 ".amdhsa_ieee_mode");
601 }
602 if (IVersion.Major >= 9) {
603 PrintField(KD.compute_pgm_rsrc1,
604 amdhsa::COMPUTE_PGM_RSRC1_GFX9_PLUS_FP16_OVFL_SHIFT,
605 amdhsa::COMPUTE_PGM_RSRC1_GFX9_PLUS_FP16_OVFL,
606 ".amdhsa_fp16_overflow");
607 }
608 if (AMDGPU::isGFX90A(STI))
609 PrintField(KD.compute_pgm_rsrc3,
610 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT_SHIFT,
611 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT, ".amdhsa_tg_split");
612 if (AMDGPU::supportsWGP(STI))
613 PrintField(KD.compute_pgm_rsrc1,
614 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_WGP_MODE_SHIFT,
615 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_WGP_MODE,
616 ".amdhsa_workgroup_processor_mode");
617 if (IVersion.Major >= 10) {
618 PrintField(KD.compute_pgm_rsrc1,
619 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_MEM_ORDERED_SHIFT,
620 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_MEM_ORDERED,
621 ".amdhsa_memory_ordered");
622 PrintField(KD.compute_pgm_rsrc1,
623 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_FWD_PROGRESS_SHIFT,
624 amdhsa::COMPUTE_PGM_RSRC1_GFX10_PLUS_FWD_PROGRESS,
625 ".amdhsa_forward_progress");
626 }
627 if (IVersion.Major >= 10 && IVersion.Major < 12) {
628 PrintField(KD.compute_pgm_rsrc3,
629 amdhsa::COMPUTE_PGM_RSRC3_GFX10_GFX11_SHARED_VGPR_COUNT_SHIFT,
630 amdhsa::COMPUTE_PGM_RSRC3_GFX10_GFX11_SHARED_VGPR_COUNT,
631 ".amdhsa_shared_vgpr_count");
632 }
633 if (IVersion.Major == 11) {
634 PrintField(KD.compute_pgm_rsrc3,
635 amdhsa::COMPUTE_PGM_RSRC3_GFX11_INST_PREF_SIZE_SHIFT,
636 amdhsa::COMPUTE_PGM_RSRC3_GFX11_INST_PREF_SIZE,
637 ".amdhsa_inst_pref_size");
638 }
639 if (IVersion.Major >= 12) {
640 PrintField(KD.compute_pgm_rsrc3,
641 amdhsa::COMPUTE_PGM_RSRC3_GFX12_PLUS_INST_PREF_SIZE_SHIFT,
642 amdhsa::COMPUTE_PGM_RSRC3_GFX12_PLUS_INST_PREF_SIZE,
643 ".amdhsa_inst_pref_size");
644 PrintField(KD.compute_pgm_rsrc1,
645 amdhsa::COMPUTE_PGM_RSRC1_GFX12_PLUS_ENABLE_WG_RR_EN_SHIFT,
646 amdhsa::COMPUTE_PGM_RSRC1_GFX12_PLUS_ENABLE_WG_RR_EN,
647 ".amdhsa_round_robin_scheduling");
648 }
649 PrintField(
650 KD.compute_pgm_rsrc2,
651 amdhsa::
652 COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INVALID_OPERATION_SHIFT,
653 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INVALID_OPERATION,
654 ".amdhsa_exception_fp_ieee_invalid_op");
655 PrintField(
656 KD.compute_pgm_rsrc2,
657 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_FP_DENORMAL_SOURCE_SHIFT,
658 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_FP_DENORMAL_SOURCE,
659 ".amdhsa_exception_fp_denorm_src");
660 PrintField(
661 KD.compute_pgm_rsrc2,
662 amdhsa::
663 COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_DIVISION_BY_ZERO_SHIFT,
664 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_DIVISION_BY_ZERO,
665 ".amdhsa_exception_fp_ieee_div_zero");
666 PrintField(
667 KD.compute_pgm_rsrc2,
668 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_OVERFLOW_SHIFT,
669 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_OVERFLOW,
670 ".amdhsa_exception_fp_ieee_overflow");
671 PrintField(
672 KD.compute_pgm_rsrc2,
673 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_UNDERFLOW_SHIFT,
674 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_UNDERFLOW,
675 ".amdhsa_exception_fp_ieee_underflow");
676 PrintField(
677 KD.compute_pgm_rsrc2,
678 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INEXACT_SHIFT,
679 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INEXACT,
680 ".amdhsa_exception_fp_ieee_inexact");
681 PrintField(
682 KD.compute_pgm_rsrc2,
683 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_INT_DIVIDE_BY_ZERO_SHIFT,
684 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_INT_DIVIDE_BY_ZERO,
685 ".amdhsa_exception_int_div_zero");
686
687 OS << "\t.end_amdhsa_kernel\n";
688}
689
690namespace {
691/// Callback type invoked by \c forEachInfoScope for each function scope in
692/// the canonical iteration order. The scope is emitted exactly once per
693/// unique \p Sym regardless of how many flat entries reference it.
694using InfoScopeEmitter = function_ref<void(
695 MCSymbol *Sym, const AMDGPU::FuncInfo *Info, ArrayRef<MCSymbol *> Uses,
696 ArrayRef<MCSymbol *> Calls, ArrayRef<StringRef> IndirectCallTypeIds,
697 ArrayRef<StringRef> TypeIds)>;
698
699/// Group the flat edge lists in \p Data by source function symbol and drive
700/// per-scope emission. A scope is opened for every function with attached
701/// info and for every function that appears only as an edge source; each
702/// scope is emitted exactly once. Both the asm and ELF streamers share this
703/// iteration logic and only differ in the per-scope emission callback.
704static void forEachInfoScope(const AMDGPU::InfoSectionData &Data,
705 InfoScopeEmitter Emit) {
706 DenseMap<MCSymbol *, SmallVector<MCSymbol *, 2>> FuncUses;
707 DenseMap<MCSymbol *, SmallVector<MCSymbol *, 4>> FuncCalls;
708 DenseMap<MCSymbol *, SmallVector<StringRef, 2>> FuncIndirectCalls;
709 DenseMap<MCSymbol *, SmallVector<StringRef, 1>> FuncTypeIds;
710 for (const auto &[Func, Res] : Data.Uses)
711 FuncUses[Func].push_back(Res);
712 for (const auto &[Src, Dst] : Data.Calls)
713 FuncCalls[Src].push_back(Dst);
714 for (const auto &[Func, TypeId] : Data.IndirectCalls)
715 FuncIndirectCalls[Func].push_back(TypeId);
716 for (const auto &[Sym, TypeId] : Data.TypeIds)
717 FuncTypeIds[Sym].push_back(TypeId);
718
719 DenseSet<MCSymbol *> Emitted;
720 auto EmitIfNew = [&](MCSymbol *Sym, const AMDGPU::FuncInfo *Info) {
721 if (!Emitted.insert(Sym).second)
722 return;
723 ArrayRef<MCSymbol *> Uses, Calls;
724 ArrayRef<StringRef> IndirectCallTypeIds, TypeIds;
725 if (auto It = FuncUses.find(Sym); It != FuncUses.end())
726 Uses = It->second;
727 if (auto It = FuncCalls.find(Sym); It != FuncCalls.end())
728 Calls = It->second;
729 if (auto It = FuncIndirectCalls.find(Sym); It != FuncIndirectCalls.end())
730 IndirectCallTypeIds = It->second;
731 if (auto It = FuncTypeIds.find(Sym); It != FuncTypeIds.end())
732 TypeIds = It->second;
733 Emit(Sym, Info, Uses, Calls, IndirectCallTypeIds, TypeIds);
734 };
735
736 for (const AMDGPU::FuncInfo &Func : Data.Funcs)
737 EmitIfNew(Func.Sym, &Func);
738 // Emit scopes for functions that only appear as edge sources (e.g. typeid
739 // tags on address-taken declarations, or callers of external functions).
740 for (const auto &[Sym, TypeId] : Data.TypeIds)
741 EmitIfNew(Sym, nullptr);
742 for (const auto &[Sym, Res] : Data.Uses)
743 EmitIfNew(Sym, nullptr);
744 for (const auto &[Sym, Dst] : Data.Calls)
745 EmitIfNew(Sym, nullptr);
746 for (const auto &[Sym, TypeId] : Data.IndirectCalls)
747 EmitIfNew(Sym, nullptr);
748}
749} // namespace
750
751void AMDGPUTargetAsmStreamer::emitAMDGPUInfo(
752 const AMDGPU::InfoSectionData &Data) {
753 forEachInfoScope(Data, [&](MCSymbol *Sym, const AMDGPU::FuncInfo *Info,
754 ArrayRef<MCSymbol *> Uses,
755 ArrayRef<MCSymbol *> Calls,
756 ArrayRef<StringRef> IndirectCallTypeIds,
757 ArrayRef<StringRef> TypeIds) {
758 OS << "\t.amdgpu_info " << Sym->getName() << '\n';
759 if (Info) {
760 AMDGPU::FuncInfoFlags Flags{};
761 if (Info->UsesVCC)
762 Flags |= AMDGPU::FuncInfoFlags::FUNC_USES_VCC;
763 if (Info->UsesFlatScratch)
764 Flags |= AMDGPU::FuncInfoFlags::FUNC_USES_FLAT_SCRATCH;
765 if (Info->HasDynStack)
766 Flags |= AMDGPU::FuncInfoFlags::FUNC_HAS_DYN_STACK;
767 OS << "\t\t.amdgpu_flags " << llvm::to_underlying(Flags) << '\n';
768 OS << "\t\t.amdgpu_num_sgpr " << Info->NumSGPR << '\n';
769 OS << "\t\t.amdgpu_num_vgpr " << Info->NumArchVGPR << '\n';
770 if (Info->NumAccVGPR)
771 OS << "\t\t.amdgpu_num_agpr " << Info->NumAccVGPR << '\n';
772 OS << "\t\t.amdgpu_private_segment_size " << Info->PrivateSegmentSize
773 << '\n';
774 }
775 for (MCSymbol *Res : Uses)
776 OS << "\t\t.amdgpu_use " << Res->getName() << '\n';
777 for (MCSymbol *Dst : Calls)
778 OS << "\t\t.amdgpu_call " << Dst->getName() << '\n';
779 for (StringRef TypeId : IndirectCallTypeIds)
780 OS << "\t\t.amdgpu_indirect_call \"" << TypeId << "\"\n";
781 for (StringRef TypeId : TypeIds)
782 OS << "\t\t.amdgpu_typeid \"" << TypeId << "\"\n";
783 OS << "\t.end_amdgpu_info\n\n";
784 });
785}
786
787//===----------------------------------------------------------------------===//
788// AMDGPUTargetELFStreamer
789//===----------------------------------------------------------------------===//
790
794
795MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() {
796 return static_cast<MCELFStreamer &>(Streamer);
797}
798
799// A hook for emitting stuff at the end.
800// We use it for emitting the accumulated PAL metadata as a .note record.
801// The PAL metadata is reset after it is emitted.
802void AMDGPUTargetELFStreamer::finish() {
803 ELFObjectWriter &W = getStreamer().getWriter();
804 W.setELFHeaderEFlags(getEFlags());
805 W.setOverrideABIVersion(
806 getELFABIVersion(STI.getTargetTriple(), CodeObjectVersion));
807
808 std::string Blob;
809 const char *Vendor = getPALMetadata()->getVendor();
810 unsigned Type = getPALMetadata()->getType();
811 getPALMetadata()->toBlob(Type, Blob);
812 if (Blob.empty())
813 return;
814 EmitNote(Vendor, MCConstantExpr::create(Blob.size(), getContext()), Type,
815 [&](MCELFStreamer &OS) { OS.emitBytes(Blob); });
816
817 // Reset the pal metadata so its data will not affect a compilation that
818 // reuses this object.
819 getPALMetadata()->reset();
820}
821
822void AMDGPUTargetELFStreamer::EmitNote(
823 StringRef Name, const MCExpr *DescSZ, unsigned NoteType,
824 function_ref<void(MCELFStreamer &)> EmitDesc) {
825 auto &S = getStreamer();
826 auto &Context = S.getContext();
827
828 auto NameSZ = Name.size() + 1;
829
830 unsigned NoteFlags = 0;
831 // TODO Apparently, this is currently needed for OpenCL as mentioned in
832 // https://reviews.llvm.org/D74995
833 if (isHsaAbi(STI))
834 NoteFlags = ELF::SHF_ALLOC;
835
836 S.pushSection();
837 S.switchSection(
838 Context.getELFSection(ElfNote::SectionName, ELF::SHT_NOTE, NoteFlags));
839 S.emitInt32(NameSZ); // namesz
840 S.emitValue(DescSZ, 4); // descz
841 S.emitInt32(NoteType); // type
842 S.emitBytes(Name); // name
843 S.emitInt8(0); // null terminator
844 S.emitValueToAlignment(Align(4), 0, 1, 0); // padding 0
845 EmitDesc(S); // desc
846 S.emitValueToAlignment(Align(4), 0, 1, 0); // padding 0
847 S.popSection();
848}
849
850unsigned AMDGPUTargetELFStreamer::getEFlags() {
851 switch (STI.getTargetTriple().getArch()) {
852 default:
853 llvm_unreachable("Unsupported Arch");
854 case Triple::r600:
855 return getEFlagsR600();
856 case Triple::amdgpu:
857 return getEFlagsAMDGCN();
858 }
859}
860
861unsigned AMDGPUTargetELFStreamer::getEFlagsR600() {
862 assert(STI.getTargetTriple().getArch() == Triple::r600);
863
864 return getElfMach(STI.getCPU());
865}
866
867unsigned AMDGPUTargetELFStreamer::getEFlagsAMDGCN() {
868 assert(STI.getTargetTriple().isAMDGCN());
869
870 switch (STI.getTargetTriple().getOS()) {
871 default:
872 // TODO: Why are some tests have "mingw" listed as OS?
873 // llvm_unreachable("Unsupported OS");
874 case Triple::UnknownOS:
875 return getEFlagsUnknownOS();
876 case Triple::AMDHSA:
877 return getEFlagsAMDHSA();
878 case Triple::AMDPAL:
879 return getEFlagsAMDPAL();
880 case Triple::Mesa3D:
881 return getEFlagsMesa3D();
882 }
883}
884
885unsigned AMDGPUTargetELFStreamer::getEFlagsUnknownOS() {
886 // TODO: Why are some tests have "mingw" listed as OS?
887 // assert(STI.getTargetTriple().getOS() == Triple::UnknownOS);
888
889 return getEFlagsV3();
890}
891
892unsigned AMDGPUTargetELFStreamer::getEFlagsAMDHSA() {
893 assert(isHsaAbi(STI));
894
895 if (CodeObjectVersion >= 6)
896 return getEFlagsV6();
897 return getEFlagsV4();
898}
899
900unsigned AMDGPUTargetELFStreamer::getEFlagsAMDPAL() {
901 assert(STI.getTargetTriple().getOS() == Triple::AMDPAL);
902
903 return getEFlagsV3();
904}
905
906unsigned AMDGPUTargetELFStreamer::getEFlagsMesa3D() {
907 assert(STI.getTargetTriple().getOS() == Triple::Mesa3D);
908
909 return getEFlagsV3();
910}
911
912unsigned AMDGPUTargetELFStreamer::getEFlagsV3() {
913 unsigned EFlagsV3 = 0;
914
915 // mach.
916 EFlagsV3 |= getElfMach(STI.getCPU());
917
918 // xnack.
919 if (getTargetID()->isXnackOnOrAny())
920 EFlagsV3 |= ELF::EF_AMDGPU_FEATURE_XNACK_V3;
921 // sramecc.
922 if (getTargetID()->isSramEccOnOrAny())
923 EFlagsV3 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_V3;
924
925 return EFlagsV3;
926}
927
928unsigned AMDGPUTargetELFStreamer::getEFlagsV4() {
929 unsigned EFlagsV4 = 0;
930
931 // mach.
932 EFlagsV4 |= getElfMach(STI.getCPU());
933
934 // xnack.
935 switch (getTargetID()->getXnackSetting()) {
936 case AMDGPU::TargetIDSetting::Unsupported:
937 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4;
938 break;
939 case AMDGPU::TargetIDSetting::Any:
940 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4;
941 break;
942 case AMDGPU::TargetIDSetting::Off:
943 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4;
944 break;
945 case AMDGPU::TargetIDSetting::On:
946 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4;
947 break;
948 }
949 // sramecc.
950 switch (getTargetID()->getSramEccSetting()) {
951 case AMDGPU::TargetIDSetting::Unsupported:
952 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4;
953 break;
954 case AMDGPU::TargetIDSetting::Any:
955 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4;
956 break;
957 case AMDGPU::TargetIDSetting::Off:
958 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4;
959 break;
960 case AMDGPU::TargetIDSetting::On:
961 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4;
962 break;
963 }
964
965 return EFlagsV4;
966}
967
968unsigned AMDGPUTargetELFStreamer::getEFlagsV6() {
969 unsigned Flags = getEFlagsV4();
970
971 unsigned Version = ForceGenericVersion;
972 if (!Version) {
973 switch (parseArchAMDGCN(STI.getCPU())) {
974 case AMDGPU::GK_GFX9_GENERIC:
975 Version = GenericVersion::GFX9;
976 break;
977 case AMDGPU::GK_GFX9_4_GENERIC:
978 Version = GenericVersion::GFX9_4;
979 break;
980 case AMDGPU::GK_GFX10_1_GENERIC:
981 Version = GenericVersion::GFX10_1;
982 break;
983 case AMDGPU::GK_GFX10_3_GENERIC:
984 Version = GenericVersion::GFX10_3;
985 break;
986 case AMDGPU::GK_GFX11_GENERIC:
987 Version = GenericVersion::GFX11;
988 break;
989 case AMDGPU::GK_GFX11_7_GENERIC:
990 Version = GenericVersion::GFX11_7;
991 break;
992 case AMDGPU::GK_GFX12_GENERIC:
993 Version = GenericVersion::GFX12;
994 break;
995 case AMDGPU::GK_GFX12_5_GENERIC:
996 Version = GenericVersion::GFX12_5;
997 break;
998 case AMDGPU::GK_GFX13_GENERIC:
999 Version = GenericVersion::GFX13;
1000 break;
1001 default:
1002 break;
1003 }
1004 }
1005
1006 // Versions start at 1.
1007 if (Version) {
1008 if (Version > ELF::EF_AMDGPU_GENERIC_VERSION_MAX)
1009 report_fatal_error("Cannot encode generic code object version " +
1010 Twine(Version) +
1011 " - no ELF flag can represent this version!");
1012 Flags |= (Version << ELF::EF_AMDGPU_GENERIC_VERSION_OFFSET);
1013 }
1014
1015 return Flags;
1016}
1017
1018void AMDGPUTargetELFStreamer::EmitDirectiveAMDGCNTarget() {}
1019
1020void AMDGPUTargetELFStreamer::EmitAMDKernelCodeT(AMDGPUMCKernelCodeT &Header) {
1021 MCStreamer &OS = getStreamer();
1022 OS.pushSection();
1023 Header.EmitKernelCodeT(OS, getContext());
1024 OS.popSection();
1025}
1026
1027void AMDGPUTargetELFStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
1028 unsigned Type) {
1029 auto *Symbol = static_cast<MCSymbolELF *>(
1030 getStreamer().getContext().getOrCreateSymbol(SymbolName));
1031 Symbol->setType(Type);
1032}
1033
1034void AMDGPUTargetELFStreamer::emitAMDGPULDS(MCSymbol *Symbol, unsigned Size,
1035 Align Alignment) {
1036 auto *SymbolELF = static_cast<MCSymbolELF *>(Symbol);
1037 SymbolELF->setType(ELF::STT_OBJECT);
1038
1039 if (!SymbolELF->isBindingSet())
1040 SymbolELF->setBinding(ELF::STB_GLOBAL);
1041
1042 if (SymbolELF->declareCommon(Size, Alignment)) {
1043 report_fatal_error("Symbol: " + Symbol->getName() +
1044 " redeclared as different type");
1045 }
1046
1047 SymbolELF->setIndex(ELF::SHN_AMDGPU_LDS);
1048 SymbolELF->setSize(MCConstantExpr::create(Size, getContext()));
1049}
1050
1051bool AMDGPUTargetELFStreamer::EmitISAVersion() {
1052 // Create two labels to mark the beginning and end of the desc field
1053 // and a MCExpr to calculate the size of the desc field.
1054 auto &Context = getContext();
1055 auto *DescBegin = Context.createTempSymbol();
1056 auto *DescEnd = Context.createTempSymbol();
1057 auto *DescSZ = MCBinaryExpr::createSub(
1058 MCSymbolRefExpr::create(DescEnd, Context),
1059 MCSymbolRefExpr::create(DescBegin, Context), Context);
1060
1061 EmitNote(ElfNote::NoteNameV2, DescSZ, ELF::NT_AMD_HSA_ISA_NAME,
1062 [&](MCELFStreamer &OS) {
1063 OS.emitLabel(DescBegin);
1064
1065 SmallString<32> Str;
1066 raw_svector_ostream StrOS(Str);
1067 StrOS << *getTargetID();
1068
1069 OS.emitBytes(StrOS.str());
1070 OS.emitLabel(DescEnd);
1071 });
1072 return true;
1073}
1074
1075bool AMDGPUTargetELFStreamer::EmitHSAMetadata(msgpack::Document &HSAMetadataDoc,
1076 bool Strict) {
1077 HSAMD::V3::MetadataVerifier Verifier(Strict);
1078 if (!Verifier.verify(HSAMetadataDoc.getRoot()))
1079 return false;
1080
1081 std::string HSAMetadataString;
1082 HSAMetadataDoc.writeToBlob(HSAMetadataString);
1083
1084 // Create two labels to mark the beginning and end of the desc field
1085 // and a MCExpr to calculate the size of the desc field.
1086 auto &Context = getContext();
1087 auto *DescBegin = Context.createTempSymbol();
1088 auto *DescEnd = Context.createTempSymbol();
1089 auto *DescSZ = MCBinaryExpr::createSub(
1090 MCSymbolRefExpr::create(DescEnd, Context),
1091 MCSymbolRefExpr::create(DescBegin, Context), Context);
1092
1093 EmitNote(ElfNote::NoteNameV3, DescSZ, ELF::NT_AMDGPU_METADATA,
1094 [&](MCELFStreamer &OS) {
1095 OS.emitLabel(DescBegin);
1096 OS.emitBytes(HSAMetadataString);
1097 OS.emitLabel(DescEnd);
1098 });
1099 return true;
1100}
1101
1102bool AMDGPUTargetELFStreamer::EmitCodeEnd(const MCSubtargetInfo &STI) {
1103 const uint32_t Encoded_s_code_end = 0xbf9f0000;
1104 const uint32_t Encoded_s_nop = 0xbf800000;
1105 uint32_t Encoded_pad = Encoded_s_code_end;
1106
1107 // Instruction cache line size in bytes.
1108 const unsigned Log2CacheLineSize = AMDGPU::isGFX11Plus(STI) ? 7 : 6;
1109 const unsigned CacheLineSize = 1u << Log2CacheLineSize;
1110
1111 // Extra padding amount in bytes to support prefetch mode 3.
1112 unsigned FillSize = 3 * CacheLineSize;
1113
1114 if (AMDGPU::isGFX90A(STI)) {
1115 Encoded_pad = Encoded_s_nop;
1116 FillSize = 16 * CacheLineSize;
1117 }
1118
1119 MCStreamer &OS = getStreamer();
1120 OS.pushSection();
1121 OS.emitValueToAlignment(Align(CacheLineSize), Encoded_pad, 4);
1122 for (unsigned I = 0; I < FillSize; I += 4)
1123 OS.emitInt32(Encoded_pad);
1124 OS.popSection();
1125 return true;
1126}
1127
1128void AMDGPUTargetELFStreamer::EmitAmdhsaKernelDescriptor(
1129 const MCSubtargetInfo &STI, StringRef KernelName,
1130 const MCKernelDescriptor &KernelDescriptor, const MCExpr *NextVGPR,
1131 const MCExpr *NextSGPR, const MCExpr *ReserveVCC,
1132 const MCExpr *ReserveFlatScr) {
1133 auto &Streamer = getStreamer();
1134 auto &Context = Streamer.getContext();
1135
1136 auto *KernelCodeSymbol =
1137 static_cast<MCSymbolELF *>(Context.getOrCreateSymbol(Twine(KernelName)));
1138 auto *KernelDescriptorSymbol = static_cast<MCSymbolELF *>(
1139 Context.getOrCreateSymbol(Twine(KernelName) + Twine(".kd")));
1140
1141 // Copy kernel descriptor symbol's binding, other and visibility from the
1142 // kernel code symbol.
1143 KernelDescriptorSymbol->setBinding(KernelCodeSymbol->getBinding());
1144 KernelDescriptorSymbol->setOther(KernelCodeSymbol->getOther());
1145 KernelDescriptorSymbol->setVisibility(KernelCodeSymbol->getVisibility());
1146 // Kernel descriptor symbol's type and size are fixed.
1147 KernelDescriptorSymbol->setType(ELF::STT_OBJECT);
1148 KernelDescriptorSymbol->setSize(
1149 MCConstantExpr::create(sizeof(amdhsa::kernel_descriptor_t), Context));
1150
1151 // The visibility of the kernel code symbol must be protected or less to allow
1152 // static relocations from the kernel descriptor to be used.
1153 if (KernelCodeSymbol->getVisibility() == ELF::STV_DEFAULT)
1154 KernelCodeSymbol->setVisibility(ELF::STV_PROTECTED);
1155
1156 Streamer.emitLabel(KernelDescriptorSymbol);
1157 Streamer.emitValue(
1158 KernelDescriptor.group_segment_fixed_size,
1159 sizeof(amdhsa::kernel_descriptor_t::group_segment_fixed_size));
1160 Streamer.emitValue(
1161 KernelDescriptor.private_segment_fixed_size,
1162 sizeof(amdhsa::kernel_descriptor_t::private_segment_fixed_size));
1163 Streamer.emitValue(KernelDescriptor.kernarg_size,
1164 sizeof(amdhsa::kernel_descriptor_t::kernarg_size));
1165
1166 for (uint32_t i = 0; i < sizeof(amdhsa::kernel_descriptor_t::reserved0); ++i)
1167 Streamer.emitInt8(0u);
1168
1169 // FIXME: Remove the use of VK_AMDGPU_REL64 in the expression below. The
1170 // expression being created is:
1171 // (start of kernel code) - (start of kernel descriptor)
1172 // It implies R_AMDGPU_REL64, but ends up being R_AMDGPU_ABS64.
1173 Streamer.emitValue(
1174 MCBinaryExpr::createSub(
1175 MCSymbolRefExpr::create(KernelCodeSymbol, AMDGPUMCExpr::S_REL64,
1176 Context),
1177 MCSymbolRefExpr::create(KernelDescriptorSymbol, Context), Context),
1178 sizeof(amdhsa::kernel_descriptor_t::kernel_code_entry_byte_offset));
1179 for (uint32_t i = 0; i < sizeof(amdhsa::kernel_descriptor_t::reserved1); ++i)
1180 Streamer.emitInt8(0u);
1181 Streamer.emitValue(KernelDescriptor.compute_pgm_rsrc3,
1182 sizeof(amdhsa::kernel_descriptor_t::compute_pgm_rsrc3));
1183 Streamer.emitValue(KernelDescriptor.compute_pgm_rsrc1,
1184 sizeof(amdhsa::kernel_descriptor_t::compute_pgm_rsrc1));
1185 Streamer.emitValue(KernelDescriptor.compute_pgm_rsrc2,
1186 sizeof(amdhsa::kernel_descriptor_t::compute_pgm_rsrc2));
1187 Streamer.emitValue(
1188 KernelDescriptor.kernel_code_properties,
1189 sizeof(amdhsa::kernel_descriptor_t::kernel_code_properties));
1190 Streamer.emitValue(KernelDescriptor.kernarg_preload,
1191 sizeof(amdhsa::kernel_descriptor_t::kernarg_preload));
1192 for (uint32_t i = 0; i < sizeof(amdhsa::kernel_descriptor_t::reserved3); ++i)
1193 Streamer.emitInt8(0u);
1194}
1195
1196void AMDGPUTargetELFStreamer::emitAMDGPUInfo(
1197 const AMDGPU::InfoSectionData &Data) {
1198 MCELFStreamer &S = getStreamer();
1199 MCContext &Context = S.getContext();
1200
1201 StringTableBuilder StrTab(StringTableBuilder::ELF);
1202 auto getOrAddString = [&](StringRef Str) -> uint32_t {
1203 if (Str.empty())
1204 return UINT32_MAX;
1205 return StrTab.add(Str);
1206 };
1207
1208 auto EmitU32Entry = [&](AMDGPU::InfoKind Kind, uint32_t Val) {
1209 S.emitInt8(static_cast<uint8_t>(Kind));
1210 S.emitInt8(4);
1211 S.emitInt32(Val);
1212 };
1213 auto EmitSymEntry = [&](AMDGPU::InfoKind Kind, MCSymbol *Sym) {
1214 S.emitInt8(static_cast<uint8_t>(Kind));
1215 S.emitInt8(8);
1216 S.emitValue(MCSymbolRefExpr::create(Sym, Context), 8);
1217 };
1218
1219 S.pushSection();
1220 MCSectionELF *InfoSec = Context.getELFSection(
1221 ".amdgpu.info", ELF::SHT_PROGBITS, ELF::SHF_EXCLUDE);
1222 S.switchSection(InfoSec);
1223
1224 forEachInfoScope(Data, [&](MCSymbol *Sym, const AMDGPU::FuncInfo *Info,
1225 ArrayRef<MCSymbol *> Uses,
1226 ArrayRef<MCSymbol *> Calls,
1227 ArrayRef<StringRef> IndirectCallTypeIds,
1228 ArrayRef<StringRef> TypeIds) {
1229 EmitSymEntry(AMDGPU::InfoKind::INFO_FUNC, Sym);
1230
1231 if (Info) {
1232 AMDGPU::FuncInfoFlags Flags{};
1233 if (Info->UsesVCC)
1234 Flags |= AMDGPU::FuncInfoFlags::FUNC_USES_VCC;
1235 if (Info->UsesFlatScratch)
1236 Flags |= AMDGPU::FuncInfoFlags::FUNC_USES_FLAT_SCRATCH;
1237 if (Info->HasDynStack)
1238 Flags |= AMDGPU::FuncInfoFlags::FUNC_HAS_DYN_STACK;
1239 EmitU32Entry(AMDGPU::InfoKind::INFO_FLAGS, llvm::to_underlying(Flags));
1240 EmitU32Entry(AMDGPU::InfoKind::INFO_NUM_SGPR, Info->NumSGPR);
1241 EmitU32Entry(AMDGPU::InfoKind::INFO_NUM_VGPR, Info->NumArchVGPR);
1242 // INFO_NUM_AGPR is only emitted when the function actually uses AGPRs,
1243 // since AGPRs are not available on all architectures.
1244 if (Info->NumAccVGPR)
1245 EmitU32Entry(AMDGPU::InfoKind::INFO_NUM_AGPR, Info->NumAccVGPR);
1246 EmitU32Entry(AMDGPU::InfoKind::INFO_PRIVATE_SEGMENT_SIZE,
1247 Info->PrivateSegmentSize);
1248 }
1249
1250 for (MCSymbol *Res : Uses)
1251 EmitSymEntry(AMDGPU::InfoKind::INFO_USE, Res);
1252 for (MCSymbol *Dst : Calls)
1253 EmitSymEntry(AMDGPU::InfoKind::INFO_CALL, Dst);
1254 for (StringRef TypeId : IndirectCallTypeIds) {
1255 EmitU32Entry(AMDGPU::InfoKind::INFO_INDIRECT_CALL,
1256 getOrAddString(TypeId));
1257 }
1258 for (StringRef TypeId : TypeIds)
1259 EmitU32Entry(AMDGPU::InfoKind::INFO_TYPEID, getOrAddString(TypeId));
1260 });
1261
1262 if (!StrTab.empty()) {
1263 StrTab.finalizeInOrder();
1264 MCSectionELF *Sec = Context.getELFSection(".amdgpu.strtab", ELF::SHT_STRTAB,
1265 ELF::SHF_EXCLUDE);
1266 S.switchSection(Sec);
1267 SmallString<128> Buf;
1268 raw_svector_ostream OS(Buf);
1269 StrTab.write(OS);
1270 S.emitBytes(Buf);
1271 }
1272
1273 S.popSection();
1274}
assert
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPUMCKernelDescriptor.h
AMDHSA kernel descriptor MCExpr struct for use in MC layer.
AMDGPUMCTargetDesc.h
Provides AMDGPU specific target descriptions.
AMDGPUMetadataVerifier.h
This is a verifier for AMDGPU HSA metadata, which can verify both well-typed metadata and untyped met...
AMDGPUMetadata.h
AMDGPU metadata definitions and in-memory representations.
AMDGPUObjLinkingInfo.h
Enums shared between the AMDGPU backend (LLVM) and the ELF linker (LLD) for the .amdgpu....
AMDGPUPTNote.h
Enums and constants for AMDGPU PT_NOTE sections.
ForceGenericVersion
static cl::opt< unsigned > ForceGenericVersion("amdgpu-force-generic-version", cl::desc("Force a specific generic_v<N> flag to be " "added. For testing purposes only."), cl::ReallyHidden, cl::init(0))
PRINT_RES_INFO
#define PRINT_RES_INFO(ARG)
AMDHSAKernelDescriptor.h
AMDHSA kernel descriptor definitions.
AMDKernelCodeTUtils.h
MC layer struct for AMDGPUMCKernelCodeT, provides MCExpr functionality where required.
I
#define I(x, y, z)
Definition MD5.cpp:57
Uses
Remove Loads Into Fake Uses
Definition RemoveLoadsIntoFakeUses.cpp:78
Verifier
verify safepoint Safepoint IR Verifier
Definition SafepointIRVerifier.cpp:246
CacheLineSize
static cl::opt< unsigned > CacheLineSize("cache-line-size", cl::init(0), cl::Hidden, cl::desc("Use this to override the target cache line size when " "specified by the user."))
llvm::AMDGPUPALMetadata::getVendor
const char * getVendor() const
Definition AMDGPUPALMetadata.cpp:1014
llvm::AMDGPUPALMetadata::toBlob
void toBlob(unsigned Type, std::string &S)
Definition AMDGPUPALMetadata.cpp:864
llvm::AMDGPUPALMetadata::toString
void toString(std::string &S)
Definition AMDGPUPALMetadata.cpp:811
llvm::AMDGPUTargetAsmStreamer::emitAMDGPUInfo
void emitAMDGPUInfo(const AMDGPU::InfoSectionData &Data) override
Definition AMDGPUTargetStreamer.cpp:751
llvm::AMDGPUTargetAsmStreamer::AMDGPUTargetAsmStreamer
AMDGPUTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
Definition AMDGPUTargetStreamer.cpp:255
llvm::AMDGPUTargetAsmStreamer::EmitHSAMetadata
bool EmitHSAMetadata(msgpack::Document &HSAMetadata, bool Strict) override
Definition AMDGPUTargetStreamer.cpp:358
llvm::AMDGPUTargetAsmStreamer::EmitAMDGPUSymbolType
void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override
Definition AMDGPUTargetStreamer.cpp:293
llvm::AMDGPUTargetAsmStreamer::EmitDirectiveAMDHSACodeObjectVersion
void EmitDirectiveAMDHSACodeObjectVersion(unsigned COV) override
Definition AMDGPUTargetStreamer.cpp:276
llvm::AMDGPUTargetAsmStreamer::EmitMCResourceMaximums
void EmitMCResourceMaximums(const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR, const MCSymbol *MaxSGPR, const MCSymbol *MaxNamedBarrier) override
Definition AMDGPUTargetStreamer.cpp:336
llvm::AMDGPUTargetAsmStreamer::EmitAMDKernelCodeT
void EmitAMDKernelCodeT(AMDGPU::AMDGPUMCKernelCodeT &Header) override
Definition AMDGPUTargetStreamer.cpp:282
llvm::AMDGPUTargetAsmStreamer::EmitAmdhsaKernelDescriptor
void EmitAmdhsaKernelDescriptor(const MCSubtargetInfo &STI, StringRef KernelName, const AMDGPU::MCKernelDescriptor &KernelDescriptor, const MCExpr *NextVGPR, const MCExpr *NextSGPR, const MCExpr *ReserveVCC, const MCExpr *ReserveFlatScr) override
Definition AMDGPUTargetStreamer.cpp:396
llvm::AMDGPUTargetAsmStreamer::EmitMCResourceInfo
void EmitMCResourceInfo(const MCSymbol *NumVGPR, const MCSymbol *NumAGPR, const MCSymbol *NumExplicitSGPR, const MCSymbol *NumNamedBarrier, const MCSymbol *PrivateSegmentSize, const MCSymbol *UsesVCC, const MCSymbol *UsesFlatScratch, const MCSymbol *HasDynamicallySizedStack, const MCSymbol *HasRecursion, const MCSymbol *HasIndirectCall) override
Definition AMDGPUTargetStreamer.cpp:310
llvm::AMDGPUTargetAsmStreamer::EmitCodeEnd
bool EmitCodeEnd(const MCSubtargetInfo &STI) override
Definition AMDGPUTargetStreamer.cpp:374
llvm::AMDGPUTargetAsmStreamer::emitAMDGPULDS
void emitAMDGPULDS(MCSymbol *Sym, unsigned Size, Align Alignment) override
Definition AMDGPUTargetStreamer.cpp:304
llvm::AMDGPUTargetELFStreamer::EmitCodeEnd
bool EmitCodeEnd(const MCSubtargetInfo &STI) override
Definition AMDGPUTargetStreamer.cpp:1102
llvm::AMDGPUTargetELFStreamer::EmitAMDKernelCodeT
void EmitAMDKernelCodeT(AMDGPU::AMDGPUMCKernelCodeT &Header) override
Definition AMDGPUTargetStreamer.cpp:1020
llvm::AMDGPUTargetELFStreamer::EmitHSAMetadata
bool EmitHSAMetadata(msgpack::Document &HSAMetadata, bool Strict) override
Definition AMDGPUTargetStreamer.cpp:1075
llvm::AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer
AMDGPUTargetELFStreamer(MCStreamer &S, const MCSubtargetInfo &STI)
Definition AMDGPUTargetStreamer.cpp:791
llvm::AMDGPUTargetELFStreamer::emitAMDGPULDS
void emitAMDGPULDS(MCSymbol *Sym, unsigned Size, Align Alignment) override
Definition AMDGPUTargetStreamer.cpp:1034
llvm::AMDGPUTargetELFStreamer::EmitAmdhsaKernelDescriptor
void EmitAmdhsaKernelDescriptor(const MCSubtargetInfo &STI, StringRef KernelName, const AMDGPU::MCKernelDescriptor &KernelDescriptor, const MCExpr *NextVGPR, const MCExpr *NextSGPR, const MCExpr *ReserveVCC, const MCExpr *ReserveFlatScr) override
Definition AMDGPUTargetStreamer.cpp:1128
llvm::AMDGPUTargetELFStreamer::EmitAMDGPUSymbolType
void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override
Definition AMDGPUTargetStreamer.cpp:1027
llvm::AMDGPUTargetELFStreamer::emitAMDGPUInfo
void emitAMDGPUInfo(const AMDGPU::InfoSectionData &Data) override
Definition AMDGPUTargetStreamer.cpp:1196
llvm::AMDGPUTargetStreamer::EmitHSAMetadata
virtual bool EmitHSAMetadata(msgpack::Document &HSAMetadata, bool Strict)
Emit HSA Metadata.
Definition AMDGPUTargetStreamer.h:112
llvm::AMDGPUTargetStreamer::getPALMetadata
AMDGPUPALMetadata * getPALMetadata()
Definition AMDGPUTargetStreamer.h:72
llvm::AMDGPUTargetStreamer::initializeTargetID
void initializeTargetID(const MCSubtargetInfo &STI, bool ApplyFeatureString=false)
Definition AMDGPUTargetStreamer.cpp:49
llvm::AMDGPUTargetStreamer::EmitDirectiveAMDHSACodeObjectVersion
virtual void EmitDirectiveAMDHSACodeObjectVersion(unsigned COV)
Definition AMDGPUTargetStreamer.h:76
llvm::AMDGPUTargetStreamer::EmitHSAMetadataV3
virtual bool EmitHSAMetadataV3(StringRef HSAMetadataString)
Definition AMDGPUTargetStreamer.cpp:58
llvm::AMDGPUTargetStreamer::getElfMach
static unsigned getElfMach(StringRef GPU)
Definition AMDGPUTargetStreamer.cpp:158
llvm::AMDGPUTargetStreamer::getTargetID
const std::optional< AMDGPU::TargetID > & getTargetID() const
Definition AMDGPUTargetStreamer.h:136
llvm::AMDGPUTargetStreamer::TargetID
std::optional< AMDGPU::TargetID > TargetID
Definition AMDGPUTargetStreamer.h:60
llvm::AMDGPUTargetStreamer::getArchNameFromElfMach
static StringRef getArchNameFromElfMach(unsigned ElfMach)
Definition AMDGPUTargetStreamer.cpp:65
llvm::ArrayRef
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition DenseMap.h:223
llvm::DenseMapBase::end
iterator end()
Definition DenseMap.h:141
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition DenseSet.h:281
llvm::MCAsmInfo
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition MCAsmInfo.h:67
llvm::MCBinaryExpr::createAdd
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:342
llvm::MCBinaryExpr::createMul
static const MCBinaryExpr * createMul(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition MCExpr.h:397
llvm::MCBinaryExpr::createSub
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition MCExpr.h:427
llvm::MCConstantExpr::create
static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition MCExpr.cpp:212
llvm::MCContext
Context object for machine code objects.
Definition MCContext.h:83
llvm::MCContext::getOrCreateSymbol
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition MCContext.cpp:208
llvm::MCContext::getAsmInfo
const MCAsmInfo & getAsmInfo() const
Definition MCContext.h:409
llvm::MCELFStreamer::getWriter
ELFObjectWriter & getWriter()
Definition MCELFStreamer.cpp:49
llvm::MCELFStreamer::emitLabel
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Definition MCELFStreamer.cpp:60
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition MCExpr.h:34
llvm::MCObjectStreamer::emitBytes
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
Definition MCObjectStreamer.cpp:681
llvm::MCSectionELF
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition MCSectionELF.h:27
llvm::MCStreamer
Streaming machine code generation interface.
Definition MCStreamer.h:222
llvm::MCStreamer::popSection
virtual bool popSection()
Restore the current and previous section from the section stack.
Definition MCStreamer.cpp:1571
llvm::MCStreamer::getContext
MCContext & getContext() const
Definition MCStreamer.h:326
llvm::MCStreamer::emitValue
void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition MCStreamer.cpp:176
llvm::MCStreamer::emitValueToAlignment
virtual void emitValueToAlignment(Align Alignment, int64_t Fill=0, uint8_t FillLen=1, unsigned MaxBytesToEmit=0)
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
Definition MCStreamer.cpp:1548
llvm::MCStreamer::pushSection
void pushSection()
Save the current and previous section on the section stack.
Definition MCStreamer.h:460
llvm::MCStreamer::switchSection
virtual void switchSection(MCSection *Section, uint32_t Subsec=0)
Set the current section where code is being emitted to Section.
Definition MCStreamer.cpp:1586
llvm::MCStreamer::emitInt32
void emitInt32(uint64_t Value)
Definition MCStreamer.h:769
llvm::MCStreamer::emitInt8
void emitInt8(uint64_t Value)
Definition MCStreamer.h:767
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition MCSubtargetInfo.h:141
llvm::MCSubtargetInfo::hasFeature
bool hasFeature(unsigned Feature) const
Definition MCSubtargetInfo.h:188
llvm::MCSubtargetInfo::getFeatureString
StringRef getFeatureString() const
Definition MCSubtargetInfo.h:186
llvm::MCSubtargetInfo::getTargetTriple
const Triple & getTargetTriple() const
Definition MCSubtargetInfo.h:177
llvm::MCSubtargetInfo::getCPU
StringRef getCPU() const
Definition MCSubtargetInfo.h:178
llvm::MCSymbolELF::setBinding
LLVM_ABI void setBinding(unsigned Binding) const
Definition MCSymbolELF.cpp:43
llvm::MCSymbolELF::setType
LLVM_ABI void setType(unsigned Type) const
Definition MCSymbolELF.cpp:92
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:213
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
llvm::MCSymbol::getName
StringRef getName() const
getName - Get the symbol name.
Definition MCSymbol.h:188
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:26
llvm::StringRef
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition StringTableBuilder.h:25
llvm::StringTableBuilder::finalizeInOrder
LLVM_ABI void finalizeInOrder()
Finalize the string table without reording it.
Definition StringTableBuilder.cpp:134
llvm::StringTableBuilder::add
LLVM_ABI size_t add(CachedHashStringRef S, uint8_t Priority=0)
Add a string to the builder.
Definition StringTableBuilder.cpp:220
llvm::StringTableBuilder::write
LLVM_ABI void write(raw_ostream &OS) const
Definition StringTableBuilder.cpp:61
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition Triple.h:512
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
llvm::Value
LLVM Value Representation.
Definition Value.h:75
llvm::formatted_raw_ostream
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
Definition FormattedStream.h:31
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition STLFunctionalExtras.h:37
llvm::msgpack::Document
Simple in-memory representation of a document of msgpack objects with ability to find and create arra...
Definition MsgPackDocument.h:293
llvm::msgpack::Document::getRoot
DocNode & getRoot()
Get ref to the document's root element.
Definition MsgPackDocument.h:317
llvm::msgpack::Document::toYAML
LLVM_ABI void toYAML(raw_ostream &OS)
Convert MsgPack Document to YAML text.
Definition MsgPackDocumentYAML.cpp:247
llvm::msgpack::Document::writeToBlob
LLVM_ABI void writeToBlob(std::string &Blob)
Write a MsgPack document to a binary MsgPack blob.
Definition MsgPackDocument.cpp:355
llvm::msgpack::Document::fromYAML
LLVM_ABI bool fromYAML(StringRef S)
Read YAML text into the MsgPack document. Returns false on failure.
Definition MsgPackDocumentYAML.cpp:253
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition raw_ostream.h:664
llvm::raw_string_ostream::str
std::string & str()
Returns the string's reference.
Definition raw_ostream.h:682
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition raw_ostream.h:694
llvm::raw_svector_ostream::str
StringRef str() const
Return a StringRef for the vector contents.
Definition raw_ostream.h:723
uint32_t
uint8_t
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition ErrorHandling.h:164
llvm::AMDGPU::ElfNote::NoteNameV2
const char NoteNameV2[]
Definition AMDGPUPTNote.h:26
llvm::AMDGPU::ElfNote::SectionName
const char SectionName[]
Definition AMDGPUPTNote.h:24
llvm::AMDGPU::ElfNote::NoteNameV3
const char NoteNameV3[]
Definition AMDGPUPTNote.h:27
llvm::AMDGPU::GenericVersion::GFX12_5
static constexpr unsigned GFX12_5
Definition AMDGPUBaseInfo.h:66
llvm::AMDGPU::GenericVersion::GFX9_4
static constexpr unsigned GFX9_4
Definition AMDGPUBaseInfo.h:60
llvm::AMDGPU::GenericVersion::GFX10_1
static constexpr unsigned GFX10_1
Definition AMDGPUBaseInfo.h:61
llvm::AMDGPU::GenericVersion::GFX10_3
static constexpr unsigned GFX10_3
Definition AMDGPUBaseInfo.h:62
llvm::AMDGPU::GenericVersion::GFX11
static constexpr unsigned GFX11
Definition AMDGPUBaseInfo.h:63
llvm::AMDGPU::GenericVersion::GFX9
static constexpr unsigned GFX9
Definition AMDGPUBaseInfo.h:59
llvm::AMDGPU::GenericVersion::GFX12
static constexpr unsigned GFX12
Definition AMDGPUBaseInfo.h:65
llvm::AMDGPU::GenericVersion::GFX13
static constexpr unsigned GFX13
Definition AMDGPUBaseInfo.h:67
llvm::AMDGPU::GenericVersion::GFX11_7
static constexpr unsigned GFX11_7
Definition AMDGPUBaseInfo.h:64
llvm::AMDGPU::HSAMD::V3::AssemblerDirectiveBegin
constexpr char AssemblerDirectiveBegin[]
HSA metadata beginning assembler directive.
Definition AMDGPUMetadata.h:466
llvm::AMDGPU::HSAMD::V3::AssemblerDirectiveEnd
constexpr char AssemblerDirectiveEnd[]
HSA metadata ending assembler directive.
Definition AMDGPUMetadata.h:468
llvm::AMDGPU::getArchNameR600
LLVM_ABI StringRef getArchNameR600(GPUKind AK)
Definition AMDGPUTargetParser.cpp:302
llvm::AMDGPU::FuncInfoFlags
FuncInfoFlags
Per-function flags packed into INFO_FLAGS entries.
Definition AMDGPUObjLinkingInfo.h:64
llvm::AMDGPU::printAMDGPUMCExpr
void printAMDGPUMCExpr(const MCExpr *Expr, raw_ostream &OS, const MCAsmInfo *MAI)
Definition AMDGPUMCExpr.cpp:750
llvm::AMDGPU::isHsaAbi
bool isHsaAbi(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:209
llvm::AMDGPU::createAMDGPUTargetID
TargetID createAMDGPUTargetID(const MCSubtargetInfo &STI, StringRef FeatureString)
Construct TargetID from MCSubtargetInfo.
Definition AMDGPUBaseInfo.cpp:1087
llvm::AMDGPU::getIsaVersion
LLVM_ABI IsaVersion getIsaVersion(StringRef GPU)
Definition AMDGPUTargetParser.cpp:355
llvm::AMDGPU::GPUKind
GPUKind
GPU kinds supported by the AMDGPU target.
Definition AMDGPUTargetParser.h:34
llvm::AMDGPU::isGFX90A
bool isGFX90A(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2641
llvm::AMDGPU::parseArchAMDGCN
LLVM_ABI GPUKind parseArchAMDGCN(StringRef CPU)
Definition AMDGPUTargetParser.cpp:307
llvm::AMDGPU::hasArchitectedFlatScratch
bool hasArchitectedFlatScratch(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2649
llvm::AMDGPU::isGFX11Plus
bool isGFX11Plus(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2581
llvm::AMDGPU::foldAMDGPUMCExpr
const MCExpr * foldAMDGPUMCExpr(const MCExpr *Expr, MCContext &Ctx)
Definition AMDGPUMCExpr.cpp:741
llvm::AMDGPU::InfoKind
InfoKind
Entry kind values for the .amdgpu.info section.
Definition AMDGPUObjLinkingInfo.h:32
llvm::AMDGPU::InfoKind::INFO_INDIRECT_CALL
@ INFO_INDIRECT_CALL
Indirect call edge: the function contains an indirect call whose callee is expected to match the type...
Definition AMDGPUObjLinkingInfo.h:56
llvm::AMDGPU::InfoKind::INFO_FLAGS
@ INFO_FLAGS
Bitfield of FuncInfoFlags properties for the function. [u32].
Definition AMDGPUObjLinkingInfo.h:38
llvm::AMDGPU::InfoKind::INFO_FUNC
@ INFO_FUNC
Opens a new function scope.
Definition AMDGPUObjLinkingInfo.h:36
llvm::AMDGPU::InfoKind::INFO_NUM_SGPR
@ INFO_NUM_SGPR
Number of SGPRs explicitly used by the function. [u32].
Definition AMDGPUObjLinkingInfo.h:40
llvm::AMDGPU::InfoKind::INFO_NUM_VGPR
@ INFO_NUM_VGPR
Number of architectural VGPRs used by the function. [u32].
Definition AMDGPUObjLinkingInfo.h:42
llvm::AMDGPU::InfoKind::INFO_CALL
@ INFO_CALL
Direct call edge: the function calls the callee identified by the 8-byte relocated symbol.
Definition AMDGPUObjLinkingInfo.h:52
llvm::AMDGPU::InfoKind::INFO_NUM_AGPR
@ INFO_NUM_AGPR
Number of accumulator VGPRs (AGPRs) used by the function. [u32].
Definition AMDGPUObjLinkingInfo.h:44
llvm::AMDGPU::InfoKind::INFO_TYPEID
@ INFO_TYPEID
Function type ID: tags an address-taken function with a type-ID string (at the given ....
Definition AMDGPUObjLinkingInfo.h:60
llvm::AMDGPU::InfoKind::INFO_PRIVATE_SEGMENT_SIZE
@ INFO_PRIVATE_SEGMENT_SIZE
Private (scratch) memory size in bytes required by the function. [u32].
Definition AMDGPUObjLinkingInfo.h:46
llvm::AMDGPU::InfoKind::INFO_USE
@ INFO_USE
Dependency edge: the function uses the resource identified by the 8-byte relocated symbol (e....
Definition AMDGPUObjLinkingInfo.h:49
llvm::AMDGPU::getArchNameAMDGCN
LLVM_ABI StringRef getArchNameAMDGCN(GPUKind AK)
Definition AMDGPUTargetParser.cpp:278
llvm::AMDGPU::hasKernargPreload
unsigned hasKernargPreload(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2665
llvm::AMDGPU::supportsWGP
bool supportsWGP(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2609
llvm::AMDGPU::isGFX1250Plus
bool isGFX1250Plus(const MCSubtargetInfo &STI)
Definition AMDGPUBaseInfo.cpp:2599
llvm::AMDGPU::getELFABIVersion
uint8_t getELFABIVersion(const Triple &T, unsigned CodeObjectVersion)
Definition AMDGPUBaseInfo.cpp:239
llvm::AMDGPU::parseArchR600
LLVM_ABI GPUKind parseArchR600(StringRef CPU)
Definition AMDGPUTargetParser.cpp:312
llvm::ELF::NT_AMDGPU_METADATA
@ NT_AMDGPU_METADATA
Definition ELF.h:1996
llvm::ELF::SHN_AMDGPU_LDS
@ SHN_AMDGPU_LDS
Definition ELF.h:1979
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition ELF.h:1292
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition ELF.h:1258
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition ELF.h:1158
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition ELF.h:1156
llvm::ELF::SHT_NOTE
@ SHT_NOTE
Definition ELF.h:1162
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition ELF.h:1415
llvm::ELF::STT_AMDGPU_HSA_KERNEL
@ STT_AMDGPU_HSA_KERNEL
Definition ELF.h:1440
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition ELF.h:1427
llvm::ELF::EF_AMDGPU_GENERIC_VERSION_MAX
@ EF_AMDGPU_GENERIC_VERSION_MAX
Definition ELF.h:932
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4
@ EF_AMDGPU_FEATURE_XNACK_ANY_V4
Definition ELF.h:909
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_V3
@ EF_AMDGPU_FEATURE_SRAMECC_V3
Definition ELF.h:900
llvm::ELF::EF_AMDGPU_GENERIC_VERSION_OFFSET
@ EF_AMDGPU_GENERIC_VERSION_OFFSET
Definition ELF.h:930
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
@ EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4
Definition ELF.h:920
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
@ EF_AMDGPU_FEATURE_SRAMECC_OFF_V4
Definition ELF.h:924
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
@ EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4
Definition ELF.h:907
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4
@ EF_AMDGPU_FEATURE_XNACK_OFF_V4
Definition ELF.h:911
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_V3
@ EF_AMDGPU_FEATURE_XNACK_V3
Definition ELF.h:895
llvm::ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4
@ EF_AMDGPU_FEATURE_XNACK_ON_V4
Definition ELF.h:913
llvm::ELF::EF_AMDGPU_MACH_NONE
@ EF_AMDGPU_MACH_NONE
Definition ELF.h:854
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
@ EF_AMDGPU_FEATURE_SRAMECC_ANY_V4
Definition ELF.h:922
llvm::ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4
@ EF_AMDGPU_FEATURE_SRAMECC_ON_V4
Definition ELF.h:926
llvm::ELF::NT_AMD_HSA_ISA_NAME
@ NT_AMD_HSA_ISA_NAME
Definition ELF.h:1989
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition ELF.h:1447
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition ELF.h:1444
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition CommandLine.h:440
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition FunctionInfo.h:25
llvm::report_fatal_error
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
llvm::to_underlying
constexpr std::underlying_type_t< Enum > to_underlying(Enum E)
Returns underlying integer value of an enum.
Definition STLForwardCompat.h:198
llvm::AMDGPU::IsaVersion
Instruction set architecture version.
Definition AMDGPUTargetParser.h:46
llvm::AMDGPU::MCKernelDescriptor::bits_get
static const MCExpr * bits_get(const MCExpr *Src, uint32_t Shift, uint32_t Mask, MCContext &Ctx)
Definition AMDGPUMCKernelDescriptor.cpp:93
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
llvm::Align::value
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
Definition Alignment.h:77
llvm::amdhsa::kernel_descriptor_t
Definition AMDHSAKernelDescriptor.h:267
llvm::amdhsa::kernel_descriptor_t::group_segment_fixed_size
uint32_t group_segment_fixed_size
Definition AMDHSAKernelDescriptor.h:268
llvm::amdhsa::kernel_descriptor_t::reserved3
uint8_t reserved3[4]
Definition AMDHSAKernelDescriptor.h:279
llvm::amdhsa::kernel_descriptor_t::reserved1
uint8_t reserved1[20]
Definition AMDHSAKernelDescriptor.h:273
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc1
uint32_t compute_pgm_rsrc1
Definition AMDHSAKernelDescriptor.h:275
llvm::amdhsa::kernel_descriptor_t::private_segment_fixed_size
uint32_t private_segment_fixed_size
Definition AMDHSAKernelDescriptor.h:269
llvm::amdhsa::kernel_descriptor_t::kernarg_size
uint32_t kernarg_size
Definition AMDHSAKernelDescriptor.h:270
llvm::amdhsa::kernel_descriptor_t::kernarg_preload
uint16_t kernarg_preload
Definition AMDHSAKernelDescriptor.h:278
llvm::amdhsa::kernel_descriptor_t::reserved0
uint8_t reserved0[4]
Definition AMDHSAKernelDescriptor.h:271
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc2
uint32_t compute_pgm_rsrc2
Definition AMDHSAKernelDescriptor.h:276
llvm::amdhsa::kernel_descriptor_t::kernel_code_properties
uint16_t kernel_code_properties
Definition AMDHSAKernelDescriptor.h:277
llvm::amdhsa::kernel_descriptor_t::compute_pgm_rsrc3
uint32_t compute_pgm_rsrc3
Definition AMDHSAKernelDescriptor.h:274
llvm::amdhsa::kernel_descriptor_t::kernel_code_entry_byte_offset
int64_t kernel_code_entry_byte_offset
Definition AMDHSAKernelDescriptor.h:272
Generated on for LLVM by doxygen 1.14.0