clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DwarfUnit.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -D PIC -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -D_RET_PROTECTOR -ret-protector -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | #include "DwarfUnit.h" |
14 | #include "AddressPool.h" |
15 | #include "DwarfCompileUnit.h" |
16 | #include "DwarfExpression.h" |
17 | #include "llvm/ADT/APFloat.h" |
18 | #include "llvm/ADT/APInt.h" |
19 | #include "llvm/ADT/None.h" |
20 | #include "llvm/ADT/StringExtras.h" |
21 | #include "llvm/ADT/iterator_range.h" |
22 | #include "llvm/CodeGen/MachineFunction.h" |
23 | #include "llvm/CodeGen/MachineOperand.h" |
24 | #include "llvm/CodeGen/TargetRegisterInfo.h" |
25 | #include "llvm/CodeGen/TargetSubtargetInfo.h" |
26 | #include "llvm/IR/Constants.h" |
27 | #include "llvm/IR/DataLayout.h" |
28 | #include "llvm/IR/GlobalValue.h" |
29 | #include "llvm/IR/Metadata.h" |
30 | #include "llvm/MC/MCAsmInfo.h" |
31 | #include "llvm/MC/MCContext.h" |
32 | #include "llvm/MC/MCDwarf.h" |
33 | #include "llvm/MC/MCSection.h" |
34 | #include "llvm/MC/MCStreamer.h" |
35 | #include "llvm/MC/MachineLocation.h" |
36 | #include "llvm/Support/Casting.h" |
37 | #include "llvm/Support/CommandLine.h" |
38 | #include "llvm/Target/TargetLoweringObjectFile.h" |
39 | #include <cassert> |
40 | #include <cstdint> |
41 | #include <string> |
42 | #include <utility> |
43 | |
44 | using namespace llvm; |
45 | |
46 | #define DEBUG_TYPE "dwarfdebug" |
47 | |
48 | DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, |
49 | DwarfCompileUnit &CU, DIELoc &DIE) |
50 | : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {} |
51 | |
52 | void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) { |
53 | CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op); |
54 | } |
55 | |
56 | void DIEDwarfExpression::emitSigned(int64_t Value) { |
57 | CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value); |
58 | } |
59 | |
60 | void DIEDwarfExpression::emitUnsigned(uint64_t Value) { |
61 | CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value); |
62 | } |
63 | |
64 | void DIEDwarfExpression::emitData1(uint8_t Value) { |
65 | CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value); |
66 | } |
67 | |
68 | void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) { |
69 | CU.addBaseTypeRef(getActiveDIE(), Idx); |
70 | } |
71 | |
72 | void DIEDwarfExpression::enableTemporaryBuffer() { |
73 | assert(!IsBuffering && "Already buffering?"); |
74 | IsBuffering = true; |
75 | } |
76 | |
77 | void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; } |
78 | |
79 | unsigned DIEDwarfExpression::getTemporaryBufferSize() { |
80 | return TmpDIE.ComputeSize(&AP); |
81 | } |
82 | |
83 | void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); } |
84 | |
85 | bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI, |
86 | llvm::Register MachineReg) { |
87 | return MachineReg == TRI.getFrameRegister(*AP.MF); |
88 | } |
89 | |
90 | DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node, |
91 | AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU) |
92 | : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU), |
93 | IndexTyDie(nullptr) {} |
94 | |
95 | DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, |
96 | DwarfDebug *DW, DwarfFile *DWU, |
97 | MCDwarfDwoLineTable *SplitLineTable) |
98 | : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU), |
99 | SplitLineTable(SplitLineTable) { |
100 | } |
101 | |
102 | DwarfUnit::~DwarfUnit() { |
103 | for (DIEBlock *B : DIEBlocks) |
104 | B->~DIEBlock(); |
105 | for (DIELoc *L : DIELocs) |
106 | L->~DIELoc(); |
107 | } |
108 | |
109 | int64_t DwarfUnit::getDefaultLowerBound() const { |
110 | switch (getLanguage()) { |
111 | default: |
112 | break; |
113 | |
114 | |
115 | case dwarf::DW_LANG_C: |
116 | case dwarf::DW_LANG_C89: |
117 | case dwarf::DW_LANG_C_plus_plus: |
118 | return 0; |
119 | |
120 | case dwarf::DW_LANG_Fortran77: |
121 | case dwarf::DW_LANG_Fortran90: |
122 | return 1; |
123 | |
124 | |
125 | case dwarf::DW_LANG_C99: |
126 | case dwarf::DW_LANG_ObjC: |
127 | case dwarf::DW_LANG_ObjC_plus_plus: |
128 | if (DD->getDwarfVersion() >= 3) |
129 | return 0; |
130 | break; |
131 | |
132 | case dwarf::DW_LANG_Fortran95: |
133 | if (DD->getDwarfVersion() >= 3) |
134 | return 1; |
135 | break; |
136 | |
137 | |
138 | case dwarf::DW_LANG_D: |
139 | case dwarf::DW_LANG_Java: |
140 | case dwarf::DW_LANG_Python: |
141 | case dwarf::DW_LANG_UPC: |
142 | if (DD->getDwarfVersion() >= 4) |
143 | return 0; |
144 | break; |
145 | |
146 | case dwarf::DW_LANG_Ada83: |
147 | case dwarf::DW_LANG_Ada95: |
148 | case dwarf::DW_LANG_Cobol74: |
149 | case dwarf::DW_LANG_Cobol85: |
150 | case dwarf::DW_LANG_Modula2: |
151 | case dwarf::DW_LANG_Pascal83: |
152 | case dwarf::DW_LANG_PLI: |
153 | if (DD->getDwarfVersion() >= 4) |
154 | return 1; |
155 | break; |
156 | |
157 | |
158 | case dwarf::DW_LANG_BLISS: |
159 | case dwarf::DW_LANG_C11: |
160 | case dwarf::DW_LANG_C_plus_plus_03: |
161 | case dwarf::DW_LANG_C_plus_plus_11: |
162 | case dwarf::DW_LANG_C_plus_plus_14: |
163 | case dwarf::DW_LANG_Dylan: |
164 | case dwarf::DW_LANG_Go: |
165 | case dwarf::DW_LANG_Haskell: |
166 | case dwarf::DW_LANG_OCaml: |
167 | case dwarf::DW_LANG_OpenCL: |
168 | case dwarf::DW_LANG_RenderScript: |
169 | case dwarf::DW_LANG_Rust: |
170 | case dwarf::DW_LANG_Swift: |
171 | if (DD->getDwarfVersion() >= 5) |
172 | return 0; |
173 | break; |
174 | |
175 | case dwarf::DW_LANG_Fortran03: |
176 | case dwarf::DW_LANG_Fortran08: |
177 | case dwarf::DW_LANG_Julia: |
178 | case dwarf::DW_LANG_Modula3: |
179 | if (DD->getDwarfVersion() >= 5) |
180 | return 1; |
181 | break; |
182 | } |
183 | |
184 | return -1; |
185 | } |
186 | |
187 | |
188 | bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const { |
189 | |
190 | |
191 | |
192 | |
193 | |
194 | |
195 | |
196 | if (isDwoUnit() && !DD->shareAcrossDWOCUs()) |
197 | return false; |
198 | return (isa<DIType>(D) || |
199 | (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) && |
200 | !DD->generateTypeUnits(); |
201 | } |
202 | |
203 | DIE *DwarfUnit::getDIE(const DINode *D) const { |
204 | if (isShareableAcrossCUs(D)) |
205 | return DU->getDIE(D); |
206 | return MDNodeToDieMap.lookup(D); |
207 | } |
208 | |
209 | void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) { |
210 | if (isShareableAcrossCUs(Desc)) { |
211 | DU->insertDIE(Desc, D); |
212 | return; |
213 | } |
214 | MDNodeToDieMap.insert(std::make_pair(Desc, D)); |
215 | } |
216 | |
217 | void DwarfUnit::insertDIE(DIE *D) { |
218 | MDNodeToDieMap.insert(std::make_pair(nullptr, D)); |
219 | } |
220 | |
221 | void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { |
222 | if (DD->getDwarfVersion() >= 4) |
223 | addAttribute(Die, Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1)); |
224 | else |
225 | addAttribute(Die, Attribute, dwarf::DW_FORM_flag, DIEInteger(1)); |
226 | } |
227 | |
228 | void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute, |
229 | Optional<dwarf::Form> Form, uint64_t Integer) { |
230 | if (!Form) |
231 | Form = DIEInteger::BestForm(false, Integer); |
232 | assert(Form != dwarf::DW_FORM_implicit_const && |
233 | "DW_FORM_implicit_const is used only for signed integers"); |
234 | addAttribute(Die, Attribute, *Form, DIEInteger(Integer)); |
235 | } |
236 | |
237 | void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form, |
238 | uint64_t Integer) { |
239 | addUInt(Block, (dwarf::Attribute)0, Form, Integer); |
240 | } |
241 | |
242 | void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute, |
243 | Optional<dwarf::Form> Form, int64_t Integer) { |
244 | if (!Form) |
245 | Form = DIEInteger::BestForm(true, Integer); |
246 | addAttribute(Die, Attribute, *Form, DIEInteger(Integer)); |
247 | } |
248 | |
249 | void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form, |
250 | int64_t Integer) { |
251 | addSInt(Die, (dwarf::Attribute)0, Form, Integer); |
252 | } |
253 | |
254 | void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, |
255 | StringRef String) { |
256 | if (CUNode->isDebugDirectivesOnly()) |
257 | return; |
258 | |
259 | if (DD->useInlineStrings()) { |
260 | addAttribute(Die, Attribute, dwarf::DW_FORM_string, |
261 | new (DIEValueAllocator) |
262 | DIEInlineString(String, DIEValueAllocator)); |
263 | return; |
264 | } |
265 | dwarf::Form IxForm = |
266 | isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp; |
267 | |
268 | auto StringPoolEntry = |
269 | useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index |
270 | ? DU->getStringPool().getIndexedEntry(*Asm, String) |
271 | : DU->getStringPool().getEntry(*Asm, String); |
272 | |
273 | |
274 | if (useSegmentedStringOffsetsTable()) { |
275 | IxForm = dwarf::DW_FORM_strx1; |
276 | unsigned Index = StringPoolEntry.getIndex(); |
277 | if (Index > 0xffffff) |
278 | IxForm = dwarf::DW_FORM_strx4; |
279 | else if (Index > 0xffff) |
280 | IxForm = dwarf::DW_FORM_strx3; |
281 | else if (Index > 0xff) |
282 | IxForm = dwarf::DW_FORM_strx2; |
283 | } |
284 | addAttribute(Die, Attribute, IxForm, DIEString(StringPoolEntry)); |
285 | } |
286 | |
287 | void DwarfUnit::addLabel(DIEValueList &Die, dwarf::Attribute Attribute, |
288 | dwarf::Form Form, const MCSymbol *Label) { |
289 | addAttribute(Die, Attribute, Form, DIELabel(Label)); |
290 | } |
291 | |
292 | void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) { |
293 | addLabel(Die, (dwarf::Attribute)0, Form, Label); |
294 | } |
295 | |
296 | void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute, |
297 | uint64_t Integer) { |
298 | addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer); |
299 | } |
300 | |
301 | unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) { |
302 | if (!SplitLineTable) |
303 | return getCU().getOrCreateSourceID(File); |
304 | if (!UsedLineTable) { |
305 | UsedLineTable = true; |
306 | |
307 | addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0); |
308 | } |
309 | return SplitLineTable->getFile( |
310 | File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), |
311 | Asm->OutContext.getDwarfVersion(), File->getSource()); |
312 | } |
313 | |
314 | void DwarfUnit::addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label) { |
315 | bool UseAddrOffsetFormOrExpressions = |
316 | DD->useAddrOffsetForm() || DD->useAddrOffsetExpressions(); |
317 | |
318 | const MCSymbol *Base = nullptr; |
319 | if (Label->isInSection() && UseAddrOffsetFormOrExpressions) |
320 | Base = DD->getSectionLabel(&Label->getSection()); |
321 | |
322 | uint32_t Index = DD->getAddressPool().getIndex(Base ? Base : Label); |
323 | |
324 | if (DD->getDwarfVersion() >= 5) { |
325 | addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx); |
326 | addUInt(Die, dwarf::DW_FORM_addrx, Index); |
327 | } else { |
328 | addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index); |
329 | addUInt(Die, dwarf::DW_FORM_GNU_addr_index, Index); |
330 | } |
331 | |
332 | if (Base && Base != Label) { |
333 | addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u); |
334 | addLabelDelta(Die, (dwarf::Attribute)0, Label, Base); |
335 | addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); |
336 | } |
337 | } |
338 | |
339 | void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) { |
340 | if (DD->getDwarfVersion() >= 5) { |
341 | addPoolOpAddress(Die, Sym); |
342 | return; |
343 | } |
344 | |
345 | if (DD->useSplitDwarf()) { |
346 | addPoolOpAddress(Die, Sym); |
347 | return; |
348 | } |
349 | |
350 | addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); |
351 | addLabel(Die, dwarf::DW_FORM_addr, Sym); |
352 | } |
353 | |
354 | void DwarfUnit::addLabelDelta(DIEValueList &Die, dwarf::Attribute Attribute, |
355 | const MCSymbol *Hi, const MCSymbol *Lo) { |
356 | addAttribute(Die, Attribute, dwarf::DW_FORM_data4, |
357 | new (DIEValueAllocator) DIEDelta(Hi, Lo)); |
358 | } |
359 | |
360 | void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) { |
361 | addDIEEntry(Die, Attribute, DIEEntry(Entry)); |
362 | } |
363 | |
364 | void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) { |
365 | |
366 | |
367 | |
368 | |
369 | addFlag(Die, dwarf::DW_AT_declaration); |
370 | |
371 | addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8, |
372 | DIEInteger(Signature)); |
373 | } |
374 | |
375 | void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, |
376 | DIEEntry Entry) { |
377 | const DIEUnit *CU = Die.getUnit(); |
378 | const DIEUnit *EntryCU = Entry.getEntry().getUnit(); |
379 | if (!CU) |
380 | |
381 | CU = getUnitDie().getUnit(); |
382 | if (!EntryCU) |
383 | EntryCU = getUnitDie().getUnit(); |
384 | addAttribute(Die, Attribute, |
385 | EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, |
386 | Entry); |
387 | } |
388 | |
389 | DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) { |
390 | DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, Tag)); |
391 | if (N) |
392 | insertDIE(N, &Die); |
393 | return Die; |
394 | } |
395 | |
396 | void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) { |
397 | Loc->ComputeSize(Asm); |
398 | DIELocs.push_back(Loc); |
399 | addAttribute(Die, Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc); |
400 | } |
401 | |
402 | void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, |
403 | DIEBlock *Block) { |
404 | Block->ComputeSize(Asm); |
405 | DIEBlocks.push_back(Block); |
406 | addAttribute(Die, Attribute, Form, Block); |
407 | } |
408 | |
409 | void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, |
410 | DIEBlock *Block) { |
411 | addBlock(Die, Attribute, Block->BestForm(), Block); |
412 | } |
413 | |
414 | void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) { |
415 | if (Line == 0) |
416 | return; |
417 | |
418 | unsigned FileID = getOrCreateSourceID(File); |
419 | addUInt(Die, dwarf::DW_AT_decl_file, None, FileID); |
420 | addUInt(Die, dwarf::DW_AT_decl_line, None, Line); |
421 | } |
422 | |
423 | void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) { |
424 | assert(V); |
425 | |
426 | addSourceLine(Die, V->getLine(), V->getFile()); |
427 | } |
428 | |
429 | void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) { |
430 | assert(G); |
431 | |
432 | addSourceLine(Die, G->getLine(), G->getFile()); |
433 | } |
434 | |
435 | void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) { |
436 | assert(SP); |
437 | |
438 | addSourceLine(Die, SP->getLine(), SP->getFile()); |
439 | } |
440 | |
441 | void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) { |
442 | assert(L); |
443 | |
444 | addSourceLine(Die, L->getLine(), L->getFile()); |
445 | } |
446 | |
447 | void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) { |
448 | assert(Ty); |
449 | |
450 | addSourceLine(Die, Ty->getLine(), Ty->getFile()); |
451 | } |
452 | |
453 | void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) { |
454 | assert(Ty); |
455 | |
456 | addSourceLine(Die, Ty->getLine(), Ty->getFile()); |
457 | } |
458 | |
459 | void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) { |
460 | |
461 | addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true); |
462 | } |
463 | |
464 | void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, |
465 | const DIType *Ty) { |
466 | addConstantValue(Die, CI->getValue(), Ty); |
467 | } |
468 | |
469 | void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) { |
470 | addConstantValue(Die, DD->isUnsignedDIType(Ty), Val); |
471 | } |
472 | |
473 | void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) { |
474 | |
475 | |
476 | addUInt(Die, dwarf::DW_AT_const_value, |
477 | Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val); |
478 | } |
479 | |
480 | void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) { |
481 | addConstantValue(Die, Val, DD->isUnsignedDIType(Ty)); |
482 | } |
483 | |
484 | void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) { |
485 | unsigned CIBitWidth = Val.getBitWidth(); |
486 | if (CIBitWidth <= 64) { |
487 | addConstantValue(Die, Unsigned, |
488 | Unsigned ? Val.getZExtValue() : Val.getSExtValue()); |
489 | return; |
490 | } |
491 | |
492 | DIEBlock *Block = new (DIEValueAllocator) DIEBlock; |
493 | |
494 | |
495 | const uint64_t *Ptr64 = Val.getRawData(); |
496 | |
497 | int NumBytes = Val.getBitWidth() / 8; |
498 | bool LittleEndian = Asm->getDataLayout().isLittleEndian(); |
499 | |
500 | |
501 | for (int i = 0; i < NumBytes; i++) { |
502 | uint8_t c; |
503 | if (LittleEndian) |
504 | c = Ptr64[i / 8] >> (8 * (i & 7)); |
505 | else |
506 | c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7)); |
507 | addUInt(*Block, dwarf::DW_FORM_data1, c); |
508 | } |
509 | |
510 | addBlock(Die, dwarf::DW_AT_const_value, Block); |
511 | } |
512 | |
513 | void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) { |
514 | if (!LinkageName.empty()) |
515 | addString(Die, |
516 | DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name |
517 | : dwarf::DW_AT_MIPS_linkage_name, |
518 | GlobalValue::dropLLVMManglingEscape(LinkageName)); |
519 | } |
520 | |
521 | void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) { |
522 | |
523 | for (const auto *Element : TParams) { |
524 | if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element)) |
| 1 | Assuming 'Element' is not a 'DITemplateTypeParameter' | |
|
| |
525 | constructTemplateTypeParameterDIE(Buffer, TTP); |
526 | else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element)) |
| 3 | | Assuming 'Element' is a 'DITemplateValueParameter' | |
|
| |
527 | constructTemplateValueParameterDIE(Buffer, TVP); |
| 5 | | Calling 'DwarfUnit::constructTemplateValueParameterDIE' | |
|
528 | } |
529 | } |
530 | |
531 | |
532 | void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) { |
533 | for (const auto *Ty : ThrownTypes) { |
534 | DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die); |
535 | addType(TT, cast<DIType>(Ty)); |
536 | } |
537 | } |
538 | |
539 | DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) { |
540 | if (!Context || isa<DIFile>(Context)) |
541 | return &getUnitDie(); |
542 | if (auto *T = dyn_cast<DIType>(Context)) |
543 | return getOrCreateTypeDIE(T); |
544 | if (auto *NS = dyn_cast<DINamespace>(Context)) |
545 | return getOrCreateNameSpace(NS); |
546 | if (auto *SP = dyn_cast<DISubprogram>(Context)) |
547 | return getOrCreateSubprogramDIE(SP); |
548 | if (auto *M = dyn_cast<DIModule>(Context)) |
549 | return getOrCreateModule(M); |
550 | return getDIE(Context); |
551 | } |
552 | |
553 | DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) { |
554 | auto *Context = Ty->getScope(); |
555 | DIE *ContextDIE = getOrCreateContextDIE(Context); |
556 | |
557 | if (DIE *TyDIE = getDIE(Ty)) |
558 | return TyDIE; |
559 | |
560 | |
561 | DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty); |
562 | |
563 | constructTypeDIE(TyDIE, cast<DICompositeType>(Ty)); |
564 | |
565 | updateAcceleratorTables(Context, Ty, TyDIE); |
566 | return &TyDIE; |
567 | } |
568 | |
569 | DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE, |
570 | const DIType *Ty) { |
571 | |
572 | DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty); |
573 | |
574 | updateAcceleratorTables(Context, Ty, TyDIE); |
575 | |
576 | if (auto *BT = dyn_cast<DIBasicType>(Ty)) |
| 17 | | Assuming 'Ty' is not a 'DIBasicType' | |
|
| |
577 | constructTypeDIE(TyDIE, BT); |
578 | else if (auto *ST = dyn_cast<DIStringType>(Ty)) |
| 19 | | Assuming 'Ty' is not a 'DIStringType' | |
|
| |
579 | constructTypeDIE(TyDIE, ST); |
580 | else if (auto *STy = dyn_cast<DISubroutineType>(Ty)) |
| 21 | | Assuming 'Ty' is not a 'DISubroutineType' | |
|
| |
581 | constructTypeDIE(TyDIE, STy); |
582 | else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) { |
| 23 | | Assuming 'Ty' is a 'DICompositeType' | |
|
| |
583 | if (DD->generateTypeUnits() && !Ty->isForwardDecl() && |
| 25 | | Assuming the condition is false | |
|
584 | (Ty->getRawName() || CTy->getRawIdentifier())) { |
585 | |
586 | if (MDString *TypeId = CTy->getRawIdentifier()) |
587 | DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy); |
588 | else { |
589 | auto X = DD->enterNonTypeUnitContext(); |
590 | finishNonUnitTypeDIE(TyDIE, CTy); |
591 | } |
592 | return &TyDIE; |
593 | } |
594 | constructTypeDIE(TyDIE, CTy); |
| 26 | | Calling 'DwarfUnit::constructTypeDIE' | |
|
595 | } else { |
596 | constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty)); |
597 | } |
598 | |
599 | return &TyDIE; |
600 | } |
601 | |
602 | DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) { |
603 | if (!TyNode) |
| |
604 | return nullptr; |
605 | |
606 | auto *Ty = cast<DIType>(TyNode); |
| |
607 | |
608 | |
609 | if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2) |
| 12 | | Assuming the condition is false | |
|
610 | return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); |
611 | |
612 | |
613 | if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5) |
| 13 | | Assuming the condition is false | |
|
614 | return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); |
615 | |
616 | |
617 | |
618 | auto *Context = Ty->getScope(); |
619 | DIE *ContextDIE = getOrCreateContextDIE(Context); |
620 | assert(ContextDIE); |
621 | |
622 | if (DIE *TyDIE = getDIE(Ty)) |
| 14 | | Assuming 'TyDIE' is null | |
|
| |
623 | return TyDIE; |
624 | |
625 | return static_cast<DwarfUnit *>(ContextDIE->getUnit()) |
| 16 | | Calling 'DwarfUnit::createTypeDIE' | |
|
626 | ->createTypeDIE(Context, *ContextDIE, Ty); |
627 | } |
628 | |
629 | void DwarfUnit::updateAcceleratorTables(const DIScope *Context, |
630 | const DIType *Ty, const DIE &TyDIE) { |
631 | if (!Ty->getName().empty() && !Ty->isForwardDecl()) { |
632 | bool IsImplementation = false; |
633 | if (auto *CT = dyn_cast<DICompositeType>(Ty)) { |
634 | |
635 | |
636 | IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete(); |
637 | } |
638 | unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0; |
639 | DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags); |
640 | |
641 | if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) || |
642 | isa<DINamespace>(Context) || isa<DICommonBlock>(Context)) |
643 | addGlobalType(Ty, TyDIE, Context); |
644 | } |
645 | } |
646 | |
647 | void DwarfUnit::addType(DIE &Entity, const DIType *Ty, |
648 | dwarf::Attribute Attribute) { |
649 | assert(Ty && "Trying to add a type that doesn't exist?"); |
650 | addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty))); |
| 9 | | Calling 'DwarfUnit::getOrCreateTypeDIE' | |
|
651 | } |
652 | |
653 | std::string DwarfUnit::getParentContextString(const DIScope *Context) const { |
654 | if (!Context) |
655 | return ""; |
656 | |
657 | |
658 | if (!dwarf::isCPlusPlus((dwarf::SourceLanguage)getLanguage())) |
659 | return ""; |
660 | |
661 | std::string CS; |
662 | SmallVector<const DIScope *, 1> Parents; |
663 | while (!isa<DICompileUnit>(Context)) { |
664 | Parents.push_back(Context); |
665 | if (const DIScope *S = Context->getScope()) |
666 | Context = S; |
667 | else |
668 | |
669 | |
670 | break; |
671 | } |
672 | |
673 | |
674 | |
675 | for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) { |
676 | StringRef Name = Ctx->getName(); |
677 | if (Name.empty() && isa<DINamespace>(Ctx)) |
678 | Name = "(anonymous namespace)"; |
679 | if (!Name.empty()) { |
680 | CS += Name; |
681 | CS += "::"; |
682 | } |
683 | } |
684 | return CS; |
685 | } |
686 | |
687 | void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) { |
688 | |
689 | StringRef Name = BTy->getName(); |
690 | |
691 | if (!Name.empty()) |
692 | addString(Buffer, dwarf::DW_AT_name, Name); |
693 | |
694 | |
695 | if (BTy->getTag() == dwarf::DW_TAG_unspecified_type) |
696 | return; |
697 | |
698 | if (BTy->getTag() != dwarf::DW_TAG_string_type) |
699 | addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, |
700 | BTy->getEncoding()); |
701 | |
702 | uint64_t Size = BTy->getSizeInBits() >> 3; |
703 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); |
704 | |
705 | if (BTy->isBigEndian()) |
706 | addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big); |
707 | else if (BTy->isLittleEndian()) |
708 | addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little); |
709 | } |
710 | |
711 | void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) { |
712 | |
713 | StringRef Name = STy->getName(); |
714 | |
715 | if (!Name.empty()) |
716 | addString(Buffer, dwarf::DW_AT_name, Name); |
717 | |
718 | if (DIVariable *Var = STy->getStringLength()) { |
719 | if (auto *VarDIE = getDIE(Var)) |
720 | addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE); |
721 | } else if (DIExpression *Expr = STy->getStringLengthExp()) { |
722 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
723 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
724 | |
725 | |
726 | |
727 | DwarfExpr.setMemoryLocationKind(); |
728 | DwarfExpr.addExpression(Expr); |
729 | addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize()); |
730 | } else { |
731 | uint64_t Size = STy->getSizeInBits() >> 3; |
732 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); |
733 | } |
734 | |
735 | if (STy->getEncoding()) { |
736 | |
737 | addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, |
738 | STy->getEncoding()); |
739 | } |
740 | } |
741 | |
742 | void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) { |
743 | |
744 | StringRef Name = DTy->getName(); |
745 | uint64_t Size = DTy->getSizeInBits() >> 3; |
746 | uint16_t Tag = Buffer.getTag(); |
747 | |
748 | |
749 | const DIType *FromTy = DTy->getBaseType(); |
750 | if (FromTy) |
751 | addType(Buffer, FromTy); |
752 | |
753 | |
754 | if (!Name.empty()) |
755 | addString(Buffer, dwarf::DW_AT_name, Name); |
756 | |
757 | |
758 | |
759 | if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) { |
760 | uint32_t AlignInBytes = DTy->getAlignInBytes(); |
761 | if (AlignInBytes > 0) |
762 | addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
763 | AlignInBytes); |
764 | } |
765 | |
766 | |
767 | if (Size && Tag != dwarf::DW_TAG_pointer_type |
768 | && Tag != dwarf::DW_TAG_ptr_to_member_type |
769 | && Tag != dwarf::DW_TAG_reference_type |
770 | && Tag != dwarf::DW_TAG_rvalue_reference_type) |
771 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); |
772 | |
773 | if (Tag == dwarf::DW_TAG_ptr_to_member_type) |
774 | addDIEEntry(Buffer, dwarf::DW_AT_containing_type, |
775 | *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType())); |
776 | |
777 | if (!DTy->isForwardDecl()) |
778 | addSourceLine(Buffer, DTy); |
779 | |
780 | |
781 | |
782 | |
783 | if (DTy->getDWARFAddressSpace()) |
784 | addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4, |
785 | DTy->getDWARFAddressSpace().getValue()); |
786 | } |
787 | |
788 | void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) { |
789 | for (unsigned i = 1, N = Args.size(); i < N; ++i) { |
790 | const DIType *Ty = Args[i]; |
791 | if (!Ty) { |
792 | assert(i == N-1 && "Unspecified parameter must be the last argument"); |
793 | createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer); |
794 | } else { |
795 | DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer); |
796 | addType(Arg, Ty); |
797 | if (Ty->isArtificial()) |
798 | addFlag(Arg, dwarf::DW_AT_artificial); |
799 | } |
800 | } |
801 | } |
802 | |
803 | void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) { |
804 | |
805 | auto Elements = cast<DISubroutineType>(CTy)->getTypeArray(); |
806 | if (Elements.size()) |
807 | if (auto RTy = Elements[0]) |
808 | addType(Buffer, RTy); |
809 | |
810 | bool isPrototyped = true; |
811 | if (Elements.size() == 2 && !Elements[1]) |
812 | isPrototyped = false; |
813 | |
814 | constructSubprogramArguments(Buffer, Elements); |
815 | |
816 | |
817 | |
818 | uint16_t Language = getLanguage(); |
819 | if (isPrototyped && |
820 | (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || |
821 | Language == dwarf::DW_LANG_ObjC)) |
822 | addFlag(Buffer, dwarf::DW_AT_prototyped); |
823 | |
824 | |
825 | if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal) |
826 | addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, |
827 | CTy->getCC()); |
828 | |
829 | if (CTy->isLValueReference()) |
830 | addFlag(Buffer, dwarf::DW_AT_reference); |
831 | |
832 | if (CTy->isRValueReference()) |
833 | addFlag(Buffer, dwarf::DW_AT_rvalue_reference); |
834 | } |
835 | |
836 | void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) { |
837 | |
838 | StringRef Name = CTy->getName(); |
839 | |
840 | uint64_t Size = CTy->getSizeInBits() >> 3; |
841 | uint16_t Tag = Buffer.getTag(); |
842 | |
843 | switch (Tag) { |
| 27 | | Control jumps to 'case DW_TAG_variant_part:' at line 850 | |
|
844 | case dwarf::DW_TAG_array_type: |
845 | constructArrayTypeDIE(Buffer, CTy); |
846 | break; |
847 | case dwarf::DW_TAG_enumeration_type: |
848 | constructEnumTypeDIE(Buffer, CTy); |
849 | break; |
850 | case dwarf::DW_TAG_variant_part: |
851 | case dwarf::DW_TAG_structure_type: |
852 | case dwarf::DW_TAG_union_type: |
853 | case dwarf::DW_TAG_class_type: { |
854 | |
855 | DIDerivedType *Discriminator = nullptr; |
856 | if (Tag == dwarf::DW_TAG_variant_part) { |
| |
857 | Discriminator = CTy->getDiscriminator(); |
| 29 | | Value assigned to 'Discriminator' | |
|
858 | if (Discriminator) { |
| 30 | | Assuming 'Discriminator' is null | |
|
| 31 | | Assuming pointer value is null | |
|
| |
859 | |
860 | |
861 | |
862 | |
863 | DIE &DiscMember = constructMemberDIE(Buffer, Discriminator); |
864 | addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember); |
865 | } |
866 | } |
867 | |
868 | |
869 | if (Tag == dwarf::DW_TAG_class_type || |
| |
870 | Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) |
871 | addTemplateParams(Buffer, CTy->getTemplateParams()); |
872 | |
873 | |
874 | DINodeArray Elements = CTy->getElements(); |
875 | for (const auto *Element : Elements) { |
876 | if (!Element) |
| 34 | | Assuming 'Element' is non-null | |
|
| |
877 | continue; |
878 | if (auto *SP = dyn_cast<DISubprogram>(Element)) |
| 36 | | Assuming 'Element' is not a 'DISubprogram' | |
|
| |
879 | getOrCreateSubprogramDIE(SP); |
880 | else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) { |
| 38 | | Assuming 'Element' is a 'DIDerivedType' | |
|
| |
881 | if (DDTy->getTag() == dwarf::DW_TAG_friend) { |
| 40 | | Assuming the condition is false | |
|
| |
882 | DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); |
883 | addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend); |
884 | } else if (DDTy->isStaticMember()) { |
| 42 | | Assuming the condition is false | |
|
| |
885 | getOrCreateStaticMemberDIE(DDTy); |
886 | } else if (Tag == dwarf::DW_TAG_variant_part) { |
| |
887 | |
888 | |
889 | DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer); |
890 | if (const ConstantInt *CI = |
| |
891 | dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) { |
| 45 | | Assuming the object is a 'ConstantInt' | |
|
892 | if (DD->isUnsignedDIType(Discriminator->getBaseType())) |
| 47 | | Called C++ object pointer is null |
|
893 | addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue()); |
894 | else |
895 | addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue()); |
896 | } |
897 | constructMemberDIE(Variant, DDTy); |
898 | } else { |
899 | constructMemberDIE(Buffer, DDTy); |
900 | } |
901 | } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) { |
902 | DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer); |
903 | StringRef PropertyName = Property->getName(); |
904 | addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); |
905 | if (Property->getType()) |
906 | addType(ElemDie, Property->getType()); |
907 | addSourceLine(ElemDie, Property); |
908 | StringRef GetterName = Property->getGetterName(); |
909 | if (!GetterName.empty()) |
910 | addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); |
911 | StringRef SetterName = Property->getSetterName(); |
912 | if (!SetterName.empty()) |
913 | addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); |
914 | if (unsigned PropertyAttributes = Property->getAttributes()) |
915 | addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None, |
916 | PropertyAttributes); |
917 | } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) { |
918 | if (Composite->getTag() == dwarf::DW_TAG_variant_part) { |
919 | DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer); |
920 | constructTypeDIE(VariantPart, Composite); |
921 | } |
922 | } |
923 | } |
924 | |
925 | if (CTy->isAppleBlockExtension()) |
926 | addFlag(Buffer, dwarf::DW_AT_APPLE_block); |
927 | |
928 | if (CTy->getExportSymbols()) |
929 | addFlag(Buffer, dwarf::DW_AT_export_symbols); |
930 | |
931 | |
932 | |
933 | |
934 | |
935 | if (auto *ContainingType = CTy->getVTableHolder()) |
936 | addDIEEntry(Buffer, dwarf::DW_AT_containing_type, |
937 | *getOrCreateTypeDIE(ContainingType)); |
938 | |
939 | if (CTy->isObjcClassComplete()) |
940 | addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type); |
941 | |
942 | |
943 | |
944 | if (!Asm->TM.Options.DebugStrictDwarf || DD->getDwarfVersion() >= 5) { |
945 | uint8_t CC = 0; |
946 | if (CTy->isTypePassByValue()) |
947 | CC = dwarf::DW_CC_pass_by_value; |
948 | else if (CTy->isTypePassByReference()) |
949 | CC = dwarf::DW_CC_pass_by_reference; |
950 | if (CC) |
951 | addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, |
952 | CC); |
953 | } |
954 | break; |
955 | } |
956 | default: |
957 | break; |
958 | } |
959 | |
960 | |
961 | if (!Name.empty()) |
962 | addString(Buffer, dwarf::DW_AT_name, Name); |
963 | |
964 | if (Tag == dwarf::DW_TAG_enumeration_type || |
965 | Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type || |
966 | Tag == dwarf::DW_TAG_union_type) { |
967 | |
968 | |
969 | |
970 | if (Size && |
971 | (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type)) |
972 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); |
973 | else if (!CTy->isForwardDecl()) |
974 | |
975 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); |
976 | |
977 | |
978 | if (CTy->isForwardDecl()) |
979 | addFlag(Buffer, dwarf::DW_AT_declaration); |
980 | |
981 | |
982 | if (!CTy->isForwardDecl()) |
983 | addSourceLine(Buffer, CTy); |
984 | |
985 | |
986 | unsigned RLang = CTy->getRuntimeLang(); |
987 | if (RLang) |
988 | addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1, |
989 | RLang); |
990 | |
991 | |
992 | if (uint32_t AlignInBytes = CTy->getAlignInBytes()) |
993 | addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
994 | AlignInBytes); |
995 | } |
996 | } |
997 | |
998 | void DwarfUnit::constructTemplateTypeParameterDIE( |
999 | DIE &Buffer, const DITemplateTypeParameter *TP) { |
1000 | DIE &ParamDIE = |
1001 | createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer); |
1002 | |
1003 | if (TP->getType()) |
1004 | addType(ParamDIE, TP->getType()); |
1005 | if (!TP->getName().empty()) |
1006 | addString(ParamDIE, dwarf::DW_AT_name, TP->getName()); |
1007 | if (TP->isDefault() && (DD->getDwarfVersion() >= 5)) |
1008 | addFlag(ParamDIE, dwarf::DW_AT_default_value); |
1009 | } |
1010 | |
1011 | void DwarfUnit::constructTemplateValueParameterDIE( |
1012 | DIE &Buffer, const DITemplateValueParameter *VP) { |
1013 | DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer); |
1014 | |
1015 | |
1016 | |
1017 | if (VP->getTag() == dwarf::DW_TAG_template_value_parameter) |
| 6 | | Assuming the condition is true | |
|
| |
1018 | addType(ParamDIE, VP->getType()); |
| 8 | | Calling 'DwarfUnit::addType' | |
|
1019 | if (!VP->getName().empty()) |
1020 | addString(ParamDIE, dwarf::DW_AT_name, VP->getName()); |
1021 | if (VP->isDefault() && (DD->getDwarfVersion() >= 5)) |
1022 | addFlag(ParamDIE, dwarf::DW_AT_default_value); |
1023 | if (Metadata *Val = VP->getValue()) { |
1024 | if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val)) |
1025 | addConstantValue(ParamDIE, CI, VP->getType()); |
1026 | else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) { |
1027 | |
1028 | |
1029 | if (!GV->hasDLLImportStorageClass()) { |
1030 | |
1031 | |
1032 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1033 | addOpAddress(*Loc, Asm->getSymbol(GV)); |
1034 | |
1035 | |
1036 | addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); |
1037 | addBlock(ParamDIE, dwarf::DW_AT_location, Loc); |
1038 | } |
1039 | } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) { |
1040 | assert(isa<MDString>(Val)); |
1041 | addString(ParamDIE, dwarf::DW_AT_GNU_template_name, |
1042 | cast<MDString>(Val)->getString()); |
1043 | } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) { |
1044 | addTemplateParams(ParamDIE, cast<MDTuple>(Val)); |
1045 | } |
1046 | } |
1047 | } |
1048 | |
1049 | DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) { |
1050 | |
1051 | |
1052 | DIE *ContextDIE = getOrCreateContextDIE(NS->getScope()); |
1053 | |
1054 | if (DIE *NDie = getDIE(NS)) |
1055 | return NDie; |
1056 | DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS); |
1057 | |
1058 | StringRef Name = NS->getName(); |
1059 | if (!Name.empty()) |
1060 | addString(NDie, dwarf::DW_AT_name, NS->getName()); |
1061 | else |
1062 | Name = "(anonymous namespace)"; |
1063 | DD->addAccelNamespace(*CUNode, Name, NDie); |
1064 | addGlobalName(Name, NDie, NS->getScope()); |
1065 | if (NS->getExportSymbols()) |
1066 | addFlag(NDie, dwarf::DW_AT_export_symbols); |
1067 | return &NDie; |
1068 | } |
1069 | |
1070 | DIE *DwarfUnit::getOrCreateModule(const DIModule *M) { |
1071 | |
1072 | |
1073 | DIE *ContextDIE = getOrCreateContextDIE(M->getScope()); |
1074 | |
1075 | if (DIE *MDie = getDIE(M)) |
1076 | return MDie; |
1077 | DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M); |
1078 | |
1079 | if (!M->getName().empty()) { |
1080 | addString(MDie, dwarf::DW_AT_name, M->getName()); |
1081 | addGlobalName(M->getName(), MDie, M->getScope()); |
1082 | } |
1083 | if (!M->getConfigurationMacros().empty()) |
1084 | addString(MDie, dwarf::DW_AT_LLVM_config_macros, |
1085 | M->getConfigurationMacros()); |
1086 | if (!M->getIncludePath().empty()) |
1087 | addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath()); |
1088 | if (!M->getAPINotesFile().empty()) |
1089 | addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile()); |
1090 | if (M->getFile()) |
1091 | addUInt(MDie, dwarf::DW_AT_decl_file, None, |
1092 | getOrCreateSourceID(M->getFile())); |
1093 | if (M->getLineNo()) |
1094 | addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo()); |
1095 | if (M->getIsDecl()) |
1096 | addFlag(MDie, dwarf::DW_AT_declaration); |
1097 | |
1098 | return &MDie; |
1099 | } |
1100 | |
1101 | DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) { |
1102 | |
1103 | |
1104 | |
1105 | DIE *ContextDIE = |
1106 | Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope()); |
1107 | |
1108 | if (DIE *SPDie = getDIE(SP)) |
1109 | return SPDie; |
1110 | |
1111 | if (auto *SPDecl = SP->getDeclaration()) { |
1112 | if (!Minimal) { |
1113 | |
1114 | ContextDIE = &getUnitDie(); |
1115 | |
1116 | getOrCreateSubprogramDIE(SPDecl); |
1117 | } |
1118 | } |
1119 | |
1120 | |
1121 | DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); |
1122 | |
1123 | |
1124 | |
1125 | if (SP->isDefinition()) |
1126 | return &SPDie; |
1127 | |
1128 | static_cast<DwarfUnit *>(SPDie.getUnit()) |
1129 | ->applySubprogramAttributes(SP, SPDie); |
1130 | return &SPDie; |
1131 | } |
1132 | |
1133 | bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP, |
1134 | DIE &SPDie, bool Minimal) { |
1135 | DIE *DeclDie = nullptr; |
1136 | StringRef DeclLinkageName; |
1137 | if (auto *SPDecl = SP->getDeclaration()) { |
1138 | if (!Minimal) { |
1139 | DITypeRefArray DeclArgs, DefinitionArgs; |
1140 | DeclArgs = SPDecl->getType()->getTypeArray(); |
1141 | DefinitionArgs = SP->getType()->getTypeArray(); |
1142 | |
1143 | if (DeclArgs.size() && DefinitionArgs.size()) |
1144 | if (DefinitionArgs[0] != NULL && DeclArgs[0] != DefinitionArgs[0]) |
1145 | addType(SPDie, DefinitionArgs[0]); |
1146 | |
1147 | DeclDie = getDIE(SPDecl); |
1148 | assert(DeclDie && "This DIE should've already been constructed when the " |
1149 | "definition DIE was created in " |
1150 | "getOrCreateSubprogramDIE"); |
1151 | |
1152 | if (DD->useAllLinkageNames()) |
1153 | DeclLinkageName = SPDecl->getLinkageName(); |
1154 | unsigned DeclID = getOrCreateSourceID(SPDecl->getFile()); |
1155 | unsigned DefID = getOrCreateSourceID(SP->getFile()); |
1156 | if (DeclID != DefID) |
1157 | addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID); |
1158 | |
1159 | if (SP->getLine() != SPDecl->getLine()) |
1160 | addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine()); |
1161 | } |
1162 | } |
1163 | |
1164 | |
1165 | addTemplateParams(SPDie, SP->getTemplateParams()); |
1166 | |
1167 | |
1168 | StringRef LinkageName = SP->getLinkageName(); |
1169 | assert(((LinkageName.empty() || DeclLinkageName.empty()) || |
1170 | LinkageName == DeclLinkageName) && |
1171 | "decl has a linkage name and it is different"); |
1172 | if (DeclLinkageName.empty() && |
1173 | |
1174 | (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP))) |
1175 | addLinkageName(SPDie, LinkageName); |
1176 | |
1177 | if (!DeclDie) |
1178 | return false; |
1179 | |
1180 | |
1181 | |
1182 | addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie); |
1183 | return true; |
1184 | } |
1185 | |
1186 | void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, |
1187 | bool SkipSPAttributes) { |
1188 | |
1189 | |
1190 | bool SkipSPSourceLocation = SkipSPAttributes && |
1191 | !CUNode->getDebugInfoForProfiling(); |
1192 | if (!SkipSPSourceLocation) |
1193 | if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes)) |
1194 | return; |
1195 | |
1196 | |
1197 | if (!SP->getName().empty()) |
1198 | addString(SPDie, dwarf::DW_AT_name, SP->getName()); |
1199 | |
1200 | if (!SkipSPSourceLocation) |
1201 | addSourceLine(SPDie, SP); |
1202 | |
1203 | |
1204 | if (SkipSPAttributes) |
1205 | return; |
1206 | |
1207 | |
1208 | |
1209 | uint16_t Language = getLanguage(); |
1210 | if (SP->isPrototyped() && |
1211 | (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || |
1212 | Language == dwarf::DW_LANG_ObjC)) |
1213 | addFlag(SPDie, dwarf::DW_AT_prototyped); |
1214 | |
1215 | if (SP->isObjCDirect()) |
1216 | addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct); |
1217 | |
1218 | unsigned CC = 0; |
1219 | DITypeRefArray Args; |
1220 | if (const DISubroutineType *SPTy = SP->getType()) { |
1221 | Args = SPTy->getTypeArray(); |
1222 | CC = SPTy->getCC(); |
1223 | } |
1224 | |
1225 | |
1226 | if (CC && CC != dwarf::DW_CC_normal) |
1227 | addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC); |
1228 | |
1229 | |
1230 | |
1231 | if (Args.size()) |
1232 | if (auto Ty = Args[0]) |
1233 | addType(SPDie, Ty); |
1234 | |
1235 | unsigned VK = SP->getVirtuality(); |
1236 | if (VK) { |
1237 | addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); |
1238 | if (SP->getVirtualIndex() != -1u) { |
1239 | DIELoc *Block = getDIELoc(); |
1240 | addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); |
1241 | addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex()); |
1242 | addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block); |
1243 | } |
1244 | ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType())); |
1245 | } |
1246 | |
1247 | if (!SP->isDefinition()) { |
1248 | addFlag(SPDie, dwarf::DW_AT_declaration); |
1249 | |
1250 | |
1251 | |
1252 | constructSubprogramArguments(SPDie, Args); |
1253 | } |
1254 | |
1255 | addThrownTypes(SPDie, SP->getThrownTypes()); |
1256 | |
1257 | if (SP->isArtificial()) |
1258 | addFlag(SPDie, dwarf::DW_AT_artificial); |
1259 | |
1260 | if (!SP->isLocalToUnit()) |
1261 | addFlag(SPDie, dwarf::DW_AT_external); |
1262 | |
1263 | if (DD->useAppleExtensionAttributes()) { |
1264 | if (SP->isOptimized()) |
1265 | addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); |
1266 | |
1267 | if (unsigned isa = Asm->getISAEncoding()) |
1268 | addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); |
1269 | } |
1270 | |
1271 | if (SP->isLValueReference()) |
1272 | addFlag(SPDie, dwarf::DW_AT_reference); |
1273 | |
1274 | if (SP->isRValueReference()) |
1275 | addFlag(SPDie, dwarf::DW_AT_rvalue_reference); |
1276 | |
1277 | if (SP->isNoReturn()) |
1278 | addFlag(SPDie, dwarf::DW_AT_noreturn); |
1279 | |
1280 | if (SP->isProtected()) |
1281 | addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1282 | dwarf::DW_ACCESS_protected); |
1283 | else if (SP->isPrivate()) |
1284 | addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1285 | dwarf::DW_ACCESS_private); |
1286 | else if (SP->isPublic()) |
1287 | addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1288 | dwarf::DW_ACCESS_public); |
1289 | |
1290 | if (SP->isExplicit()) |
1291 | addFlag(SPDie, dwarf::DW_AT_explicit); |
1292 | |
1293 | if (SP->isMainSubprogram()) |
1294 | addFlag(SPDie, dwarf::DW_AT_main_subprogram); |
1295 | if (SP->isPure()) |
1296 | addFlag(SPDie, dwarf::DW_AT_pure); |
1297 | if (SP->isElemental()) |
1298 | addFlag(SPDie, dwarf::DW_AT_elemental); |
1299 | if (SP->isRecursive()) |
1300 | addFlag(SPDie, dwarf::DW_AT_recursive); |
1301 | |
1302 | if (DD->getDwarfVersion() >= 5 && SP->isDeleted()) |
1303 | addFlag(SPDie, dwarf::DW_AT_deleted); |
1304 | } |
1305 | |
1306 | void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, |
1307 | DIE *IndexTy) { |
1308 | DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer); |
1309 | addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy); |
1310 | |
1311 | |
1312 | |
1313 | |
1314 | |
1315 | int64_t DefaultLowerBound = getDefaultLowerBound(); |
1316 | |
1317 | auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, |
1318 | DISubrange::BoundType Bound) -> void { |
1319 | if (auto *BV = Bound.dyn_cast<DIVariable *>()) { |
1320 | if (auto *VarDIE = getDIE(BV)) |
1321 | addDIEEntry(DW_Subrange, Attr, *VarDIE); |
1322 | } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) { |
1323 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1324 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1325 | DwarfExpr.setMemoryLocationKind(); |
1326 | DwarfExpr.addExpression(BE); |
1327 | addBlock(DW_Subrange, Attr, DwarfExpr.finalize()); |
1328 | } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) { |
1329 | if (Attr == dwarf::DW_AT_count) { |
1330 | if (BI->getSExtValue() != -1) |
1331 | addUInt(DW_Subrange, Attr, None, BI->getSExtValue()); |
1332 | } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || |
1333 | BI->getSExtValue() != DefaultLowerBound) |
1334 | addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue()); |
1335 | } |
1336 | }; |
1337 | |
1338 | AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound()); |
1339 | |
1340 | AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount()); |
1341 | |
1342 | AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound()); |
1343 | |
1344 | AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride()); |
1345 | } |
1346 | |
1347 | void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer, |
1348 | const DIGenericSubrange *GSR, |
1349 | DIE *IndexTy) { |
1350 | DIE &DwGenericSubrange = |
1351 | createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer); |
1352 | addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy); |
1353 | |
1354 | int64_t DefaultLowerBound = getDefaultLowerBound(); |
1355 | |
1356 | auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, |
1357 | DIGenericSubrange::BoundType Bound) -> void { |
1358 | if (auto *BV = Bound.dyn_cast<DIVariable *>()) { |
1359 | if (auto *VarDIE = getDIE(BV)) |
1360 | addDIEEntry(DwGenericSubrange, Attr, *VarDIE); |
1361 | } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) { |
1362 | if (BE->isConstant() && |
1363 | DIExpression::SignedOrUnsignedConstant::SignedConstant == |
1364 | *BE->isConstant()) { |
1365 | if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || |
1366 | static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound) |
1367 | addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata, |
1368 | BE->getElement(1)); |
1369 | } else { |
1370 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1371 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1372 | DwarfExpr.setMemoryLocationKind(); |
1373 | DwarfExpr.addExpression(BE); |
1374 | addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize()); |
1375 | } |
1376 | } |
1377 | }; |
1378 | |
1379 | AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound()); |
1380 | AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount()); |
1381 | AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound()); |
1382 | AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride()); |
1383 | } |
1384 | |
1385 | DIE *DwarfUnit::getIndexTyDie() { |
1386 | if (IndexTyDie) |
1387 | return IndexTyDie; |
1388 | |
1389 | IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie()); |
1390 | StringRef Name = "__ARRAY_SIZE_TYPE__"; |
1391 | addString(*IndexTyDie, dwarf::DW_AT_name, Name); |
1392 | addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t)); |
1393 | addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, |
1394 | dwarf::DW_ATE_unsigned); |
1395 | DD->addAccelType(*CUNode, Name, *IndexTyDie, 0); |
1396 | return IndexTyDie; |
1397 | } |
1398 | |
1399 | |
1400 | |
1401 | |
1402 | static bool hasVectorBeenPadded(const DICompositeType *CTy) { |
1403 | assert(CTy && CTy->isVector() && "Composite type is not a vector"); |
1404 | const uint64_t ActualSize = CTy->getSizeInBits(); |
1405 | |
1406 | |
1407 | DIType *BaseTy = CTy->getBaseType(); |
1408 | assert(BaseTy && "Unknown vector element type."); |
1409 | const uint64_t ElementSize = BaseTy->getSizeInBits(); |
1410 | |
1411 | |
1412 | const DINodeArray Elements = CTy->getElements(); |
1413 | assert(Elements.size() == 1 && |
1414 | Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && |
1415 | "Invalid vector element array, expected one element of type subrange"); |
1416 | const auto Subrange = cast<DISubrange>(Elements[0]); |
1417 | const auto NumVecElements = |
1418 | Subrange->getCount() |
1419 | ? Subrange->getCount().get<ConstantInt *>()->getSExtValue() |
1420 | : 0; |
1421 | |
1422 | |
1423 | |
1424 | assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size"); |
1425 | return ActualSize != (NumVecElements * ElementSize); |
1426 | } |
1427 | |
1428 | void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) { |
1429 | if (CTy->isVector()) { |
1430 | addFlag(Buffer, dwarf::DW_AT_GNU_vector); |
1431 | if (hasVectorBeenPadded(CTy)) |
1432 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, |
1433 | CTy->getSizeInBits() / CHAR_BIT); |
1434 | } |
1435 | |
1436 | if (DIVariable *Var = CTy->getDataLocation()) { |
1437 | if (auto *VarDIE = getDIE(Var)) |
1438 | addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE); |
1439 | } else if (DIExpression *Expr = CTy->getDataLocationExp()) { |
1440 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1441 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1442 | DwarfExpr.setMemoryLocationKind(); |
1443 | DwarfExpr.addExpression(Expr); |
1444 | addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize()); |
1445 | } |
1446 | |
1447 | if (DIVariable *Var = CTy->getAssociated()) { |
1448 | if (auto *VarDIE = getDIE(Var)) |
1449 | addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE); |
1450 | } else if (DIExpression *Expr = CTy->getAssociatedExp()) { |
1451 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1452 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1453 | DwarfExpr.setMemoryLocationKind(); |
1454 | DwarfExpr.addExpression(Expr); |
1455 | addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize()); |
1456 | } |
1457 | |
1458 | if (DIVariable *Var = CTy->getAllocated()) { |
1459 | if (auto *VarDIE = getDIE(Var)) |
1460 | addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE); |
1461 | } else if (DIExpression *Expr = CTy->getAllocatedExp()) { |
1462 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1463 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1464 | DwarfExpr.setMemoryLocationKind(); |
1465 | DwarfExpr.addExpression(Expr); |
1466 | addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize()); |
1467 | } |
1468 | |
1469 | if (auto *RankConst = CTy->getRankConst()) { |
1470 | addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata, |
1471 | RankConst->getSExtValue()); |
1472 | } else if (auto *RankExpr = CTy->getRankExp()) { |
1473 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; |
1474 | DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); |
1475 | DwarfExpr.setMemoryLocationKind(); |
1476 | DwarfExpr.addExpression(RankExpr); |
1477 | addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize()); |
1478 | } |
1479 | |
1480 | |
1481 | addType(Buffer, CTy->getBaseType()); |
1482 | |
1483 | |
1484 | |
1485 | |
1486 | DIE *IdxTy = getIndexTyDie(); |
1487 | |
1488 | |
1489 | DINodeArray Elements = CTy->getElements(); |
1490 | for (DINode *E : Elements) { |
1491 | |
1492 | if (auto *Element = dyn_cast_or_null<DINode>(E)) { |
1493 | if (Element->getTag() == dwarf::DW_TAG_subrange_type) |
1494 | constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy); |
1495 | else if (Element->getTag() == dwarf::DW_TAG_generic_subrange) |
1496 | constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element), |
1497 | IdxTy); |
1498 | } |
1499 | } |
1500 | } |
1501 | |
1502 | void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) { |
1503 | const DIType *DTy = CTy->getBaseType(); |
1504 | bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy); |
1505 | if (DTy) { |
1506 | if (DD->getDwarfVersion() >= 3) |
1507 | addType(Buffer, DTy); |
1508 | if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass)) |
1509 | addFlag(Buffer, dwarf::DW_AT_enum_class); |
1510 | } |
1511 | |
1512 | auto *Context = CTy->getScope(); |
1513 | bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) || |
1514 | isa<DINamespace>(Context) || isa<DICommonBlock>(Context); |
1515 | DINodeArray Elements = CTy->getElements(); |
1516 | |
1517 | |
1518 | for (const DINode *E : Elements) { |
1519 | auto *Enum = dyn_cast_or_null<DIEnumerator>(E); |
1520 | if (Enum) { |
1521 | DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); |
1522 | StringRef Name = Enum->getName(); |
1523 | addString(Enumerator, dwarf::DW_AT_name, Name); |
1524 | addConstantValue(Enumerator, Enum->getValue(), IsUnsigned); |
1525 | if (IndexEnumerators) |
1526 | addGlobalName(Name, Enumerator, Context); |
1527 | } |
1528 | } |
1529 | } |
1530 | |
1531 | void DwarfUnit::constructContainingTypeDIEs() { |
1532 | for (auto &P : ContainingTypeMap) { |
1533 | DIE &SPDie = *P.first; |
1534 | const DINode *D = P.second; |
1535 | if (!D) |
1536 | continue; |
1537 | DIE *NDie = getDIE(D); |
1538 | if (!NDie) |
1539 | continue; |
1540 | addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie); |
1541 | } |
1542 | } |
1543 | |
1544 | DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) { |
1545 | DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer); |
1546 | StringRef Name = DT->getName(); |
1547 | if (!Name.empty()) |
1548 | addString(MemberDie, dwarf::DW_AT_name, Name); |
1549 | |
1550 | if (DIType *Resolved = DT->getBaseType()) |
1551 | addType(MemberDie, Resolved); |
1552 | |
1553 | addSourceLine(MemberDie, DT); |
1554 | |
1555 | if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) { |
1556 | |
1557 | |
1558 | |
1559 | |
1560 | |
1561 | DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc; |
1562 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); |
1563 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); |
1564 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); |
1565 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits()); |
1566 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); |
1567 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); |
1568 | addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); |
1569 | |
1570 | addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie); |
1571 | } else { |
1572 | uint64_t Size = DT->getSizeInBits(); |
1573 | uint64_t FieldSize = DD->getBaseTypeSize(DT); |
1574 | uint32_t AlignInBytes = DT->getAlignInBytes(); |
1575 | uint64_t OffsetInBytes; |
1576 | |
1577 | bool IsBitfield = FieldSize && Size != FieldSize; |
1578 | if (IsBitfield) { |
1579 | |
1580 | if (DD->useDWARF2Bitfields()) |
1581 | addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8); |
1582 | addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size); |
1583 | |
1584 | uint64_t Offset = DT->getOffsetInBits(); |
1585 | |
1586 | |
1587 | |
1588 | uint32_t AlignInBits = FieldSize; |
1589 | uint32_t AlignMask = ~(AlignInBits - 1); |
1590 | |
1591 | uint64_t StartBitOffset = Offset - (Offset & AlignMask); |
1592 | |
1593 | OffsetInBytes = (Offset - StartBitOffset) / 8; |
1594 | |
1595 | if (DD->useDWARF2Bitfields()) { |
1596 | uint64_t HiMark = (Offset + FieldSize) & AlignMask; |
1597 | uint64_t FieldOffset = (HiMark - FieldSize); |
1598 | Offset -= FieldOffset; |
1599 | |
1600 | |
1601 | if (Asm->getDataLayout().isLittleEndian()) |
1602 | Offset = FieldSize - (Offset + Size); |
1603 | |
1604 | addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset); |
1605 | OffsetInBytes = FieldOffset >> 3; |
1606 | } else { |
1607 | addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset); |
1608 | } |
1609 | } else { |
1610 | |
1611 | OffsetInBytes = DT->getOffsetInBits() / 8; |
1612 | if (AlignInBytes) |
1613 | addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
1614 | AlignInBytes); |
1615 | } |
1616 | |
1617 | if (DD->getDwarfVersion() <= 2) { |
1618 | DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc; |
1619 | addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); |
1620 | addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes); |
1621 | addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie); |
1622 | } else if (!IsBitfield || DD->useDWARF2Bitfields()) { |
1623 | |
1624 | |
1625 | |
1626 | |
1627 | if (DD->getDwarfVersion() == 3) |
1628 | addUInt(MemberDie, dwarf::DW_AT_data_member_location, |
1629 | dwarf::DW_FORM_udata, OffsetInBytes); |
1630 | else |
1631 | addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, |
1632 | OffsetInBytes); |
1633 | } |
1634 | } |
1635 | |
1636 | if (DT->isProtected()) |
1637 | addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1638 | dwarf::DW_ACCESS_protected); |
1639 | else if (DT->isPrivate()) |
1640 | addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1641 | dwarf::DW_ACCESS_private); |
1642 | |
1643 | else if (DT->isPublic()) |
1644 | addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1645 | dwarf::DW_ACCESS_public); |
1646 | if (DT->isVirtual()) |
1647 | addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, |
1648 | dwarf::DW_VIRTUALITY_virtual); |
1649 | |
1650 | |
1651 | if (DINode *PNode = DT->getObjCProperty()) |
1652 | if (DIE *PDie = getDIE(PNode)) |
1653 | addAttribute(MemberDie, dwarf::DW_AT_APPLE_property, |
1654 | dwarf::DW_FORM_ref4, DIEEntry(*PDie)); |
1655 | |
1656 | if (DT->isArtificial()) |
1657 | addFlag(MemberDie, dwarf::DW_AT_artificial); |
1658 | |
1659 | return MemberDie; |
1660 | } |
1661 | |
1662 | DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) { |
1663 | if (!DT) |
1664 | return nullptr; |
1665 | |
1666 | |
1667 | |
1668 | DIE *ContextDIE = getOrCreateContextDIE(DT->getScope()); |
1669 | assert(dwarf::isType(ContextDIE->getTag()) && |
1670 | "Static member should belong to a type."); |
1671 | |
1672 | if (DIE *StaticMemberDIE = getDIE(DT)) |
1673 | return StaticMemberDIE; |
1674 | |
1675 | DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT); |
1676 | |
1677 | const DIType *Ty = DT->getBaseType(); |
1678 | |
1679 | addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName()); |
1680 | addType(StaticMemberDIE, Ty); |
1681 | addSourceLine(StaticMemberDIE, DT); |
1682 | addFlag(StaticMemberDIE, dwarf::DW_AT_external); |
1683 | addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); |
1684 | |
1685 | |
1686 | |
1687 | if (DT->isProtected()) |
1688 | addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1689 | dwarf::DW_ACCESS_protected); |
1690 | else if (DT->isPrivate()) |
1691 | addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1692 | dwarf::DW_ACCESS_private); |
1693 | else if (DT->isPublic()) |
1694 | addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, |
1695 | dwarf::DW_ACCESS_public); |
1696 | |
1697 | if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant())) |
1698 | addConstantValue(StaticMemberDIE, CI, Ty); |
1699 | if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant())) |
1700 | addConstantFPValue(StaticMemberDIE, CFP); |
1701 | |
1702 | if (uint32_t AlignInBytes = DT->getAlignInBytes()) |
1703 | addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, |
1704 | AlignInBytes); |
1705 | |
1706 | return &StaticMemberDIE; |
1707 | } |
1708 | |
1709 | void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) { |
1710 | |
1711 | if (!DD->useSectionsAsReferences()) |
1712 | EndLabel = Asm->emitDwarfUnitLength( |
1713 | isDwoUnit() ? "debug_info_dwo" : "debug_info", "Length of Unit"); |
1714 | else |
1715 | Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(), |
1716 | "Length of Unit"); |
1717 | |
1718 | Asm->OutStreamer->AddComment("DWARF version number"); |
1719 | unsigned Version = DD->getDwarfVersion(); |
1720 | Asm->emitInt16(Version); |
1721 | |
1722 | |
1723 | if (Version >= 5) { |
1724 | Asm->OutStreamer->AddComment("DWARF Unit Type"); |
1725 | Asm->emitInt8(UT); |
1726 | Asm->OutStreamer->AddComment("Address Size (in bytes)"); |
1727 | Asm->emitInt8(Asm->MAI->getCodePointerSize()); |
1728 | } |
1729 | |
1730 | |
1731 | |
1732 | |
1733 | Asm->OutStreamer->AddComment("Offset Into Abbrev. Section"); |
1734 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
1735 | if (UseOffsets) |
1736 | Asm->emitDwarfLengthOrOffset(0); |
1737 | else |
1738 | Asm->emitDwarfSymbolReference( |
1739 | TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false); |
1740 | |
1741 | if (Version <= 4) { |
1742 | Asm->OutStreamer->AddComment("Address Size (in bytes)"); |
1743 | Asm->emitInt8(Asm->MAI->getCodePointerSize()); |
1744 | } |
1745 | } |
1746 | |
1747 | void DwarfTypeUnit::emitHeader(bool UseOffsets) { |
1748 | DwarfUnit::emitCommonHeader(UseOffsets, |
1749 | DD->useSplitDwarf() ? dwarf::DW_UT_split_type |
1750 | : dwarf::DW_UT_type); |
1751 | Asm->OutStreamer->AddComment("Type Signature"); |
1752 | Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature)); |
1753 | Asm->OutStreamer->AddComment("Type DIE Offset"); |
1754 | |
1755 | Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0); |
1756 | } |
1757 | |
1758 | void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, |
1759 | const MCSymbol *Hi, const MCSymbol *Lo) { |
1760 | addAttribute(Die, Attribute, DD->getDwarfSectionOffsetForm(), |
1761 | new (DIEValueAllocator) DIEDelta(Hi, Lo)); |
1762 | } |
1763 | |
1764 | void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, |
1765 | const MCSymbol *Label, const MCSymbol *Sec) { |
1766 | if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) |
1767 | addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label); |
1768 | else |
1769 | addSectionDelta(Die, Attribute, Label, Sec); |
1770 | } |
1771 | |
1772 | bool DwarfTypeUnit::isDwoUnit() const { |
1773 | |
1774 | |
1775 | return DD->useSplitDwarf(); |
1776 | } |
1777 | |
1778 | void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die, |
1779 | const DIScope *Context) { |
1780 | getCU().addGlobalNameForTypeUnit(Name, Context); |
1781 | } |
1782 | |
1783 | void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die, |
1784 | const DIScope *Context) { |
1785 | getCU().addGlobalTypeUnitType(Ty, Context); |
1786 | } |
1787 | |
1788 | const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const { |
1789 | if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections()) |
1790 | return nullptr; |
1791 | if (isDwoUnit()) |
1792 | return nullptr; |
1793 | return getSection()->getBeginSymbol(); |
1794 | } |
1795 | |
1796 | void DwarfUnit::addStringOffsetsStart() { |
1797 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
1798 | addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base, |
1799 | DU->getStringOffsetsStartSym(), |
1800 | TLOF.getDwarfStrOffSection()->getBeginSymbol()); |
1801 | } |
1802 | |
1803 | void DwarfUnit::addRnglistsBase() { |
1804 | assert(DD->getDwarfVersion() >= 5 && |
1805 | "DW_AT_rnglists_base requires DWARF version 5 or later"); |
1806 | const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); |
1807 | addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base, |
1808 | DU->getRnglistsTableBaseSym(), |
1809 | TLOF.getDwarfRnglistsSection()->getBeginSymbol()); |
1810 | } |
1811 | |
1812 | void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) { |
1813 | addFlag(D, dwarf::DW_AT_declaration); |
1814 | StringRef Name = CTy->getName(); |
1815 | if (!Name.empty()) |
1816 | addString(D, dwarf::DW_AT_name, Name); |
1817 | getCU().createTypeDIE(CTy); |
1818 | } |