1 //===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
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 // This file implements the helper classes used to build and interpret debug
11 // information in LLVM IR form.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "llvm/IR/DebugInfo.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallPtrSet.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DIBuilder.h"
21 #include "llvm/IR/DerivedTypes.h"
22 #include "llvm/IR/GVMaterializer.h"
23 #include "llvm/IR/Instructions.h"
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/IR/ValueHandle.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/Dwarf.h"
30 #include "llvm/Support/raw_ostream.h"
31 using namespace llvm;
32 using namespace llvm::dwarf;
33
getDISubprogram(const MDNode * Scope)34 DISubprogram *llvm::getDISubprogram(const MDNode *Scope) {
35 if (auto *LocalScope = dyn_cast_or_null<DILocalScope>(Scope))
36 return LocalScope->getSubprogram();
37 return nullptr;
38 }
39
40 //===----------------------------------------------------------------------===//
41 // DebugInfoFinder implementations.
42 //===----------------------------------------------------------------------===//
43
reset()44 void DebugInfoFinder::reset() {
45 CUs.clear();
46 SPs.clear();
47 GVs.clear();
48 TYs.clear();
49 Scopes.clear();
50 NodesSeen.clear();
51 }
52
processModule(const Module & M)53 void DebugInfoFinder::processModule(const Module &M) {
54 for (auto *CU : M.debug_compile_units()) {
55 addCompileUnit(CU);
56 for (auto *DIG : CU->getGlobalVariables()) {
57 if (addGlobalVariable(DIG)) {
58 processScope(DIG->getScope());
59 processType(DIG->getType().resolve());
60 }
61 }
62 for (auto *ET : CU->getEnumTypes())
63 processType(ET);
64 for (auto *RT : CU->getRetainedTypes())
65 if (auto *T = dyn_cast<DIType>(RT))
66 processType(T);
67 else
68 processSubprogram(cast<DISubprogram>(RT));
69 for (auto *Import : CU->getImportedEntities()) {
70 auto *Entity = Import->getEntity().resolve();
71 if (auto *T = dyn_cast<DIType>(Entity))
72 processType(T);
73 else if (auto *SP = dyn_cast<DISubprogram>(Entity))
74 processSubprogram(SP);
75 else if (auto *NS = dyn_cast<DINamespace>(Entity))
76 processScope(NS->getScope());
77 else if (auto *M = dyn_cast<DIModule>(Entity))
78 processScope(M->getScope());
79 }
80 }
81 for (auto &F : M.functions())
82 if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
83 processSubprogram(SP);
84 }
85
processLocation(const Module & M,const DILocation * Loc)86 void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
87 if (!Loc)
88 return;
89 processScope(Loc->getScope());
90 processLocation(M, Loc->getInlinedAt());
91 }
92
processType(DIType * DT)93 void DebugInfoFinder::processType(DIType *DT) {
94 if (!addType(DT))
95 return;
96 processScope(DT->getScope().resolve());
97 if (auto *ST = dyn_cast<DISubroutineType>(DT)) {
98 for (DITypeRef Ref : ST->getTypeArray())
99 processType(Ref.resolve());
100 return;
101 }
102 if (auto *DCT = dyn_cast<DICompositeType>(DT)) {
103 processType(DCT->getBaseType().resolve());
104 for (Metadata *D : DCT->getElements()) {
105 if (auto *T = dyn_cast<DIType>(D))
106 processType(T);
107 else if (auto *SP = dyn_cast<DISubprogram>(D))
108 processSubprogram(SP);
109 }
110 return;
111 }
112 if (auto *DDT = dyn_cast<DIDerivedType>(DT)) {
113 processType(DDT->getBaseType().resolve());
114 }
115 }
116
processScope(DIScope * Scope)117 void DebugInfoFinder::processScope(DIScope *Scope) {
118 if (!Scope)
119 return;
120 if (auto *Ty = dyn_cast<DIType>(Scope)) {
121 processType(Ty);
122 return;
123 }
124 if (auto *CU = dyn_cast<DICompileUnit>(Scope)) {
125 addCompileUnit(CU);
126 return;
127 }
128 if (auto *SP = dyn_cast<DISubprogram>(Scope)) {
129 processSubprogram(SP);
130 return;
131 }
132 if (!addScope(Scope))
133 return;
134 if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
135 processScope(LB->getScope());
136 } else if (auto *NS = dyn_cast<DINamespace>(Scope)) {
137 processScope(NS->getScope());
138 } else if (auto *M = dyn_cast<DIModule>(Scope)) {
139 processScope(M->getScope());
140 }
141 }
142
processSubprogram(DISubprogram * SP)143 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
144 if (!addSubprogram(SP))
145 return;
146 processScope(SP->getScope().resolve());
147 processType(SP->getType());
148 for (auto *Element : SP->getTemplateParams()) {
149 if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
150 processType(TType->getType().resolve());
151 } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
152 processType(TVal->getType().resolve());
153 }
154 }
155 }
156
processDeclare(const Module & M,const DbgDeclareInst * DDI)157 void DebugInfoFinder::processDeclare(const Module &M,
158 const DbgDeclareInst *DDI) {
159 auto *N = dyn_cast<MDNode>(DDI->getVariable());
160 if (!N)
161 return;
162
163 auto *DV = dyn_cast<DILocalVariable>(N);
164 if (!DV)
165 return;
166
167 if (!NodesSeen.insert(DV).second)
168 return;
169 processScope(DV->getScope());
170 processType(DV->getType().resolve());
171 }
172
processValue(const Module & M,const DbgValueInst * DVI)173 void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
174 auto *N = dyn_cast<MDNode>(DVI->getVariable());
175 if (!N)
176 return;
177
178 auto *DV = dyn_cast<DILocalVariable>(N);
179 if (!DV)
180 return;
181
182 if (!NodesSeen.insert(DV).second)
183 return;
184 processScope(DV->getScope());
185 processType(DV->getType().resolve());
186 }
187
addType(DIType * DT)188 bool DebugInfoFinder::addType(DIType *DT) {
189 if (!DT)
190 return false;
191
192 if (!NodesSeen.insert(DT).second)
193 return false;
194
195 TYs.push_back(const_cast<DIType *>(DT));
196 return true;
197 }
198
addCompileUnit(DICompileUnit * CU)199 bool DebugInfoFinder::addCompileUnit(DICompileUnit *CU) {
200 if (!CU)
201 return false;
202 if (!NodesSeen.insert(CU).second)
203 return false;
204
205 CUs.push_back(CU);
206 return true;
207 }
208
addGlobalVariable(DIGlobalVariable * DIG)209 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable *DIG) {
210 if (!DIG)
211 return false;
212
213 if (!NodesSeen.insert(DIG).second)
214 return false;
215
216 GVs.push_back(DIG);
217 return true;
218 }
219
addSubprogram(DISubprogram * SP)220 bool DebugInfoFinder::addSubprogram(DISubprogram *SP) {
221 if (!SP)
222 return false;
223
224 if (!NodesSeen.insert(SP).second)
225 return false;
226
227 SPs.push_back(SP);
228 return true;
229 }
230
addScope(DIScope * Scope)231 bool DebugInfoFinder::addScope(DIScope *Scope) {
232 if (!Scope)
233 return false;
234 // FIXME: Ocaml binding generates a scope with no content, we treat it
235 // as null for now.
236 if (Scope->getNumOperands() == 0)
237 return false;
238 if (!NodesSeen.insert(Scope).second)
239 return false;
240 Scopes.push_back(Scope);
241 return true;
242 }
243
stripDebugInfo(Function & F)244 bool llvm::stripDebugInfo(Function &F) {
245 bool Changed = false;
246 if (F.getSubprogram()) {
247 Changed = true;
248 F.setSubprogram(nullptr);
249 }
250
251 for (BasicBlock &BB : F) {
252 for (auto II = BB.begin(), End = BB.end(); II != End;) {
253 Instruction &I = *II++; // We may delete the instruction, increment now.
254 if (isa<DbgInfoIntrinsic>(&I)) {
255 I.eraseFromParent();
256 Changed = true;
257 continue;
258 }
259 if (I.getDebugLoc()) {
260 Changed = true;
261 I.setDebugLoc(DebugLoc());
262 }
263 }
264 }
265 return Changed;
266 }
267
StripDebugInfo(Module & M)268 bool llvm::StripDebugInfo(Module &M) {
269 bool Changed = false;
270
271 for (Module::named_metadata_iterator NMI = M.named_metadata_begin(),
272 NME = M.named_metadata_end(); NMI != NME;) {
273 NamedMDNode *NMD = &*NMI;
274 ++NMI;
275 if (NMD->getName().startswith("llvm.dbg.")) {
276 NMD->eraseFromParent();
277 Changed = true;
278 }
279 }
280
281 for (Function &F : M)
282 Changed |= stripDebugInfo(F);
283
284 if (GVMaterializer *Materializer = M.getMaterializer())
285 Materializer->setStripDebugInfo();
286
287 return Changed;
288 }
289
getDebugMetadataVersionFromModule(const Module & M)290 unsigned llvm::getDebugMetadataVersionFromModule(const Module &M) {
291 if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
292 M.getModuleFlag("Debug Info Version")))
293 return Val->getZExtValue();
294 return 0;
295 }
296