1 //===- SIMachineFunctionInfo.cpp - SI Machine Function Info ---------------===//
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 #include "SIMachineFunctionInfo.h"
10 #include "AMDGPUArgumentUsageInfo.h"
11 #include "AMDGPUTargetMachine.h"
12 #include "AMDGPUSubtarget.h"
13 #include "SIRegisterInfo.h"
14 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
15 #include "Utils/AMDGPUBaseInfo.h"
16 #include "llvm/ADT/Optional.h"
17 #include "llvm/CodeGen/MachineBasicBlock.h"
18 #include "llvm/CodeGen/MachineFrameInfo.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineRegisterInfo.h"
21 #include "llvm/IR/CallingConv.h"
22 #include "llvm/IR/Function.h"
23 #include <cassert>
24 #include <vector>
25 
26 #define MAX_LANES 64
27 
28 using namespace llvm;
29 
30 SIMachineFunctionInfo::SIMachineFunctionInfo(const MachineFunction &MF)
31   : AMDGPUMachineFunction(MF),
32     PrivateSegmentBuffer(false),
33     DispatchPtr(false),
34     QueuePtr(false),
35     KernargSegmentPtr(false),
36     DispatchID(false),
37     FlatScratchInit(false),
38     WorkGroupIDX(false),
39     WorkGroupIDY(false),
40     WorkGroupIDZ(false),
41     WorkGroupInfo(false),
42     PrivateSegmentWaveByteOffset(false),
43     WorkItemIDX(false),
44     WorkItemIDY(false),
45     WorkItemIDZ(false),
46     ImplicitBufferPtr(false),
47     ImplicitArgPtr(false),
48     GITPtrHigh(0xffffffff),
49     HighBitsOf32BitAddress(0),
50     GDSSize(0) {
51   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
52   const Function &F = MF.getFunction();
53   FlatWorkGroupSizes = ST.getFlatWorkGroupSizes(F);
54   WavesPerEU = ST.getWavesPerEU(F);
55 
56   Occupancy = ST.computeOccupancy(MF, getLDSSize());
57   CallingConv::ID CC = F.getCallingConv();
58 
59   // FIXME: Should have analysis or something rather than attribute to detect
60   // calls.
61   const bool HasCalls = F.hasFnAttribute("amdgpu-calls");
62 
63   // Enable all kernel inputs if we have the fixed ABI. Don't bother if we don't
64   // have any calls.
65   const bool UseFixedABI = AMDGPUTargetMachine::EnableFixedFunctionABI &&
66                            (!isEntryFunction() || HasCalls);
67 
68   if (CC == CallingConv::AMDGPU_KERNEL || CC == CallingConv::SPIR_KERNEL) {
69     if (!F.arg_empty())
70       KernargSegmentPtr = true;
71     WorkGroupIDX = true;
72     WorkItemIDX = true;
73   } else if (CC == CallingConv::AMDGPU_PS) {
74     PSInputAddr = AMDGPU::getInitialPSInputAddr(F);
75   }
76 
77   if (!isEntryFunction()) {
78     // Non-entry functions have no special inputs for now, other registers
79     // required for scratch access.
80     ScratchRSrcReg = AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3;
81 
82     // TODO: Pick a high register, and shift down, similar to a kernel.
83     FrameOffsetReg = AMDGPU::SGPR33;
84     StackPtrOffsetReg = AMDGPU::SGPR32;
85 
86     ArgInfo.PrivateSegmentBuffer =
87       ArgDescriptor::createRegister(ScratchRSrcReg);
88 
89     if (F.hasFnAttribute("amdgpu-implicitarg-ptr"))
90       ImplicitArgPtr = true;
91   } else {
92     if (F.hasFnAttribute("amdgpu-implicitarg-ptr")) {
93       KernargSegmentPtr = true;
94       MaxKernArgAlign = std::max(ST.getAlignmentForImplicitArgPtr(),
95                                  MaxKernArgAlign);
96     }
97   }
98 
99   if (UseFixedABI) {
100     WorkGroupIDX = true;
101     WorkGroupIDY = true;
102     WorkGroupIDZ = true;
103     WorkItemIDX = true;
104     WorkItemIDY = true;
105     WorkItemIDZ = true;
106     ImplicitArgPtr = true;
107   } else {
108     if (F.hasFnAttribute("amdgpu-work-group-id-x"))
109       WorkGroupIDX = true;
110 
111     if (F.hasFnAttribute("amdgpu-work-group-id-y"))
112       WorkGroupIDY = true;
113 
114     if (F.hasFnAttribute("amdgpu-work-group-id-z"))
115       WorkGroupIDZ = true;
116 
117     if (F.hasFnAttribute("amdgpu-work-item-id-x"))
118       WorkItemIDX = true;
119 
120     if (F.hasFnAttribute("amdgpu-work-item-id-y"))
121       WorkItemIDY = true;
122 
123     if (F.hasFnAttribute("amdgpu-work-item-id-z"))
124       WorkItemIDZ = true;
125   }
126 
127   bool HasStackObjects = F.hasFnAttribute("amdgpu-stack-objects");
128   if (isEntryFunction()) {
129     // X, XY, and XYZ are the only supported combinations, so make sure Y is
130     // enabled if Z is.
131     if (WorkItemIDZ)
132       WorkItemIDY = true;
133 
134     PrivateSegmentWaveByteOffset = true;
135 
136     // HS and GS always have the scratch wave offset in SGPR5 on GFX9.
137     if (ST.getGeneration() >= AMDGPUSubtarget::GFX9 &&
138         (CC == CallingConv::AMDGPU_HS || CC == CallingConv::AMDGPU_GS))
139       ArgInfo.PrivateSegmentWaveByteOffset =
140           ArgDescriptor::createRegister(AMDGPU::SGPR5);
141   }
142 
143   bool isAmdHsaOrMesa = ST.isAmdHsaOrMesa(F);
144   if (isAmdHsaOrMesa) {
145     PrivateSegmentBuffer = true;
146 
147     if (UseFixedABI) {
148       DispatchPtr = true;
149       QueuePtr = true;
150 
151       // FIXME: We don't need this?
152       DispatchID = true;
153     } else {
154       if (F.hasFnAttribute("amdgpu-dispatch-ptr"))
155         DispatchPtr = true;
156 
157       if (F.hasFnAttribute("amdgpu-queue-ptr"))
158         QueuePtr = true;
159 
160       if (F.hasFnAttribute("amdgpu-dispatch-id"))
161         DispatchID = true;
162     }
163   } else if (ST.isMesaGfxShader(F)) {
164     ImplicitBufferPtr = true;
165   }
166 
167   if (UseFixedABI || F.hasFnAttribute("amdgpu-kernarg-segment-ptr"))
168     KernargSegmentPtr = true;
169 
170   if (ST.hasFlatAddressSpace() && isEntryFunction() && isAmdHsaOrMesa) {
171     // TODO: This could be refined a lot. The attribute is a poor way of
172     // detecting calls or stack objects that may require it before argument
173     // lowering.
174     if (HasCalls || HasStackObjects)
175       FlatScratchInit = true;
176   }
177 
178   Attribute A = F.getFnAttribute("amdgpu-git-ptr-high");
179   StringRef S = A.getValueAsString();
180   if (!S.empty())
181     S.consumeInteger(0, GITPtrHigh);
182 
183   A = F.getFnAttribute("amdgpu-32bit-address-high-bits");
184   S = A.getValueAsString();
185   if (!S.empty())
186     S.consumeInteger(0, HighBitsOf32BitAddress);
187 
188   S = F.getFnAttribute("amdgpu-gds-size").getValueAsString();
189   if (!S.empty())
190     S.consumeInteger(0, GDSSize);
191 }
192 
193 void SIMachineFunctionInfo::limitOccupancy(const MachineFunction &MF) {
194   limitOccupancy(getMaxWavesPerEU());
195   const GCNSubtarget& ST = MF.getSubtarget<GCNSubtarget>();
196   limitOccupancy(ST.getOccupancyWithLocalMemSize(getLDSSize(),
197                  MF.getFunction()));
198 }
199 
200 Register SIMachineFunctionInfo::addPrivateSegmentBuffer(
201   const SIRegisterInfo &TRI) {
202   ArgInfo.PrivateSegmentBuffer =
203     ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
204     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SGPR_128RegClass));
205   NumUserSGPRs += 4;
206   return ArgInfo.PrivateSegmentBuffer.getRegister();
207 }
208 
209 Register SIMachineFunctionInfo::addDispatchPtr(const SIRegisterInfo &TRI) {
210   ArgInfo.DispatchPtr = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
211     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
212   NumUserSGPRs += 2;
213   return ArgInfo.DispatchPtr.getRegister();
214 }
215 
216 Register SIMachineFunctionInfo::addQueuePtr(const SIRegisterInfo &TRI) {
217   ArgInfo.QueuePtr = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
218     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
219   NumUserSGPRs += 2;
220   return ArgInfo.QueuePtr.getRegister();
221 }
222 
223 Register SIMachineFunctionInfo::addKernargSegmentPtr(const SIRegisterInfo &TRI) {
224   ArgInfo.KernargSegmentPtr
225     = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
226     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
227   NumUserSGPRs += 2;
228   return ArgInfo.KernargSegmentPtr.getRegister();
229 }
230 
231 Register SIMachineFunctionInfo::addDispatchID(const SIRegisterInfo &TRI) {
232   ArgInfo.DispatchID = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
233     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
234   NumUserSGPRs += 2;
235   return ArgInfo.DispatchID.getRegister();
236 }
237 
238 Register SIMachineFunctionInfo::addFlatScratchInit(const SIRegisterInfo &TRI) {
239   ArgInfo.FlatScratchInit = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
240     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
241   NumUserSGPRs += 2;
242   return ArgInfo.FlatScratchInit.getRegister();
243 }
244 
245 Register SIMachineFunctionInfo::addImplicitBufferPtr(const SIRegisterInfo &TRI) {
246   ArgInfo.ImplicitBufferPtr = ArgDescriptor::createRegister(TRI.getMatchingSuperReg(
247     getNextUserSGPR(), AMDGPU::sub0, &AMDGPU::SReg_64RegClass));
248   NumUserSGPRs += 2;
249   return ArgInfo.ImplicitBufferPtr.getRegister();
250 }
251 
252 bool SIMachineFunctionInfo::isCalleeSavedReg(const MCPhysReg *CSRegs,
253                                              MCPhysReg Reg) {
254   for (unsigned I = 0; CSRegs[I]; ++I) {
255     if (CSRegs[I] == Reg)
256       return true;
257   }
258 
259   return false;
260 }
261 
262 /// \p returns true if \p NumLanes slots are available in VGPRs already used for
263 /// SGPR spilling.
264 //
265 // FIXME: This only works after processFunctionBeforeFrameFinalized
266 bool SIMachineFunctionInfo::haveFreeLanesForSGPRSpill(const MachineFunction &MF,
267                                                       unsigned NumNeed) const {
268   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
269   unsigned WaveSize = ST.getWavefrontSize();
270   return NumVGPRSpillLanes + NumNeed <= WaveSize * SpillVGPRs.size();
271 }
272 
273 /// Reserve a slice of a VGPR to support spilling for FrameIndex \p FI.
274 bool SIMachineFunctionInfo::allocateSGPRSpillToVGPR(MachineFunction &MF,
275                                                     int FI) {
276   std::vector<SpilledReg> &SpillLanes = SGPRToVGPRSpills[FI];
277 
278   // This has already been allocated.
279   if (!SpillLanes.empty())
280     return true;
281 
282   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
283   const SIRegisterInfo *TRI = ST.getRegisterInfo();
284   MachineFrameInfo &FrameInfo = MF.getFrameInfo();
285   MachineRegisterInfo &MRI = MF.getRegInfo();
286   unsigned WaveSize = ST.getWavefrontSize();
287   SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
288 
289   unsigned Size = FrameInfo.getObjectSize(FI);
290   assert(Size >= 4 && Size <= 64 && "invalid sgpr spill size");
291   assert(TRI->spillSGPRToVGPR() && "not spilling SGPRs to VGPRs");
292 
293   int NumLanes = Size / 4;
294 
295   const MCPhysReg *CSRegs = MRI.getCalleeSavedRegs();
296 
297   // Make sure to handle the case where a wide SGPR spill may span between two
298   // VGPRs.
299   for (int I = 0; I < NumLanes; ++I, ++NumVGPRSpillLanes) {
300     Register LaneVGPR;
301     unsigned VGPRIndex = (NumVGPRSpillLanes % WaveSize);
302 
303     if (VGPRIndex == 0 && !FuncInfo->VGPRReservedForSGPRSpill) {
304       LaneVGPR = TRI->findUnusedRegister(MRI, &AMDGPU::VGPR_32RegClass, MF);
305       if (LaneVGPR == AMDGPU::NoRegister) {
306         // We have no VGPRs left for spilling SGPRs. Reset because we will not
307         // partially spill the SGPR to VGPRs.
308         SGPRToVGPRSpills.erase(FI);
309         NumVGPRSpillLanes -= I;
310         return false;
311       }
312 
313       Optional<int> CSRSpillFI;
314       if ((FrameInfo.hasCalls() || !isEntryFunction()) && CSRegs &&
315           isCalleeSavedReg(CSRegs, LaneVGPR)) {
316         CSRSpillFI = FrameInfo.CreateSpillStackObject(4, Align(4));
317       }
318 
319       SpillVGPRs.push_back(SGPRSpillVGPRCSR(LaneVGPR, CSRSpillFI));
320 
321       // Add this register as live-in to all blocks to avoid machine verifer
322       // complaining about use of an undefined physical register.
323       for (MachineBasicBlock &BB : MF)
324         BB.addLiveIn(LaneVGPR);
325     } else {
326       LaneVGPR = SpillVGPRs.back().VGPR;
327     }
328 
329     SpillLanes.push_back(SpilledReg(LaneVGPR, VGPRIndex));
330   }
331 
332   return true;
333 }
334 
335 /// Reserve a VGPR for spilling of SGPRs
336 bool SIMachineFunctionInfo::reserveVGPRforSGPRSpills(MachineFunction &MF) {
337   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
338   const SIRegisterInfo *TRI = ST.getRegisterInfo();
339   SIMachineFunctionInfo *FuncInfo = MF.getInfo<SIMachineFunctionInfo>();
340 
341   Register LaneVGPR = TRI->findUnusedRegister(
342       MF.getRegInfo(), &AMDGPU::VGPR_32RegClass, MF, true);
343   SpillVGPRs.push_back(SGPRSpillVGPRCSR(LaneVGPR, None));
344   FuncInfo->VGPRReservedForSGPRSpill = LaneVGPR;
345   return true;
346 }
347 
348 /// Reserve AGPRs or VGPRs to support spilling for FrameIndex \p FI.
349 /// Either AGPR is spilled to VGPR to vice versa.
350 /// Returns true if a \p FI can be eliminated completely.
351 bool SIMachineFunctionInfo::allocateVGPRSpillToAGPR(MachineFunction &MF,
352                                                     int FI,
353                                                     bool isAGPRtoVGPR) {
354   MachineRegisterInfo &MRI = MF.getRegInfo();
355   MachineFrameInfo &FrameInfo = MF.getFrameInfo();
356   const GCNSubtarget &ST =  MF.getSubtarget<GCNSubtarget>();
357 
358   assert(ST.hasMAIInsts() && FrameInfo.isSpillSlotObjectIndex(FI));
359 
360   auto &Spill = VGPRToAGPRSpills[FI];
361 
362   // This has already been allocated.
363   if (!Spill.Lanes.empty())
364     return Spill.FullyAllocated;
365 
366   unsigned Size = FrameInfo.getObjectSize(FI);
367   unsigned NumLanes = Size / 4;
368   Spill.Lanes.resize(NumLanes, AMDGPU::NoRegister);
369 
370   const TargetRegisterClass &RC =
371       isAGPRtoVGPR ? AMDGPU::VGPR_32RegClass : AMDGPU::AGPR_32RegClass;
372   auto Regs = RC.getRegisters();
373 
374   auto &SpillRegs = isAGPRtoVGPR ? SpillAGPR : SpillVGPR;
375   const SIRegisterInfo *TRI = ST.getRegisterInfo();
376   Spill.FullyAllocated = true;
377 
378   // FIXME: Move allocation logic out of MachineFunctionInfo and initialize
379   // once.
380   BitVector OtherUsedRegs;
381   OtherUsedRegs.resize(TRI->getNumRegs());
382 
383   const uint32_t *CSRMask =
384       TRI->getCallPreservedMask(MF, MF.getFunction().getCallingConv());
385   if (CSRMask)
386     OtherUsedRegs.setBitsInMask(CSRMask);
387 
388   // TODO: Should include register tuples, but doesn't matter with current
389   // usage.
390   for (MCPhysReg Reg : SpillAGPR)
391     OtherUsedRegs.set(Reg);
392   for (MCPhysReg Reg : SpillVGPR)
393     OtherUsedRegs.set(Reg);
394 
395   SmallVectorImpl<MCPhysReg>::const_iterator NextSpillReg = Regs.begin();
396   for (unsigned I = 0; I < NumLanes; ++I) {
397     NextSpillReg = std::find_if(
398         NextSpillReg, Regs.end(), [&MRI, &OtherUsedRegs](MCPhysReg Reg) {
399           return MRI.isAllocatable(Reg) && !MRI.isPhysRegUsed(Reg) &&
400                  !OtherUsedRegs[Reg];
401         });
402 
403     if (NextSpillReg == Regs.end()) { // Registers exhausted
404       Spill.FullyAllocated = false;
405       break;
406     }
407 
408     OtherUsedRegs.set(*NextSpillReg);
409     SpillRegs.push_back(*NextSpillReg);
410     Spill.Lanes[I] = *NextSpillReg++;
411   }
412 
413   return Spill.FullyAllocated;
414 }
415 
416 void SIMachineFunctionInfo::removeDeadFrameIndices(MachineFrameInfo &MFI) {
417   // The FP & BP spills haven't been inserted yet, so keep them around.
418   for (auto &R : SGPRToVGPRSpills) {
419     if (R.first != FramePointerSaveIndex && R.first != BasePointerSaveIndex)
420       MFI.RemoveStackObject(R.first);
421   }
422 
423   // All other SPGRs must be allocated on the default stack, so reset the stack
424   // ID.
425   for (int i = MFI.getObjectIndexBegin(), e = MFI.getObjectIndexEnd(); i != e;
426        ++i)
427     if (i != FramePointerSaveIndex && i != BasePointerSaveIndex)
428       MFI.setStackID(i, TargetStackID::Default);
429 
430   for (auto &R : VGPRToAGPRSpills) {
431     if (R.second.FullyAllocated)
432       MFI.RemoveStackObject(R.first);
433   }
434 }
435 
436 MCPhysReg SIMachineFunctionInfo::getNextUserSGPR() const {
437   assert(NumSystemSGPRs == 0 && "System SGPRs must be added after user SGPRs");
438   return AMDGPU::SGPR0 + NumUserSGPRs;
439 }
440 
441 MCPhysReg SIMachineFunctionInfo::getNextSystemSGPR() const {
442   return AMDGPU::SGPR0 + NumUserSGPRs + NumSystemSGPRs;
443 }
444 
445 Register
446 SIMachineFunctionInfo::getGITPtrLoReg(const MachineFunction &MF) const {
447   const GCNSubtarget &ST = MF.getSubtarget<GCNSubtarget>();
448   if (!ST.isAmdPalOS())
449     return Register();
450   Register GitPtrLo = AMDGPU::SGPR0; // Low GIT address passed in
451   if (ST.hasMergedShaders()) {
452     switch (MF.getFunction().getCallingConv()) {
453     case CallingConv::AMDGPU_HS:
454     case CallingConv::AMDGPU_GS:
455       // Low GIT address is passed in s8 rather than s0 for an LS+HS or
456       // ES+GS merged shader on gfx9+.
457       GitPtrLo = AMDGPU::SGPR8;
458       return GitPtrLo;
459     default:
460       return GitPtrLo;
461     }
462   }
463   return GitPtrLo;
464 }
465 
466 static yaml::StringValue regToString(Register Reg,
467                                      const TargetRegisterInfo &TRI) {
468   yaml::StringValue Dest;
469   {
470     raw_string_ostream OS(Dest.Value);
471     OS << printReg(Reg, &TRI);
472   }
473   return Dest;
474 }
475 
476 static Optional<yaml::SIArgumentInfo>
477 convertArgumentInfo(const AMDGPUFunctionArgInfo &ArgInfo,
478                     const TargetRegisterInfo &TRI) {
479   yaml::SIArgumentInfo AI;
480 
481   auto convertArg = [&](Optional<yaml::SIArgument> &A,
482                         const ArgDescriptor &Arg) {
483     if (!Arg)
484       return false;
485 
486     // Create a register or stack argument.
487     yaml::SIArgument SA = yaml::SIArgument::createArgument(Arg.isRegister());
488     if (Arg.isRegister()) {
489       raw_string_ostream OS(SA.RegisterName.Value);
490       OS << printReg(Arg.getRegister(), &TRI);
491     } else
492       SA.StackOffset = Arg.getStackOffset();
493     // Check and update the optional mask.
494     if (Arg.isMasked())
495       SA.Mask = Arg.getMask();
496 
497     A = SA;
498     return true;
499   };
500 
501   bool Any = false;
502   Any |= convertArg(AI.PrivateSegmentBuffer, ArgInfo.PrivateSegmentBuffer);
503   Any |= convertArg(AI.DispatchPtr, ArgInfo.DispatchPtr);
504   Any |= convertArg(AI.QueuePtr, ArgInfo.QueuePtr);
505   Any |= convertArg(AI.KernargSegmentPtr, ArgInfo.KernargSegmentPtr);
506   Any |= convertArg(AI.DispatchID, ArgInfo.DispatchID);
507   Any |= convertArg(AI.FlatScratchInit, ArgInfo.FlatScratchInit);
508   Any |= convertArg(AI.PrivateSegmentSize, ArgInfo.PrivateSegmentSize);
509   Any |= convertArg(AI.WorkGroupIDX, ArgInfo.WorkGroupIDX);
510   Any |= convertArg(AI.WorkGroupIDY, ArgInfo.WorkGroupIDY);
511   Any |= convertArg(AI.WorkGroupIDZ, ArgInfo.WorkGroupIDZ);
512   Any |= convertArg(AI.WorkGroupInfo, ArgInfo.WorkGroupInfo);
513   Any |= convertArg(AI.PrivateSegmentWaveByteOffset,
514                     ArgInfo.PrivateSegmentWaveByteOffset);
515   Any |= convertArg(AI.ImplicitArgPtr, ArgInfo.ImplicitArgPtr);
516   Any |= convertArg(AI.ImplicitBufferPtr, ArgInfo.ImplicitBufferPtr);
517   Any |= convertArg(AI.WorkItemIDX, ArgInfo.WorkItemIDX);
518   Any |= convertArg(AI.WorkItemIDY, ArgInfo.WorkItemIDY);
519   Any |= convertArg(AI.WorkItemIDZ, ArgInfo.WorkItemIDZ);
520 
521   if (Any)
522     return AI;
523 
524   return None;
525 }
526 
527 yaml::SIMachineFunctionInfo::SIMachineFunctionInfo(
528   const llvm::SIMachineFunctionInfo& MFI,
529   const TargetRegisterInfo &TRI)
530   : ExplicitKernArgSize(MFI.getExplicitKernArgSize()),
531     MaxKernArgAlign(MFI.getMaxKernArgAlign()),
532     LDSSize(MFI.getLDSSize()),
533     IsEntryFunction(MFI.isEntryFunction()),
534     NoSignedZerosFPMath(MFI.hasNoSignedZerosFPMath()),
535     MemoryBound(MFI.isMemoryBound()),
536     WaveLimiter(MFI.needsWaveLimiter()),
537     HighBitsOf32BitAddress(MFI.get32BitAddressHighBits()),
538     ScratchRSrcReg(regToString(MFI.getScratchRSrcReg(), TRI)),
539     FrameOffsetReg(regToString(MFI.getFrameOffsetReg(), TRI)),
540     StackPtrOffsetReg(regToString(MFI.getStackPtrOffsetReg(), TRI)),
541     ArgInfo(convertArgumentInfo(MFI.getArgInfo(), TRI)),
542     Mode(MFI.getMode()) {}
543 
544 void yaml::SIMachineFunctionInfo::mappingImpl(yaml::IO &YamlIO) {
545   MappingTraits<SIMachineFunctionInfo>::mapping(YamlIO, *this);
546 }
547 
548 bool SIMachineFunctionInfo::initializeBaseYamlFields(
549   const yaml::SIMachineFunctionInfo &YamlMFI) {
550   ExplicitKernArgSize = YamlMFI.ExplicitKernArgSize;
551   MaxKernArgAlign = assumeAligned(YamlMFI.MaxKernArgAlign);
552   LDSSize = YamlMFI.LDSSize;
553   HighBitsOf32BitAddress = YamlMFI.HighBitsOf32BitAddress;
554   IsEntryFunction = YamlMFI.IsEntryFunction;
555   NoSignedZerosFPMath = YamlMFI.NoSignedZerosFPMath;
556   MemoryBound = YamlMFI.MemoryBound;
557   WaveLimiter = YamlMFI.WaveLimiter;
558   return false;
559 }
560 
561 // Remove VGPR which was reserved for SGPR spills if there are no spilled SGPRs
562 bool SIMachineFunctionInfo::removeVGPRForSGPRSpill(Register ReservedVGPR,
563                                                    MachineFunction &MF) {
564   for (auto *i = SpillVGPRs.begin(); i < SpillVGPRs.end(); i++) {
565     if (i->VGPR == ReservedVGPR) {
566       SpillVGPRs.erase(i);
567 
568       for (MachineBasicBlock &MBB : MF) {
569         MBB.removeLiveIn(ReservedVGPR);
570         MBB.sortUniqueLiveIns();
571       }
572       this->VGPRReservedForSGPRSpill = AMDGPU::NoRegister;
573       return true;
574     }
575   }
576   return false;
577 }
578