1 | //===- DebugInfo.h - Debug Information Helpers ------------------*- C++ -*-===// |
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 | // This file defines a bunch of datatypes that are useful for creating and |
10 | // walking debug info in LLVM IR form. They essentially provide wrappers around |
11 | // the information in the global variables that's needed when constructing the |
12 | // DWARF information. |
13 | // |
14 | //===----------------------------------------------------------------------===// |
15 | |
16 | #ifndef LLVM_IR_DEBUGINFO_H |
17 | #define LLVM_IR_DEBUGINFO_H |
18 | |
19 | #include "llvm/ADT/STLExtras.h" |
20 | #include "llvm/ADT/SmallPtrSet.h" |
21 | #include "llvm/ADT/SmallVector.h" |
22 | #include "llvm/ADT/TinyPtrVector.h" |
23 | #include "llvm/ADT/iterator_range.h" |
24 | #include "llvm/IR/DebugInfoMetadata.h" |
25 | |
26 | namespace llvm { |
27 | |
28 | class DbgDeclareInst; |
29 | class DbgValueInst; |
30 | class DbgVariableIntrinsic; |
31 | class Instruction; |
32 | class Module; |
33 | |
34 | /// Finds all intrinsics declaring local variables as living in the memory that |
35 | /// 'V' points to. This may include a mix of dbg.declare and |
36 | /// dbg.addr intrinsics. |
37 | TinyPtrVector<DbgVariableIntrinsic *> FindDbgAddrUses(Value *V); |
38 | |
39 | /// Like \c FindDbgAddrUses, but only returns dbg.declare intrinsics, not |
40 | /// dbg.addr. |
41 | TinyPtrVector<DbgDeclareInst *> FindDbgDeclareUses(Value *V); |
42 | |
43 | /// Finds the llvm.dbg.value intrinsics describing a value. |
44 | void findDbgValues(SmallVectorImpl<DbgValueInst *> &DbgValues, Value *V); |
45 | |
46 | /// Finds the debug info intrinsics describing a value. |
47 | void findDbgUsers(SmallVectorImpl<DbgVariableIntrinsic *> &DbgInsts, Value *V); |
48 | |
49 | /// Find subprogram that is enclosing this scope. |
50 | DISubprogram *getDISubprogram(const MDNode *Scope); |
51 | |
52 | /// Strip debug info in the module if it exists. |
53 | /// |
54 | /// To do this, we remove all calls to the debugger intrinsics and any named |
55 | /// metadata for debugging. We also remove debug locations for instructions. |
56 | /// Return true if module is modified. |
57 | bool StripDebugInfo(Module &M); |
58 | bool stripDebugInfo(Function &F); |
59 | |
60 | /// Downgrade the debug info in a module to contain only line table information. |
61 | /// |
62 | /// In order to convert debug info to what -gline-tables-only would have |
63 | /// created, this does the following: |
64 | /// 1) Delete all debug intrinsics. |
65 | /// 2) Delete all non-CU named metadata debug info nodes. |
66 | /// 3) Create new DebugLocs for each instruction. |
67 | /// 4) Create a new CU debug info, and similarly for every metadata node |
68 | /// that's reachable from the CU debug info. |
69 | /// All debug type metadata nodes are unreachable and garbage collected. |
70 | bool stripNonLineTableDebugInfo(Module &M); |
71 | |
72 | /// Update the debug locations contained within the MD_loop metadata attached |
73 | /// to the instruction \p I, if one exists. \p Updater is applied to each debug |
74 | /// location in the MD_loop metadata: the returned value is included in the |
75 | /// updated loop metadata node if it is non-null. |
76 | void updateLoopMetadataDebugLocations( |
77 | Instruction &I, function_ref<DILocation *(const DILocation &)> Updater); |
78 | |
79 | /// Return Debug Info Metadata Version by checking module flags. |
80 | unsigned getDebugMetadataVersionFromModule(const Module &M); |
81 | |
82 | /// Utility to find all debug info in a module. |
83 | /// |
84 | /// DebugInfoFinder tries to list all debug info MDNodes used in a module. To |
85 | /// list debug info MDNodes used by an instruction, DebugInfoFinder uses |
86 | /// processDeclare, processValue and processLocation to handle DbgDeclareInst, |
87 | /// DbgValueInst and DbgLoc attached to instructions. processModule will go |
88 | /// through all DICompileUnits in llvm.dbg.cu and list debug info MDNodes |
89 | /// used by the CUs. |
90 | class DebugInfoFinder { |
91 | public: |
92 | /// Process entire module and collect debug info anchors. |
93 | void processModule(const Module &M); |
94 | /// Process a single instruction and collect debug info anchors. |
95 | void processInstruction(const Module &M, const Instruction &I); |
96 | |
97 | /// Process DbgVariableIntrinsic. |
98 | void processVariable(const Module &M, const DbgVariableIntrinsic &DVI); |
99 | /// Process debug info location. |
100 | void processLocation(const Module &M, const DILocation *Loc); |
101 | |
102 | /// Process subprogram. |
103 | void processSubprogram(DISubprogram *SP); |
104 | |
105 | /// Clear all lists. |
106 | void reset(); |
107 | |
108 | private: |
109 | void InitializeTypeMap(const Module &M); |
110 | |
111 | void processCompileUnit(DICompileUnit *CU); |
112 | void processScope(DIScope *Scope); |
113 | void processType(DIType *DT); |
114 | bool addCompileUnit(DICompileUnit *CU); |
115 | bool addGlobalVariable(DIGlobalVariableExpression *DIG); |
116 | bool addScope(DIScope *Scope); |
117 | bool addSubprogram(DISubprogram *SP); |
118 | bool addType(DIType *DT); |
119 | |
120 | public: |
121 | using compile_unit_iterator = |
122 | SmallVectorImpl<DICompileUnit *>::const_iterator; |
123 | using subprogram_iterator = SmallVectorImpl<DISubprogram *>::const_iterator; |
124 | using global_variable_expression_iterator = |
125 | SmallVectorImpl<DIGlobalVariableExpression *>::const_iterator; |
126 | using type_iterator = SmallVectorImpl<DIType *>::const_iterator; |
127 | using scope_iterator = SmallVectorImpl<DIScope *>::const_iterator; |
128 | |
129 | iterator_range<compile_unit_iterator> compile_units() const { |
130 | return make_range(CUs.begin(), CUs.end()); |
131 | } |
132 | |
133 | iterator_range<subprogram_iterator> subprograms() const { |
134 | return make_range(SPs.begin(), SPs.end()); |
135 | } |
136 | |
137 | iterator_range<global_variable_expression_iterator> global_variables() const { |
138 | return make_range(GVs.begin(), GVs.end()); |
139 | } |
140 | |
141 | iterator_range<type_iterator> types() const { |
142 | return make_range(TYs.begin(), TYs.end()); |
143 | } |
144 | |
145 | iterator_range<scope_iterator> scopes() const { |
146 | return make_range(Scopes.begin(), Scopes.end()); |
147 | } |
148 | |
149 | unsigned compile_unit_count() const { return CUs.size(); } |
150 | unsigned global_variable_count() const { return GVs.size(); } |
151 | unsigned subprogram_count() const { return SPs.size(); } |
152 | unsigned type_count() const { return TYs.size(); } |
153 | unsigned scope_count() const { return Scopes.size(); } |
154 | |
155 | private: |
156 | SmallVector<DICompileUnit *, 8> CUs; |
157 | SmallVector<DISubprogram *, 8> SPs; |
158 | SmallVector<DIGlobalVariableExpression *, 8> GVs; |
159 | SmallVector<DIType *, 8> TYs; |
160 | SmallVector<DIScope *, 8> Scopes; |
161 | SmallPtrSet<const MDNode *, 32> NodesSeen; |
162 | }; |
163 | |
164 | } // end namespace llvm |
165 | |
166 | #endif // LLVM_IR_DEBUGINFO_H |
167 | |