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"
31using namespace llvm;
32using namespace llvm::dwarf;
33
34DISubprogram *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
44void DebugInfoFinder::reset() {
45  CUs.clear();
46  SPs.clear();
47  GVs.clear();
48  TYs.clear();
49  Scopes.clear();
50  NodesSeen.clear();
51}
52
53void 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
86void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
87  if (!Loc)
88    return;
89  processScope(Loc->getScope());
90  processLocation(M, Loc->getInlinedAt());
91}
92
93void 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
117void 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
143void 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
157void 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
173void 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
188bool 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
199bool 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
209bool 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
220bool 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
231bool 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
244bool 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
268bool 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
290unsigned 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