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