1 //===- Debugify.cpp - Attach synthetic debug info to everything -----------===//
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
7 //===----------------------------------------------------------------------===//
9 /// \file This pass attaches synthetic debug info to everything. It can be used
10 /// to create targeted tests for debug info preservation.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Transforms/Utils/Debugify.h"
15 #include "llvm/ADT/BitVector.h"
16 #include "llvm/ADT/StringExtras.h"
17 #include "llvm/IR/DIBuilder.h"
18 #include "llvm/IR/DebugInfo.h"
19 #include "llvm/IR/InstIterator.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/IntrinsicInst.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/Pass.h"
24 #include "llvm/Support/CommandLine.h"
30 cl::opt<bool> Quiet("debugify-quiet",
31 cl::desc("Suppress verbose debugify output"));
37 cl::opt<Level> DebugifyLevel(
38 "debugify-level", cl::desc("Kind of debug info to add"),
39 cl::values(clEnumValN(Level::Locations, "locations", "Locations only"),
40 clEnumValN(Level::LocationsAndVariables, "location+variables",
41 "Locations and Variables")),
42 cl::init(Level::LocationsAndVariables));
44 raw_ostream &dbg() { return Quiet ? nulls() : errs(); }
46 uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
47 return Ty->isSized() ? M.getDataLayout().getTypeAllocSizeInBits(Ty) : 0;
50 bool isFunctionSkipped(Function &F) {
51 return F.isDeclaration() || !F.hasExactDefinition();
54 /// Find the basic block's terminating instruction.
56 /// Special care is needed to handle musttail and deopt calls, as these behave
57 /// like (but are in fact not) terminators.
58 Instruction *findTerminatingInstruction(BasicBlock &BB) {
59 if (auto *I = BB.getTerminatingMustTailCall())
61 if (auto *I = BB.getTerminatingDeoptimizeCall())
63 return BB.getTerminator();
65 } // end anonymous namespace
67 bool llvm::applyDebugifyMetadata(
68 Module &M, iterator_range<Module::iterator> Functions, StringRef Banner,
69 std::function<bool(DIBuilder &DIB, Function &F)> ApplyToMF) {
70 // Skip modules with debug info.
71 if (M.getNamedMetadata("llvm.dbg.cu")) {
72 dbg() << Banner << "Skipping module with debug info\n";
77 LLVMContext &Ctx = M.getContext();
78 auto *Int32Ty = Type::getInt32Ty(Ctx);
80 // Get a DIType which corresponds to Ty.
81 DenseMap<uint64_t, DIType *> TypeCache;
82 auto getCachedDIType = [&](Type *Ty) -> DIType * {
83 uint64_t Size = getAllocSizeInBits(M, Ty);
84 DIType *&DTy = TypeCache[Size];
86 std::string Name = "ty" + utostr(Size);
87 DTy = DIB.createBasicType(Name, Size, dwarf::DW_ATE_unsigned);
92 unsigned NextLine = 1;
94 auto File = DIB.createFile(M.getName(), "/");
95 auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "debugify",
96 /*isOptimized=*/true, "", 0);
98 // Visit each instruction.
99 for (Function &F : Functions) {
100 if (isFunctionSkipped(F))
103 bool InsertedDbgVal = false;
104 auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
105 DISubprogram::DISPFlags SPFlags =
106 DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized;
107 if (F.hasPrivateLinkage() || F.hasInternalLinkage())
108 SPFlags |= DISubprogram::SPFlagLocalToUnit;
109 auto SP = DIB.createFunction(CU, F.getName(), F.getName(), File, NextLine,
110 SPType, NextLine, DINode::FlagZero, SPFlags);
113 // Helper that inserts a dbg.value before \p InsertBefore, copying the
114 // location (and possibly the type, if it's non-void) from \p TemplateInst.
115 auto insertDbgVal = [&](Instruction &TemplateInst,
116 Instruction *InsertBefore) {
117 std::string Name = utostr(NextVar++);
118 Value *V = &TemplateInst;
119 if (TemplateInst.getType()->isVoidTy())
120 V = ConstantInt::get(Int32Ty, 0);
121 const DILocation *Loc = TemplateInst.getDebugLoc().get();
122 auto LocalVar = DIB.createAutoVariable(SP, Name, File, Loc->getLine(),
123 getCachedDIType(V->getType()),
124 /*AlwaysPreserve=*/true);
125 DIB.insertDbgValueIntrinsic(V, LocalVar, DIB.createExpression(), Loc,
129 for (BasicBlock &BB : F) {
130 // Attach debug locations.
131 for (Instruction &I : BB)
132 I.setDebugLoc(DILocation::get(Ctx, NextLine++, 1, SP));
134 if (DebugifyLevel < Level::LocationsAndVariables)
137 // Inserting debug values into EH pads can break IR invariants.
141 // Find the terminating instruction, after which no debug values are
143 Instruction *LastInst = findTerminatingInstruction(BB);
144 assert(LastInst && "Expected basic block with a terminator");
146 // Maintain an insertion point which can't be invalidated when updates
148 BasicBlock::iterator InsertPt = BB.getFirstInsertionPt();
149 assert(InsertPt != BB.end() && "Expected to find an insertion point");
150 Instruction *InsertBefore = &*InsertPt;
152 // Attach debug values.
153 for (Instruction *I = &*BB.begin(); I != LastInst; I = I->getNextNode()) {
154 // Skip void-valued instructions.
155 if (I->getType()->isVoidTy())
158 // Phis and EH pads must be grouped at the beginning of the block.
159 // Only advance the insertion point when we finish visiting these.
160 if (!isa<PHINode>(I) && !I->isEHPad())
161 InsertBefore = I->getNextNode();
163 insertDbgVal(*I, InsertBefore);
164 InsertedDbgVal = true;
167 // Make sure we emit at least one dbg.value, otherwise MachineDebugify may
168 // not have anything to work with as it goes about inserting DBG_VALUEs.
169 // (It's common for MIR tests to be written containing skeletal IR with
170 // empty functions -- we're still interested in debugifying the MIR within
171 // those tests, and this helps with that.)
172 if (DebugifyLevel == Level::LocationsAndVariables && !InsertedDbgVal) {
173 auto *Term = findTerminatingInstruction(F.getEntryBlock());
174 insertDbgVal(*Term, Term);
178 DIB.finalizeSubprogram(SP);
182 // Track the number of distinct lines and variables.
183 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.debugify");
184 auto addDebugifyOperand = [&](unsigned N) {
185 NMD->addOperand(MDNode::get(
186 Ctx, ValueAsMetadata::getConstant(ConstantInt::get(Int32Ty, N))));
188 addDebugifyOperand(NextLine - 1); // Original number of lines.
189 addDebugifyOperand(NextVar - 1); // Original number of variables.
190 assert(NMD->getNumOperands() == 2 &&
191 "llvm.debugify should have exactly 2 operands!");
193 // Claim that this synthetic debug info is valid.
194 StringRef DIVersionKey = "Debug Info Version";
195 if (!M.getModuleFlag(DIVersionKey))
196 M.addModuleFlag(Module::Warning, DIVersionKey, DEBUG_METADATA_VERSION);
201 bool llvm::stripDebugifyMetadata(Module &M) {
202 bool Changed = false;
204 // Remove the llvm.debugify module-level named metadata.
205 NamedMDNode *DebugifyMD = M.getNamedMetadata("llvm.debugify");
207 M.eraseNamedMetadata(DebugifyMD);
211 // Strip out all debug intrinsics and supporting metadata (subprograms, types,
213 Changed |= StripDebugInfo(M);
215 // Strip out the dead dbg.value prototype.
216 Function *DbgValF = M.getFunction("llvm.dbg.value");
218 assert(DbgValF->isDeclaration() && DbgValF->use_empty() &&
219 "Not all debug info stripped?");
220 DbgValF->eraseFromParent();
224 // Strip out the module-level Debug Info Version metadata.
225 // FIXME: There must be an easier way to remove an operand from a NamedMDNode.
226 NamedMDNode *NMD = M.getModuleFlagsMetadata();
229 SmallVector<MDNode *, 4> Flags;
230 for (MDNode *Flag : NMD->operands())
231 Flags.push_back(Flag);
232 NMD->clearOperands();
233 for (MDNode *Flag : Flags) {
234 MDString *Key = dyn_cast_or_null<MDString>(Flag->getOperand(1));
235 if (Key->getString() == "Debug Info Version") {
239 NMD->addOperand(Flag);
241 // If we left it empty we might as well remove it.
242 if (NMD->getNumOperands() == 0)
243 NMD->eraseFromParent();
249 /// Return true if a mis-sized diagnostic is issued for \p DVI.
250 bool diagnoseMisSizedDbgValue(Module &M, DbgValueInst *DVI) {
251 // The size of a dbg.value's value operand should match the size of the
252 // variable it corresponds to.
254 // TODO: This, along with a check for non-null value operands, should be
255 // promoted to verifier failures.
256 Value *V = DVI->getValue();
260 // For now, don't try to interpret anything more complicated than an empty
261 // DIExpression. Eventually we should try to handle OP_deref and fragments.
262 if (DVI->getExpression()->getNumElements())
265 Type *Ty = V->getType();
266 uint64_t ValueOperandSize = getAllocSizeInBits(M, Ty);
267 Optional<uint64_t> DbgVarSize = DVI->getFragmentSizeInBits();
268 if (!ValueOperandSize || !DbgVarSize)
271 bool HasBadSize = false;
272 if (Ty->isIntegerTy()) {
273 auto Signedness = DVI->getVariable()->getSignedness();
274 if (Signedness && *Signedness == DIBasicType::Signedness::Signed)
275 HasBadSize = ValueOperandSize < *DbgVarSize;
277 HasBadSize = ValueOperandSize != *DbgVarSize;
281 dbg() << "ERROR: dbg.value operand has size " << ValueOperandSize
282 << ", but its variable has size " << *DbgVarSize << ": ";
289 bool checkDebugifyMetadata(Module &M,
290 iterator_range<Module::iterator> Functions,
291 StringRef NameOfWrappedPass, StringRef Banner,
292 bool Strip, DebugifyStatsMap *StatsMap) {
293 // Skip modules without debugify metadata.
294 NamedMDNode *NMD = M.getNamedMetadata("llvm.debugify");
296 dbg() << Banner << ": Skipping module without debugify metadata\n";
300 auto getDebugifyOperand = [&](unsigned Idx) -> unsigned {
301 return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
304 assert(NMD->getNumOperands() == 2 &&
305 "llvm.debugify should have exactly 2 operands!");
306 unsigned OriginalNumLines = getDebugifyOperand(0);
307 unsigned OriginalNumVars = getDebugifyOperand(1);
308 bool HasErrors = false;
310 // Track debug info loss statistics if able.
311 DebugifyStatistics *Stats = nullptr;
312 if (StatsMap && !NameOfWrappedPass.empty())
313 Stats = &StatsMap->operator[](NameOfWrappedPass);
315 BitVector MissingLines{OriginalNumLines, true};
316 BitVector MissingVars{OriginalNumVars, true};
317 for (Function &F : Functions) {
318 if (isFunctionSkipped(F))
321 // Find missing lines.
322 for (Instruction &I : instructions(F)) {
323 if (isa<DbgValueInst>(&I) || isa<PHINode>(&I))
326 auto DL = I.getDebugLoc();
327 if (DL && DL.getLine() != 0) {
328 MissingLines.reset(DL.getLine() - 1);
333 dbg() << "WARNING: Instruction with empty DebugLoc in function ";
334 dbg() << F.getName() << " --";
340 // Find missing variables and mis-sized debug values.
341 for (Instruction &I : instructions(F)) {
342 auto *DVI = dyn_cast<DbgValueInst>(&I);
347 (void)to_integer(DVI->getVariable()->getName(), Var, 10);
348 assert(Var <= OriginalNumVars && "Unexpected name for DILocalVariable");
349 bool HasBadSize = diagnoseMisSizedDbgValue(M, DVI);
351 MissingVars.reset(Var - 1);
352 HasErrors |= HasBadSize;
356 // Print the results.
357 for (unsigned Idx : MissingLines.set_bits())
358 dbg() << "WARNING: Missing line " << Idx + 1 << "\n";
360 for (unsigned Idx : MissingVars.set_bits())
361 dbg() << "WARNING: Missing variable " << Idx + 1 << "\n";
363 // Update DI loss statistics.
365 Stats->NumDbgLocsExpected += OriginalNumLines;
366 Stats->NumDbgLocsMissing += MissingLines.count();
367 Stats->NumDbgValuesExpected += OriginalNumVars;
368 Stats->NumDbgValuesMissing += MissingVars.count();
372 if (!NameOfWrappedPass.empty())
373 dbg() << " [" << NameOfWrappedPass << "]";
374 dbg() << ": " << (HasErrors ? "FAIL" : "PASS") << '\n';
376 // Strip debugify metadata if required.
378 return stripDebugifyMetadata(M);
383 /// ModulePass for attaching synthetic debug info to everything, used with the
384 /// legacy module pass manager.
385 struct DebugifyModulePass : public ModulePass {
386 bool runOnModule(Module &M) override {
387 return applyDebugifyMetadata(M, M.functions(),
388 "ModuleDebugify: ", /*ApplyToMF*/ nullptr);
391 DebugifyModulePass() : ModulePass(ID) {}
393 void getAnalysisUsage(AnalysisUsage &AU) const override {
394 AU.setPreservesAll();
397 static char ID; // Pass identification.
400 /// FunctionPass for attaching synthetic debug info to instructions within a
401 /// single function, used with the legacy module pass manager.
402 struct DebugifyFunctionPass : public FunctionPass {
403 bool runOnFunction(Function &F) override {
404 Module &M = *F.getParent();
405 auto FuncIt = F.getIterator();
406 return applyDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
407 "FunctionDebugify: ", /*ApplyToMF*/ nullptr);
410 DebugifyFunctionPass() : FunctionPass(ID) {}
412 void getAnalysisUsage(AnalysisUsage &AU) const override {
413 AU.setPreservesAll();
416 static char ID; // Pass identification.
419 /// ModulePass for checking debug info inserted by -debugify, used with the
420 /// legacy module pass manager.
421 struct CheckDebugifyModulePass : public ModulePass {
422 bool runOnModule(Module &M) override {
423 return checkDebugifyMetadata(M, M.functions(), NameOfWrappedPass,
424 "CheckModuleDebugify", Strip, StatsMap);
427 CheckDebugifyModulePass(bool Strip = false, StringRef NameOfWrappedPass = "",
428 DebugifyStatsMap *StatsMap = nullptr)
429 : ModulePass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass),
430 StatsMap(StatsMap) {}
432 void getAnalysisUsage(AnalysisUsage &AU) const override {
433 AU.setPreservesAll();
436 static char ID; // Pass identification.
440 StringRef NameOfWrappedPass;
441 DebugifyStatsMap *StatsMap;
444 /// FunctionPass for checking debug info inserted by -debugify-function, used
445 /// with the legacy module pass manager.
446 struct CheckDebugifyFunctionPass : public FunctionPass {
447 bool runOnFunction(Function &F) override {
448 Module &M = *F.getParent();
449 auto FuncIt = F.getIterator();
450 return checkDebugifyMetadata(M, make_range(FuncIt, std::next(FuncIt)),
451 NameOfWrappedPass, "CheckFunctionDebugify",
455 CheckDebugifyFunctionPass(bool Strip = false,
456 StringRef NameOfWrappedPass = "",
457 DebugifyStatsMap *StatsMap = nullptr)
458 : FunctionPass(ID), Strip(Strip), NameOfWrappedPass(NameOfWrappedPass),
459 StatsMap(StatsMap) {}
461 void getAnalysisUsage(AnalysisUsage &AU) const override {
462 AU.setPreservesAll();
465 static char ID; // Pass identification.
469 StringRef NameOfWrappedPass;
470 DebugifyStatsMap *StatsMap;
473 } // end anonymous namespace
475 ModulePass *createDebugifyModulePass() { return new DebugifyModulePass(); }
477 FunctionPass *createDebugifyFunctionPass() {
478 return new DebugifyFunctionPass();
481 PreservedAnalyses NewPMDebugifyPass::run(Module &M, ModuleAnalysisManager &) {
482 applyDebugifyMetadata(M, M.functions(),
483 "ModuleDebugify: ", /*ApplyToMF*/ nullptr);
484 return PreservedAnalyses::all();
487 ModulePass *createCheckDebugifyModulePass(bool Strip,
488 StringRef NameOfWrappedPass,
489 DebugifyStatsMap *StatsMap) {
490 return new CheckDebugifyModulePass(Strip, NameOfWrappedPass, StatsMap);
493 FunctionPass *createCheckDebugifyFunctionPass(bool Strip,
494 StringRef NameOfWrappedPass,
495 DebugifyStatsMap *StatsMap) {
496 return new CheckDebugifyFunctionPass(Strip, NameOfWrappedPass, StatsMap);
499 PreservedAnalyses NewPMCheckDebugifyPass::run(Module &M,
500 ModuleAnalysisManager &) {
501 checkDebugifyMetadata(M, M.functions(), "", "CheckModuleDebugify", false,
503 return PreservedAnalyses::all();
506 char DebugifyModulePass::ID = 0;
507 static RegisterPass<DebugifyModulePass> DM("debugify",
508 "Attach debug info to everything");
510 char CheckDebugifyModulePass::ID = 0;
511 static RegisterPass<CheckDebugifyModulePass>
512 CDM("check-debugify", "Check debug info from -debugify");
514 char DebugifyFunctionPass::ID = 0;
515 static RegisterPass<DebugifyFunctionPass> DF("debugify-function",
516 "Attach debug info to a function");
518 char CheckDebugifyFunctionPass::ID = 0;
519 static RegisterPass<CheckDebugifyFunctionPass>
520 CDF("check-debugify-function", "Check debug info from -debugify-function");