87 std::unique_ptr<MCStreamer> &&
Streamer) {
104 AMDGPUAsmPrinter *Asm;
107 AMDGPUAsmPrinterHandler(AMDGPUAsmPrinter *
A) : Asm(
A) {}
111 void endFunction(
const MachineFunction *MF)
override { Asm->endFunction(MF); }
113 void endModule()
override {}
118 std::unique_ptr<MCStreamer>
Streamer)
126 if (
auto *ResourceUsageW =
128 return &ResourceUsageW->getResourceInfo();
134 return "AMDGPU Assembly Printer";
138 return &
TM.getMCSubtargetInfo();
151void AMDGPUAsmPrinter::initTargetStreamer(
Module &M) {
157 initializeTargetID(M);
159 const Triple &TT = M.getTargetTriple();
178 initTargetStreamer(M);
180 const Triple &TT = M.getTargetTriple();
187 HSAMetadataStream->end();
202 STM.getCPU() +
" is only available on code object version 6 or better");
208 initializeTargetID(*
F.getParent());
213 if (STM.isMesaKernel(
F) &&
217 getAmdKernelCode(KernelCode, CurrentProgramInfo, *
MF);
222 if (STM.isAmdHsaOS())
223 HSAMetadataStream->emitKernel(*
MF, CurrentProgramInfo);
249 getAmdhsaKernelDescriptor(*
MF, CurrentProgramInfo);
262 const MCExpr *InstPrefSize =
269 auto &Context =
Streamer.getContext();
270 auto &ObjectFileInfo = *Context.getObjectFileInfo();
271 auto &ReadOnlySection = *ObjectFileInfo.getReadOnlySection();
274 Streamer.switchSection(&ReadOnlySection);
279 ReadOnlySection.ensureMinAlignment(
Align(64));
284 STM, KernelName, KD, CurrentProgramInfo.NumVGPRsForWavesPerEU,
286 CurrentProgramInfo.NumSGPRsForWavesPerEU,
288 CurrentProgramInfo.VCCUsed, CurrentProgramInfo.FlatUsed,
291 CurrentProgramInfo.VCCUsed, CurrentProgramInfo.FlatUsed);
301 OS <<
"implicit-def: "
302 <<
printReg(RegNo,
MF->getSubtarget().getRegisterInfo());
305 OS <<
" : SGPR spill to VGPR lane";
325 if (DumpCodeInstEmitter) {
352 ": unsupported initializer for address space");
365 "LDS definitions should have been externalized when object "
366 "linking is enabled");
374 "' is already defined");
383 TS->emitAMDGPULDS(GVSym,
Size, Alignment);
391 const Triple &TT = M.getTargetTriple();
399 "codegen with no subarch in the target triple is deprecated and will "
400 "become an error; use the target triple '" +
401 Fixed.str() +
"' instead",
405 "codegen with no subarch in the target triple is deprecated and will "
414 const AMDGPUOptions &CLOpts =
416 switch (CodeObjectVersion) {
419 std::make_unique<HSAMD::MetadataStreamerMsgPackV4>(CLOpts);
423 std::make_unique<HSAMD::MetadataStreamerMsgPackV5>(CLOpts);
427 std::make_unique<HSAMD::MetadataStreamerMsgPackV6>(CLOpts);
446 unsigned DynamicVGPRBlockSize,
460 auto CreateExpr = [&Ctx](
unsigned Value) {
470 {CreateExpr(MaxWaves), CreateExpr(Granule),
471 CreateExpr(TargetTotalNumVGPRs),
472 CreateExpr(InitOcc), CreateExpr(SGPRTotal),
473 CreateExpr(SGPRGranule),
474 CreateExpr(SGPRTrapReserve), SGPRArg, NumVGPRs},
478void AMDGPUAsmPrinter::validateMCResourceInfo(
Function &
F) {
483 const GCNSubtarget &STM =
TM.getSubtarget<GCNSubtarget>(
F);
486 auto TryGetMCExprValue = [](
const MCExpr *
Value,
uint64_t &Res) ->
bool {
488 if (
Value->evaluateAsAbsolute(Val)) {
495 const uint64_t MaxScratchPerWorkitem =
498 RI.getSymbol(FnSym->getName(), RIK::RIK_PrivateSegSize,
OutContext);
502 ScratchSize > MaxScratchPerWorkitem) {
503 DiagnosticInfoStackSize DiagStackSize(
F, ScratchSize, MaxScratchPerWorkitem,
505 F.getContext().diagnose(DiagStackSize);
511 RI.getSymbol(FnSym->getName(), RIK::RIK_NumSGPR,
OutContext);
513 !STM.hasSGPRInitBug()) {
518 NumSgpr > MaxAddressableNumSGPRs) {
519 F.getContext().diagnose(DiagnosticInfoResourceLimit(
520 F,
"addressable scalar registers", NumSgpr, MaxAddressableNumSGPRs,
527 RI.getSymbol(FnSym->getName(), RIK::RIK_UsesVCC,
OutContext);
529 RI.getSymbol(FnSym->getName(), RIK::RIK_UsesFlatScratch,
OutContext);
530 uint64_t VCCUsed, FlatUsed, NumSgpr;
541 STM, VCCUsed, FlatUsed,
544 STM.hasSGPRInitBug()) {
546 if (NumSgpr > MaxAddressableNumSGPRs) {
547 F.getContext().diagnose(DiagnosticInfoResourceLimit(
548 F,
"scalar registers", NumSgpr, MaxAddressableNumSGPRs,
DS_Error,
555 RI.getSymbol(FnSym->getName(), RIK::RIK_NumVGPR,
OutContext);
557 RI.getSymbol(FnSym->getName(), RIK::RIK_NumAGPR,
OutContext);
565 const SIMachineFunctionInfo &MFI = *
MF->getInfo<SIMachineFunctionInfo>();
569 static_cast<uint32_t
>(NumVgpr));
571 std::max({TotalNumVgpr, (
uint64_t)1,
574 uint64_t NumSGPRsForWavesPerEU = std::max(
584 F,
"amdgpu-waves-per-eu", {0, 0},
true);
586 if (TryGetMCExprValue(OccupancyExpr, Occupancy) && Occupancy < MinWEU) {
587 DiagnosticInfoOptimizationFailure Diag(
588 F,
F.getSubprogram(),
589 "failed to meet occupancy target given by 'amdgpu-waves-per-eu' in "
591 F.getName() +
"': desired occupancy was " + Twine(MinWEU) +
592 ", final occupancy is " + Twine(Occupancy));
593 F.getContext().diagnose(Diag);
602 if (Ty->isVoidTy()) {
627 for (
Type *ParamTy : FTy->params())
635 const SIInstrInfo *
TII =
MF->getSubtarget<GCNSubtarget>().getInstrInfo();
636 const MachineOperand *
Callee =
637 TII->getNamedOperand(
MI, AMDGPU::OpName::callee);
638 if (!Callee || !
Callee->isGlobal())
640 DirectCallEdges.insert(
644void AMDGPUAsmPrinter::emitAMDGPUInfo(
Module &M) {
648 const NamedMDNode *LDSMD =
M.getNamedMetadata(
"amdgpu.lds.uses");
651 const NamedMDNode *BarMD =
M.getNamedMetadata(
"amdgpu.named_barrier.uses");
655 DenseMap<const Function *, std::string> AddrTakenTypeIds;
656 using IndirectCallInfo = std::pair<const Function *, std::string>;
662 if (!IsKernel &&
F.hasAddressTaken(
nullptr,
666 AddrTakenTypeIds[&
F] =
670 if (
F.isDeclaration())
673 StringSet<> SeenTypeIds;
674 for (
const BasicBlock &BB :
F) {
675 for (
const Instruction &
I : BB) {
677 if (!CB || !CB->isIndirectCall())
681 if (SeenTypeIds.
insert(TId).second)
682 IndirectCalls.
push_back({&
F, std::move(TId)});
687 if (FunctionInfos.empty() && DirectCallEdges.empty() && !HasLDSUses &&
688 !HasNamedBarriers && AddrTakenTypeIds.
empty() && IndirectCalls.
empty())
691 AMDGPU::InfoSectionData
Data;
692 Data.Funcs = std::move(FunctionInfos);
694 for (
auto &[
F, TypeId] : AddrTakenTypeIds) {
696 Data.TypeIds.push_back({Sym, TypeId});
699 for (
auto &[CallerSym, CalleeSym] : DirectCallEdges)
700 Data.Calls.push_back({CallerSym, CalleeSym});
701 DirectCallEdges.clear();
704 for (
const MDNode *
N : LDSMD->
operands()) {
711 if (HasNamedBarriers) {
712 for (
const MDNode *
N : BarMD->
operands()) {
715 for (
unsigned I = 1,
E =
N->getNumOperands();
I <
E; ++
I) {
722 for (
auto &[Caller, Enc] : IndirectCalls) {
724 Data.IndirectCalls.push_back({CallerSym, Enc});
731 const Triple &TT = M.getTargetTriple();
772 validateMCResourceInfo(
F);
784 auto &Context =
Streamer.getContext();
791void AMDGPUAsmPrinter::emitCommonFunctionComments(
796 OutStreamer->emitRawComment(
" TotalNumSgprs: " + getMCExprStr(NumSGPR),
798 OutStreamer->emitRawComment(
" NumVgprs: " + getMCExprStr(NumVGPR),
false);
799 if (NumAGPR && TotalNumVGPR) {
800 OutStreamer->emitRawComment(
" NumAgprs: " + getMCExprStr(NumAGPR),
false);
801 OutStreamer->emitRawComment(
" TotalNumVgprs: " + getMCExprStr(TotalNumVGPR),
804 OutStreamer->emitRawComment(
" ScratchSize: " + getMCExprStr(ScratchSize),
810const MCExpr *AMDGPUAsmPrinter::getAmdhsaKernelCodeProperties(
812 const SIMachineFunctionInfo &MFI = *
MF.getInfo<SIMachineFunctionInfo>();
813 MCContext &Ctx =
MF.getContext();
814 uint16_t KernelCodeProperties = 0;
818 KernelCodeProperties |=
819 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_BUFFER;
822 KernelCodeProperties |=
823 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_PTR;
826 KernelCodeProperties |= amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_QUEUE_PTR;
829 KernelCodeProperties |=
830 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_KERNARG_SEGMENT_PTR;
833 KernelCodeProperties |=
834 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_ID;
837 KernelCodeProperties |=
838 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_FLAT_SCRATCH_INIT;
841 KernelCodeProperties |=
842 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_SIZE;
844 if (
MF.getSubtarget<GCNSubtarget>().isWave32()) {
845 KernelCodeProperties |=
846 amdhsa::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32;
853 const MCExpr *KernelCodePropExpr =
856 amdhsa::KERNEL_CODE_PROPERTY_USES_DYNAMIC_STACK_SHIFT, Ctx);
861 return KernelCodePropExpr;
867 const GCNSubtarget &STM =
MF.getSubtarget<GCNSubtarget>();
869 const SIMachineFunctionInfo *
Info =
MF.getInfo<SIMachineFunctionInfo>();
870 MCContext &Ctx =
MF.getContext();
872 MCKernelDescriptor KernelDescriptor;
878 Align MaxKernArgAlign;
886 int64_t PGM_Rsrc3 = 1;
887 bool EvaluatableRsrc3 =
888 CurrentProgramInfo.ComputePGMRSrc3->evaluateAsAbsolute(PGM_Rsrc3);
890 (void)EvaluatableRsrc3;
892 STM.hasGFX90AInsts() || STM.hasGFX1250Insts() || !EvaluatableRsrc3 ||
893 static_cast<uint64_t>(PGM_Rsrc3) == 0);
900 return KernelDescriptor;
907 initTargetStreamer(*
MF.getFunction().getParent());
910 CurrentProgramInfo.reset(
MF);
936 FunctionInfos.push_back(
948 getSIProgramInfo(CurrentProgramInfo,
MF);
953 EmitPALMetadata(
MF, CurrentProgramInfo);
955 emitPALFunctionMetadata(
MF);
957 EmitProgramInfoSI(
MF, CurrentProgramInfo);
960 DumpCodeInstEmitter =
nullptr;
961 if (STM.dumpCode()) {
984 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_NumNamedBarrier,
986 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_PrivateSegSize,
989 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_UsesFlatScratch,
991 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_HasDynSizedStack,
993 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_HasRecursion,
995 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_HasIndirectCall,
1000 emitDVgprSymbol(
MF);
1009 OutStreamer->emitRawComment(
" Function info:",
false);
1011 emitCommonFunctionComments(
1013 ->getVariableValue(),
1014 STM.hasMAIInsts() ? RI.getSymbol(
CurrentFnSym->getName(),
1016 ->getVariableValue()
1018 RI.createTotalNumVGPRs(
MF, Ctx),
1019 RI.createTotalNumSGPRs(
1023 RI.getSymbol(
CurrentFnSym->getName(), RIK::RIK_PrivateSegSize,
1025 ->getVariableValue(),
1026 CurrentProgramInfo.getFunctionCodeSize(
MF), MFI);
1030 OutStreamer->emitRawComment(
" Kernel info:",
false);
1031 emitCommonFunctionComments(
1032 CurrentProgramInfo.NumArchVGPR,
1033 STM.hasMAIInsts() ? CurrentProgramInfo.NumAccVGPR :
nullptr,
1034 CurrentProgramInfo.NumVGPR, CurrentProgramInfo.NumSGPR,
1035 CurrentProgramInfo.ScratchSize,
1036 CurrentProgramInfo.getFunctionCodeSize(
MF), MFI);
1039 " FloatMode: " +
Twine(CurrentProgramInfo.FloatMode),
false);
1041 " IeeeMode: " +
Twine(CurrentProgramInfo.IEEEMode),
false);
1043 " LDSByteSize: " +
Twine(CurrentProgramInfo.LDSSize) +
1044 " bytes/workgroup (compile time only)",
1048 " SGPRBlocks: " + getMCExprStr(CurrentProgramInfo.SGPRBlocks),
false);
1051 " VGPRBlocks: " + getMCExprStr(CurrentProgramInfo.VGPRBlocks),
false);
1054 " NumSGPRsForWavesPerEU: " +
1055 getMCExprStr(CurrentProgramInfo.NumSGPRsForWavesPerEU),
1058 " NumVGPRsForWavesPerEU: " +
1059 getMCExprStr(CurrentProgramInfo.NumVGPRsForWavesPerEU),
1062 if (STM.hasGFX90AInsts()) {
1068 " AccumOffset: " + getMCExprStr(AdjustedAccum),
false);
1071 if (STM.hasGFX1250Insts())
1073 " NamedBarCnt: " + getMCExprStr(CurrentProgramInfo.NamedBarCnt),
1077 " Occupancy: " + getMCExprStr(CurrentProgramInfo.Occupancy),
false);
1083 " COMPUTE_PGM_RSRC2:SCRATCH_EN: " +
1084 getMCExprStr(CurrentProgramInfo.ScratchEnable),
1086 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:USER_SGPR: " +
1087 Twine(CurrentProgramInfo.UserSGPR),
1089 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:TRAP_HANDLER: " +
1090 Twine(CurrentProgramInfo.TrapHandlerEnable),
1092 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:TGID_X_EN: " +
1093 Twine(CurrentProgramInfo.TGIdXEnable),
1095 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:TGID_Y_EN: " +
1096 Twine(CurrentProgramInfo.TGIdYEnable),
1098 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:TGID_Z_EN: " +
1099 Twine(CurrentProgramInfo.TGIdZEnable),
1101 OutStreamer->emitRawComment(
" COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: " +
1102 Twine(CurrentProgramInfo.TIdIGCompCount),
1105 [[maybe_unused]] int64_t PGMRSrc3;
1107 STM.hasGFX90AInsts() || STM.hasGFX1250Insts() ||
1108 (CurrentProgramInfo.ComputePGMRSrc3->evaluateAsAbsolute(PGMRSrc3) &&
1109 static_cast<uint64_t
>(PGMRSrc3) == 0));
1110 if (STM.hasGFX90AInsts()) {
1112 " COMPUTE_PGM_RSRC3_GFX90A:ACCUM_OFFSET: " +
1114 CurrentProgramInfo.ComputePGMRSrc3,
1115 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET_SHIFT,
1116 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET, Ctx)),
1119 " COMPUTE_PGM_RSRC3_GFX90A:TG_SPLIT: " +
1121 CurrentProgramInfo.ComputePGMRSrc3,
1122 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT_SHIFT,
1123 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT, Ctx)),
1128 if (DumpCodeInstEmitter) {
1134 std::string Comment =
"\n";
1137 Comment +=
" ; " +
HexLines[i] +
"\n";
1162 const MCExpr *EncodedBlocks;
1165 NumVGPRs,
nullptr) &&
1166 NumVGPRs.isAbsolute()) {
1170 unsigned NumBlocks =
1175 {},
"DVGPR block count " +
Twine(NumBlocks) +
1176 " exceeds maximum of " +
1178 " for __dvgpr$ symbol for '" +
1182 unsigned EncodedNumBlocks = (NumBlocks - 1) << 3;
1190 {CurrentProgramInfo.NumVGPRsForWavesPerEU, One}, Ctx);
1193 BlockSizeConst, Ctx);
1204 OutStreamer->emitAssignment(DVgprFuncSym, DVgprFuncVal);
1211void AMDGPUAsmPrinter::initializeTargetID(
const Module &M) {
1219 if (FeatureString.
contains(
"xnack")) {
1220 M.getContext().diagnose(DiagnosticInfoGeneric(
1221 "xnack/sramecc should be specified via module flags. "
1222 "Use module flag 'amdgpu.xnack' instead of subtarget feature",
1225 if (FeatureString.
contains(
"sramecc")) {
1226 M.getContext().diagnose(DiagnosticInfoGeneric(
1227 "xnack/sramecc should be specified via module flags. "
1228 "Use module flag 'amdgpu.sramecc' instead of subtarget feature",
1233 const auto &GCNTM =
static_cast<const GCNTargetMachine &
>(
TM);
1234 if (
getGlobalSTI()->getFeatureBits().
test(AMDGPU::FeatureXNACKOnOffModes)) {
1236 GCNTM.getTargetIDSettingFromModuleFlag(M,
"amdgpu.xnack");
1237 if (Setting != AMDGPU::TargetIDSetting::Any)
1238 TSTargetID->setXnackSetting(Setting);
1241 if (
getGlobalSTI()->getFeatureBits().
test(AMDGPU::FeatureSRAMECCOnOffModes)) {
1243 GCNTM.getTargetIDSettingFromModuleFlag(M,
"amdgpu.sramecc");
1244 if (Setting != AMDGPU::TargetIDSetting::Any)
1245 TSTargetID->setSramEccSetting(Setting);
1256 const MCExpr *MaximumTaken =
1272 return Granule ? Granule : 256;
1275void AMDGPUAsmPrinter::getSIProgramInfo(
SIProgramInfo &ProgInfo,
1277 const GCNSubtarget &STM =
MF.getSubtarget<GCNSubtarget>();
1278 MCContext &Ctx =
MF.getContext();
1280 auto CreateExpr = [&Ctx](int64_t
Value) {
1284 auto TryGetMCExprValue = [](
const MCExpr *
Value,
uint64_t &Res) ->
bool {
1286 if (
Value->evaluateAsAbsolute(Val)) {
1293 auto GetSymRefExpr =
1300 ProgInfo.
NumArchVGPR = GetSymRefExpr(RIK::RIK_NumVGPR);
1301 ProgInfo.
NumAccVGPR = GetSymRefExpr(RIK::RIK_NumAGPR);
1308 ProgInfo.
NumSGPR = GetSymRefExpr(RIK::RIK_NumSGPR);
1309 ProgInfo.
ScratchSize = GetSymRefExpr(RIK::RIK_PrivateSegSize);
1310 ProgInfo.
VCCUsed = GetSymRefExpr(RIK::RIK_UsesVCC);
1311 ProgInfo.
FlatUsed = GetSymRefExpr(RIK::RIK_UsesFlatScratch);
1314 GetSymRefExpr(RIK::RIK_HasRecursion), Ctx);
1318 GetSymRefExpr(RIK::RIK_NumNamedBarrier), BarBlkConst, Ctx);
1321 const SIMachineFunctionInfo *MFI =
MF.getInfo<SIMachineFunctionInfo>();
1332 !STM.hasSGPRInitBug()) {
1335 if (TryGetMCExprValue(ProgInfo.
NumSGPR, NumSgpr) &&
1336 NumSgpr > MaxAddressableNumSGPRs) {
1338 LLVMContext &Ctx =
MF.getFunction().getContext();
1339 Ctx.
diagnose(DiagnosticInfoResourceLimit(
1340 MF.getFunction(),
"addressable scalar registers", NumSgpr,
1342 ProgInfo.
NumSGPR = CreateExpr(MaxAddressableNumSGPRs - 1);
1356 if (WaveDispatchNumSGPR) {
1364 if (WaveDispatchNumVGPR) {
1366 {ProgInfo.
NumArchVGPR, CreateExpr(WaveDispatchNumVGPR)}, Ctx);
1386 STM.hasSGPRInitBug()) {
1389 if (TryGetMCExprValue(ProgInfo.
NumSGPR, NumSgpr) &&
1390 NumSgpr > MaxAddressableNumSGPRs) {
1393 LLVMContext &Ctx =
MF.getFunction().getContext();
1394 Ctx.
diagnose(DiagnosticInfoResourceLimit(
1395 MF.getFunction(),
"scalar registers", NumSgpr, MaxAddressableNumSGPRs,
1397 ProgInfo.
NumSGPR = CreateExpr(MaxAddressableNumSGPRs);
1402 if (STM.hasSGPRInitBug()) {
1410 LLVMContext &Ctx =
MF.getFunction().getContext();
1411 Ctx.
diagnose(DiagnosticInfoResourceLimit(
1417 LLVMContext &Ctx =
MF.getFunction().getContext();
1418 Ctx.
diagnose(DiagnosticInfoResourceLimit(
1433 LLVMContext &Ctx =
F.getContext();
1434 Ctx.
diagnose(DiagnosticInfoResourceLimit(
1435 F,
"dynamic VGPR entry point vector registers", NumVgpr,
BlockSize,
1442 auto GetNumGPRBlocks = [&CreateExpr, &Ctx](
const MCExpr *NumGPR,
1444 const MCExpr *OneConst = CreateExpr(1ul);
1445 const MCExpr *GranuleConst = CreateExpr(Granule);
1447 const MCExpr *AlignToGPR =
1449 const MCExpr *DivGPR =
1464 const SIModeRegisterDefaults
Mode = MFI->
getMode();
1481 alignTo(ProgInfo.
LDSSize, LDSGranularityBytes) / LDSGranularityBytes;
1484 auto DivideCeil = [&Ctx](
const MCExpr *Numerator,
const MCExpr *Denominator) {
1485 const MCExpr *Ceil =
1491 unsigned ScratchAlignShift =
1499 CreateExpr(1ULL << ScratchAlignShift));
1501 if (STM.hasSupportsWGP()) {
1507 ProgInfo.
FwdProgress = !
F.hasFnAttribute(
"amdgpu-no-fwd-progress");
1511 unsigned TIDIGCompCnt = 0;
1540 if (STM.hasGFX90AInsts()) {
1543 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET,
1544 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_ACCUM_OFFSET_SHIFT, Ctx);
1547 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT,
1548 amdhsa::COMPUTE_PGM_RSRC3_GFX90A_TG_SPLIT_SHIFT, Ctx);
1551 if (STM.hasGFX1250Insts())
1554 amdhsa::COMPUTE_PGM_RSRC3_GFX125_NAMED_BAR_CNT,
1555 amdhsa::COMPUTE_PGM_RSRC3_GFX125_NAMED_BAR_CNT_SHIFT, Ctx);
1562 const auto [MinWEU, MaxWEU] =
1565 if (TryGetMCExprValue(ProgInfo.
Occupancy, Occupancy) && Occupancy < MinWEU) {
1566 DiagnosticInfoOptimizationFailure Diag(
1567 F,
F.getSubprogram(),
1568 "failed to meet occupancy target given by 'amdgpu-waves-per-eu' in "
1570 F.getName() +
"': desired occupancy was " + Twine(MinWEU) +
1571 ", final occupancy is " + Twine(Occupancy));
1572 F.getContext().diagnose(Diag);
1597void AMDGPUAsmPrinter::EmitProgramInfoSI(
1599 const SIMachineFunctionInfo *MFI =
MF.getInfo<SIMachineFunctionInfo>();
1600 const GCNSubtarget &STM =
MF.getSubtarget<GCNSubtarget>();
1601 unsigned RsrcReg =
getRsrcReg(
MF.getFunction().getCallingConv());
1602 MCContext &Ctx =
MF.getContext();
1605 auto SetBits = [&Ctx](
const MCExpr *
Value, uint32_t
Mask, uint32_t Shift) {
1612 auto EmitResolvedOrExpr = [
this](
const MCExpr *
Value,
unsigned Size) {
1614 if (
Value->evaluateAsAbsolute(Val))
1623 EmitResolvedOrExpr(CurrentProgramInfo.getComputePGMRSrc1(STM, Ctx),
1627 EmitResolvedOrExpr(CurrentProgramInfo.getComputePGMRSrc2(STM, Ctx),
1635 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1639 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1643 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1654 SetBits(CurrentProgramInfo.VGPRBlocks, 0x3F, 0),
1655 SetBits(CurrentProgramInfo.SGPRBlocks, 0x0F, 6),
1657 EmitResolvedOrExpr(GPRBlocks, 4);
1663 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1667 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1671 EmitResolvedOrExpr(SetBits(CurrentProgramInfo.ScratchBlocks,
1680 ?
divideCeil(CurrentProgramInfo.LDSBlocks, 2)
1681 : CurrentProgramInfo.LDSBlocks;
1699 unsigned DynamicVGPRBlockSize) {
1700 if (ST.hasFeature(AMDGPU::FeatureDX10ClampAndIEEEMode))
1712 if (DynamicVGPRBlockSize != 0)
1726void AMDGPUAsmPrinter::EmitPALMetadata(
1728 const SIMachineFunctionInfo *MFI =
MF.getInfo<SIMachineFunctionInfo>();
1729 auto CC =
MF.getFunction().getCallingConv();
1731 auto &Ctx =
MF.getContext();
1733 MD->setEntryPoint(
CC,
MF.getFunction().getName());
1734 MD->setNumUsedVgprs(
CC, CurrentProgramInfo.NumVGPRsForWavesPerEU, Ctx);
1738 const GCNSubtarget &STM =
MF.getSubtarget<GCNSubtarget>();
1741 MD->setHwStage(
CC,
".dynamic_vgpr_saved_count",
1745 if (STM.hasMAIInsts()) {
1746 MD->setNumUsedAgprs(
CC, CurrentProgramInfo.NumAccVGPR);
1749 MD->setNumUsedSgprs(
CC, CurrentProgramInfo.NumSGPRsForWavesPerEU, Ctx);
1750 if (MD->getPALMajorVersion() < 3) {
1751 MD->setRsrc1(
CC, CurrentProgramInfo.getPGMRSrc1(
CC, STM, Ctx), Ctx);
1753 MD->setRsrc2(
CC, CurrentProgramInfo.getComputePGMRSrc2(STM, Ctx), Ctx);
1755 const MCExpr *HasScratchBlocks =
1759 MD->setRsrc2(
CC,
maskShiftSet(HasScratchBlocks, Mask, Shift, Ctx), Ctx);
1762 MD->setHwStage(
CC,
".debug_mode", (
bool)CurrentProgramInfo.DebugMode);
1764 CurrentProgramInfo.ScratchEnable);
1778 ?
divideCeil(CurrentProgramInfo.LDSBlocks, 2)
1779 : CurrentProgramInfo.LDSBlocks;
1780 if (MD->getPALMajorVersion() < 3) {
1789 const unsigned ExtraLdsDwGranularity =
1791 MD->setGraphicsRegisters(
1792 ".ps_extra_lds_size",
1793 (
unsigned)(ExtraLDSSize * ExtraLdsDwGranularity *
sizeof(uint32_t)));
1796 static StringLiteral
const PsInputFields[] = {
1797 ".persp_sample_ena",
".persp_center_ena",
1798 ".persp_centroid_ena",
".persp_pull_model_ena",
1799 ".linear_sample_ena",
".linear_center_ena",
1800 ".linear_centroid_ena",
".line_stipple_tex_ena",
1801 ".pos_x_float_ena",
".pos_y_float_ena",
1802 ".pos_z_float_ena",
".pos_w_float_ena",
1803 ".front_face_ena",
".ancillary_ena",
1804 ".sample_coverage_ena",
".pos_fixed_pt_ena"};
1808 MD->setGraphicsRegisters(
".spi_ps_input_ena",
Field,
1809 (
bool)((PSInputEna >>
Idx) & 1));
1810 MD->setGraphicsRegisters(
".spi_ps_input_addr",
Field,
1811 (
bool)((PSInputAddr >>
Idx) & 1));
1817 if (MD->getPALMajorVersion() < 3 && STM.
isWave32())
1818 MD->setWave32(
MF.getFunction().getCallingConv());
1821void AMDGPUAsmPrinter::emitPALFunctionMetadata(
const MachineFunction &MF) {
1823 const MachineFrameInfo &MFI =
MF.getFrameInfo();
1824 StringRef FnName =
MF.getFunction().getName();
1825 MD->setFunctionScratchSize(FnName, MFI.
getStackSize());
1826 const GCNSubtarget &
ST =
MF.getSubtarget<GCNSubtarget>();
1827 MCContext &Ctx =
MF.getContext();
1829 if (MD->getPALMajorVersion() < 3) {
1835 CurrentProgramInfo.getComputePGMRSrc2(ST, Ctx), Ctx);
1839 MF.getInfo<SIMachineFunctionInfo>()->getDynamicVGPRBlockSize());
1843 MD->setFunctionLdsSize(FnName, CurrentProgramInfo.LDSSize);
1844 MD->setFunctionNumUsedVgprs(FnName, CurrentProgramInfo.NumVGPRsForWavesPerEU);
1845 MD->setFunctionNumUsedSgprs(FnName, CurrentProgramInfo.NumSGPRsForWavesPerEU);
1862void AMDGPUAsmPrinter::getAmdKernelCode(AMDGPUMCKernelCodeT &Out,
1869 const SIMachineFunctionInfo *MFI =
MF.getInfo<SIMachineFunctionInfo>();
1870 const GCNSubtarget &STM =
MF.getSubtarget<GCNSubtarget>();
1871 MCContext &Ctx =
MF.getContext();
1873 Out.initDefault(STM, Ctx,
false);
1875 Out.compute_pgm_resource1_registers =
1876 CurrentProgramInfo.getComputePGMRSrc1(STM, Ctx);
1877 Out.compute_pgm_resource2_registers =
1878 CurrentProgramInfo.getComputePGMRSrc2(STM, Ctx);
1881 Out.is_dynamic_callstack = CurrentProgramInfo.DynamicCallStack;
1909 if (STM.isXNACKEnabled())
1912 Align MaxKernArgAlign;
1913 Out.kernarg_segment_byte_size = STM.getKernArgSegmentSize(
F, MaxKernArgAlign);
1914 Out.wavefront_sgpr_count = CurrentProgramInfo.NumSGPR;
1915 Out.workitem_vgpr_count = CurrentProgramInfo.NumVGPR;
1916 Out.workitem_private_segment_byte_size = CurrentProgramInfo.ScratchSize;
1917 Out.workgroup_group_segment_byte_size = CurrentProgramInfo.LDSSize;
1922 Out.kernarg_segment_alignment =
1923 static_cast<uint8_t
>(
Log2(std::max(
Align(16), MaxKernArgAlign)));
1932 if (ExtraCode && ExtraCode[0]) {
1933 if (ExtraCode[1] != 0)
1936 switch (ExtraCode[0]) {
1948 *
MF->getSubtarget().getRegisterInfo());
1952 int64_t Val = MO.
getImm();
1956 O <<
format(
"0x%" PRIx16,
static_cast<uint16_t
>(Val));
1960 O <<
format(
"0x%" PRIx64,
static_cast<uint64_t
>(Val));
1969 const char *ExtraCode,
1973 *
MF->getSubtarget().getRegisterInfo());
1985void AMDGPUAsmPrinter::emitResourceUsageRemarks(
1991 const char *Name =
"kernel-resource-usage";
1992 const char *Indent =
" ";
1996 if (!Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(Name))
2003 auto EmitResourceUsageRemark = [&](
StringRef RemarkName,
2008 std::string LabelStr = RemarkLabel.str() +
": ";
2009 if (RemarkName !=
"FunctionName")
2010 LabelStr = Indent + LabelStr;
2025 EmitResourceUsageRemark(
"FunctionName",
"Function Name",
2026 MF.getFunction().getName());
2027 EmitResourceUsageRemark(
"NumSGPR",
"TotalSGPRs",
2028 getMCExprStr(CurrentProgramInfo.NumSGPR));
2029 EmitResourceUsageRemark(
"NumVGPR",
"VGPRs",
2030 getMCExprStr(CurrentProgramInfo.NumArchVGPR));
2032 EmitResourceUsageRemark(
"NumAGPR",
"AGPRs",
2033 getMCExprStr(CurrentProgramInfo.NumAccVGPR));
2035 EmitResourceUsageRemark(
"ScratchSize",
"ScratchSize [bytes/lane]",
2036 getMCExprStr(CurrentProgramInfo.ScratchSize));
2038 bool DynStackEvaluatable =
2039 CurrentProgramInfo.DynamicCallStack->evaluateAsAbsolute(DynStack);
2040 StringRef DynamicStackStr =
2041 DynStackEvaluatable && DynStack ?
"True" :
"False";
2042 EmitResourceUsageRemark(
"DynamicStack",
"Dynamic Stack", DynamicStackStr);
2043 EmitResourceUsageRemark(
"Occupancy",
"Occupancy [waves/SIMD]",
2044 getMCExprStr(CurrentProgramInfo.Occupancy));
2045 EmitResourceUsageRemark(
"SGPRSpill",
"SGPRs Spill",
2046 CurrentProgramInfo.SGPRSpill);
2047 EmitResourceUsageRemark(
"VGPRSpill",
"VGPRs Spill",
2048 CurrentProgramInfo.VGPRSpill);
2049 if (isModuleEntryFunction)
2050 EmitResourceUsageRemark(
"BytesLDS",
"LDS Size [bytes/block]",
2051 CurrentProgramInfo.LDSSize);
2092 "AMDGPU Assembly Printer",
false,
false)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static void EmitPALMetadataCommon(AMDGPUPALMetadata *MD, const SIProgramInfo &CurrentProgramInfo, CallingConv::ID CC, const GCNSubtarget &ST, unsigned DynamicVGPRBlockSize)
const AMDGPUMCExpr * createOccupancy(unsigned InitOcc, const MCExpr *NumSGPRs, const MCExpr *NumVGPRs, unsigned DynamicVGPRBlockSize, const GCNSubtarget &STM, MCContext &Ctx)
Mimics GCNSubtarget::computeOccupancy for MCExpr.
static unsigned getRsrcReg(CallingConv::ID CallConv)
LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUAsmPrinter()
static amd_element_byte_size_t getElementByteSizeValue(unsigned Size)
static const MCExpr * setBits(const MCExpr *Dst, const MCExpr *Value, uint32_t Mask, uint32_t Shift, MCContext &Ctx)
Set bits in a kernel descriptor MCExpr field: return ((Dst & ~Mask) | (Value << Shift))
static uint32_t getFPMode(SIModeRegisterDefaults Mode)
static std::string computeTypeId(const FunctionType *FTy, const DataLayout &DL)
static const MCExpr * computeAccumOffset(const MCExpr *NumVGPR, MCContext &Ctx)
static void appendTypeEncoding(std::string &Enc, Type *Ty, const DataLayout &DL, bool IsReturnType)
static AsmPrinter * createAMDGPUAsmPrinterPass(TargetMachine &tm, std::unique_ptr< MCStreamer > &&Streamer)
AMDGPU Assembly printer class.
AMDHSA kernel descriptor MCExpr struct for use in MC layer.
MC infrastructure to propagate the function level resource usage info.
Analyzes how many registers and other resources are used by functions.
The AMDGPU TargetMachine interface definition for hw codegen targets.
AMDHSA kernel descriptor definitions.
MC layer struct for AMDGPUMCKernelCodeT, provides MCExpr functionality where required.
amd_element_byte_size_t
The values used to define the number of bytes to use for the swizzle element size.
#define AMD_HSA_BITS_SET(dst, mask, val)
@ AMD_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_ID
@ AMD_CODE_PROPERTY_PRIVATE_ELEMENT_SIZE
@ AMD_CODE_PROPERTY_ENABLE_SGPR_KERNARG_SEGMENT_PTR
@ AMD_CODE_PROPERTY_ENABLE_SGPR_QUEUE_PTR
@ AMD_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_SIZE
@ AMD_CODE_PROPERTY_ENABLE_SGPR_PRIVATE_SEGMENT_BUFFER
@ AMD_CODE_PROPERTY_ENABLE_SGPR_DISPATCH_PTR
@ AMD_CODE_PROPERTY_IS_XNACK_SUPPORTED
@ AMD_CODE_PROPERTY_ENABLE_SGPR_FLAT_SCRATCH_INIT
@ AMD_CODE_PROPERTY_IS_PTR64
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static const Function * getParent(const Value *V)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_EXTERNAL_VISIBILITY
AMD GCN specific subclass of TargetSubtarget.
const HexagonInstrInfo * TII
OptimizedStructLayoutField Field
ModuleAnalysisManager MAM
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
R600 Assembly printer class.
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
#define R_00B028_SPI_SHADER_PGM_RSRC1_PS
#define R_0286E8_SPI_TMPRING_SIZE
#define FP_ROUND_MODE_DP(x)
#define C_00B84C_SCRATCH_EN
#define FP_ROUND_ROUND_TO_NEAREST
#define R_0286D0_SPI_PS_INPUT_ADDR
#define R_00B860_COMPUTE_TMPRING_SIZE
#define R_00B428_SPI_SHADER_PGM_RSRC1_HS
#define R_00B328_SPI_SHADER_PGM_RSRC1_ES
#define R_00B528_SPI_SHADER_PGM_RSRC1_LS
#define R_0286CC_SPI_PS_INPUT_ENA
#define R_00B128_SPI_SHADER_PGM_RSRC1_VS
#define FP_DENORM_MODE_DP(x)
#define R_00B848_COMPUTE_PGM_RSRC1
#define FP_ROUND_MODE_SP(x)
#define FP_DENORM_MODE_SP(x)
#define R_00B228_SPI_SHADER_PGM_RSRC1_GS
#define S_00B02C_EXTRA_LDS_SIZE(x)
#define R_00B84C_COMPUTE_PGM_RSRC2
#define R_00B02C_SPI_SHADER_PGM_RSRC2_PS
std::unique_ptr< MCStreamer > && Streamer
static const int BlockSize
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)
void emitFunctionEntryLabel() override
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
const MCSubtargetInfo * getGlobalSTI() const
void emitImplicitDef(const MachineInstr *MI) const override
Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode.
std::vector< std::string > DisasmLines
std::function< const AMDGPUResourceUsageAnalysisImpl::SIFunctionResourceInfo *(MachineFunction &)> GetResourceUsage
void emitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
void endFunction(const MachineFunction *MF)
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum, const char *ExtraCode, raw_ostream &O) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
std::vector< std::string > HexLines
bool IsTargetStreamerInitialized
void emitGlobalVariable(const GlobalVariable *GV) override
Emit the specified global variable to the .s file.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
AMDGPUAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
void emitBasicBlockStart(const MachineBasicBlock &MBB) override
Targets can override this to emit stuff at the start of a basic block.
AMDGPUTargetStreamer * getTargetStreamer() const
static void printRegOperand(MCRegister Reg, raw_ostream &O, const MCRegisterInfo &MRI)
AMDGPU target specific MCExpr operations.
static const AMDGPUMCExpr * createInstPrefSize(const MCExpr *CodeSizeBytes, MCContext &Ctx)
Create an expression for instruction prefetch size computation: min(divideCeil(CodeSizeBytes,...
static const AMDGPUMCExpr * createMax(ArrayRef< const MCExpr * > Args, MCContext &Ctx)
static const AMDGPUMCExpr * createTotalNumVGPR(const MCExpr *NumAGPR, const MCExpr *NumVGPR, MCContext &Ctx)
static const AMDGPUMCExpr * create(VariantKind Kind, ArrayRef< const MCExpr * > Args, MCContext &Ctx)
static const AMDGPUMCExpr * createExtraSGPRs(const MCExpr *VCCUsed, const MCExpr *FlatScrUsed, bool XNACKUsed, MCContext &Ctx)
Allow delayed MCExpr resolve of ExtraSGPRs (in case VCCUsed or FlatScrUsed are unresolvable but neede...
static const AMDGPUMCExpr * createAlignTo(const MCExpr *Value, const MCExpr *Align, MCContext &Ctx)
bool isMemoryBound() const
bool isModuleEntryFunction() const
bool needsWaveLimiter() const
uint32_t getLDSSize() const
bool isEntryFunction() const
std::pair< unsigned, unsigned > getOccupancyWithWorkGroupSizes(uint32_t LDSBytes, const Function &F) const
Subtarget's minimum/maximum occupancy, in number of waves per EU, that can be achieved when the only ...
unsigned getAddressableLocalMemorySize() const
Return the maximum number of bytes of LDS that can be allocated to a single workgroup.
unsigned getKernArgSegmentSize(const Function &F, Align &MaxAlign) const
unsigned getWavefrontSize() const
static bool EnableObjectLinking
virtual void EmitAmdhsaKernelDescriptor(const MCSubtargetInfo &STI, StringRef KernelName, const AMDGPU::MCKernelDescriptor &KernelDescriptor, const MCExpr *NextVGPR, const MCExpr *NextSGPR, const MCExpr *ReserveVCC, const MCExpr *ReserveFlatScr)
virtual void emitAMDGPUInfo(const AMDGPU::InfoSectionData &Data)
AMDGPUPALMetadata * getPALMetadata()
void initializeTargetID(const MCSubtargetInfo &STI, bool ApplyFeatureString=false)
virtual void EmitDirectiveAMDHSACodeObjectVersion(unsigned COV)
virtual bool EmitISAVersion()
virtual 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)
virtual bool EmitCodeEnd(const MCSubtargetInfo &STI)
virtual void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type)
const std::optional< AMDGPU::TargetID > & getTargetID() const
void emitDirectiveAMDGCNTargetOnce()
Emit the .amdgcn_target directive unless it has already been emitted to this streamer.
virtual void EmitAMDKernelCodeT(AMDGPU::AMDGPUMCKernelCodeT &Header)
virtual void EmitMCResourceMaximums(const MCSymbol *MaxVGPR, const MCSymbol *MaxAGPR, const MCSymbol *MaxSGPR, const MCSymbol *MaxNamedBarrier)
GPUKind getGPUKind() const
bool isXnackOnOrAny() const
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
This class represents an incoming formal argument to a Function.
Collects and handles AsmPrinter objects required to build debug or EH information.
This class is intended to be used as a driving class for all asm writers.
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
MCSymbol * getSymbol(const GlobalValue *GV) const
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
dwarf::Attribute TypeAddressSpaceAttribute
The attribute used for a pointer type's DWARF address space.
TargetMachine & TM
Target machine description.
MachineFunction * MF
The current machine function.
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
void emitFunctionBody()
This method emits the body and trailer for a function.
virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const
Return true if the basic block has exactly one predecessor and the control transfer mechanism between...
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const
This emits linkage information about GVSym based on GV, if this is supported by the target.
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
unsigned getFunctionNumber() const
Return a unique ID for the current function.
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer, char &ID=AsmPrinter::ID)
MCSymbol * CurrentFnSym
The symbol for the current function.
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
MCContext & OutContext
This is the context for the output file that we are streaming.
bool doFinalization(Module &M) override
Shut down the asmprinter.
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the start of a basic block.
void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const
This emits visibility information about symbol, if this is supported by the target.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
const MCAsmInfo & MAI
Target Asm Printer information.
std::function< MachineModuleInfo *()> GetMMI
bool isVerbose() const
Return true if assembly output should contain comments.
MCSymbol * getFunctionEnd() const
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
void addAsmPrinterHandler(std::unique_ptr< AsmPrinterHandler > Handler)
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
A parsed version of the target data layout string in and methods for querying it.
DISubprogram * getSubprogram() const
Get the attached subprogram.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
unsigned getMinNumSGPRs(unsigned WavesPerEU) const
unsigned getTotalNumVGPRs() const
unsigned getMinNumVGPRs(unsigned WavesPerEU, unsigned DynamicVGPRBlockSize) const
bool hasInstPrefSize() const
bool isCuModeEnabled() const
const AMDGPU::TargetID & getTargetID() const
void getInstPrefSizeArgs(uint32_t &Mask, uint32_t &Shift, uint32_t &Width, uint32_t &CacheLineSize) const
unsigned getMaxNumUserSGPRs() const
unsigned getMaxWavesPerEU() const
Generation getGeneration() const
unsigned getAddressableNumSGPRs() const
unsigned getMaxWaveScratchSize() const
bool hasKernargSegmentPtr() const
bool hasDispatchID() const
bool hasPrivateSegmentBuffer() const
bool hasPrivateSegmentSize() const
bool hasDispatchPtr() const
bool hasFlatScratchInit() const
VisibilityTypes getVisibility() const
LLVM_ABI bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
unsigned getAddressSpace() const
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
LLVM_ABI uint64_t getGlobalSize(const DataLayout &DL) const
Get the size of this global variable in bytes.
This is an important class for using LLVM in a threaded context.
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
MCCodeEmitter * getEmitterPtr() const
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
static const MCBinaryExpr * createAnd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createOr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createLOr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createMul(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createGT(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createDiv(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createShl(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Context object for machine code objects.
LLVM_ABI void reportError(SMLoc L, const Twine &Msg)
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Base class for the full range of assembler expressions which are needed for parsing.
LLVM_ABI bool evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm) const
Try to evaluate the expression to a relocatable value, i.e.
MCSection * getTextSection() const
MCContext & getContext() const
This represents a section on linux, lots of unix variants and some bare metal systems.
Instances of this class represent a uniqued identifier for a section in the current translation unit.
bool hasInstructions() const
Generic base class for all target subtargets.
StringRef getFeatureString() const
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
StringRef getName() const
getName - Get the symbol name.
bool isVariable() const
isVariable - Check if this is a variable symbol.
void redefineIfPossible()
Prepare this symbol to be redefined.
const MCExpr * getVariableValue() const
Get the expression of the variable symbol.
MCStreamer & getStreamer()
static const MCUnaryExpr * createNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
MCContext & getContext() const
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineBasicBlock & front() const
Representation of each machine instruction.
MachineOperand class - Representation of each machine instruction operand.
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
Register getReg() const
getReg - Returns the register number.
A Module instance is used to store all the information related to an LLVM module.
LLVM_ABI unsigned getNumOperands() const
iterator_range< op_iterator > operands()
AnalysisType * getAnalysisIfAvailable() const
getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information tha...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Wrapper class representing virtual and physical registers.
This class keeps track of the SPI_SP_INPUT_ADDR config register, which tells the hardware which inter...
unsigned getNumWaveDispatchVGPRs() const
unsigned getNumSpilledVGPRs() const
unsigned getNumWaveDispatchSGPRs() const
unsigned getNumSpilledSGPRs() const
GCNUserSGPRUsageInfo & getUserSGPRInfo()
unsigned getDynamicVGPRBlockSize() const
unsigned getMaxWavesPerEU() const
bool hasWorkGroupIDZ() const
bool hasWorkGroupIDY() const
SIModeRegisterDefaults getMode() const
bool hasWorkGroupInfo() const
bool hasWorkItemIDY() const
bool hasWorkGroupIDX() const
unsigned getNumUserSGPRs() const
unsigned getScratchReservedForDynamicVGPRs() const
bool isDynamicVGPREnabled() const
unsigned getPSInputAddr() const
bool hasWorkItemIDZ() const
unsigned getPSInputEnable() const
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void push_back(const T &Elt)
Represent a constant reference to a string, i.e.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
std::pair< typename Base::iterator, bool > insert(StringRef key)
Primary interface to the complete machine description for the target machine.
Triple - Helper class for working with autoconf configuration names.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an SmallVector or SmallString.
StringRef str() const
Return a StringRef for the vector contents.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ LOCAL_ADDRESS
Address space for local memory.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
@ FIXED_NUM_SGPRS_FOR_INIT_BUG
bool isSGPROccupancyLimited(const MCSubtargetInfo &STI)
unsigned getVGPREncodingGranule(const MCSubtargetInfo &STI, std::optional< bool > EnableWavefrontSize32)
static constexpr unsigned MaxDynamicVGPRBlocks
Maximum number of VGPR blocks that can be allocated in dynamic VGPR mode.
unsigned getSGPREncodingGranule(const MCSubtargetInfo &STI)
unsigned getNumExtraSGPRs(const MCSubtargetInfo &STI, bool VCCUsed, bool FlatScrUsed, bool XNACKUsed)
unsigned getVGPRAllocGranule(const MCSubtargetInfo &STI, unsigned DynamicVGPRBlockSize, std::optional< bool > EnableWavefrontSize32)
LLVM_ABI unsigned getLDSEncodingGranule(GPUKind AK)
void printAMDGPUMCExpr(const MCExpr *Expr, raw_ostream &OS, const MCAsmInfo *MAI)
LLVM_READNONE constexpr bool isModuleEntryFunctionCC(CallingConv::ID CC)
LLVM_ABI IsaVersion getIsaVersion(StringRef GPU)
LLVM_ABI unsigned getTotalNumVGPRs(GPUKind AK, bool IsWave32)
LLVM_ABI unsigned getTotalNumSGPRs(GPUKind AK)
const MCExpr * maskShiftSet(const MCExpr *Val, uint32_t Mask, uint32_t Shift, MCContext &Ctx)
Provided with the MCExpr * Val, uint32 Mask and Shift, will return the masked and left shifted,...
unsigned getAMDHSACodeObjectVersion(const Module &M)
bool isTgSplitEnabled(const Function &F)
GPUKind
GPU kinds supported by the AMDGPU target.
bool isGFX90A(const MCSubtargetInfo &STI)
LLVM_READNONE constexpr bool isKernel(CallingConv::ID CC)
LLVM_ABI unsigned getSGPRAllocGranule(GPUKind AK)
LLVM_READNONE constexpr bool isEntryFunctionCC(CallingConv::ID CC)
LLVM_READNONE constexpr bool isCompute(CallingConv::ID CC)
bool hasMAIInsts(const MCSubtargetInfo &STI)
LLVM_ABI Triple::SubArchType getSubArch(GPUKind AK)
LLVM_READNONE bool isInlinableIntLiteral(int64_t Literal)
Is this literal inlinable, and not one of the values intended for floating point values.
LLVM_ABI GPUKind parseArchAMDGCN(StringRef CPU)
const MCExpr * foldAMDGPUMCExpr(const MCExpr *Expr, MCContext &Ctx)
bool isGFX10Plus(const MCSubtargetInfo &STI)
constexpr std::pair< unsigned, unsigned > getShiftMask(unsigned Value)
Deduce the least significant bit aligned shift and mask values for a binary Complement Value (as they...
unsigned hasKernargPreload(const MCSubtargetInfo &STI)
std::pair< unsigned, unsigned > getIntegerPairAttribute(const Function &F, StringRef Name, std::pair< unsigned, unsigned > Default, bool OnlyFirstRequired)
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ AMDGPU_CS
Used for Mesa/AMDPAL compute shaders.
@ AMDGPU_VS
Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
@ AMDGPU_HS
Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
@ AMDGPU_GS
Used for Mesa/AMDPAL geometry shaders.
@ AMDGPU_CS_Chain
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AMDGPU_PS
Used for Mesa/AMDPAL pixel shaders.
@ SPIR_KERNEL
Used for SPIR kernel functions.
@ AMDGPU_ES
Used for AMDPAL shader stage before geometry shader if geometry is in use.
@ AMDGPU_LS
Used for AMDPAL vertex shader if tessellation is in use.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
DiagnosticInfoOptimizationBase::Argument NV
NodeAddr< FuncNode * > Func
This is an optimization pass for GlobalISel generic memory operations.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
static StringRef getCPU(StringRef CPU)
Processes a CPU name.
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
Target & getTheR600Target()
The target for R600 GPUs.
AsmPrinter * createR600AsmPrinterPass(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
LLVM_ABI void setupModuleAsmPrinter(Module &M, ModuleAnalysisManager &MAM, AsmPrinter &AsmPrinter)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
@ Success
The lock was released successfully.
constexpr T divideCeil(U Numerator, V Denominator)
Returns the integer ceil(Numerator / Denominator).
Target & getTheGCNTarget()
The target for GCN GPUs.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI void setupMachineFunctionAsmPrinter(MachineFunctionAnalysisManager &MFAM, MachineFunction &MF, AsmPrinter &AsmPrinter)
Target & getTheGCNLegacyTarget()
The target for GCN GPUs, registered under the legacy "amdgcn" architecture name for use with -march.
unsigned Log2(Align A)
Returns the log2 of the alignment.
LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Implement std::hash so that hash_code can be used in STL containers.
bool HasDynamicallySizedStack
uint64_t PrivateSegmentSize
AMDGPUResourceUsageAnalysisImpl::SIFunctionResourceInfo FunctionResourceInfo
void validate(const MCSubtargetInfo *STI, MCContext &Ctx)
const MCExpr * compute_pgm_rsrc2
const MCExpr * kernarg_size
const MCExpr * kernarg_preload
const MCExpr * compute_pgm_rsrc3
const MCExpr * private_segment_fixed_size
static const MCExpr * bits_get(const MCExpr *Src, uint32_t Shift, uint32_t Mask, MCContext &Ctx)
const MCExpr * compute_pgm_rsrc1
const MCExpr * group_segment_fixed_size
const MCExpr * kernel_code_properties
This struct is a compact representation of a valid (non-zero power of two) alignment.
Track resource usage for kernels / entry functions.
const MCExpr * NumArchVGPR
const MCExpr * VGPRBlocks
const MCExpr * ScratchBlocks
const MCExpr * ComputePGMRSrc3
const MCExpr * getComputePGMRSrc1(const GCNSubtarget &ST, MCContext &Ctx) const
Compute the value of the ComputePGMRsrc1 register.
uint32_t TrapHandlerEnable
const MCExpr * NamedBarCnt
const MCExpr * ScratchEnable
const MCExpr * AccumOffset
const MCExpr * NumAccVGPR
const MCExpr * DynamicCallStack
const MCExpr * SGPRBlocks
const MCExpr * NumVGPRsForWavesPerEU
const MCExpr * ScratchSize
const MCExpr * NumSGPRsForWavesPerEU
const MCExpr * getComputePGMRSrc2(const GCNSubtarget &ST, MCContext &Ctx) const
Compute the value of the ComputePGMRsrc2 register.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.