1//===- TargetFrameLoweringImpl.cpp - Implement target frame interface ------==//
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// Implements the layout of a stack frame on the target machine.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/BitVector.h"
14#include "llvm/CodeGen/MachineFrameInfo.h"
15#include "llvm/CodeGen/MachineFunction.h"
16#include "llvm/CodeGen/MachineRegisterInfo.h"
17#include "llvm/CodeGen/TargetFrameLowering.h"
18#include "llvm/CodeGen/TargetInstrInfo.h"
19#include "llvm/CodeGen/TargetSubtargetInfo.h"
20#include "llvm/IR/Attributes.h"
21#include "llvm/IR/Function.h"
22#include "llvm/IR/InstrTypes.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Target/TargetMachine.h"
25#include "llvm/Target/TargetOptions.h"
26
27using namespace llvm;
28
29TargetFrameLowering::~TargetFrameLowering() = default;
30
31bool TargetFrameLowering::enableCalleeSaveSkip(const MachineFunction &MF) const {
32 assert(MF.getFunction().hasFnAttribute(Attribute::NoReturn) &&
33 MF.getFunction().hasFnAttribute(Attribute::NoUnwind) &&
34 !MF.getFunction().hasFnAttribute(Attribute::UWTable));
35 return false;
36}
37
38bool TargetFrameLowering::enableCFIFixup(const MachineFunction &MF) const {
39 return !MF.usesWindowsUnwindInfo() && MF.needsFrameMoves();
40}
41
42/// Returns the displacement from the frame register to the stack
43/// frame of the specified index, along with the frame register used
44/// (in output arg FrameReg). This is the default implementation which
45/// is overridden for some targets.
46StackOffset
47TargetFrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
48 Register &FrameReg) const {
49 const MachineFrameInfo &MFI = MF.getFrameInfo();
50 const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();
51
52 // By default, assume all frame indices are referenced via whatever
53 // getFrameRegister() says. The target can override this if it's doing
54 // something different.
55 FrameReg = RI->getFrameRegister(MF);
56
57 return StackOffset::getFixed(Fixed: MFI.getObjectOffset(ObjectIdx: FI) + MFI.getStackSize() -
58 getOffsetOfLocalArea() +
59 MFI.getOffsetAdjustment());
60}
61
62/// Returns the offset from the stack pointer to the slot of the specified
63/// index. This function serves to provide a comparable offset from a single
64/// reference point (the value of the stack-pointer at function entry) that can
65/// be used for analysis. This is the default implementation using
66/// MachineFrameInfo offsets.
67StackOffset
68TargetFrameLowering::getFrameIndexReferenceFromSP(const MachineFunction &MF,
69 int FI) const {
70 // To display the true offset from SP, we need to subtract the offset to the
71 // local area from MFI's ObjectOffset.
72 return StackOffset::getFixed(Fixed: MF.getFrameInfo().getObjectOffset(ObjectIdx: FI) -
73 getOffsetOfLocalArea());
74}
75
76bool TargetFrameLowering::needsFrameIndexResolution(
77 const MachineFunction &MF) const {
78 return MF.getFrameInfo().hasStackObjects();
79}
80
81void TargetFrameLowering::getCalleeSaves(const MachineFunction &MF,
82 BitVector &CalleeSaves) const {
83 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
84 CalleeSaves.resize(N: TRI.getNumRegs());
85
86 const MachineFrameInfo &MFI = MF.getFrameInfo();
87 if (!MFI.isCalleeSavedInfoValid())
88 return;
89
90 for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
91 CalleeSaves.set(Info.getReg());
92}
93
94const MCPhysReg *
95TargetFrameLowering::getMustPreserveRegisters(const MachineFunction &MF) const {
96 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
97
98 // Get the callee saved register list...
99 const MCPhysReg *CSRegs = nullptr;
100
101 // When interprocedural register allocation is enabled, callee saved register
102 // list should be empty, since caller saved registers are preferred over
103 // callee saved registers. Unless it has some risked CSR to be optimized out.
104 if (MF.getTarget().Options.EnableIPRA &&
105 isSafeForNoCSROpt(F: MF.getFunction()) &&
106 isProfitableForNoCSROpt(F: MF.getFunction()))
107 CSRegs = TRI.getIPRACSRegs(MF: &MF);
108 else
109 CSRegs = MF.getRegInfo().getCalleeSavedRegs();
110
111 // Early exit if there are no callee saved registers.
112 if (!CSRegs || CSRegs[0] == 0)
113 return nullptr;
114
115 // In Naked functions we aren't going to save any registers.
116 if (MF.getFunction().hasFnAttribute(Kind: Attribute::Naked))
117 return nullptr;
118
119 // Noreturn+nounwind functions never restore CSR, so no saves are needed.
120 // Purely noreturn functions may still return through throws, so those must
121 // save CSR for caller exception handlers.
122 //
123 // If the function uses longjmp to break out of its current path of
124 // execution we do not need the CSR spills either: setjmp stores all CSRs
125 // it was called with into the jmp_buf, which longjmp then restores.
126 if (MF.getFunction().hasFnAttribute(Kind: Attribute::NoReturn) &&
127 MF.getFunction().hasFnAttribute(Kind: Attribute::NoUnwind) &&
128 !MF.getFunction().hasFnAttribute(Kind: Attribute::UWTable) &&
129 enableCalleeSaveSkip(MF))
130 return nullptr;
131
132 return CSRegs;
133}
134
135void TargetFrameLowering::determineUncondPrologCalleeSaves(
136 MachineFunction &MF, const MCPhysReg *CSRegs, BitVector &SavedRegs) const {
137 // Functions which call __builtin_unwind_init get all their registers saved.
138 if (!MF.callsUnwindInit())
139 return;
140 for (unsigned i = 0; CSRegs[i]; ++i) {
141 unsigned Reg = CSRegs[i];
142 SavedRegs.set(Reg);
143 }
144}
145
146void TargetFrameLowering::determineCalleeSaves(MachineFunction &MF,
147 BitVector &PrologCSRs,
148 RegScavenger *RS) const {
149 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
150
151 // Resize before the early returns. Some backends expect that
152 // SavedRegs.size() == TRI.getNumRegs() after this call even if there are no
153 // saved registers.
154 PrologCSRs.resize(N: TRI.getNumRegs());
155
156 // Get the callee saved register list...
157 const MCPhysReg *CSRegs = getMustPreserveRegisters(MF);
158 // Early exit if there are no callee saved registers.
159 if (!CSRegs || CSRegs[0] == 0)
160 return;
161
162 determineUncondPrologCalleeSaves(MF, CSRegs, SavedRegs&: PrologCSRs);
163
164 const MachineRegisterInfo &MRI = MF.getRegInfo();
165 for (unsigned i = 0; CSRegs[i]; ++i) {
166 unsigned Reg = CSRegs[i];
167 if (MRI.isPhysRegModified(PhysReg: Reg))
168 PrologCSRs.set(Reg);
169 }
170}
171
172bool TargetFrameLowering::allocateScavengingFrameIndexesNearIncomingSP(
173 const MachineFunction &MF) const {
174 if (!hasFP(MF))
175 return false;
176
177 const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
178 return RegInfo->useFPForScavengingIndex(MF) &&
179 !RegInfo->hasStackRealignment(MF);
180}
181
182bool TargetFrameLowering::isSafeForNoCSROpt(const Function &F) {
183 if (!F.hasLocalLinkage() || F.hasAddressTaken() ||
184 !F.hasFnAttribute(Kind: Attribute::NoRecurse))
185 return false;
186 // Function should not be optimized as tail call.
187 for (const User *U : F.users())
188 if (auto *CB = dyn_cast<CallBase>(Val: U))
189 if (CB->isTailCall())
190 return false;
191 return true;
192}
193
194int TargetFrameLowering::getInitialCFAOffset(const MachineFunction &MF) const {
195 llvm_unreachable("getInitialCFAOffset() not implemented!");
196}
197
198Register
199TargetFrameLowering::getInitialCFARegister(const MachineFunction &MF) const {
200 llvm_unreachable("getInitialCFARegister() not implemented!");
201}
202
203TargetFrameLowering::DwarfFrameBase
204TargetFrameLowering::getDwarfFrameBase(const MachineFunction &MF) const {
205 const TargetRegisterInfo *RI = MF.getSubtarget().getRegisterInfo();
206 return DwarfFrameBase{.Kind: DwarfFrameBase::Register, .Location: {.Reg: RI->getFrameRegister(MF).id()}};
207}
208
209void TargetFrameLowering::spillCalleeSavedRegister(
210 MachineBasicBlock &SaveBlock, MachineBasicBlock::iterator MI,
211 const CalleeSavedInfo &CS, const TargetInstrInfo *TII,
212 const TargetRegisterInfo *TRI) const {
213 // Insert the spill to the stack frame.
214 MCRegister Reg = CS.getReg();
215
216 if (CS.isSpilledToReg()) {
217 BuildMI(BB&: SaveBlock, I: MI, MIMD: DebugLoc(), MCID: TII->get(Opcode: TargetOpcode::COPY),
218 DestReg: CS.getDstReg())
219 .addReg(RegNo: Reg, Flags: getKillRegState(B: true));
220 } else {
221 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
222 TII->storeRegToStackSlot(MBB&: SaveBlock, MI, SrcReg: Reg, isKill: true, FrameIndex: CS.getFrameIdx(), RC,
223 VReg: Register());
224 }
225}
226
227void TargetFrameLowering::restoreCalleeSavedRegister(
228 MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
229 const CalleeSavedInfo &CS, const TargetInstrInfo *TII,
230 const TargetRegisterInfo *TRI) const {
231 MCRegister Reg = CS.getReg();
232 if (CS.isSpilledToReg()) {
233 BuildMI(BB&: MBB, I: MI, MIMD: DebugLoc(), MCID: TII->get(Opcode: TargetOpcode::COPY), DestReg: Reg)
234 .addReg(RegNo: CS.getDstReg(), Flags: getKillRegState(B: true));
235 } else {
236 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
237 TII->loadRegFromStackSlot(MBB, MI, DestReg: Reg, FrameIndex: CS.getFrameIdx(), RC, VReg: Register());
238 assert(MI != MBB.begin() && "loadRegFromStackSlot didn't insert any code!");
239 }
240}
241