1 //===-- StackFrameLayoutAnalysisPass.cpp 2 //------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // StackFrameLayoutAnalysisPass implementation. Outputs information about the 11 // layout of the stack frame, using the remarks interface. On the CLI it prints 12 // a textual representation of the stack frame. When possible it prints the 13 // values that occupy a stack slot using any available debug information. Since 14 // output is remarks based, it is also available in a machine readable file 15 // format, such as YAML. 16 // 17 //===----------------------------------------------------------------------===// 18 19 #include "llvm/ADT/SetVector.h" 20 #include "llvm/Analysis/OptimizationRemarkEmitter.h" 21 #include "llvm/CodeGen/MachineFrameInfo.h" 22 #include "llvm/CodeGen/MachineFunction.h" 23 #include "llvm/CodeGen/MachineFunctionPass.h" 24 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h" 25 #include "llvm/CodeGen/Passes.h" 26 #include "llvm/CodeGen/SlotIndexes.h" 27 #include "llvm/CodeGen/StackProtector.h" 28 #include "llvm/CodeGen/TargetFrameLowering.h" 29 #include "llvm/CodeGen/TargetSubtargetInfo.h" 30 #include "llvm/IR/DebugInfoMetadata.h" 31 #include "llvm/IR/PrintPasses.h" 32 #include "llvm/InitializePasses.h" 33 #include "llvm/Support/Debug.h" 34 #include "llvm/Support/FormatVariadic.h" 35 #include "llvm/Support/raw_ostream.h" 36 37 using namespace llvm; 38 39 #define DEBUG_TYPE "stack-frame-layout" 40 41 namespace { 42 43 /// StackFrameLayoutAnalysisPass - This is a pass to dump the stack frame of a 44 /// MachineFunction. 45 /// 46 struct StackFrameLayoutAnalysisPass : public MachineFunctionPass { 47 using SlotDbgMap = SmallDenseMap<int, SetVector<const DILocalVariable *>>; 48 static char ID; 49 50 enum SlotType { 51 Spill, // a Spill slot 52 Fixed, // a Fixed slot (e.g. arguments passed on the stack) 53 VariableSized, // a variable sized object 54 StackProtector, // Stack Protector slot 55 Variable, // a slot used to store a local data (could be a tmp) 56 Invalid // It's an error for a slot to have this type 57 }; 58 59 struct SlotData { 60 int Slot; 61 int Size; 62 int Align; 63 StackOffset Offset; 64 SlotType SlotTy; 65 bool Scalable; 66 67 SlotData(const MachineFrameInfo &MFI, const StackOffset Offset, 68 const int Idx) 69 : Slot(Idx), Size(MFI.getObjectSize(Idx)), 70 Align(MFI.getObjectAlign(Idx).value()), Offset(Offset), 71 SlotTy(Invalid), Scalable(false) { 72 Scalable = MFI.getStackID(Idx) == TargetStackID::ScalableVector; 73 if (MFI.isSpillSlotObjectIndex(Idx)) 74 SlotTy = SlotType::Spill; 75 else if (MFI.isFixedObjectIndex(Idx)) 76 SlotTy = SlotType::Fixed; 77 else if (MFI.isVariableSizedObjectIndex(Idx)) 78 SlotTy = SlotType::VariableSized; 79 else if (MFI.hasStackProtectorIndex() && 80 Idx == MFI.getStackProtectorIndex()) 81 SlotTy = SlotType::StackProtector; 82 else 83 SlotTy = SlotType::Variable; 84 } 85 86 bool isVarSize() const { return SlotTy == SlotType::VariableSized; } 87 88 // We use this to sort in reverse order, so that the layout is displayed 89 // correctly. Variable sized slots are sorted to the end of the list, as 90 // offsets are currently incorrect for these but they reside at the end of 91 // the stack frame. The Slot index is used to ensure deterministic order 92 // when offsets are equal. 93 bool operator<(const SlotData &Rhs) const { 94 return std::make_tuple(!isVarSize(), 95 Offset.getFixed() + Offset.getScalable(), Slot) > 96 std::make_tuple(!Rhs.isVarSize(), 97 Rhs.Offset.getFixed() + Rhs.Offset.getScalable(), 98 Rhs.Slot); 99 } 100 }; 101 102 StackFrameLayoutAnalysisPass() : MachineFunctionPass(ID) {} 103 104 StringRef getPassName() const override { 105 return "Stack Frame Layout Analysis"; 106 } 107 108 void getAnalysisUsage(AnalysisUsage &AU) const override { 109 AU.setPreservesAll(); 110 MachineFunctionPass::getAnalysisUsage(AU); 111 AU.addRequired<MachineOptimizationRemarkEmitterPass>(); 112 } 113 114 bool runOnMachineFunction(MachineFunction &MF) override { 115 // TODO: We should implement a similar filter for remarks: 116 // -Rpass-func-filter=<regex> 117 if (!isFunctionInPrintList(MF.getName())) 118 return false; 119 120 LLVMContext &Ctx = MF.getFunction().getContext(); 121 if (!Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(DEBUG_TYPE)) 122 return false; 123 124 MachineOptimizationRemarkAnalysis Rem(DEBUG_TYPE, "StackLayout", 125 MF.getFunction().getSubprogram(), 126 &MF.front()); 127 Rem << ("\nFunction: " + MF.getName()).str(); 128 emitStackFrameLayoutRemarks(MF, Rem); 129 getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE().emit(Rem); 130 return false; 131 } 132 133 std::string getTypeString(SlotType Ty) { 134 switch (Ty) { 135 case SlotType::Spill: 136 return "Spill"; 137 case SlotType::Fixed: 138 return "Fixed"; 139 case SlotType::VariableSized: 140 return "VariableSized"; 141 case SlotType::StackProtector: 142 return "Protector"; 143 case SlotType::Variable: 144 return "Variable"; 145 default: 146 llvm_unreachable("bad slot type for stack layout"); 147 } 148 } 149 150 void emitStackSlotRemark(const MachineFunction &MF, const SlotData &D, 151 MachineOptimizationRemarkAnalysis &Rem) { 152 // To make it easy to understand the stack layout from the CLI, we want to 153 // print each slot like the following: 154 // 155 // Offset: [SP+8], Type: Spill, Align: 8, Size: 16 156 // foo @ /path/to/file.c:25 157 // bar @ /path/to/file.c:35 158 // 159 // Which prints the size, alignment, and offset from the SP at function 160 // entry. 161 // 162 // But we also want the machine readable remarks data to be nicely 163 // organized. So we print some additional data as strings for the CLI 164 // output, but maintain more structured data for the YAML. 165 // 166 // For example we store the Offset in YAML as: 167 // ... 168 // - Offset: -8 169 // - ScalableOffset: -16 170 // Note: the ScalableOffset entries are added only for slots with non-zero 171 // scalable offsets. 172 // 173 // But we print it to the CLI as: 174 // Offset: [SP-8] 175 // 176 // Or with non-zero scalable offset: 177 // Offset: [SP-8-16 x vscale] 178 179 // Negative offsets will print a leading `-`, so only add `+` 180 std::string Prefix = 181 formatv("\nOffset: [SP{0}", (D.Offset.getFixed() < 0) ? "" : "+").str(); 182 Rem << Prefix << ore::NV("Offset", D.Offset.getFixed()); 183 184 if (D.Offset.getScalable()) { 185 Rem << ((D.Offset.getScalable() < 0) ? "" : "+") 186 << ore::NV("ScalableOffset", D.Offset.getScalable()) << " x vscale"; 187 } 188 189 Rem << "], Type: " << ore::NV("Type", getTypeString(D.SlotTy)) 190 << ", Align: " << ore::NV("Align", D.Align) 191 << ", Size: " << ore::NV("Size", ElementCount::get(D.Size, D.Scalable)); 192 } 193 194 void emitSourceLocRemark(const MachineFunction &MF, const DILocalVariable *N, 195 MachineOptimizationRemarkAnalysis &Rem) { 196 std::string Loc = 197 formatv("{0} @ {1}:{2}", N->getName(), N->getFilename(), N->getLine()) 198 .str(); 199 Rem << "\n " << ore::NV("DataLoc", Loc); 200 } 201 202 StackOffset getStackOffset(const MachineFunction &MF, 203 const MachineFrameInfo &MFI, 204 const TargetFrameLowering *FI, int FrameIdx) { 205 if (!FI) 206 return StackOffset::getFixed(MFI.getObjectOffset(FrameIdx)); 207 208 return FI->getFrameIndexReferenceFromSP(MF, FrameIdx); 209 } 210 211 void emitStackFrameLayoutRemarks(MachineFunction &MF, 212 MachineOptimizationRemarkAnalysis &Rem) { 213 const MachineFrameInfo &MFI = MF.getFrameInfo(); 214 if (!MFI.hasStackObjects()) 215 return; 216 217 const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering(); 218 219 LLVM_DEBUG(dbgs() << "getStackProtectorIndex ==" 220 << MFI.getStackProtectorIndex() << "\n"); 221 222 std::vector<SlotData> SlotInfo; 223 224 const unsigned int NumObj = MFI.getNumObjects(); 225 SlotInfo.reserve(NumObj); 226 // initialize slot info 227 for (int Idx = MFI.getObjectIndexBegin(), EndIdx = MFI.getObjectIndexEnd(); 228 Idx != EndIdx; ++Idx) { 229 if (MFI.isDeadObjectIndex(Idx)) 230 continue; 231 SlotInfo.emplace_back(MFI, getStackOffset(MF, MFI, FI, Idx), Idx); 232 } 233 234 // sort the ordering, to match the actual layout in memory 235 llvm::sort(SlotInfo); 236 237 SlotDbgMap SlotMap = genSlotDbgMapping(MF); 238 239 for (const SlotData &Info : SlotInfo) { 240 emitStackSlotRemark(MF, Info, Rem); 241 for (const DILocalVariable *N : SlotMap[Info.Slot]) 242 emitSourceLocRemark(MF, N, Rem); 243 } 244 } 245 246 // We need to generate a mapping of slots to the values that are stored to 247 // them. This information is lost by the time we need to print out the frame, 248 // so we reconstruct it here by walking the CFG, and generating the mapping. 249 SlotDbgMap genSlotDbgMapping(MachineFunction &MF) { 250 SlotDbgMap SlotDebugMap; 251 252 // add variables to the map 253 for (MachineFunction::VariableDbgInfo &DI : 254 MF.getInStackSlotVariableDbgInfo()) 255 SlotDebugMap[DI.getStackSlot()].insert(DI.Var); 256 257 // Then add all the spills that have debug data 258 for (MachineBasicBlock &MBB : MF) { 259 for (MachineInstr &MI : MBB) { 260 for (MachineMemOperand *MO : MI.memoperands()) { 261 if (!MO->isStore()) 262 continue; 263 auto *FI = dyn_cast_or_null<FixedStackPseudoSourceValue>( 264 MO->getPseudoValue()); 265 if (!FI) 266 continue; 267 int FrameIdx = FI->getFrameIndex(); 268 SmallVector<MachineInstr *> Dbg; 269 MI.collectDebugValues(Dbg); 270 271 for (MachineInstr *MI : Dbg) 272 SlotDebugMap[FrameIdx].insert(MI->getDebugVariable()); 273 } 274 } 275 } 276 277 return SlotDebugMap; 278 } 279 }; 280 281 char StackFrameLayoutAnalysisPass::ID = 0; 282 } // namespace 283 284 char &llvm::StackFrameLayoutAnalysisPassID = StackFrameLayoutAnalysisPass::ID; 285 INITIALIZE_PASS(StackFrameLayoutAnalysisPass, "stack-frame-layout", 286 "Stack Frame Layout", false, false) 287 288 namespace llvm { 289 /// Returns a newly-created StackFrameLayout pass. 290 MachineFunctionPass *createStackFrameLayoutAnalysisPass() { 291 return new StackFrameLayoutAnalysisPass(); 292 } 293 294 } // namespace llvm 295