1 //===-- MachineFrameInfo.cpp ---------------------------------------------===//
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 /// \file Implements MachineFrameInfo that manages the stack frame.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/CodeGen/MachineFrameInfo.h"
14
15 #include "llvm/ADT/BitVector.h"
16 #include "llvm/CodeGen/MachineFunction.h"
17 #include "llvm/CodeGen/MachineRegisterInfo.h"
18 #include "llvm/CodeGen/TargetFrameLowering.h"
19 #include "llvm/CodeGen/TargetInstrInfo.h"
20 #include "llvm/CodeGen/TargetRegisterInfo.h"
21 #include "llvm/CodeGen/TargetSubtargetInfo.h"
22 #include "llvm/Config/llvm-config.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include <cassert>
26
27 #define DEBUG_TYPE "codegen"
28
29 using namespace llvm;
30
ensureMaxAlignment(Align Alignment)31 void MachineFrameInfo::ensureMaxAlignment(Align Alignment) {
32 if (!StackRealignable)
33 assert(Alignment <= StackAlignment &&
34 "For targets without stack realignment, Alignment is out of limit!");
35 if (MaxAlignment < Alignment)
36 MaxAlignment = Alignment;
37 }
38
39 /// Clamp the alignment if requested and emit a warning.
clampStackAlignment(bool ShouldClamp,Align Alignment,Align StackAlignment)40 static inline Align clampStackAlignment(bool ShouldClamp, Align Alignment,
41 Align StackAlignment) {
42 if (!ShouldClamp || Alignment <= StackAlignment)
43 return Alignment;
44 LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Alignment.value()
45 << " exceeds the stack alignment " << StackAlignment.value()
46 << " when stack realignment is off" << '\n');
47 return StackAlignment;
48 }
49
CreateStackObject(uint64_t Size,Align Alignment,bool IsSpillSlot,const AllocaInst * Alloca,uint8_t StackID)50 int MachineFrameInfo::CreateStackObject(uint64_t Size, Align Alignment,
51 bool IsSpillSlot,
52 const AllocaInst *Alloca,
53 uint8_t StackID) {
54 assert(Size != 0 && "Cannot allocate zero size stack objects!");
55 Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
56 Objects.push_back(StackObject(Size, Alignment, 0, false, IsSpillSlot, Alloca,
57 !IsSpillSlot, StackID));
58 int Index = (int)Objects.size() - NumFixedObjects - 1;
59 assert(Index >= 0 && "Bad frame index!");
60 if (StackID == 0)
61 ensureMaxAlignment(Alignment);
62 return Index;
63 }
64
CreateSpillStackObject(uint64_t Size,Align Alignment)65 int MachineFrameInfo::CreateSpillStackObject(uint64_t Size, Align Alignment) {
66 Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
67 CreateStackObject(Size, Alignment, true);
68 int Index = (int)Objects.size() - NumFixedObjects - 1;
69 ensureMaxAlignment(Alignment);
70 return Index;
71 }
72
CreateVariableSizedObject(Align Alignment,const AllocaInst * Alloca)73 int MachineFrameInfo::CreateVariableSizedObject(Align Alignment,
74 const AllocaInst *Alloca) {
75 HasVarSizedObjects = true;
76 Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
77 Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true));
78 ensureMaxAlignment(Alignment);
79 return (int)Objects.size()-NumFixedObjects-1;
80 }
81
CreateFixedObject(uint64_t Size,int64_t SPOffset,bool IsImmutable,bool IsAliased)82 int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset,
83 bool IsImmutable, bool IsAliased) {
84 assert(Size != 0 && "Cannot allocate zero size fixed stack objects!");
85 // The alignment of the frame index can be determined from its offset from
86 // the incoming frame position. If the frame object is at offset 32 and
87 // the stack is guaranteed to be 16-byte aligned, then we know that the
88 // object is 16-byte aligned. Note that unlike the non-fixed case, if the
89 // stack needs realignment, we can't assume that the stack will in fact be
90 // aligned.
91 Align Alignment =
92 commonAlignment(ForcedRealign ? Align::None() : StackAlignment, SPOffset);
93 Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
94 Objects.insert(Objects.begin(),
95 StackObject(Size, Alignment, SPOffset, IsImmutable,
96 /*IsSpillSlot=*/false, /*Alloca=*/nullptr,
97 IsAliased));
98 return -++NumFixedObjects;
99 }
100
CreateFixedSpillStackObject(uint64_t Size,int64_t SPOffset,bool IsImmutable)101 int MachineFrameInfo::CreateFixedSpillStackObject(uint64_t Size,
102 int64_t SPOffset,
103 bool IsImmutable) {
104 Align Alignment =
105 commonAlignment(ForcedRealign ? Align::None() : StackAlignment, SPOffset);
106 Alignment = clampStackAlignment(!StackRealignable, Alignment, StackAlignment);
107 Objects.insert(Objects.begin(),
108 StackObject(Size, Alignment, SPOffset, IsImmutable,
109 /*IsSpillSlot=*/true, /*Alloca=*/nullptr,
110 /*IsAliased=*/false));
111 return -++NumFixedObjects;
112 }
113
getPristineRegs(const MachineFunction & MF) const114 BitVector MachineFrameInfo::getPristineRegs(const MachineFunction &MF) const {
115 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
116 BitVector BV(TRI->getNumRegs());
117
118 // Before CSI is calculated, no registers are considered pristine. They can be
119 // freely used and PEI will make sure they are saved.
120 if (!isCalleeSavedInfoValid())
121 return BV;
122
123 const MachineRegisterInfo &MRI = MF.getRegInfo();
124 for (const MCPhysReg *CSR = MRI.getCalleeSavedRegs(); CSR && *CSR;
125 ++CSR)
126 BV.set(*CSR);
127
128 // Saved CSRs are not pristine.
129 for (auto &I : getCalleeSavedInfo())
130 for (MCSubRegIterator S(I.getReg(), TRI, true); S.isValid(); ++S)
131 BV.reset(*S);
132
133 return BV;
134 }
135
estimateStackSize(const MachineFunction & MF) const136 uint64_t MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
137 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
138 const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
139 unsigned MaxAlign = getMaxAlignment();
140 int64_t Offset = 0;
141
142 // This code is very, very similar to PEI::calculateFrameObjectOffsets().
143 // It really should be refactored to share code. Until then, changes
144 // should keep in mind that there's tight coupling between the two.
145
146 for (int i = getObjectIndexBegin(); i != 0; ++i) {
147 // Only estimate stack size of default stack.
148 if (getStackID(i) != TargetStackID::Default)
149 continue;
150 int64_t FixedOff = -getObjectOffset(i);
151 if (FixedOff > Offset) Offset = FixedOff;
152 }
153 for (unsigned i = 0, e = getObjectIndexEnd(); i != e; ++i) {
154 // Only estimate stack size of live objects on default stack.
155 if (isDeadObjectIndex(i) || getStackID(i) != TargetStackID::Default)
156 continue;
157 Offset += getObjectSize(i);
158 unsigned Align = getObjectAlignment(i);
159 // Adjust to alignment boundary
160 Offset = (Offset+Align-1)/Align*Align;
161
162 MaxAlign = std::max(Align, MaxAlign);
163 }
164
165 if (adjustsStack() && TFI->hasReservedCallFrame(MF))
166 Offset += getMaxCallFrameSize();
167
168 // Round up the size to a multiple of the alignment. If the function has
169 // any calls or alloca's, align to the target's StackAlignment value to
170 // ensure that the callee's frame or the alloca data is suitably aligned;
171 // otherwise, for leaf functions, align to the TransientStackAlignment
172 // value.
173 unsigned StackAlign;
174 if (adjustsStack() || hasVarSizedObjects() ||
175 (RegInfo->needsStackRealignment(MF) && getObjectIndexEnd() != 0))
176 StackAlign = TFI->getStackAlignment();
177 else
178 StackAlign = TFI->getTransientStackAlignment();
179
180 // If the frame pointer is eliminated, all frame offsets will be relative to
181 // SP not FP. Align to MaxAlign so this works.
182 StackAlign = std::max(StackAlign, MaxAlign);
183 unsigned AlignMask = StackAlign - 1;
184 Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
185
186 return (uint64_t)Offset;
187 }
188
computeMaxCallFrameSize(const MachineFunction & MF)189 void MachineFrameInfo::computeMaxCallFrameSize(const MachineFunction &MF) {
190 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
191 unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
192 unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
193 assert(FrameSetupOpcode != ~0u && FrameDestroyOpcode != ~0u &&
194 "Can only compute MaxCallFrameSize if Setup/Destroy opcode are known");
195
196 MaxCallFrameSize = 0;
197 for (const MachineBasicBlock &MBB : MF) {
198 for (const MachineInstr &MI : MBB) {
199 unsigned Opcode = MI.getOpcode();
200 if (Opcode == FrameSetupOpcode || Opcode == FrameDestroyOpcode) {
201 unsigned Size = TII.getFrameSize(MI);
202 MaxCallFrameSize = std::max(MaxCallFrameSize, Size);
203 AdjustsStack = true;
204 } else if (MI.isInlineAsm()) {
205 // Some inline asm's need a stack frame, as indicated by operand 1.
206 unsigned ExtraInfo = MI.getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
207 if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
208 AdjustsStack = true;
209 }
210 }
211 }
212 }
213
print(const MachineFunction & MF,raw_ostream & OS) const214 void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
215 if (Objects.empty()) return;
216
217 const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering();
218 int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0);
219
220 OS << "Frame Objects:\n";
221
222 for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
223 const StackObject &SO = Objects[i];
224 OS << " fi#" << (int)(i-NumFixedObjects) << ": ";
225
226 if (SO.StackID != 0)
227 OS << "id=" << static_cast<unsigned>(SO.StackID) << ' ';
228
229 if (SO.Size == ~0ULL) {
230 OS << "dead\n";
231 continue;
232 }
233 if (SO.Size == 0)
234 OS << "variable sized";
235 else
236 OS << "size=" << SO.Size;
237 OS << ", align=" << SO.Alignment.value();
238
239 if (i < NumFixedObjects)
240 OS << ", fixed";
241 if (i < NumFixedObjects || SO.SPOffset != -1) {
242 int64_t Off = SO.SPOffset - ValOffset;
243 OS << ", at location [SP";
244 if (Off > 0)
245 OS << "+" << Off;
246 else if (Off < 0)
247 OS << Off;
248 OS << "]";
249 }
250 OS << "\n";
251 }
252 }
253
254 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump(const MachineFunction & MF) const255 LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {
256 print(MF, dbgs());
257 }
258 #endif
259