1 | //===- MachineDebugify.cpp - Attach synthetic debug info to everything ----===// |
2 | // |
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 |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | /// |
9 | /// \file This pass attaches synthetic debug info to everything. It can be used |
10 | /// to create targeted tests for debug info preservation, or test for CodeGen |
11 | /// differences with vs. without debug info. |
12 | /// |
13 | /// This isn't intended to have feature parity with Debugify. |
14 | //===----------------------------------------------------------------------===// |
15 | |
16 | #include "llvm/ADT/DenseMap.h" |
17 | #include "llvm/ADT/SmallSet.h" |
18 | #include "llvm/ADT/SmallVector.h" |
19 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
20 | #include "llvm/CodeGen/MachineModuleInfo.h" |
21 | #include "llvm/CodeGen/Passes.h" |
22 | #include "llvm/CodeGen/TargetInstrInfo.h" |
23 | #include "llvm/CodeGen/TargetSubtargetInfo.h" |
24 | #include "llvm/IR/IntrinsicInst.h" |
25 | #include "llvm/InitializePasses.h" |
26 | #include "llvm/Transforms/Utils/Debugify.h" |
27 | |
28 | #define DEBUG_TYPE "mir-debugify" |
29 | |
30 | using namespace llvm; |
31 | |
32 | namespace { |
33 | bool applyDebugifyMetadataToMachineFunction(MachineModuleInfo &MMI, |
34 | DIBuilder &DIB, Function &F) { |
35 | MachineFunction *MaybeMF = MMI.getMachineFunction(F); |
36 | if (!MaybeMF) |
37 | return false; |
38 | MachineFunction &MF = *MaybeMF; |
39 | const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo(); |
40 | |
41 | DISubprogram *SP = F.getSubprogram(); |
42 | assert(SP && "IR Debugify just created it?" ); |
43 | |
44 | Module &M = *F.getParent(); |
45 | LLVMContext &Ctx = M.getContext(); |
46 | |
47 | unsigned NextLine = SP->getLine(); |
48 | for (MachineBasicBlock &MBB : MF) { |
49 | for (MachineInstr &MI : MBB) { |
50 | // This will likely emit line numbers beyond the end of the imagined |
51 | // source function and into subsequent ones. We don't do anything about |
52 | // that as it doesn't really matter to the compiler where the line is in |
53 | // the imaginary source code. |
54 | MI.setDebugLoc(DILocation::get(Context&: Ctx, Line: NextLine++, Column: 1, Scope: SP)); |
55 | } |
56 | } |
57 | |
58 | // Find local variables defined by debugify. No attempt is made to match up |
59 | // MIR-level regs to the 'correct' IR-level variables: there isn't a simple |
60 | // way to do that, and it isn't necessary to find interesting CodeGen bugs. |
61 | // Instead, simply keep track of one variable per line. Later, we can insert |
62 | // DBG_VALUE insts that point to these local variables. Emitting DBG_VALUEs |
63 | // which cover a wide range of lines can help stress the debug info passes: |
64 | // if we can't do that, fall back to using the local variable which precedes |
65 | // all the others. |
66 | Function *DbgValF = M.getFunction(Name: "llvm.dbg.value" ); |
67 | DbgValueInst *EarliestDVI = nullptr; |
68 | DenseMap<unsigned, DILocalVariable *> Line2Var; |
69 | DIExpression *Expr = nullptr; |
70 | if (DbgValF) { |
71 | for (const Use &U : DbgValF->uses()) { |
72 | auto *DVI = dyn_cast<DbgValueInst>(Val: U.getUser()); |
73 | if (!DVI || DVI->getFunction() != &F) |
74 | continue; |
75 | unsigned Line = DVI->getDebugLoc().getLine(); |
76 | assert(Line != 0 && "debugify should not insert line 0 locations" ); |
77 | Line2Var[Line] = DVI->getVariable(); |
78 | if (!EarliestDVI || Line < EarliestDVI->getDebugLoc().getLine()) |
79 | EarliestDVI = DVI; |
80 | Expr = DVI->getExpression(); |
81 | } |
82 | } |
83 | if (Line2Var.empty()) |
84 | return true; |
85 | |
86 | // Now, try to insert a DBG_VALUE instruction after each real instruction. |
87 | // Do this by introducing debug uses of each register definition. If that is |
88 | // not possible (e.g. we have a phi or a meta instruction), emit a constant. |
89 | uint64_t NextImm = 0; |
90 | SmallSet<DILocalVariable *, 16> VarSet; |
91 | const MCInstrDesc &DbgValDesc = TII.get(Opcode: TargetOpcode::DBG_VALUE); |
92 | for (MachineBasicBlock &MBB : MF) { |
93 | MachineBasicBlock::iterator FirstNonPHIIt = MBB.getFirstNonPHI(); |
94 | for (auto I = MBB.begin(), E = MBB.end(); I != E;) { |
95 | MachineInstr &MI = *I; |
96 | ++I; |
97 | |
98 | // `I` may point to a DBG_VALUE created in the previous loop iteration. |
99 | if (MI.isDebugInstr()) |
100 | continue; |
101 | |
102 | // It's not allowed to insert DBG_VALUEs after a terminator. |
103 | if (MI.isTerminator()) |
104 | continue; |
105 | |
106 | // Find a suitable insertion point for the DBG_VALUE. |
107 | auto InsertBeforeIt = MI.isPHI() ? FirstNonPHIIt : I; |
108 | |
109 | // Find a suitable local variable for the DBG_VALUE. |
110 | unsigned Line = MI.getDebugLoc().getLine(); |
111 | if (!Line2Var.count(Val: Line)) |
112 | Line = EarliestDVI->getDebugLoc().getLine(); |
113 | DILocalVariable *LocalVar = Line2Var[Line]; |
114 | assert(LocalVar && "No variable for current line?" ); |
115 | VarSet.insert(Ptr: LocalVar); |
116 | |
117 | // Emit DBG_VALUEs for register definitions. |
118 | SmallVector<MachineOperand *, 4> RegDefs; |
119 | for (MachineOperand &MO : MI.all_defs()) |
120 | if (MO.getReg()) |
121 | RegDefs.push_back(Elt: &MO); |
122 | for (MachineOperand *MO : RegDefs) |
123 | BuildMI(BB&: MBB, I: InsertBeforeIt, DL: MI.getDebugLoc(), MCID: DbgValDesc, |
124 | /*IsIndirect=*/false, MOs: *MO, Variable: LocalVar, Expr); |
125 | |
126 | // OK, failing that, emit a constant DBG_VALUE. |
127 | if (RegDefs.empty()) { |
128 | auto ImmOp = MachineOperand::CreateImm(Val: NextImm++); |
129 | BuildMI(BB&: MBB, I: InsertBeforeIt, DL: MI.getDebugLoc(), MCID: DbgValDesc, |
130 | /*IsIndirect=*/false, MOs: ImmOp, Variable: LocalVar, Expr); |
131 | } |
132 | } |
133 | } |
134 | |
135 | // Here we save the number of lines and variables into "llvm.mir.debugify". |
136 | // It is useful for mir-check-debugify. |
137 | NamedMDNode *NMD = M.getNamedMetadata(Name: "llvm.mir.debugify" ); |
138 | IntegerType *Int32Ty = Type::getInt32Ty(C&: Ctx); |
139 | if (!NMD) { |
140 | NMD = M.getOrInsertNamedMetadata(Name: "llvm.mir.debugify" ); |
141 | auto addDebugifyOperand = [&](unsigned N) { |
142 | NMD->addOperand(M: MDNode::get( |
143 | Context&: Ctx, MDs: ValueAsMetadata::getConstant(C: ConstantInt::get(Ty: Int32Ty, V: N)))); |
144 | }; |
145 | // Add number of lines. |
146 | addDebugifyOperand(NextLine - 1); |
147 | // Add number of variables. |
148 | addDebugifyOperand(VarSet.size()); |
149 | } else { |
150 | assert(NMD->getNumOperands() == 2 && |
151 | "llvm.mir.debugify should have exactly 2 operands!" ); |
152 | auto setDebugifyOperand = [&](unsigned Idx, unsigned N) { |
153 | NMD->setOperand(I: Idx, New: MDNode::get(Context&: Ctx, MDs: ValueAsMetadata::getConstant( |
154 | C: ConstantInt::get(Ty: Int32Ty, V: N)))); |
155 | }; |
156 | auto getDebugifyOperand = [&](unsigned Idx) { |
157 | return mdconst::extract<ConstantInt>(MD: NMD->getOperand(i: Idx)->getOperand(I: 0)) |
158 | ->getZExtValue(); |
159 | }; |
160 | // Set number of lines. |
161 | setDebugifyOperand(0, NextLine - 1); |
162 | // Set number of variables. |
163 | auto OldNumVars = getDebugifyOperand(1); |
164 | setDebugifyOperand(1, OldNumVars + VarSet.size()); |
165 | } |
166 | |
167 | return true; |
168 | } |
169 | |
170 | /// ModulePass for attaching synthetic debug info to everything, used with the |
171 | /// legacy module pass manager. |
172 | struct DebugifyMachineModule : public ModulePass { |
173 | bool runOnModule(Module &M) override { |
174 | // We will insert new debugify metadata, so erasing the old one. |
175 | assert(!M.getNamedMetadata("llvm.mir.debugify" ) && |
176 | "llvm.mir.debugify metadata already exists! Strip it first" ); |
177 | MachineModuleInfo &MMI = |
178 | getAnalysis<MachineModuleInfoWrapperPass>().getMMI(); |
179 | return applyDebugifyMetadata( |
180 | M, Functions: M.functions(), |
181 | Banner: "ModuleDebugify: " , ApplyToMF: [&](DIBuilder &DIB, Function &F) -> bool { |
182 | return applyDebugifyMetadataToMachineFunction(MMI, DIB, F); |
183 | }); |
184 | } |
185 | |
186 | DebugifyMachineModule() : ModulePass(ID) {} |
187 | |
188 | void getAnalysisUsage(AnalysisUsage &AU) const override { |
189 | AU.addRequired<MachineModuleInfoWrapperPass>(); |
190 | AU.addPreserved<MachineModuleInfoWrapperPass>(); |
191 | AU.setPreservesCFG(); |
192 | } |
193 | |
194 | static char ID; // Pass identification. |
195 | }; |
196 | char DebugifyMachineModule::ID = 0; |
197 | |
198 | } // end anonymous namespace |
199 | |
200 | INITIALIZE_PASS_BEGIN(DebugifyMachineModule, DEBUG_TYPE, |
201 | "Machine Debugify Module" , false, false) |
202 | INITIALIZE_PASS_END(DebugifyMachineModule, DEBUG_TYPE, |
203 | "Machine Debugify Module" , false, false) |
204 | |
205 | ModulePass *llvm::createDebugifyMachineModulePass() { |
206 | return new DebugifyMachineModule(); |
207 | } |
208 | |