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 #include <sstream> 38 39 using namespace llvm; 40 41 #define DEBUG_TYPE "stack-frame-layout" 42 43 namespace { 44 45 /// StackFrameLayoutAnalysisPass - This is a pass to dump the stack frame of a 46 /// MachineFunction. 47 /// 48 struct StackFrameLayoutAnalysisPass : public MachineFunctionPass { 49 using SlotDbgMap = SmallDenseMap<int, SetVector<const DILocalVariable *>>; 50 static char ID; 51 52 enum SlotType { 53 Spill, // a Spill slot 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 int Offset; 64 SlotType SlotTy; 65 66 SlotData(const MachineFrameInfo &MFI, const int ValOffset, const int Idx) 67 : Slot(Idx), Size(MFI.getObjectSize(Idx)), 68 Align(MFI.getObjectAlign(Idx).value()), 69 Offset(MFI.getObjectOffset(Idx) - ValOffset), SlotTy(Invalid) { 70 if (MFI.isSpillSlotObjectIndex(Idx)) 71 SlotTy = SlotType::Spill; 72 else if (Idx == MFI.getStackProtectorIndex()) 73 SlotTy = SlotType::StackProtector; 74 else 75 SlotTy = SlotType::Variable; 76 } 77 78 // we use this to sort in reverse order, so that the layout is displayed 79 // correctly 80 bool operator<(const SlotData &Rhs) const { return Offset > Rhs.Offset; } 81 }; 82 83 StackFrameLayoutAnalysisPass() : MachineFunctionPass(ID) {} 84 85 StringRef getPassName() const override { 86 return "Stack Frame Layout Analysis"; 87 } 88 89 void getAnalysisUsage(AnalysisUsage &AU) const override { 90 AU.setPreservesAll(); 91 MachineFunctionPass::getAnalysisUsage(AU); 92 AU.addRequired<MachineOptimizationRemarkEmitterPass>(); 93 } 94 95 bool runOnMachineFunction(MachineFunction &MF) override { 96 // TODO: We should implement a similar filter for remarks: 97 // -Rpass-func-filter=<regex> 98 if (!isFunctionInPrintList(MF.getName())) 99 return false; 100 101 LLVMContext &Ctx = MF.getFunction().getContext(); 102 if (!Ctx.getDiagHandlerPtr()->isAnalysisRemarkEnabled(DEBUG_TYPE)) 103 return false; 104 105 MachineOptimizationRemarkAnalysis Rem(DEBUG_TYPE, "StackLayout", 106 MF.getFunction().getSubprogram(), 107 &MF.front()); 108 Rem << ("\nFunction: " + MF.getName()).str(); 109 emitStackFrameLayoutRemarks(MF, Rem); 110 getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE().emit(Rem); 111 return false; 112 } 113 114 std::string getTypeString(SlotType Ty) { 115 switch (Ty) { 116 case SlotType::Spill: 117 return "Spill"; 118 case SlotType::StackProtector: 119 return "Protector"; 120 case SlotType::Variable: 121 return "Variable"; 122 default: 123 llvm_unreachable("bad slot type for stack layout"); 124 } 125 } 126 127 void emitStackSlotRemark(const MachineFunction &MF, const SlotData &D, 128 MachineOptimizationRemarkAnalysis &Rem) { 129 // To make it easy to understand the stack layout from the CLI, we want to 130 // print each slot like the following: 131 // 132 // Offset: [SP+8], Type: Spill, Align: 8, Size: 16 133 // foo @ /path/to/file.c:25 134 // bar @ /path/to/file.c:35 135 // 136 // Which prints the size, alignment, and offset from the SP at function 137 // entry. 138 // 139 // But we also want the machine readable remarks data to be nicely 140 // organized. So we print some additional data as strings for the CLI 141 // output, but maintain more structured data for the YAML. 142 // 143 // For example we store the Offset in YAML as: 144 // ... 145 // - Offset: -8 146 // 147 // But we print it to the CLI as 148 // Offset: [SP-8] 149 150 // Negative offsets will print a leading `-`, so only add `+` 151 std::string Prefix = 152 formatv("\nOffset: [SP{0}", (D.Offset < 0) ? "" : "+").str(); 153 Rem << Prefix << ore::NV("Offset", D.Offset) 154 << "], Type: " << ore::NV("Type", getTypeString(D.SlotTy)) 155 << ", Align: " << ore::NV("Align", D.Align) 156 << ", Size: " << ore::NV("Size", D.Size); 157 } 158 159 void emitSourceLocRemark(const MachineFunction &MF, const DILocalVariable *N, 160 MachineOptimizationRemarkAnalysis &Rem) { 161 std::string Loc = 162 formatv("{0} @ {1}:{2}", N->getName(), N->getFilename(), N->getLine()) 163 .str(); 164 Rem << "\n " << ore::NV("DataLoc", Loc); 165 } 166 167 void emitStackFrameLayoutRemarks(MachineFunction &MF, 168 MachineOptimizationRemarkAnalysis &Rem) { 169 const MachineFrameInfo &MFI = MF.getFrameInfo(); 170 if (!MFI.hasStackObjects()) 171 return; 172 173 // ValOffset is the offset to the local area from the SP at function entry. 174 // To display the true offset from SP, we need to subtract ValOffset from 175 // MFI's ObjectOffset. 176 const TargetFrameLowering *FI = MF.getSubtarget().getFrameLowering(); 177 const int ValOffset = (FI ? FI->getOffsetOfLocalArea() : 0); 178 179 LLVM_DEBUG(dbgs() << "getStackProtectorIndex ==" 180 << MFI.getStackProtectorIndex() << "\n"); 181 182 std::vector<SlotData> SlotInfo; 183 184 const unsigned int NumObj = MFI.getNumObjects(); 185 SlotInfo.reserve(NumObj); 186 // initialize slot info 187 for (int Idx = MFI.getObjectIndexBegin(), EndIdx = MFI.getObjectIndexEnd(); 188 Idx != EndIdx; ++Idx) { 189 if (MFI.isDeadObjectIndex(Idx)) 190 continue; 191 SlotInfo.emplace_back(MFI, ValOffset, Idx); 192 } 193 194 // sort the ordering, to match the actual layout in memory 195 llvm::sort(SlotInfo); 196 197 SlotDbgMap SlotMap = genSlotDbgMapping(MF); 198 199 for (const SlotData &Info : SlotInfo) { 200 emitStackSlotRemark(MF, Info, Rem); 201 for (const DILocalVariable *N : SlotMap[Info.Slot]) 202 emitSourceLocRemark(MF, N, Rem); 203 } 204 } 205 206 // We need to generate a mapping of slots to the values that are stored to 207 // them. This information is lost by the time we need to print out the frame, 208 // so we reconstruct it here by walking the CFG, and generating the mapping. 209 SlotDbgMap genSlotDbgMapping(MachineFunction &MF) { 210 SlotDbgMap SlotDebugMap; 211 212 // add variables to the map 213 for (MachineFunction::VariableDbgInfo &DI : 214 MF.getInStackSlotVariableDbgInfo()) 215 SlotDebugMap[DI.getStackSlot()].insert(DI.Var); 216 217 // Then add all the spills that have debug data 218 for (MachineBasicBlock &MBB : MF) { 219 for (MachineInstr &MI : MBB) { 220 for (MachineMemOperand *MO : MI.memoperands()) { 221 if (!MO->isStore()) 222 continue; 223 auto *FI = dyn_cast_or_null<FixedStackPseudoSourceValue>( 224 MO->getPseudoValue()); 225 if (!FI) 226 continue; 227 int FrameIdx = FI->getFrameIndex(); 228 SmallVector<MachineInstr *> Dbg; 229 MI.collectDebugValues(Dbg); 230 231 for (MachineInstr *MI : Dbg) 232 SlotDebugMap[FrameIdx].insert(MI->getDebugVariable()); 233 } 234 } 235 } 236 237 return SlotDebugMap; 238 } 239 }; 240 241 char StackFrameLayoutAnalysisPass::ID = 0; 242 } // namespace 243 244 char &llvm::StackFrameLayoutAnalysisPassID = StackFrameLayoutAnalysisPass::ID; 245 INITIALIZE_PASS(StackFrameLayoutAnalysisPass, "stack-frame-layout", 246 "Stack Frame Layout", false, false) 247 248 namespace llvm { 249 /// Returns a newly-created StackFrameLayout pass. 250 MachineFunctionPass *createStackFrameLayoutAnalysisPass() { 251 return new StackFrameLayoutAnalysisPass(); 252 } 253 254 } // namespace llvm 255