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