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