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 "AMDGPUPTNote.h" 15 #include "AMDKernelCodeT.h" 16 #include "Utils/AMDGPUBaseInfo.h" 17 #include "Utils/AMDKernelCodeTUtils.h" 18 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h" 19 #include "llvm/BinaryFormat/ELF.h" 20 #include "llvm/MC/MCAssembler.h" 21 #include "llvm/MC/MCContext.h" 22 #include "llvm/MC/MCELFStreamer.h" 23 #include "llvm/MC/MCSectionELF.h" 24 #include "llvm/MC/MCSubtargetInfo.h" 25 #include "llvm/Support/AMDGPUMetadata.h" 26 #include "llvm/Support/AMDHSAKernelDescriptor.h" 27 #include "llvm/Support/Casting.h" 28 #include "llvm/Support/FormattedStream.h" 29 #include "llvm/Support/TargetParser.h" 30 31 using namespace llvm; 32 using namespace llvm::AMDGPU; 33 34 //===----------------------------------------------------------------------===// 35 // AMDGPUTargetStreamer 36 //===----------------------------------------------------------------------===// 37 38 static void convertIsaVersionV2(uint32_t &Major, uint32_t &Minor, 39 uint32_t &Stepping, bool Sramecc, bool Xnack) { 40 if (Major == 9 && Minor == 0) { 41 switch (Stepping) { 42 case 0: 43 case 2: 44 case 4: 45 case 6: 46 if (Xnack) 47 Stepping++; 48 } 49 } 50 } 51 52 bool AMDGPUTargetStreamer::EmitHSAMetadataV2(StringRef HSAMetadataString) { 53 HSAMD::Metadata HSAMetadata; 54 if (HSAMD::fromString(HSAMetadataString, HSAMetadata)) 55 return false; 56 return EmitHSAMetadata(HSAMetadata); 57 } 58 59 bool AMDGPUTargetStreamer::EmitHSAMetadataV3(StringRef HSAMetadataString) { 60 msgpack::Document HSAMetadataDoc; 61 if (!HSAMetadataDoc.fromYAML(HSAMetadataString)) 62 return false; 63 return EmitHSAMetadata(HSAMetadataDoc, false); 64 } 65 66 StringRef AMDGPUTargetStreamer::getArchNameFromElfMach(unsigned ElfMach) { 67 AMDGPU::GPUKind AK; 68 69 switch (ElfMach) { 70 default: llvm_unreachable("Unhandled ELF::EF_AMDGPU type"); 71 case ELF::EF_AMDGPU_MACH_R600_R600: AK = GK_R600; break; 72 case ELF::EF_AMDGPU_MACH_R600_R630: AK = GK_R630; break; 73 case ELF::EF_AMDGPU_MACH_R600_RS880: AK = GK_RS880; break; 74 case ELF::EF_AMDGPU_MACH_R600_RV670: AK = GK_RV670; break; 75 case ELF::EF_AMDGPU_MACH_R600_RV710: AK = GK_RV710; break; 76 case ELF::EF_AMDGPU_MACH_R600_RV730: AK = GK_RV730; break; 77 case ELF::EF_AMDGPU_MACH_R600_RV770: AK = GK_RV770; break; 78 case ELF::EF_AMDGPU_MACH_R600_CEDAR: AK = GK_CEDAR; break; 79 case ELF::EF_AMDGPU_MACH_R600_CYPRESS: AK = GK_CYPRESS; break; 80 case ELF::EF_AMDGPU_MACH_R600_JUNIPER: AK = GK_JUNIPER; break; 81 case ELF::EF_AMDGPU_MACH_R600_REDWOOD: AK = GK_REDWOOD; break; 82 case ELF::EF_AMDGPU_MACH_R600_SUMO: AK = GK_SUMO; break; 83 case ELF::EF_AMDGPU_MACH_R600_BARTS: AK = GK_BARTS; break; 84 case ELF::EF_AMDGPU_MACH_R600_CAICOS: AK = GK_CAICOS; break; 85 case ELF::EF_AMDGPU_MACH_R600_CAYMAN: AK = GK_CAYMAN; break; 86 case ELF::EF_AMDGPU_MACH_R600_TURKS: AK = GK_TURKS; break; 87 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX600: AK = GK_GFX600; break; 88 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX601: AK = GK_GFX601; break; 89 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX602: AK = GK_GFX602; break; 90 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX700: AK = GK_GFX700; break; 91 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX701: AK = GK_GFX701; break; 92 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX702: AK = GK_GFX702; break; 93 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX703: AK = GK_GFX703; break; 94 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX704: AK = GK_GFX704; break; 95 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX705: AK = GK_GFX705; break; 96 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX801: AK = GK_GFX801; break; 97 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX802: AK = GK_GFX802; break; 98 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX803: AK = GK_GFX803; break; 99 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX805: AK = GK_GFX805; break; 100 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX810: AK = GK_GFX810; break; 101 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX900: AK = GK_GFX900; break; 102 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX902: AK = GK_GFX902; break; 103 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX904: AK = GK_GFX904; break; 104 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX906: AK = GK_GFX906; break; 105 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX908: AK = GK_GFX908; break; 106 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX909: AK = GK_GFX909; break; 107 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A: AK = GK_GFX90A; break; 108 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C: AK = GK_GFX90C; break; 109 case ELF::EF_AMDGPU_MACH_AMDGCN_GFX940: AK = GK_GFX940; 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_NONE: AK = GK_NONE; break; 122 } 123 124 StringRef GPUName = getArchNameAMDGCN(AK); 125 if (GPUName != "") 126 return GPUName; 127 return getArchNameR600(AK); 128 } 129 130 unsigned AMDGPUTargetStreamer::getElfMach(StringRef GPU) { 131 AMDGPU::GPUKind AK = parseArchAMDGCN(GPU); 132 if (AK == AMDGPU::GPUKind::GK_NONE) 133 AK = parseArchR600(GPU); 134 135 switch (AK) { 136 case GK_R600: return ELF::EF_AMDGPU_MACH_R600_R600; 137 case GK_R630: return ELF::EF_AMDGPU_MACH_R600_R630; 138 case GK_RS880: return ELF::EF_AMDGPU_MACH_R600_RS880; 139 case GK_RV670: return ELF::EF_AMDGPU_MACH_R600_RV670; 140 case GK_RV710: return ELF::EF_AMDGPU_MACH_R600_RV710; 141 case GK_RV730: return ELF::EF_AMDGPU_MACH_R600_RV730; 142 case GK_RV770: return ELF::EF_AMDGPU_MACH_R600_RV770; 143 case GK_CEDAR: return ELF::EF_AMDGPU_MACH_R600_CEDAR; 144 case GK_CYPRESS: return ELF::EF_AMDGPU_MACH_R600_CYPRESS; 145 case GK_JUNIPER: return ELF::EF_AMDGPU_MACH_R600_JUNIPER; 146 case GK_REDWOOD: return ELF::EF_AMDGPU_MACH_R600_REDWOOD; 147 case GK_SUMO: return ELF::EF_AMDGPU_MACH_R600_SUMO; 148 case GK_BARTS: return ELF::EF_AMDGPU_MACH_R600_BARTS; 149 case GK_CAICOS: return ELF::EF_AMDGPU_MACH_R600_CAICOS; 150 case GK_CAYMAN: return ELF::EF_AMDGPU_MACH_R600_CAYMAN; 151 case GK_TURKS: return ELF::EF_AMDGPU_MACH_R600_TURKS; 152 case GK_GFX600: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX600; 153 case GK_GFX601: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX601; 154 case GK_GFX602: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX602; 155 case GK_GFX700: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX700; 156 case GK_GFX701: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX701; 157 case GK_GFX702: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX702; 158 case GK_GFX703: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX703; 159 case GK_GFX704: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX704; 160 case GK_GFX705: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX705; 161 case GK_GFX801: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX801; 162 case GK_GFX802: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX802; 163 case GK_GFX803: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX803; 164 case GK_GFX805: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX805; 165 case GK_GFX810: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX810; 166 case GK_GFX900: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX900; 167 case GK_GFX902: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX902; 168 case GK_GFX904: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX904; 169 case GK_GFX906: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX906; 170 case GK_GFX908: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX908; 171 case GK_GFX909: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX909; 172 case GK_GFX90A: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A; 173 case GK_GFX90C: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C; 174 case GK_GFX940: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX940; 175 case GK_GFX1010: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010; 176 case GK_GFX1011: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011; 177 case GK_GFX1012: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012; 178 case GK_GFX1013: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013; 179 case GK_GFX1030: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030; 180 case GK_GFX1031: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031; 181 case GK_GFX1032: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032; 182 case GK_GFX1033: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033; 183 case GK_GFX1034: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034; 184 case GK_GFX1035: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035; 185 case GK_GFX1036: return ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036; 186 case GK_NONE: return ELF::EF_AMDGPU_MACH_NONE; 187 } 188 189 llvm_unreachable("unknown GPU"); 190 } 191 192 //===----------------------------------------------------------------------===// 193 // AMDGPUTargetAsmStreamer 194 //===----------------------------------------------------------------------===// 195 196 AMDGPUTargetAsmStreamer::AMDGPUTargetAsmStreamer(MCStreamer &S, 197 formatted_raw_ostream &OS) 198 : AMDGPUTargetStreamer(S), OS(OS) { } 199 200 // A hook for emitting stuff at the end. 201 // We use it for emitting the accumulated PAL metadata as directives. 202 // The PAL metadata is reset after it is emitted. 203 void AMDGPUTargetAsmStreamer::finish() { 204 std::string S; 205 getPALMetadata()->toString(S); 206 OS << S; 207 208 // Reset the pal metadata so its data will not affect a compilation that 209 // reuses this object. 210 getPALMetadata()->reset(); 211 } 212 213 void AMDGPUTargetAsmStreamer::EmitDirectiveAMDGCNTarget() { 214 OS << "\t.amdgcn_target \"" << getTargetID()->toString() << "\"\n"; 215 } 216 217 void AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectVersion( 218 uint32_t Major, uint32_t Minor) { 219 OS << "\t.hsa_code_object_version " << 220 Twine(Major) << "," << Twine(Minor) << '\n'; 221 } 222 223 void 224 AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectISAV2(uint32_t Major, 225 uint32_t Minor, 226 uint32_t Stepping, 227 StringRef VendorName, 228 StringRef ArchName) { 229 convertIsaVersionV2(Major, Minor, Stepping, TargetID->isSramEccOnOrAny(), TargetID->isXnackOnOrAny()); 230 OS << "\t.hsa_code_object_isa " << Twine(Major) << "," << Twine(Minor) << "," 231 << Twine(Stepping) << ",\"" << VendorName << "\",\"" << ArchName << "\"\n"; 232 } 233 234 void 235 AMDGPUTargetAsmStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) { 236 OS << "\t.amd_kernel_code_t\n"; 237 dumpAmdKernelCode(&Header, OS, "\t\t"); 238 OS << "\t.end_amd_kernel_code_t\n"; 239 } 240 241 void AMDGPUTargetAsmStreamer::EmitAMDGPUSymbolType(StringRef SymbolName, 242 unsigned Type) { 243 switch (Type) { 244 default: llvm_unreachable("Invalid AMDGPU symbol type"); 245 case ELF::STT_AMDGPU_HSA_KERNEL: 246 OS << "\t.amdgpu_hsa_kernel " << SymbolName << '\n' ; 247 break; 248 } 249 } 250 251 void AMDGPUTargetAsmStreamer::emitAMDGPULDS(MCSymbol *Symbol, unsigned Size, 252 Align Alignment) { 253 OS << "\t.amdgpu_lds " << Symbol->getName() << ", " << Size << ", " 254 << Alignment.value() << '\n'; 255 } 256 257 bool AMDGPUTargetAsmStreamer::EmitISAVersion() { 258 OS << "\t.amd_amdgpu_isa \"" << getTargetID()->toString() << "\"\n"; 259 return true; 260 } 261 262 bool AMDGPUTargetAsmStreamer::EmitHSAMetadata( 263 const AMDGPU::HSAMD::Metadata &HSAMetadata) { 264 std::string HSAMetadataString; 265 if (HSAMD::toString(HSAMetadata, HSAMetadataString)) 266 return false; 267 268 OS << '\t' << HSAMD::AssemblerDirectiveBegin << '\n'; 269 OS << HSAMetadataString << '\n'; 270 OS << '\t' << HSAMD::AssemblerDirectiveEnd << '\n'; 271 return true; 272 } 273 274 bool AMDGPUTargetAsmStreamer::EmitHSAMetadata( 275 msgpack::Document &HSAMetadataDoc, bool Strict) { 276 HSAMD::V3::MetadataVerifier Verifier(Strict); 277 if (!Verifier.verify(HSAMetadataDoc.getRoot())) 278 return false; 279 280 std::string HSAMetadataString; 281 raw_string_ostream StrOS(HSAMetadataString); 282 HSAMetadataDoc.toYAML(StrOS); 283 284 OS << '\t' << HSAMD::V3::AssemblerDirectiveBegin << '\n'; 285 OS << StrOS.str() << '\n'; 286 OS << '\t' << HSAMD::V3::AssemblerDirectiveEnd << '\n'; 287 return true; 288 } 289 290 bool AMDGPUTargetAsmStreamer::EmitCodeEnd(const MCSubtargetInfo &STI) { 291 const uint32_t Encoded_s_code_end = 0xbf9f0000; 292 const uint32_t Encoded_s_nop = 0xbf800000; 293 uint32_t Encoded_pad = Encoded_s_code_end; 294 295 // Instruction cache line size in bytes. 296 const unsigned Log2CacheLineSize = 6; 297 const unsigned CacheLineSize = 1u << Log2CacheLineSize; 298 299 // Extra padding amount in bytes to support prefetch mode 3. 300 unsigned FillSize = 3 * CacheLineSize; 301 302 if (AMDGPU::isGFX90A(STI)) { 303 Encoded_pad = Encoded_s_nop; 304 FillSize = 16 * CacheLineSize; 305 } 306 307 OS << "\t.p2alignl " << Log2CacheLineSize << ", " << Encoded_pad << '\n'; 308 OS << "\t.fill " << (FillSize / 4) << ", 4, " << Encoded_pad << '\n'; 309 return true; 310 } 311 312 void AMDGPUTargetAsmStreamer::EmitAmdhsaKernelDescriptor( 313 const MCSubtargetInfo &STI, StringRef KernelName, 314 const amdhsa::kernel_descriptor_t &KD, uint64_t NextVGPR, uint64_t NextSGPR, 315 bool ReserveVCC, bool ReserveFlatScr) { 316 IsaVersion IVersion = getIsaVersion(STI.getCPU()); 317 318 OS << "\t.amdhsa_kernel " << KernelName << '\n'; 319 320 #define PRINT_FIELD(STREAM, DIRECTIVE, KERNEL_DESC, MEMBER_NAME, FIELD_NAME) \ 321 STREAM << "\t\t" << DIRECTIVE << " " \ 322 << AMDHSA_BITS_GET(KERNEL_DESC.MEMBER_NAME, FIELD_NAME) << '\n'; 323 324 OS << "\t\t.amdhsa_group_segment_fixed_size " << KD.group_segment_fixed_size 325 << '\n'; 326 OS << "\t\t.amdhsa_private_segment_fixed_size " 327 << KD.private_segment_fixed_size << '\n'; 328 OS << "\t\t.amdhsa_kernarg_size " << KD.kernarg_size << '\n'; 329 330 PRINT_FIELD(OS, ".amdhsa_user_sgpr_count", KD, 331 compute_pgm_rsrc2, 332 amdhsa::COMPUTE_PGM_RSRC2_USER_SGPR_COUNT); 333 334 if (!hasArchitectedFlatScratch(STI)) 335 PRINT_FIELD( 336 OS, ".amdhsa_user_sgpr_private_segment_buffer", KD, 337 kernel_code_properties, 338 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_BUFFER); 339 PRINT_FIELD(OS, ".amdhsa_user_sgpr_dispatch_ptr", KD, 340 kernel_code_properties, 341 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_PTR); 342 PRINT_FIELD(OS, ".amdhsa_user_sgpr_queue_ptr", KD, 343 kernel_code_properties, 344 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_QUEUE_PTR); 345 PRINT_FIELD(OS, ".amdhsa_user_sgpr_kernarg_segment_ptr", KD, 346 kernel_code_properties, 347 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_KERNARG_SEGMENT_PTR); 348 PRINT_FIELD(OS, ".amdhsa_user_sgpr_dispatch_id", KD, 349 kernel_code_properties, 350 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_ID); 351 if (!hasArchitectedFlatScratch(STI)) 352 PRINT_FIELD(OS, ".amdhsa_user_sgpr_flat_scratch_init", KD, 353 kernel_code_properties, 354 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_FLAT_SCRATCH_INIT); 355 PRINT_FIELD(OS, ".amdhsa_user_sgpr_private_segment_size", KD, 356 kernel_code_properties, 357 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_SIZE); 358 if (IVersion.Major >= 10) 359 PRINT_FIELD(OS, ".amdhsa_wavefront_size32", KD, 360 kernel_code_properties, 361 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32); 362 PRINT_FIELD(OS, 363 (hasArchitectedFlatScratch(STI) 364 ? ".amdhsa_enable_private_segment" 365 : ".amdhsa_system_sgpr_private_segment_wavefront_offset"), 366 KD, compute_pgm_rsrc2, 367 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_PRIVATE_SEGMENT); 368 PRINT_FIELD(OS, ".amdhsa_system_sgpr_workgroup_id_x", KD, 369 compute_pgm_rsrc2, 370 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_X); 371 PRINT_FIELD(OS, ".amdhsa_system_sgpr_workgroup_id_y", KD, 372 compute_pgm_rsrc2, 373 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Y); 374 PRINT_FIELD(OS, ".amdhsa_system_sgpr_workgroup_id_z", KD, 375 compute_pgm_rsrc2, 376 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_ID_Z); 377 PRINT_FIELD(OS, ".amdhsa_system_sgpr_workgroup_info", KD, 378 compute_pgm_rsrc2, 379 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_SGPR_WORKGROUP_INFO); 380 PRINT_FIELD(OS, ".amdhsa_system_vgpr_workitem_id", KD, 381 compute_pgm_rsrc2, 382 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_VGPR_WORKITEM_ID); 383 384 // These directives are required. 385 OS << "\t\t.amdhsa_next_free_vgpr " << NextVGPR << '\n'; 386 OS << "\t\t.amdhsa_next_free_sgpr " << NextSGPR << '\n'; 387 388 if (AMDGPU::isGFX90A(STI)) 389 OS << "\t\t.amdhsa_accum_offset " << 390 (AMDHSA_BITS_GET(KD.compute_pgm_rsrc3, 391 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET) + 1) * 4 392 << '\n'; 393 394 if (!ReserveVCC) 395 OS << "\t\t.amdhsa_reserve_vcc " << ReserveVCC << '\n'; 396 if (IVersion.Major >= 7 && !ReserveFlatScr && !hasArchitectedFlatScratch(STI)) 397 OS << "\t\t.amdhsa_reserve_flat_scratch " << ReserveFlatScr << '\n'; 398 399 if (Optional<uint8_t> HsaAbiVer = getHsaAbiVersion(&STI)) { 400 switch (*HsaAbiVer) { 401 default: 402 break; 403 case ELF::ELFABIVERSION_AMDGPU_HSA_V2: 404 break; 405 case ELF::ELFABIVERSION_AMDGPU_HSA_V3: 406 case ELF::ELFABIVERSION_AMDGPU_HSA_V4: 407 case ELF::ELFABIVERSION_AMDGPU_HSA_V5: 408 if (getTargetID()->isXnackSupported()) 409 OS << "\t\t.amdhsa_reserve_xnack_mask " << getTargetID()->isXnackOnOrAny() << '\n'; 410 break; 411 } 412 } 413 414 PRINT_FIELD(OS, ".amdhsa_float_round_mode_32", KD, 415 compute_pgm_rsrc1, 416 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_32); 417 PRINT_FIELD(OS, ".amdhsa_float_round_mode_16_64", KD, 418 compute_pgm_rsrc1, 419 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_ROUND_MODE_16_64); 420 PRINT_FIELD(OS, ".amdhsa_float_denorm_mode_32", KD, 421 compute_pgm_rsrc1, 422 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_32); 423 PRINT_FIELD(OS, ".amdhsa_float_denorm_mode_16_64", KD, 424 compute_pgm_rsrc1, 425 amdhsa::COMPUTE_PGM_RSRC1_FLOAT_DENORM_MODE_16_64); 426 PRINT_FIELD(OS, ".amdhsa_dx10_clamp", KD, 427 compute_pgm_rsrc1, 428 amdhsa::COMPUTE_PGM_RSRC1_ENABLE_DX10_CLAMP); 429 PRINT_FIELD(OS, ".amdhsa_ieee_mode", KD, 430 compute_pgm_rsrc1, 431 amdhsa::COMPUTE_PGM_RSRC1_ENABLE_IEEE_MODE); 432 if (IVersion.Major >= 9) 433 PRINT_FIELD(OS, ".amdhsa_fp16_overflow", KD, 434 compute_pgm_rsrc1, 435 amdhsa::COMPUTE_PGM_RSRC1_FP16_OVFL); 436 if (AMDGPU::isGFX90A(STI)) 437 PRINT_FIELD(OS, ".amdhsa_tg_split", KD, 438 compute_pgm_rsrc3, 439 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT); 440 if (IVersion.Major >= 10) { 441 PRINT_FIELD(OS, ".amdhsa_workgroup_processor_mode", KD, 442 compute_pgm_rsrc1, 443 amdhsa::COMPUTE_PGM_RSRC1_WGP_MODE); 444 PRINT_FIELD(OS, ".amdhsa_memory_ordered", KD, 445 compute_pgm_rsrc1, 446 amdhsa::COMPUTE_PGM_RSRC1_MEM_ORDERED); 447 PRINT_FIELD(OS, ".amdhsa_forward_progress", KD, 448 compute_pgm_rsrc1, 449 amdhsa::COMPUTE_PGM_RSRC1_FWD_PROGRESS); 450 PRINT_FIELD(OS, ".amdhsa_shared_vgpr_count", KD, compute_pgm_rsrc3, 451 amdhsa::COMPUTE_PGM_RSRC3_GFX10_SHARED_VGPR_COUNT); 452 } 453 PRINT_FIELD( 454 OS, ".amdhsa_exception_fp_ieee_invalid_op", KD, 455 compute_pgm_rsrc2, 456 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INVALID_OPERATION); 457 PRINT_FIELD(OS, ".amdhsa_exception_fp_denorm_src", KD, 458 compute_pgm_rsrc2, 459 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_FP_DENORMAL_SOURCE); 460 PRINT_FIELD( 461 OS, ".amdhsa_exception_fp_ieee_div_zero", KD, 462 compute_pgm_rsrc2, 463 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_DIVISION_BY_ZERO); 464 PRINT_FIELD(OS, ".amdhsa_exception_fp_ieee_overflow", KD, 465 compute_pgm_rsrc2, 466 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_OVERFLOW); 467 PRINT_FIELD(OS, ".amdhsa_exception_fp_ieee_underflow", KD, 468 compute_pgm_rsrc2, 469 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_UNDERFLOW); 470 PRINT_FIELD(OS, ".amdhsa_exception_fp_ieee_inexact", KD, 471 compute_pgm_rsrc2, 472 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_IEEE_754_FP_INEXACT); 473 PRINT_FIELD(OS, ".amdhsa_exception_int_div_zero", KD, 474 compute_pgm_rsrc2, 475 amdhsa::COMPUTE_PGM_RSRC2_ENABLE_EXCEPTION_INT_DIVIDE_BY_ZERO); 476 #undef PRINT_FIELD 477 478 OS << "\t.end_amdhsa_kernel\n"; 479 } 480 481 //===----------------------------------------------------------------------===// 482 // AMDGPUTargetELFStreamer 483 //===----------------------------------------------------------------------===// 484 485 AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(MCStreamer &S, 486 const MCSubtargetInfo &STI) 487 : AMDGPUTargetStreamer(S), STI(STI), Streamer(S) {} 488 489 MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() { 490 return static_cast<MCELFStreamer &>(Streamer); 491 } 492 493 // A hook for emitting stuff at the end. 494 // We use it for emitting the accumulated PAL metadata as a .note record. 495 // The PAL metadata is reset after it is emitted. 496 void AMDGPUTargetELFStreamer::finish() { 497 MCAssembler &MCA = getStreamer().getAssembler(); 498 MCA.setELFHeaderEFlags(getEFlags()); 499 500 std::string Blob; 501 const char *Vendor = getPALMetadata()->getVendor(); 502 unsigned Type = getPALMetadata()->getType(); 503 getPALMetadata()->toBlob(Type, Blob); 504 if (Blob.empty()) 505 return; 506 EmitNote(Vendor, MCConstantExpr::create(Blob.size(), getContext()), Type, 507 [&](MCELFStreamer &OS) { OS.emitBytes(Blob); }); 508 509 // Reset the pal metadata so its data will not affect a compilation that 510 // reuses this object. 511 getPALMetadata()->reset(); 512 } 513 514 void AMDGPUTargetELFStreamer::EmitNote( 515 StringRef Name, const MCExpr *DescSZ, unsigned NoteType, 516 function_ref<void(MCELFStreamer &)> EmitDesc) { 517 auto &S = getStreamer(); 518 auto &Context = S.getContext(); 519 520 auto NameSZ = Name.size() + 1; 521 522 unsigned NoteFlags = 0; 523 // TODO Apparently, this is currently needed for OpenCL as mentioned in 524 // https://reviews.llvm.org/D74995 525 if (STI.getTargetTriple().getOS() == Triple::AMDHSA) 526 NoteFlags = ELF::SHF_ALLOC; 527 528 S.PushSection(); 529 S.SwitchSection( 530 Context.getELFSection(ElfNote::SectionName, ELF::SHT_NOTE, NoteFlags)); 531 S.emitInt32(NameSZ); // namesz 532 S.emitValue(DescSZ, 4); // descz 533 S.emitInt32(NoteType); // type 534 S.emitBytes(Name); // name 535 S.emitValueToAlignment(4, 0, 1, 0); // padding 0 536 EmitDesc(S); // desc 537 S.emitValueToAlignment(4, 0, 1, 0); // padding 0 538 S.PopSection(); 539 } 540 541 unsigned AMDGPUTargetELFStreamer::getEFlags() { 542 switch (STI.getTargetTriple().getArch()) { 543 default: 544 llvm_unreachable("Unsupported Arch"); 545 case Triple::r600: 546 return getEFlagsR600(); 547 case Triple::amdgcn: 548 return getEFlagsAMDGCN(); 549 } 550 } 551 552 unsigned AMDGPUTargetELFStreamer::getEFlagsR600() { 553 assert(STI.getTargetTriple().getArch() == Triple::r600); 554 555 return getElfMach(STI.getCPU()); 556 } 557 558 unsigned AMDGPUTargetELFStreamer::getEFlagsAMDGCN() { 559 assert(STI.getTargetTriple().getArch() == Triple::amdgcn); 560 561 switch (STI.getTargetTriple().getOS()) { 562 default: 563 // TODO: Why are some tests have "mingw" listed as OS? 564 // llvm_unreachable("Unsupported OS"); 565 case Triple::UnknownOS: 566 return getEFlagsUnknownOS(); 567 case Triple::AMDHSA: 568 return getEFlagsAMDHSA(); 569 case Triple::AMDPAL: 570 return getEFlagsAMDPAL(); 571 case Triple::Mesa3D: 572 return getEFlagsMesa3D(); 573 } 574 } 575 576 unsigned AMDGPUTargetELFStreamer::getEFlagsUnknownOS() { 577 // TODO: Why are some tests have "mingw" listed as OS? 578 // assert(STI.getTargetTriple().getOS() == Triple::UnknownOS); 579 580 return getEFlagsV3(); 581 } 582 583 unsigned AMDGPUTargetELFStreamer::getEFlagsAMDHSA() { 584 assert(STI.getTargetTriple().getOS() == Triple::AMDHSA); 585 586 if (Optional<uint8_t> HsaAbiVer = getHsaAbiVersion(&STI)) { 587 switch (*HsaAbiVer) { 588 case ELF::ELFABIVERSION_AMDGPU_HSA_V2: 589 case ELF::ELFABIVERSION_AMDGPU_HSA_V3: 590 return getEFlagsV3(); 591 case ELF::ELFABIVERSION_AMDGPU_HSA_V4: 592 case ELF::ELFABIVERSION_AMDGPU_HSA_V5: 593 return getEFlagsV4(); 594 } 595 } 596 597 llvm_unreachable("HSA OS ABI Version identification must be defined"); 598 } 599 600 unsigned AMDGPUTargetELFStreamer::getEFlagsAMDPAL() { 601 assert(STI.getTargetTriple().getOS() == Triple::AMDPAL); 602 603 return getEFlagsV3(); 604 } 605 606 unsigned AMDGPUTargetELFStreamer::getEFlagsMesa3D() { 607 assert(STI.getTargetTriple().getOS() == Triple::Mesa3D); 608 609 return getEFlagsV3(); 610 } 611 612 unsigned AMDGPUTargetELFStreamer::getEFlagsV3() { 613 unsigned EFlagsV3 = 0; 614 615 // mach. 616 EFlagsV3 |= getElfMach(STI.getCPU()); 617 618 // xnack. 619 if (getTargetID()->isXnackOnOrAny()) 620 EFlagsV3 |= ELF::EF_AMDGPU_FEATURE_XNACK_V3; 621 // sramecc. 622 if (getTargetID()->isSramEccOnOrAny()) 623 EFlagsV3 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_V3; 624 625 return EFlagsV3; 626 } 627 628 unsigned AMDGPUTargetELFStreamer::getEFlagsV4() { 629 unsigned EFlagsV4 = 0; 630 631 // mach. 632 EFlagsV4 |= getElfMach(STI.getCPU()); 633 634 // xnack. 635 switch (getTargetID()->getXnackSetting()) { 636 case AMDGPU::IsaInfo::TargetIDSetting::Unsupported: 637 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4; 638 break; 639 case AMDGPU::IsaInfo::TargetIDSetting::Any: 640 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_ANY_V4; 641 break; 642 case AMDGPU::IsaInfo::TargetIDSetting::Off: 643 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_OFF_V4; 644 break; 645 case AMDGPU::IsaInfo::TargetIDSetting::On: 646 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_XNACK_ON_V4; 647 break; 648 } 649 // sramecc. 650 switch (getTargetID()->getSramEccSetting()) { 651 case AMDGPU::IsaInfo::TargetIDSetting::Unsupported: 652 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_UNSUPPORTED_V4; 653 break; 654 case AMDGPU::IsaInfo::TargetIDSetting::Any: 655 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_ANY_V4; 656 break; 657 case AMDGPU::IsaInfo::TargetIDSetting::Off: 658 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_OFF_V4; 659 break; 660 case AMDGPU::IsaInfo::TargetIDSetting::On: 661 EFlagsV4 |= ELF::EF_AMDGPU_FEATURE_SRAMECC_ON_V4; 662 break; 663 } 664 665 return EFlagsV4; 666 } 667 668 void AMDGPUTargetELFStreamer::EmitDirectiveAMDGCNTarget() {} 669 670 void AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectVersion( 671 uint32_t Major, uint32_t Minor) { 672 673 EmitNote(ElfNote::NoteNameV2, MCConstantExpr::create(8, getContext()), 674 ELF::NT_AMD_HSA_CODE_OBJECT_VERSION, [&](MCELFStreamer &OS) { 675 OS.emitInt32(Major); 676 OS.emitInt32(Minor); 677 }); 678 } 679 680 void 681 AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectISAV2(uint32_t Major, 682 uint32_t Minor, 683 uint32_t Stepping, 684 StringRef VendorName, 685 StringRef ArchName) { 686 uint16_t VendorNameSize = VendorName.size() + 1; 687 uint16_t ArchNameSize = ArchName.size() + 1; 688 689 unsigned DescSZ = sizeof(VendorNameSize) + sizeof(ArchNameSize) + 690 sizeof(Major) + sizeof(Minor) + sizeof(Stepping) + 691 VendorNameSize + ArchNameSize; 692 693 convertIsaVersionV2(Major, Minor, Stepping, TargetID->isSramEccOnOrAny(), TargetID->isXnackOnOrAny()); 694 EmitNote(ElfNote::NoteNameV2, MCConstantExpr::create(DescSZ, getContext()), 695 ELF::NT_AMD_HSA_ISA_VERSION, [&](MCELFStreamer &OS) { 696 OS.emitInt16(VendorNameSize); 697 OS.emitInt16(ArchNameSize); 698 OS.emitInt32(Major); 699 OS.emitInt32(Minor); 700 OS.emitInt32(Stepping); 701 OS.emitBytes(VendorName); 702 OS.emitInt8(0); // NULL terminate VendorName 703 OS.emitBytes(ArchName); 704 OS.emitInt8(0); // NULL terminate ArchName 705 }); 706 } 707 708 void 709 AMDGPUTargetELFStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) { 710 711 MCStreamer &OS = getStreamer(); 712 OS.PushSection(); 713 OS.emitBytes(StringRef((const char*)&Header, sizeof(Header))); 714 OS.PopSection(); 715 } 716 717 void AMDGPUTargetELFStreamer::EmitAMDGPUSymbolType(StringRef SymbolName, 718 unsigned Type) { 719 MCSymbolELF *Symbol = cast<MCSymbolELF>( 720 getStreamer().getContext().getOrCreateSymbol(SymbolName)); 721 Symbol->setType(Type); 722 } 723 724 void AMDGPUTargetELFStreamer::emitAMDGPULDS(MCSymbol *Symbol, unsigned Size, 725 Align Alignment) { 726 MCSymbolELF *SymbolELF = cast<MCSymbolELF>(Symbol); 727 SymbolELF->setType(ELF::STT_OBJECT); 728 729 if (!SymbolELF->isBindingSet()) { 730 SymbolELF->setBinding(ELF::STB_GLOBAL); 731 SymbolELF->setExternal(true); 732 } 733 734 if (SymbolELF->declareCommon(Size, Alignment.value(), true)) { 735 report_fatal_error("Symbol: " + Symbol->getName() + 736 " redeclared as different type"); 737 } 738 739 SymbolELF->setIndex(ELF::SHN_AMDGPU_LDS); 740 SymbolELF->setSize(MCConstantExpr::create(Size, getContext())); 741 } 742 743 bool AMDGPUTargetELFStreamer::EmitISAVersion() { 744 // Create two labels to mark the beginning and end of the desc field 745 // and a MCExpr to calculate the size of the desc field. 746 auto &Context = getContext(); 747 auto *DescBegin = Context.createTempSymbol(); 748 auto *DescEnd = Context.createTempSymbol(); 749 auto *DescSZ = MCBinaryExpr::createSub( 750 MCSymbolRefExpr::create(DescEnd, Context), 751 MCSymbolRefExpr::create(DescBegin, Context), Context); 752 753 EmitNote(ElfNote::NoteNameV2, DescSZ, ELF::NT_AMD_HSA_ISA_NAME, 754 [&](MCELFStreamer &OS) { 755 OS.emitLabel(DescBegin); 756 OS.emitBytes(getTargetID()->toString()); 757 OS.emitLabel(DescEnd); 758 }); 759 return true; 760 } 761 762 bool AMDGPUTargetELFStreamer::EmitHSAMetadata(msgpack::Document &HSAMetadataDoc, 763 bool Strict) { 764 HSAMD::V3::MetadataVerifier Verifier(Strict); 765 if (!Verifier.verify(HSAMetadataDoc.getRoot())) 766 return false; 767 768 std::string HSAMetadataString; 769 HSAMetadataDoc.writeToBlob(HSAMetadataString); 770 771 // Create two labels to mark the beginning and end of the desc field 772 // and a MCExpr to calculate the size of the desc field. 773 auto &Context = getContext(); 774 auto *DescBegin = Context.createTempSymbol(); 775 auto *DescEnd = Context.createTempSymbol(); 776 auto *DescSZ = MCBinaryExpr::createSub( 777 MCSymbolRefExpr::create(DescEnd, Context), 778 MCSymbolRefExpr::create(DescBegin, Context), Context); 779 780 EmitNote(ElfNote::NoteNameV3, DescSZ, ELF::NT_AMDGPU_METADATA, 781 [&](MCELFStreamer &OS) { 782 OS.emitLabel(DescBegin); 783 OS.emitBytes(HSAMetadataString); 784 OS.emitLabel(DescEnd); 785 }); 786 return true; 787 } 788 789 bool AMDGPUTargetELFStreamer::EmitHSAMetadata( 790 const AMDGPU::HSAMD::Metadata &HSAMetadata) { 791 std::string HSAMetadataString; 792 if (HSAMD::toString(HSAMetadata, HSAMetadataString)) 793 return false; 794 795 // Create two labels to mark the beginning and end of the desc field 796 // and a MCExpr to calculate the size of the desc field. 797 auto &Context = getContext(); 798 auto *DescBegin = Context.createTempSymbol(); 799 auto *DescEnd = Context.createTempSymbol(); 800 auto *DescSZ = MCBinaryExpr::createSub( 801 MCSymbolRefExpr::create(DescEnd, Context), 802 MCSymbolRefExpr::create(DescBegin, Context), Context); 803 804 EmitNote(ElfNote::NoteNameV2, DescSZ, ELF::NT_AMD_HSA_METADATA, 805 [&](MCELFStreamer &OS) { 806 OS.emitLabel(DescBegin); 807 OS.emitBytes(HSAMetadataString); 808 OS.emitLabel(DescEnd); 809 }); 810 return true; 811 } 812 813 bool AMDGPUTargetELFStreamer::EmitCodeEnd(const MCSubtargetInfo &STI) { 814 const uint32_t Encoded_s_code_end = 0xbf9f0000; 815 const uint32_t Encoded_s_nop = 0xbf800000; 816 uint32_t Encoded_pad = Encoded_s_code_end; 817 818 // Instruction cache line size in bytes. 819 const unsigned Log2CacheLineSize = 6; 820 const unsigned CacheLineSize = 1u << Log2CacheLineSize; 821 822 // Extra padding amount in bytes to support prefetch mode 3. 823 unsigned FillSize = 3 * CacheLineSize; 824 825 if (AMDGPU::isGFX90A(STI)) { 826 Encoded_pad = Encoded_s_nop; 827 FillSize = 16 * CacheLineSize; 828 } 829 830 MCStreamer &OS = getStreamer(); 831 OS.PushSection(); 832 OS.emitValueToAlignment(CacheLineSize, Encoded_pad, 4); 833 for (unsigned I = 0; I < FillSize; I += 4) 834 OS.emitInt32(Encoded_pad); 835 OS.PopSection(); 836 return true; 837 } 838 839 void AMDGPUTargetELFStreamer::EmitAmdhsaKernelDescriptor( 840 const MCSubtargetInfo &STI, StringRef KernelName, 841 const amdhsa::kernel_descriptor_t &KernelDescriptor, uint64_t NextVGPR, 842 uint64_t NextSGPR, bool ReserveVCC, bool ReserveFlatScr) { 843 auto &Streamer = getStreamer(); 844 auto &Context = Streamer.getContext(); 845 846 MCSymbolELF *KernelCodeSymbol = cast<MCSymbolELF>( 847 Context.getOrCreateSymbol(Twine(KernelName))); 848 MCSymbolELF *KernelDescriptorSymbol = cast<MCSymbolELF>( 849 Context.getOrCreateSymbol(Twine(KernelName) + Twine(".kd"))); 850 851 // Copy kernel descriptor symbol's binding, other and visibility from the 852 // kernel code symbol. 853 KernelDescriptorSymbol->setBinding(KernelCodeSymbol->getBinding()); 854 KernelDescriptorSymbol->setOther(KernelCodeSymbol->getOther()); 855 KernelDescriptorSymbol->setVisibility(KernelCodeSymbol->getVisibility()); 856 // Kernel descriptor symbol's type and size are fixed. 857 KernelDescriptorSymbol->setType(ELF::STT_OBJECT); 858 KernelDescriptorSymbol->setSize( 859 MCConstantExpr::create(sizeof(KernelDescriptor), Context)); 860 861 // The visibility of the kernel code symbol must be protected or less to allow 862 // static relocations from the kernel descriptor to be used. 863 if (KernelCodeSymbol->getVisibility() == ELF::STV_DEFAULT) 864 KernelCodeSymbol->setVisibility(ELF::STV_PROTECTED); 865 866 Streamer.emitLabel(KernelDescriptorSymbol); 867 Streamer.emitInt32(KernelDescriptor.group_segment_fixed_size); 868 Streamer.emitInt32(KernelDescriptor.private_segment_fixed_size); 869 Streamer.emitInt32(KernelDescriptor.kernarg_size); 870 871 for (uint8_t Res : KernelDescriptor.reserved0) 872 Streamer.emitInt8(Res); 873 874 // FIXME: Remove the use of VK_AMDGPU_REL64 in the expression below. The 875 // expression being created is: 876 // (start of kernel code) - (start of kernel descriptor) 877 // It implies R_AMDGPU_REL64, but ends up being R_AMDGPU_ABS64. 878 Streamer.emitValue(MCBinaryExpr::createSub( 879 MCSymbolRefExpr::create( 880 KernelCodeSymbol, MCSymbolRefExpr::VK_AMDGPU_REL64, Context), 881 MCSymbolRefExpr::create( 882 KernelDescriptorSymbol, MCSymbolRefExpr::VK_None, Context), 883 Context), 884 sizeof(KernelDescriptor.kernel_code_entry_byte_offset)); 885 for (uint8_t Res : KernelDescriptor.reserved1) 886 Streamer.emitInt8(Res); 887 Streamer.emitInt32(KernelDescriptor.compute_pgm_rsrc3); 888 Streamer.emitInt32(KernelDescriptor.compute_pgm_rsrc1); 889 Streamer.emitInt32(KernelDescriptor.compute_pgm_rsrc2); 890 Streamer.emitInt16(KernelDescriptor.kernel_code_properties); 891 for (uint8_t Res : KernelDescriptor.reserved2) 892 Streamer.emitInt8(Res); 893 } 894