1 //===- AArch64FrameLowering.cpp - AArch64 Frame Information ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the AArch64 implementation of TargetFrameLowering class.
12 //===----------------------------------------------------------------------===//
15 #include "AArch64FrameLowering.h"
16 #include "AArch64MachineFunctionInfo.h"
17 #include "AArch64InstrInfo.h"
18 #include "llvm/CodeGen/MachineFrameInfo.h"
19 #include "llvm/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineInstrBuilder.h"
21 #include "llvm/CodeGen/MachineMemOperand.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/CodeGen/MachineRegisterInfo.h"
24 #include "llvm/CodeGen/RegisterScavenging.h"
25 #include "llvm/IR/Function.h"
26 #include "llvm/MC/MachineLocation.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/ErrorHandling.h"
32 void AArch64FrameLowering::splitSPAdjustments(uint64_t Total,
34 uint64_t &Residual) const {
35 // 0x1f0 here is a pessimistic (i.e. realistic) boundary: x-register LDP
36 // instructions have a 7-bit signed immediate scaled by 8, giving a reach of
37 // 0x1f8, but stack adjustment should always be a multiple of 16.
43 Residual = Total - Initial;
47 void AArch64FrameLowering::emitPrologue(MachineFunction &MF) const {
48 AArch64MachineFunctionInfo *FuncInfo =
49 MF.getInfo<AArch64MachineFunctionInfo>();
50 MachineBasicBlock &MBB = MF.front();
51 MachineBasicBlock::iterator MBBI = MBB.begin();
52 MachineFrameInfo *MFI = MF.getFrameInfo();
53 const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
54 DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
56 MachineModuleInfo &MMI = MF.getMMI();
57 std::vector<MachineMove> &Moves = MMI.getFrameMoves();
58 bool NeedsFrameMoves = MMI.hasDebugInfo()
59 || MF.getFunction()->needsUnwindTableEntry();
61 uint64_t NumInitialBytes, NumResidualBytes;
63 // Currently we expect the stack to be laid out by
64 // sub sp, sp, #initial
65 // stp x29, x30, [sp, #offset]
67 // str xxx, [sp, #offset]
68 // sub sp, sp, #rest (possibly via extra instructions).
69 if (MFI->getCalleeSavedInfo().size()) {
70 // If there are callee-saved registers, we want to store them efficiently as
71 // a block, and virtual base assignment happens too early to do it for us so
72 // we adjust the stack in two phases: first just for callee-saved fiddling,
73 // then to allocate the rest of the frame.
74 splitSPAdjustments(MFI->getStackSize(), NumInitialBytes, NumResidualBytes);
76 // If there aren't any callee-saved registers, two-phase adjustment is
77 // inefficient. It's more efficient to adjust with NumInitialBytes too
78 // because when we're in a "callee pops argument space" situation, that pop
79 // must be tacked onto Initial for correctness.
80 NumInitialBytes = MFI->getStackSize();
84 // Tell everyone else how much adjustment we're expecting them to use. In
85 // particular if an adjustment is required for a tail call the epilogue could
86 // have a different view of things.
87 FuncInfo->setInitialStackAdjust(NumInitialBytes);
89 emitSPUpdate(MBB, MBBI, DL, TII, AArch64::X16, -NumInitialBytes,
90 MachineInstr::FrameSetup);
92 if (NeedsFrameMoves && NumInitialBytes) {
93 // We emit this update even if the CFA is set from a frame pointer later so
94 // that the CFA is valid in the interim.
95 MCSymbol *SPLabel = MMI.getContext().CreateTempSymbol();
96 BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::PROLOG_LABEL))
99 MachineLocation Dst(MachineLocation::VirtualFP);
100 MachineLocation Src(AArch64::XSP, NumInitialBytes);
101 Moves.push_back(MachineMove(SPLabel, Dst, Src));
104 // Otherwise we need to set the frame pointer and/or add a second stack
107 bool FPNeedsSetting = hasFP(MF);
108 for (; MBBI != MBB.end(); ++MBBI) {
109 // Note that this search makes strong assumptions about the operation used
110 // to store the frame-pointer: it must be "STP x29, x30, ...". This could
111 // change in future, but until then there's no point in implementing
112 // untestable more generic cases.
113 if (FPNeedsSetting && MBBI->getOpcode() == AArch64::LSPair64_STR
114 && MBBI->getOperand(0).getReg() == AArch64::X29) {
115 int64_t X29FrameIdx = MBBI->getOperand(2).getIndex();
116 FuncInfo->setFramePointerOffset(MFI->getObjectOffset(X29FrameIdx));
119 emitRegUpdate(MBB, MBBI, DL, TII, AArch64::X29, AArch64::XSP,
121 NumInitialBytes + MFI->getObjectOffset(X29FrameIdx),
122 MachineInstr::FrameSetup);
124 // The offset adjustment used when emitting debugging locations relative
125 // to whatever frame base is set. AArch64 uses the default frame base (FP
126 // or SP) and this adjusts the calculations to be correct.
127 MFI->setOffsetAdjustment(- MFI->getObjectOffset(X29FrameIdx)
128 - MFI->getStackSize());
130 if (NeedsFrameMoves) {
131 MCSymbol *FPLabel = MMI.getContext().CreateTempSymbol();
132 BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::PROLOG_LABEL))
134 MachineLocation Dst(MachineLocation::VirtualFP);
135 MachineLocation Src(AArch64::X29, -MFI->getObjectOffset(X29FrameIdx));
136 Moves.push_back(MachineMove(FPLabel, Dst, Src));
139 FPNeedsSetting = false;
142 if (!MBBI->getFlag(MachineInstr::FrameSetup))
146 assert(!FPNeedsSetting && "Frame pointer couldn't be set");
148 emitSPUpdate(MBB, MBBI, DL, TII, AArch64::X16, -NumResidualBytes,
149 MachineInstr::FrameSetup);
151 // Now we emit the rest of the frame setup information, if necessary: we've
152 // already noted the FP and initial SP moves so we're left with the prologue's
153 // final SP update and callee-saved register locations.
154 if (!NeedsFrameMoves)
157 // Reuse the label if appropriate, so create it in this outer scope.
158 MCSymbol *CSLabel = 0;
160 // The rest of the stack adjustment
161 if (!hasFP(MF) && NumResidualBytes) {
162 CSLabel = MMI.getContext().CreateTempSymbol();
163 BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::PROLOG_LABEL))
166 MachineLocation Dst(MachineLocation::VirtualFP);
167 MachineLocation Src(AArch64::XSP, NumResidualBytes + NumInitialBytes);
168 Moves.push_back(MachineMove(CSLabel, Dst, Src));
171 // And any callee-saved registers (it's fine to leave them to the end here,
172 // because the old values are still valid at this point.
173 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
176 CSLabel = MMI.getContext().CreateTempSymbol();
177 BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::PROLOG_LABEL))
181 for (std::vector<CalleeSavedInfo>::const_iterator I = CSI.begin(),
182 E = CSI.end(); I != E; ++I) {
183 MachineLocation Dst(MachineLocation::VirtualFP,
184 MFI->getObjectOffset(I->getFrameIdx()));
185 MachineLocation Src(I->getReg());
186 Moves.push_back(MachineMove(CSLabel, Dst, Src));
192 AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
193 MachineBasicBlock &MBB) const {
194 AArch64MachineFunctionInfo *FuncInfo =
195 MF.getInfo<AArch64MachineFunctionInfo>();
197 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
198 DebugLoc DL = MBBI->getDebugLoc();
199 const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
200 MachineFrameInfo &MFI = *MF.getFrameInfo();
201 unsigned RetOpcode = MBBI->getOpcode();
203 // Initial and residual are named for consitency with the prologue. Note that
204 // in the epilogue, the residual adjustment is executed first.
205 uint64_t NumInitialBytes = FuncInfo->getInitialStackAdjust();
206 uint64_t NumResidualBytes = MFI.getStackSize() - NumInitialBytes;
207 uint64_t ArgumentPopSize = 0;
208 if (RetOpcode == AArch64::TC_RETURNdi ||
209 RetOpcode == AArch64::TC_RETURNxi) {
210 MachineOperand &JumpTarget = MBBI->getOperand(0);
211 MachineOperand &StackAdjust = MBBI->getOperand(1);
213 MachineInstrBuilder MIB;
214 if (RetOpcode == AArch64::TC_RETURNdi) {
215 MIB = BuildMI(MBB, MBBI, DL, TII.get(AArch64::TAIL_Bimm));
216 if (JumpTarget.isGlobal()) {
217 MIB.addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
218 JumpTarget.getTargetFlags());
220 assert(JumpTarget.isSymbol() && "unexpected tail call destination");
221 MIB.addExternalSymbol(JumpTarget.getSymbolName(),
222 JumpTarget.getTargetFlags());
225 assert(RetOpcode == AArch64::TC_RETURNxi && JumpTarget.isReg()
226 && "Unexpected tail call");
228 MIB = BuildMI(MBB, MBBI, DL, TII.get(AArch64::TAIL_BRx));
229 MIB.addReg(JumpTarget.getReg(), RegState::Kill);
232 // Add the extra operands onto the new tail call instruction even though
233 // they're not used directly (so that liveness is tracked properly etc).
234 for (unsigned i = 2, e = MBBI->getNumOperands(); i != e; ++i)
235 MIB->addOperand(MBBI->getOperand(i));
238 // Delete the pseudo instruction TC_RETURN.
239 MachineInstr *NewMI = prior(MBBI);
243 // For a tail-call in a callee-pops-arguments environment, some or all of
244 // the stack may actually be in use for the call's arguments, this is
245 // calculated during LowerCall and consumed here...
246 ArgumentPopSize = StackAdjust.getImm();
248 // ... otherwise the amount to pop is *all* of the argument space,
249 // conveniently stored in the MachineFunctionInfo by
250 // LowerFormalArguments. This will, of course, be zero for the C calling
252 ArgumentPopSize = FuncInfo->getArgumentStackToRestore();
255 assert(NumInitialBytes % 16 == 0 && NumResidualBytes % 16 == 0
256 && "refusing to adjust stack by misaligned amt");
258 // We may need to address callee-saved registers differently, so find out the
259 // bound on the frame indices.
260 const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
265 MinCSFI = CSI[0].getFrameIdx();
266 MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();
269 // The "residual" stack update comes first from this direction and guarantees
270 // that SP is NumInitialBytes below its value on function entry, either by a
271 // direct update or restoring it from the frame pointer.
272 if (NumInitialBytes + ArgumentPopSize != 0) {
273 emitSPUpdate(MBB, MBBI, DL, TII, AArch64::X16,
274 NumInitialBytes + ArgumentPopSize);
279 // MBBI now points to the instruction just past the last callee-saved
280 // restoration (either RET/B if NumInitialBytes == 0, or the "ADD sp, sp"
283 // Now we need to find out where to put the bulk of the stack adjustment
284 MachineBasicBlock::iterator FirstEpilogue = MBBI;
285 while (MBBI != MBB.begin()) {
289 for (FrameOp = 0; FrameOp < MBBI->getNumOperands(); ++FrameOp) {
290 if (MBBI->getOperand(FrameOp).isFI())
294 // If this instruction doesn't have a frame index we've reached the end of
295 // the callee-save restoration.
296 if (FrameOp == MBBI->getNumOperands())
299 // Likewise if it *is* a local reference, but not to a callee-saved object.
300 int FrameIdx = MBBI->getOperand(FrameOp).getIndex();
301 if (FrameIdx < MinCSFI || FrameIdx > MaxCSFI)
304 FirstEpilogue = MBBI;
307 if (MF.getFrameInfo()->hasVarSizedObjects()) {
308 int64_t StaticFrameBase;
309 StaticFrameBase = -(NumInitialBytes + FuncInfo->getFramePointerOffset());
310 emitRegUpdate(MBB, FirstEpilogue, DL, TII,
311 AArch64::XSP, AArch64::X29, AArch64::NoRegister,
314 emitSPUpdate(MBB, FirstEpilogue, DL,TII, AArch64::X16, NumResidualBytes);
319 AArch64FrameLowering::resolveFrameIndexReference(MachineFunction &MF,
323 bool IsCalleeSaveOp) const {
324 AArch64MachineFunctionInfo *FuncInfo =
325 MF.getInfo<AArch64MachineFunctionInfo>();
326 MachineFrameInfo *MFI = MF.getFrameInfo();
328 int64_t TopOfFrameOffset = MFI->getObjectOffset(FrameIndex);
330 assert(!(IsCalleeSaveOp && FuncInfo->getInitialStackAdjust() == 0)
331 && "callee-saved register in unexpected place");
333 // If the frame for this function is particularly large, we adjust the stack
334 // in two phases which means the callee-save related operations see a
335 // different (intermediate) stack size.
337 if (IsCalleeSaveOp) {
338 FrameReg = AArch64::XSP;
339 FrameRegPos = -static_cast<int64_t>(FuncInfo->getInitialStackAdjust());
340 } else if (useFPForAddressing(MF)) {
341 // Have to use the frame pointer since we have no idea where SP is.
342 FrameReg = AArch64::X29;
343 FrameRegPos = FuncInfo->getFramePointerOffset();
345 FrameReg = AArch64::XSP;
346 FrameRegPos = -static_cast<int64_t>(MFI->getStackSize()) + SPAdj;
349 return TopOfFrameOffset - FrameRegPos;
352 /// Estimate and return the size of the frame.
353 static unsigned estimateStackSize(MachineFunction &MF) {
354 // FIXME: Make generic? Really consider after upstreaming. This code is now
355 // shared between PEI, ARM *and* here.
356 const MachineFrameInfo *MFI = MF.getFrameInfo();
357 const TargetFrameLowering *TFI = MF.getTarget().getFrameLowering();
358 const TargetRegisterInfo *RegInfo = MF.getTarget().getRegisterInfo();
359 unsigned MaxAlign = MFI->getMaxAlignment();
362 // This code is very, very similar to PEI::calculateFrameObjectOffsets().
363 // It really should be refactored to share code. Until then, changes
364 // should keep in mind that there's tight coupling between the two.
366 for (int i = MFI->getObjectIndexBegin(); i != 0; ++i) {
367 int FixedOff = -MFI->getObjectOffset(i);
368 if (FixedOff > Offset) Offset = FixedOff;
370 for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) {
371 if (MFI->isDeadObjectIndex(i))
373 Offset += MFI->getObjectSize(i);
374 unsigned Align = MFI->getObjectAlignment(i);
375 // Adjust to alignment boundary
376 Offset = (Offset+Align-1)/Align*Align;
378 MaxAlign = std::max(Align, MaxAlign);
381 if (MFI->adjustsStack() && TFI->hasReservedCallFrame(MF))
382 Offset += MFI->getMaxCallFrameSize();
384 // Round up the size to a multiple of the alignment. If the function has
385 // any calls or alloca's, align to the target's StackAlignment value to
386 // ensure that the callee's frame or the alloca data is suitably aligned;
387 // otherwise, for leaf functions, align to the TransientStackAlignment
390 if (MFI->adjustsStack() || MFI->hasVarSizedObjects() ||
391 (RegInfo->needsStackRealignment(MF) && MFI->getObjectIndexEnd() != 0))
392 StackAlign = TFI->getStackAlignment();
394 StackAlign = TFI->getTransientStackAlignment();
396 // If the frame pointer is eliminated, all frame offsets will be relative to
397 // SP not FP. Align to MaxAlign so this works.
398 StackAlign = std::max(StackAlign, MaxAlign);
399 unsigned AlignMask = StackAlign - 1;
400 Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
402 return (unsigned)Offset;
406 AArch64FrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
407 RegScavenger *RS) const {
408 const AArch64RegisterInfo *RegInfo =
409 static_cast<const AArch64RegisterInfo *>(MF.getTarget().getRegisterInfo());
410 MachineFrameInfo *MFI = MF.getFrameInfo();
411 const AArch64InstrInfo &TII =
412 *static_cast<const AArch64InstrInfo *>(MF.getTarget().getInstrInfo());
415 MF.getRegInfo().setPhysRegUsed(AArch64::X29);
416 MF.getRegInfo().setPhysRegUsed(AArch64::X30);
419 // If addressing of local variables is going to be more complicated than
420 // shoving a base register and an offset into the instruction then we may well
421 // need to scavenge registers. We should either specifically add an
422 // callee-save register for this purpose or allocate an extra spill slot.
425 (RS && estimateStackSize(MF) >= TII.estimateRSStackLimit(MF))
426 || MFI->hasVarSizedObjects() // Access will be from X29: messes things up
427 || (MFI->adjustsStack() && !hasReservedCallFrame(MF));
432 // We certainly need some slack space for the scavenger, preferably an extra
434 const uint16_t *CSRegs = RegInfo->getCalleeSavedRegs();
435 uint16_t ExtraReg = AArch64::NoRegister;
437 for (unsigned i = 0; CSRegs[i]; ++i) {
438 if (AArch64::GPR64RegClass.contains(CSRegs[i]) &&
439 !MF.getRegInfo().isPhysRegUsed(CSRegs[i])) {
440 ExtraReg = CSRegs[i];
446 MF.getRegInfo().setPhysRegUsed(ExtraReg);
448 // Create a stack slot for scavenging purposes. PrologEpilogInserter
449 // helpfully places it near either SP or FP for us to avoid
450 // infinitely-regression during scavenging.
451 const TargetRegisterClass *RC = &AArch64::GPR64RegClass;
452 RS->setScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(),
458 bool AArch64FrameLowering::determinePrologueDeath(MachineBasicBlock &MBB,
459 unsigned Reg) const {
460 // If @llvm.returnaddress is called then it will refer to X30 by some means;
461 // the prologue store does not kill the register.
462 if (Reg == AArch64::X30) {
463 if (MBB.getParent()->getFrameInfo()->isReturnAddressTaken()
464 && MBB.getParent()->getRegInfo().isLiveIn(Reg))
468 // In all other cases, physical registers are dead after they've been saved
469 // but live at the beginning of the prologue block.
475 AArch64FrameLowering::emitFrameMemOps(bool isPrologue, MachineBasicBlock &MBB,
476 MachineBasicBlock::iterator MBBI,
477 const std::vector<CalleeSavedInfo> &CSI,
478 const TargetRegisterInfo *TRI,
479 LoadStoreMethod PossClasses[],
480 unsigned NumClasses) const {
481 DebugLoc DL = MBB.findDebugLoc(MBBI);
482 MachineFunction &MF = *MBB.getParent();
483 MachineFrameInfo &MFI = *MF.getFrameInfo();
484 const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
486 // A certain amount of implicit contract is present here. The actual stack
487 // offsets haven't been allocated officially yet, so for strictly correct code
488 // we rely on the fact that the elements of CSI are allocated in order
489 // starting at SP, purely as dictated by size and alignment. In practice since
490 // this function handles the only accesses to those slots it's not quite so
493 // We have also ordered the Callee-saved register list in AArch64CallingConv
494 // so that the above scheme puts registers in order: in particular we want
495 // &X30 to be &X29+8 for an ABI-correct frame record (PCS 5.2.2)
496 for (unsigned i = 0, e = CSI.size(); i < e; ++i) {
497 unsigned Reg = CSI[i].getReg();
499 // First we need to find out which register class the register belongs to so
500 // that we can use the correct load/store instrucitons.
502 for (ClassIdx = 0; ClassIdx < NumClasses; ++ClassIdx) {
503 if (PossClasses[ClassIdx].RegClass->contains(Reg))
506 assert(ClassIdx != NumClasses
507 && "Asked to store register in unexpected class");
508 const TargetRegisterClass &TheClass = *PossClasses[ClassIdx].RegClass;
510 // Now we need to decide whether it's possible to emit a paired instruction:
511 // for this we want the next register to be in the same class.
512 MachineInstrBuilder NewMI;
514 if (i + 1 < CSI.size() && TheClass.contains(CSI[i+1].getReg())) {
516 unsigned StLow = 0, StHigh = 0;
518 // Most of these registers will be live-in to the MBB and killed by our
519 // store, though there are exceptions (see determinePrologueDeath).
520 StLow = getKillRegState(determinePrologueDeath(MBB, CSI[i+1].getReg()));
521 StHigh = getKillRegState(determinePrologueDeath(MBB, CSI[i].getReg()));
523 StLow = RegState::Define;
524 StHigh = RegState::Define;
527 NewMI = BuildMI(MBB, MBBI, DL, TII.get(PossClasses[ClassIdx].PairOpcode))
528 .addReg(CSI[i+1].getReg(), StLow)
529 .addReg(CSI[i].getReg(), StHigh);
531 // If it's a paired op, we've consumed two registers
536 State = getKillRegState(determinePrologueDeath(MBB, CSI[i].getReg()));
538 State = RegState::Define;
541 NewMI = BuildMI(MBB, MBBI, DL,
542 TII.get(PossClasses[ClassIdx].SingleOpcode))
543 .addReg(CSI[i].getReg(), State);
546 // Note that the FrameIdx refers to the second register in a pair: it will
547 // be allocated the smaller numeric address and so is the one an LDP/STP
549 int FrameIdx = CSI[i].getFrameIdx();
550 MachineMemOperand::MemOperandFlags Flags;
551 Flags = isPrologue ? MachineMemOperand::MOStore : MachineMemOperand::MOLoad;
552 MachineMemOperand *MMO =
553 MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
555 Pair ? TheClass.getSize() * 2 : TheClass.getSize(),
556 MFI.getObjectAlignment(FrameIdx));
558 NewMI.addFrameIndex(FrameIdx)
559 .addImm(0) // address-register offset
563 NewMI.setMIFlags(MachineInstr::FrameSetup);
565 // For aesthetic reasons, during an epilogue we want to emit complementary
566 // operations to the prologue, but in the opposite order. So we still
567 // iterate through the CalleeSavedInfo list in order, but we put the
568 // instructions successively earlier in the MBB.
575 AArch64FrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
576 MachineBasicBlock::iterator MBBI,
577 const std::vector<CalleeSavedInfo> &CSI,
578 const TargetRegisterInfo *TRI) const {
582 static LoadStoreMethod PossibleClasses[] = {
583 {&AArch64::GPR64RegClass, AArch64::LSPair64_STR, AArch64::LS64_STR},
584 {&AArch64::FPR64RegClass, AArch64::LSFPPair64_STR, AArch64::LSFP64_STR},
586 unsigned NumClasses = llvm::array_lengthof(PossibleClasses);
588 emitFrameMemOps(/* isPrologue = */ true, MBB, MBBI, CSI, TRI,
589 PossibleClasses, NumClasses);
595 AArch64FrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
596 MachineBasicBlock::iterator MBBI,
597 const std::vector<CalleeSavedInfo> &CSI,
598 const TargetRegisterInfo *TRI) const {
603 static LoadStoreMethod PossibleClasses[] = {
604 {&AArch64::GPR64RegClass, AArch64::LSPair64_LDR, AArch64::LS64_LDR},
605 {&AArch64::FPR64RegClass, AArch64::LSFPPair64_LDR, AArch64::LSFP64_LDR},
607 unsigned NumClasses = llvm::array_lengthof(PossibleClasses);
609 emitFrameMemOps(/* isPrologue = */ false, MBB, MBBI, CSI, TRI,
610 PossibleClasses, NumClasses);
616 AArch64FrameLowering::hasFP(const MachineFunction &MF) const {
617 const MachineFrameInfo *MFI = MF.getFrameInfo();
618 const TargetRegisterInfo *RI = MF.getTarget().getRegisterInfo();
620 // This is a decision of ABI compliance. The AArch64 PCS gives various options
621 // for conformance, and even at the most stringent level more or less permits
622 // elimination for leaf functions because there's no loss of functionality
623 // (for debugging etc)..
624 if (MF.getTarget().Options.DisableFramePointerElim(MF) && MFI->hasCalls())
627 // The following are hard-limits: incorrect code will be generated if we try
628 // to omit the frame.
629 return (RI->needsStackRealignment(MF) ||
630 MFI->hasVarSizedObjects() ||
631 MFI->isFrameAddressTaken());
635 AArch64FrameLowering::useFPForAddressing(const MachineFunction &MF) const {
636 return MF.getFrameInfo()->hasVarSizedObjects();
640 AArch64FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
641 const MachineFrameInfo *MFI = MF.getFrameInfo();
643 // Of the various reasons for having a frame pointer, it's actually only
644 // variable-sized objects that prevent reservation of a call frame.
645 return !(hasFP(MF) && MFI->hasVarSizedObjects());