1 //===- DebugInfo.h - Debug Information Helpers ------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a bunch of datatypes that are useful for creating and
11 // walking debug info in LLVM IR form. They essentially provide wrappers around
12 // the information in the global variables that's needed when constructing the
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_IR_DEBUGINFO_H
18 #define LLVM_IR_DEBUGINFO_H
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/iterator_range.h"
25 #include "llvm/IR/DebugInfoMetadata.h"
26 #include "llvm/Support/Casting.h"
27 #include "llvm/Support/Dwarf.h"
28 #include "llvm/Support/ErrorHandling.h"
52 class DILexicalBlockFile;
58 /// \brief Maps from type identifier to the actual MDNode.
59 typedef DenseMap<const MDString *, MDNode *> DITypeIdentifierMap;
65 DIDescriptor(const MDNode *N = nullptr) : N(const_cast<MDNode *>(N)) {}
67 operator MDNode *() const { return N; }
68 MDNode *operator->() const { return N; }
69 MDNode &operator*() const { return *N; }
72 #define DECLARE_SIMPLIFY_DESCRIPTOR(DESC) \
74 template <> struct simplify_type<const DESC>; \
75 template <> struct simplify_type<DESC>;
76 DECLARE_SIMPLIFY_DESCRIPTOR(DIDescriptor)
77 DECLARE_SIMPLIFY_DESCRIPTOR(DISubrange)
78 DECLARE_SIMPLIFY_DESCRIPTOR(DIEnumerator)
79 DECLARE_SIMPLIFY_DESCRIPTOR(DIScope)
80 DECLARE_SIMPLIFY_DESCRIPTOR(DIType)
81 DECLARE_SIMPLIFY_DESCRIPTOR(DIBasicType)
82 DECLARE_SIMPLIFY_DESCRIPTOR(DIDerivedType)
83 DECLARE_SIMPLIFY_DESCRIPTOR(DICompositeType)
84 DECLARE_SIMPLIFY_DESCRIPTOR(DISubroutineType)
85 DECLARE_SIMPLIFY_DESCRIPTOR(DIFile)
86 DECLARE_SIMPLIFY_DESCRIPTOR(DICompileUnit)
87 DECLARE_SIMPLIFY_DESCRIPTOR(DISubprogram)
88 DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlock)
89 DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
90 DECLARE_SIMPLIFY_DESCRIPTOR(DINameSpace)
91 DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
92 DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
93 DECLARE_SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
94 DECLARE_SIMPLIFY_DESCRIPTOR(DIVariable)
95 DECLARE_SIMPLIFY_DESCRIPTOR(DIExpression)
96 DECLARE_SIMPLIFY_DESCRIPTOR(DILocation)
97 DECLARE_SIMPLIFY_DESCRIPTOR(DIObjCProperty)
98 DECLARE_SIMPLIFY_DESCRIPTOR(DIImportedEntity)
99 #undef DECLARE_SIMPLIFY_DESCRIPTOR
101 typedef DebugNodeArray DIArray;
102 typedef MDTypeRefArray DITypeArray;
108 DISubrange(const MDSubrange *N = nullptr) : N(const_cast<MDSubrange *>(N)) {}
110 operator MDSubrange *() const { return N; }
111 MDSubrange *operator->() const { return N; }
112 MDSubrange &operator*() const { return *N; }
119 DIEnumerator(const MDEnumerator *N = nullptr)
120 : N(const_cast<MDEnumerator *>(N)) {}
122 operator MDEnumerator *() const { return N; }
123 MDEnumerator *operator->() const { return N; }
124 MDEnumerator &operator*() const { return *N; }
127 template <typename T> class DIRef;
128 typedef DIRef<DIDescriptor> DIDescriptorRef;
129 typedef DIRef<DIScope> DIScopeRef;
130 typedef DIRef<DIType> DITypeRef;
136 DIScope(const MDScope *N = nullptr) : N(const_cast<MDScope *>(N)) {}
138 operator DIDescriptor() const { return N; }
139 operator MDScope *() const { return N; }
140 MDScope *operator->() const { return N; }
141 MDScope &operator*() const { return *N; }
144 /// \brief Represents reference to a DIDescriptor.
146 /// Abstracts over direct and identifier-based metadata references.
147 template <typename T> class DIRef {
148 /// \brief Val can be either a MDNode or a MDString.
150 /// In the latter, MDString specifies the type identifier.
155 DIRef(const TypedDebugNodeRef<U> &Ref,
156 typename std::enable_if<std::is_convertible<U *, T>::value>::type * =
160 T resolve(const DITypeIdentifierMap &Map) const;
161 operator Metadata *() const { return const_cast<Metadata *>(Val); }
165 DIDescriptor DIRef<DIDescriptor>::resolve(const DITypeIdentifierMap &Map) const;
167 DIScope DIRef<DIScope>::resolve(const DITypeIdentifierMap &Map) const;
168 template <> DIType DIRef<DIType>::resolve(const DITypeIdentifierMap &Map) const;
174 DIType(const MDType *N = nullptr) : N(const_cast<MDType *>(N)) {}
176 operator DIDescriptor() const { return N; }
177 operator DIScope() const { return N; }
178 operator MDType *() const { return N; }
179 MDType *operator->() const { return N; }
180 MDType &operator*() const { return *N; }
187 DIBasicType(const MDBasicType *N = nullptr)
188 : N(const_cast<MDBasicType *>(N)) {}
190 operator DIDescriptor() const { return N; }
191 operator DIType() const { return N; }
192 operator MDBasicType *() const { return N; }
193 MDBasicType *operator->() const { return N; }
194 MDBasicType &operator*() const { return *N; }
197 class DIDerivedType {
198 MDDerivedTypeBase *N;
201 DIDerivedType(const MDDerivedTypeBase *N = nullptr)
202 : N(const_cast<MDDerivedTypeBase *>(N)) {}
204 operator DIDescriptor() const { return N; }
205 operator DIType() const { return N; }
206 operator MDDerivedTypeBase *() const { return N; }
207 MDDerivedTypeBase *operator->() const { return N; }
208 MDDerivedTypeBase &operator*() const { return *N; }
211 class DICompositeType {
212 MDCompositeTypeBase *N;
215 DICompositeType(const MDCompositeTypeBase *N = nullptr)
216 : N(const_cast<MDCompositeTypeBase *>(N)) {}
218 operator DIDescriptor() const { return N; }
219 operator DIType() const { return N; }
220 operator MDCompositeTypeBase *() const { return N; }
221 MDCompositeTypeBase *operator->() const { return N; }
222 MDCompositeTypeBase &operator*() const { return *N; }
225 class DISubroutineType {
229 DISubroutineType(const MDSubroutineType *N = nullptr)
230 : N(const_cast<MDSubroutineType *>(N)) {}
232 operator DIDescriptor() const { return N; }
233 operator DIType() const { return N; }
234 operator DICompositeType() const { return N; }
235 operator MDSubroutineType *() const { return N; }
236 MDSubroutineType *operator->() const { return N; }
237 MDSubroutineType &operator*() const { return *N; }
244 DIFile(const MDFile *N = nullptr) : N(const_cast<MDFile *>(N)) {}
246 operator DIDescriptor() const { return N; }
247 operator DIScope() const { return N; }
248 operator MDFile *() const { return N; }
249 MDFile *operator->() const { return N; }
250 MDFile &operator*() const { return *N; }
253 class DICompileUnit {
257 DICompileUnit(const MDCompileUnit *N = nullptr)
258 : N(const_cast<MDCompileUnit *>(N)) {}
260 operator DIDescriptor() const { return N; }
261 operator DIScope() const { return N; }
262 operator MDCompileUnit *() const { return N; }
263 MDCompileUnit *operator->() const { return N; }
264 MDCompileUnit &operator*() const { return *N; }
271 DISubprogram(const MDSubprogram *N = nullptr)
272 : N(const_cast<MDSubprogram *>(N)) {}
274 operator DIDescriptor() const { return N; }
275 operator DIScope() const { return N; }
276 operator MDSubprogram *() const { return N; }
277 MDSubprogram *operator->() const { return N; }
278 MDSubprogram &operator*() const { return *N; }
281 class DILexicalBlock {
282 MDLexicalBlockBase *N;
285 DILexicalBlock(const MDLexicalBlockBase *N = nullptr)
286 : N(const_cast<MDLexicalBlockBase *>(N)) {}
288 operator DIDescriptor() const { return N; }
289 operator MDLexicalBlockBase *() const { return N; }
290 MDLexicalBlockBase *operator->() const { return N; }
291 MDLexicalBlockBase &operator*() const { return *N; }
294 class DILexicalBlockFile {
295 MDLexicalBlockFile *N;
298 DILexicalBlockFile(const MDLexicalBlockFile *N = nullptr)
299 : N(const_cast<MDLexicalBlockFile *>(N)) {}
301 operator DIDescriptor() const { return N; }
302 operator MDLexicalBlockFile *() const { return N; }
303 MDLexicalBlockFile *operator->() const { return N; }
304 MDLexicalBlockFile &operator*() const { return *N; }
311 DINameSpace(const MDNamespace *N = nullptr)
312 : N(const_cast<MDNamespace *>(N)) {}
314 operator DIDescriptor() const { return N; }
315 operator DIScope() const { return N; }
316 operator MDNamespace *() const { return N; }
317 MDNamespace *operator->() const { return N; }
318 MDNamespace &operator*() const { return *N; }
321 class DITemplateTypeParameter {
322 MDTemplateTypeParameter *N;
325 DITemplateTypeParameter(const MDTemplateTypeParameter *N = nullptr)
326 : N(const_cast<MDTemplateTypeParameter *>(N)) {}
328 operator MDTemplateTypeParameter *() const { return N; }
329 MDTemplateTypeParameter *operator->() const { return N; }
330 MDTemplateTypeParameter &operator*() const { return *N; }
333 class DITemplateValueParameter {
334 MDTemplateValueParameter *N;
337 DITemplateValueParameter(const MDTemplateValueParameter *N = nullptr)
338 : N(const_cast<MDTemplateValueParameter *>(N)) {}
340 operator MDTemplateValueParameter *() const { return N; }
341 MDTemplateValueParameter *operator->() const { return N; }
342 MDTemplateValueParameter &operator*() const { return *N; }
345 class DIGlobalVariable {
349 DIGlobalVariable(const MDGlobalVariable *N = nullptr)
350 : N(const_cast<MDGlobalVariable *>(N)) {}
352 operator DIDescriptor() const { return N; }
353 operator MDGlobalVariable *() const { return N; }
354 MDGlobalVariable *operator->() const { return N; }
355 MDGlobalVariable &operator*() const { return *N; }
362 DIVariable(const MDLocalVariable *N = nullptr)
363 : N(const_cast<MDLocalVariable *>(N)) {}
365 operator MDLocalVariable *() const { return N; }
366 MDLocalVariable *operator->() const { return N; }
367 MDLocalVariable &operator*() const { return *N; }
374 DIExpression(const MDExpression *N = nullptr)
375 : N(const_cast<MDExpression *>(N)) {}
377 operator MDExpression *() const { return N; }
378 MDExpression *operator->() const { return N; }
379 MDExpression &operator*() const { return *N; }
386 DILocation(const MDLocation *N = nullptr) : N(const_cast<MDLocation *>(N)) {}
388 operator MDLocation *() const { return N; }
389 MDLocation *operator->() const { return N; }
390 MDLocation &operator*() const { return *N; }
393 class DIObjCProperty {
397 DIObjCProperty(const MDObjCProperty *N = nullptr)
398 : N(const_cast<MDObjCProperty *>(N)) {}
400 operator MDObjCProperty *() const { return N; }
401 MDObjCProperty *operator->() const { return N; }
402 MDObjCProperty &operator*() const { return *N; }
405 class DIImportedEntity {
409 DIImportedEntity(const MDImportedEntity *N = nullptr)
410 : N(const_cast<MDImportedEntity *>(N)) {}
412 operator DIDescriptor() const { return N; }
413 operator MDImportedEntity *() const { return N; }
414 MDImportedEntity *operator->() const { return N; }
415 MDImportedEntity &operator*() const { return *N; }
418 #define SIMPLIFY_DESCRIPTOR(DESC) \
419 template <> struct simplify_type<const DESC> { \
420 typedef Metadata *SimpleType; \
421 static SimpleType getSimplifiedValue(const DESC &DI) { return DI; } \
423 template <> struct simplify_type<DESC> : simplify_type<const DESC> {};
424 SIMPLIFY_DESCRIPTOR(DIDescriptor)
425 SIMPLIFY_DESCRIPTOR(DISubrange)
426 SIMPLIFY_DESCRIPTOR(DIEnumerator)
427 SIMPLIFY_DESCRIPTOR(DIScope)
428 SIMPLIFY_DESCRIPTOR(DIType)
429 SIMPLIFY_DESCRIPTOR(DIBasicType)
430 SIMPLIFY_DESCRIPTOR(DIDerivedType)
431 SIMPLIFY_DESCRIPTOR(DICompositeType)
432 SIMPLIFY_DESCRIPTOR(DISubroutineType)
433 SIMPLIFY_DESCRIPTOR(DIFile)
434 SIMPLIFY_DESCRIPTOR(DICompileUnit)
435 SIMPLIFY_DESCRIPTOR(DISubprogram)
436 SIMPLIFY_DESCRIPTOR(DILexicalBlock)
437 SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
438 SIMPLIFY_DESCRIPTOR(DINameSpace)
439 SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
440 SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
441 SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
442 SIMPLIFY_DESCRIPTOR(DIVariable)
443 SIMPLIFY_DESCRIPTOR(DIExpression)
444 SIMPLIFY_DESCRIPTOR(DILocation)
445 SIMPLIFY_DESCRIPTOR(DIObjCProperty)
446 SIMPLIFY_DESCRIPTOR(DIImportedEntity)
447 #undef SIMPLIFY_DESCRIPTOR
449 /// \brief Find subprogram that is enclosing this scope.
450 DISubprogram getDISubprogram(const MDNode *Scope);
452 /// \brief Find debug info for a given function.
453 /// \returns a valid DISubprogram, if found. Otherwise, it returns an empty
455 DISubprogram getDISubprogram(const Function *F);
457 /// \brief Find underlying composite type.
458 DICompositeType getDICompositeType(DIType T);
460 /// \brief Generate map by visiting all retained types.
461 DITypeIdentifierMap generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes);
463 /// \brief Strip debug info in the module if it exists.
465 /// To do this, we remove all calls to the debugger intrinsics and any named
466 /// metadata for debugging. We also remove debug locations for instructions.
467 /// Return true if module is modified.
468 bool StripDebugInfo(Module &M);
469 bool stripDebugInfo(Function &F);
471 /// \brief Return Debug Info Metadata Version by checking module flags.
472 unsigned getDebugMetadataVersionFromModule(const Module &M);
474 /// \brief Utility to find all debug info in a module.
476 /// DebugInfoFinder tries to list all debug info MDNodes used in a module. To
477 /// list debug info MDNodes used by an instruction, DebugInfoFinder uses
478 /// processDeclare, processValue and processLocation to handle DbgDeclareInst,
479 /// DbgValueInst and DbgLoc attached to instructions. processModule will go
480 /// through all DICompileUnits in llvm.dbg.cu and list debug info MDNodes
482 class DebugInfoFinder {
484 DebugInfoFinder() : TypeMapInitialized(false) {}
486 /// \brief Process entire module and collect debug info anchors.
487 void processModule(const Module &M);
489 /// \brief Process DbgDeclareInst.
490 void processDeclare(const Module &M, const DbgDeclareInst *DDI);
491 /// \brief Process DbgValueInst.
492 void processValue(const Module &M, const DbgValueInst *DVI);
493 /// \brief Process DILocation.
494 void processLocation(const Module &M, DILocation Loc);
496 /// \brief Clear all lists.
500 void InitializeTypeMap(const Module &M);
502 void processType(DIType DT);
503 void processSubprogram(DISubprogram SP);
504 void processScope(DIScope Scope);
505 bool addCompileUnit(DICompileUnit CU);
506 bool addGlobalVariable(DIGlobalVariable DIG);
507 bool addSubprogram(DISubprogram SP);
508 bool addType(DIType DT);
509 bool addScope(DIScope Scope);
512 typedef SmallVectorImpl<DICompileUnit>::const_iterator compile_unit_iterator;
513 typedef SmallVectorImpl<DISubprogram>::const_iterator subprogram_iterator;
514 typedef SmallVectorImpl<DIGlobalVariable>::const_iterator
515 global_variable_iterator;
516 typedef SmallVectorImpl<DIType>::const_iterator type_iterator;
517 typedef SmallVectorImpl<DIScope>::const_iterator scope_iterator;
519 iterator_range<compile_unit_iterator> compile_units() const {
520 return iterator_range<compile_unit_iterator>(CUs.begin(), CUs.end());
523 iterator_range<subprogram_iterator> subprograms() const {
524 return iterator_range<subprogram_iterator>(SPs.begin(), SPs.end());
527 iterator_range<global_variable_iterator> global_variables() const {
528 return iterator_range<global_variable_iterator>(GVs.begin(), GVs.end());
531 iterator_range<type_iterator> types() const {
532 return iterator_range<type_iterator>(TYs.begin(), TYs.end());
535 iterator_range<scope_iterator> scopes() const {
536 return iterator_range<scope_iterator>(Scopes.begin(), Scopes.end());
539 unsigned compile_unit_count() const { return CUs.size(); }
540 unsigned global_variable_count() const { return GVs.size(); }
541 unsigned subprogram_count() const { return SPs.size(); }
542 unsigned type_count() const { return TYs.size(); }
543 unsigned scope_count() const { return Scopes.size(); }
546 SmallVector<DICompileUnit, 8> CUs;
547 SmallVector<DISubprogram, 8> SPs;
548 SmallVector<DIGlobalVariable, 8> GVs;
549 SmallVector<DIType, 8> TYs;
550 SmallVector<DIScope, 8> Scopes;
551 SmallPtrSet<MDNode *, 64> NodesSeen;
552 DITypeIdentifierMap TypeIdentifierMap;
554 /// \brief Specify if TypeIdentifierMap is initialized.
555 bool TypeMapInitialized;
558 DenseMap<const Function *, DISubprogram> makeSubprogramMap(const Module &M);
560 } // end namespace llvm