File: | llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp |
Warning: | line 892, column 38 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===// | ||||
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 contains support for constructing a dwarf compile unit. | ||||
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" "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?")(static_cast <bool> (!IsBuffering && "Already buffering?" ) ? void (0) : __assert_fail ("!IsBuffering && \"Already buffering?\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 73, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // The languages below have valid values in all DWARF versions. | ||||
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 | // The languages below have valid values only if the DWARF version >= 3. | ||||
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 | // Starting with DWARF v4, all defined languages have valid values. | ||||
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 | // The languages below are new in DWARF v5. | ||||
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 | /// Check whether the DIE for this MDNode can be shared across CUs. | ||||
188 | bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const { | ||||
189 | // When the MDNode can be part of the type system, the DIE can be shared | ||||
190 | // across CUs. | ||||
191 | // Combining type units and cross-CU DIE sharing is lower value (since | ||||
192 | // cross-CU DIE sharing is used in LTO and removes type redundancy at that | ||||
193 | // level already) but may be implementable for some value in projects | ||||
194 | // building multiple independent libraries with LTO and then linking those | ||||
195 | // together. | ||||
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 &&(static_cast <bool> (Form != dwarf::DW_FORM_implicit_const && "DW_FORM_implicit_const is used only for signed integers" ) ? void (0) : __assert_fail ("Form != dwarf::DW_FORM_implicit_const && \"DW_FORM_implicit_const is used only for signed integers\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 233, __extension__ __PRETTY_FUNCTION__)) | ||||
233 | "DW_FORM_implicit_const is used only for signed integers")(static_cast <bool> (Form != dwarf::DW_FORM_implicit_const && "DW_FORM_implicit_const is used only for signed integers" ) ? void (0) : __assert_fail ("Form != dwarf::DW_FORM_implicit_const && \"DW_FORM_implicit_const is used only for signed integers\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 233, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // For DWARF v5 and beyond, use the smallest strx? form possible. | ||||
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 | // This is a split type unit that needs a line table. | ||||
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 | // Flag the type unit reference as a declaration so that if it contains | ||||
366 | // members (implicit special members, static data member definitions, member | ||||
367 | // declarations for definitions in this CU, etc) consumers don't get confused | ||||
368 | // and think this is a full definition. | ||||
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 | // We assume that Die belongs to this CU, if it is not linked to any CU yet. | ||||
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); // Memoize so we can call the destructor later on. | ||||
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); // Memoize so we can call the destructor later on. | ||||
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)(static_cast <bool> (V) ? void (0) : __assert_fail ("V" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 424, __extension__ __PRETTY_FUNCTION__)); | ||||
425 | |||||
426 | addSourceLine(Die, V->getLine(), V->getFile()); | ||||
427 | } | ||||
428 | |||||
429 | void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) { | ||||
430 | assert(G)(static_cast <bool> (G) ? void (0) : __assert_fail ("G" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 430, __extension__ __PRETTY_FUNCTION__)); | ||||
431 | |||||
432 | addSourceLine(Die, G->getLine(), G->getFile()); | ||||
433 | } | ||||
434 | |||||
435 | void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) { | ||||
436 | assert(SP)(static_cast <bool> (SP) ? void (0) : __assert_fail ("SP" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 436, __extension__ __PRETTY_FUNCTION__)); | ||||
437 | |||||
438 | addSourceLine(Die, SP->getLine(), SP->getFile()); | ||||
439 | } | ||||
440 | |||||
441 | void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) { | ||||
442 | assert(L)(static_cast <bool> (L) ? void (0) : __assert_fail ("L" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 442, __extension__ __PRETTY_FUNCTION__)); | ||||
443 | |||||
444 | addSourceLine(Die, L->getLine(), L->getFile()); | ||||
445 | } | ||||
446 | |||||
447 | void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) { | ||||
448 | assert(Ty)(static_cast <bool> (Ty) ? void (0) : __assert_fail ("Ty" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 448, __extension__ __PRETTY_FUNCTION__)); | ||||
449 | |||||
450 | addSourceLine(Die, Ty->getLine(), Ty->getFile()); | ||||
451 | } | ||||
452 | |||||
453 | void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) { | ||||
454 | assert(Ty)(static_cast <bool> (Ty) ? void (0) : __assert_fail ("Ty" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 454, __extension__ __PRETTY_FUNCTION__)); | ||||
455 | |||||
456 | addSourceLine(Die, Ty->getLine(), Ty->getFile()); | ||||
457 | } | ||||
458 | |||||
459 | void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) { | ||||
460 | // Pass this down to addConstantValue as an unsigned bag of bits. | ||||
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 | // FIXME: This is a bit conservative/simple - it emits negative values always | ||||
475 | // sign extended to 64 bits rather than minimizing the number of bytes. | ||||
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 | // Get the raw data form of the large APInt. | ||||
495 | const uint64_t *Ptr64 = Val.getRawData(); | ||||
496 | |||||
497 | int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. | ||||
498 | bool LittleEndian = Asm->getDataLayout().isLittleEndian(); | ||||
499 | |||||
500 | // Output the constant to DWARF one byte at a time. | ||||
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 | // Add template parameters. | ||||
523 | for (const auto *Element : TParams) { | ||||
524 | if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element)) | ||||
525 | constructTemplateTypeParameterDIE(Buffer, TTP); | ||||
526 | else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element)) | ||||
527 | constructTemplateValueParameterDIE(Buffer, TVP); | ||||
528 | } | ||||
529 | } | ||||
530 | |||||
531 | /// Add thrown types. | ||||
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 | // Create new type. | ||||
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 | // Create new type. | ||||
572 | DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty); | ||||
573 | |||||
574 | updateAcceleratorTables(Context, Ty, TyDIE); | ||||
575 | |||||
576 | if (auto *BT
| ||||
577 | constructTypeDIE(TyDIE, BT); | ||||
578 | else if (auto *ST
| ||||
579 | constructTypeDIE(TyDIE, ST); | ||||
580 | else if (auto *STy
| ||||
581 | constructTypeDIE(TyDIE, STy); | ||||
582 | else if (auto *CTy
| ||||
583 | if (DD->generateTypeUnits() && !Ty->isForwardDecl() && | ||||
584 | (Ty->getRawName() || CTy->getRawIdentifier())) { | ||||
585 | // Skip updating the accelerator tables since this is not the full type. | ||||
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); | ||||
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 | // DW_TAG_restrict_type is not supported in DWARF2 | ||||
609 | if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2) | ||||
610 | return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); | ||||
611 | |||||
612 | // DW_TAG_atomic_type is not supported in DWARF < 5 | ||||
613 | if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5) | ||||
614 | return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); | ||||
615 | |||||
616 | // Construct the context before querying for the existence of the DIE in case | ||||
617 | // such construction creates the DIE. | ||||
618 | auto *Context = Ty->getScope(); | ||||
619 | DIE *ContextDIE = getOrCreateContextDIE(Context); | ||||
620 | assert(ContextDIE)(static_cast <bool> (ContextDIE) ? void (0) : __assert_fail ("ContextDIE", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 620, __extension__ __PRETTY_FUNCTION__)); | ||||
621 | |||||
622 | if (DIE *TyDIE = getDIE(Ty)) | ||||
623 | return TyDIE; | ||||
624 | |||||
625 | return static_cast<DwarfUnit *>(ContextDIE->getUnit()) | ||||
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 | // A runtime language of 0 actually means C/C++ and that any | ||||
635 | // non-negative value is some version of Objective-C/C++. | ||||
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?")(static_cast <bool> (Ty && "Trying to add a type that doesn't exist?" ) ? void (0) : __assert_fail ("Ty && \"Trying to add a type that doesn't exist?\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 649, __extension__ __PRETTY_FUNCTION__)); | ||||
650 | addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty))); | ||||
651 | } | ||||
652 | |||||
653 | std::string DwarfUnit::getParentContextString(const DIScope *Context) const { | ||||
654 | if (!Context) | ||||
655 | return ""; | ||||
656 | |||||
657 | // FIXME: Decide whether to implement this for non-C++ languages. | ||||
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 | // Structure, etc types will have a NULL context if they're at the top | ||||
669 | // level. | ||||
670 | break; | ||||
671 | } | ||||
672 | |||||
673 | // Reverse iterate over our list to go from the outermost construct to the | ||||
674 | // innermost. | ||||
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 | // Get core information. | ||||
689 | StringRef Name = BTy->getName(); | ||||
690 | // Add name if not anonymous or intermediate type. | ||||
691 | if (!Name.empty()) | ||||
692 | addString(Buffer, dwarf::DW_AT_name, Name); | ||||
693 | |||||
694 | // An unspecified type only has a name attribute. | ||||
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 | // Get core information. | ||||
713 | StringRef Name = STy->getName(); | ||||
714 | // Add name if not anonymous or intermediate type. | ||||
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 | // This is to describe the memory location of the | ||||
725 | // length of a Fortran deferred length string, so | ||||
726 | // lock it down as such. | ||||
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 | // For eventual Unicode support. | ||||
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 | // Get core information. | ||||
744 | StringRef Name = DTy->getName(); | ||||
745 | uint64_t Size = DTy->getSizeInBits() >> 3; | ||||
746 | uint16_t Tag = Buffer.getTag(); | ||||
747 | |||||
748 | // Map to main type, void will not have a type. | ||||
749 | const DIType *FromTy = DTy->getBaseType(); | ||||
750 | if (FromTy
| ||||
| |||||
751 | addType(Buffer, FromTy); | ||||
752 | |||||
753 | // Add name if not anonymous or intermediate type. | ||||
754 | if (!Name.empty()) | ||||
755 | addString(Buffer, dwarf::DW_AT_name, Name); | ||||
756 | |||||
757 | // If alignment is specified for a typedef , create and insert DW_AT_alignment | ||||
758 | // attribute in DW_TAG_typedef DIE. | ||||
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 | // Add size if non-zero (derived types might be zero-sized.) | ||||
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 | // Add source line info if available and TyDesc is not a forward declaration. | ||||
777 | if (!DTy->isForwardDecl()) | ||||
778 | addSourceLine(Buffer, DTy); | ||||
779 | |||||
780 | // If DWARF address space value is other than None, add it. The IR | ||||
781 | // verifier checks that DWARF address space only exists for pointer | ||||
782 | // or reference types. | ||||
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")(static_cast <bool> (i == N-1 && "Unspecified parameter must be the last argument" ) ? void (0) : __assert_fail ("i == N-1 && \"Unspecified parameter must be the last argument\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 792, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // Add return type. A void return won't have a type. | ||||
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 | // Add prototype flag if we're dealing with a C language and the function has | ||||
817 | // been prototyped. | ||||
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 | // Add a DW_AT_calling_convention if this has an explicit convention. | ||||
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 | // Add name if not anonymous or intermediate type. | ||||
838 | StringRef Name = CTy->getName(); | ||||
839 | |||||
840 | uint64_t Size = CTy->getSizeInBits() >> 3; | ||||
841 | uint16_t Tag = Buffer.getTag(); | ||||
842 | |||||
843 | switch (Tag) { | ||||
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 | // Emit the discriminator for a variant part. | ||||
855 | DIDerivedType *Discriminator = nullptr; | ||||
856 | if (Tag
| ||||
857 | Discriminator = CTy->getDiscriminator(); | ||||
858 | if (Discriminator) { | ||||
859 | // DWARF says: | ||||
860 | // If the variant part has a discriminant, the discriminant is | ||||
861 | // represented by a separate debugging information entry which is | ||||
862 | // a child of the variant part entry. | ||||
863 | DIE &DiscMember = constructMemberDIE(Buffer, Discriminator); | ||||
864 | addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember); | ||||
865 | } | ||||
866 | } | ||||
867 | |||||
868 | // Add template parameters to a class, structure or union types. | ||||
869 | if (Tag
| ||||
870 | Tag
| ||||
871 | addTemplateParams(Buffer, CTy->getTemplateParams()); | ||||
872 | |||||
873 | // Add elements to structure type. | ||||
874 | DINodeArray Elements = CTy->getElements(); | ||||
875 | for (const auto *Element : Elements) { | ||||
876 | if (!Element) | ||||
877 | continue; | ||||
878 | if (auto *SP
| ||||
879 | getOrCreateSubprogramDIE(SP); | ||||
880 | else if (auto *DDTy
| ||||
881 | if (DDTy->getTag() == dwarf::DW_TAG_friend) { | ||||
882 | DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); | ||||
883 | addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend); | ||||
884 | } else if (DDTy->isStaticMember()) { | ||||
885 | getOrCreateStaticMemberDIE(DDTy); | ||||
886 | } else if (Tag
| ||||
887 | // When emitting a variant part, wrap each member in | ||||
888 | // DW_TAG_variant. | ||||
889 | DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer); | ||||
890 | if (const ConstantInt *CI
| ||||
891 | dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) { | ||||
892 | if (DD->isUnsignedDIType(Discriminator->getBaseType())) | ||||
| |||||
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 | // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type | ||||
932 | // inside C++ composite types to point to the base class with the vtable. | ||||
933 | // Rust uses DW_AT_containing_type to link a vtable to the type | ||||
934 | // for which it was created. | ||||
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 | // Add the type's non-standard calling convention. | ||||
943 | // DW_CC_pass_by_value/DW_CC_pass_by_reference are introduced in DWARF 5. | ||||
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 | // Add name if not anonymous or intermediate type. | ||||
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 | // Add size if non-zero (derived types might be zero-sized.) | ||||
968 | // Ignore the size if it's a non-enum forward decl. | ||||
969 | // TODO: Do we care about size for enum forward declarations? | ||||
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 | // Add zero size if it is not a forward declaration. | ||||
975 | addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); | ||||
976 | |||||
977 | // If we're a forward decl, say so. | ||||
978 | if (CTy->isForwardDecl()) | ||||
979 | addFlag(Buffer, dwarf::DW_AT_declaration); | ||||
980 | |||||
981 | // Add source line info if available. | ||||
982 | if (!CTy->isForwardDecl()) | ||||
983 | addSourceLine(Buffer, CTy); | ||||
984 | |||||
985 | // No harm in adding the runtime language to the declaration. | ||||
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 | // Add align info if available. | ||||
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 | // Add the type if it exists, it could be void and therefore no type. | ||||
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 | // Add the type if there is one, template template and template parameter | ||||
1016 | // packs will not have a type. | ||||
1017 | if (VP->getTag() == dwarf::DW_TAG_template_value_parameter) | ||||
1018 | addType(ParamDIE, VP->getType()); | ||||
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 | // We cannot describe the location of dllimport'd entities: the | ||||
1028 | // computation of their address requires loads from the IAT. | ||||
1029 | if (!GV->hasDLLImportStorageClass()) { | ||||
1030 | // For declaration non-type template parameters (such as global values | ||||
1031 | // and functions) | ||||
1032 | DIELoc *Loc = new (DIEValueAllocator) DIELoc; | ||||
1033 | addOpAddress(*Loc, Asm->getSymbol(GV)); | ||||
1034 | // Emit DW_OP_stack_value to use the address as the immediate value of | ||||
1035 | // the parameter, rather than a pointer to it. | ||||
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))(static_cast <bool> (isa<MDString>(Val)) ? void ( 0) : __assert_fail ("isa<MDString>(Val)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1040, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // Construct the context before querying for the existence of the DIE in case | ||||
1051 | // such construction creates the DIE. | ||||
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 | // Construct the context before querying for the existence of the DIE in case | ||||
1072 | // such construction creates the DIE. | ||||
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 | // Construct the context before querying for the existence of the DIE in case | ||||
1103 | // such construction creates the DIE (as is the case for member function | ||||
1104 | // declarations). | ||||
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 | // Add subprogram definitions to the CU die directly. | ||||
1114 | ContextDIE = &getUnitDie(); | ||||
1115 | // Build the decl now to ensure it precedes the definition. | ||||
1116 | getOrCreateSubprogramDIE(SPDecl); | ||||
1117 | } | ||||
1118 | } | ||||
1119 | |||||
1120 | // DW_TAG_inlined_subroutine may refer to this DIE. | ||||
1121 | DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); | ||||
1122 | |||||
1123 | // Stop here and fill this in later, depending on whether or not this | ||||
1124 | // subprogram turns out to have inlined instances or not. | ||||
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__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 "(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the " "definition DIE was created in " "getOrCreateSubprogramDIE") ? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1150, __extension__ __PRETTY_FUNCTION__)) | ||||
1149 | "definition DIE was created in "(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the " "definition DIE was created in " "getOrCreateSubprogramDIE") ? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1150, __extension__ __PRETTY_FUNCTION__)) | ||||
1150 | "getOrCreateSubprogramDIE")(static_cast <bool> (DeclDie && "This DIE should've already been constructed when the " "definition DIE was created in " "getOrCreateSubprogramDIE") ? void (0) : __assert_fail ("DeclDie && \"This DIE should've already been constructed when the \" \"definition DIE was created in \" \"getOrCreateSubprogramDIE\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1150, __extension__ __PRETTY_FUNCTION__)); | ||||
1151 | // Look at the Decl's linkage name only if we emitted it. | ||||
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 | // Add function template parameters. | ||||
1165 | addTemplateParams(SPDie, SP->getTemplateParams()); | ||||
1166 | |||||
1167 | // Add the linkage name if we have one and it isn't in the Decl. | ||||
1168 | StringRef LinkageName = SP->getLinkageName(); | ||||
1169 | assert(((LinkageName.empty() || DeclLinkageName.empty()) ||(static_cast <bool> (((LinkageName.empty() || DeclLinkageName .empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different" ) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1171, __extension__ __PRETTY_FUNCTION__)) | ||||
1170 | LinkageName == DeclLinkageName) &&(static_cast <bool> (((LinkageName.empty() || DeclLinkageName .empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different" ) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1171, __extension__ __PRETTY_FUNCTION__)) | ||||
1171 | "decl has a linkage name and it is different")(static_cast <bool> (((LinkageName.empty() || DeclLinkageName .empty()) || LinkageName == DeclLinkageName) && "decl has a linkage name and it is different" ) ? void (0) : __assert_fail ("((LinkageName.empty() || DeclLinkageName.empty()) || LinkageName == DeclLinkageName) && \"decl has a linkage name and it is different\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1171, __extension__ __PRETTY_FUNCTION__)); | ||||
1172 | if (DeclLinkageName.empty() && | ||||
1173 | // Always emit it for abstract subprograms. | ||||
1174 | (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP))) | ||||
1175 | addLinkageName(SPDie, LinkageName); | ||||
1176 | |||||
1177 | if (!DeclDie) | ||||
1178 | return false; | ||||
1179 | |||||
1180 | // Refer to the function declaration where all the other attributes will be | ||||
1181 | // found. | ||||
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 | // If -fdebug-info-for-profiling is enabled, need to emit the subprogram | ||||
1189 | // and its source location. | ||||
1190 | bool SkipSPSourceLocation = SkipSPAttributes && | ||||
1191 | !CUNode->getDebugInfoForProfiling(); | ||||
1192 | if (!SkipSPSourceLocation) | ||||
1193 | if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes)) | ||||
1194 | return; | ||||
1195 | |||||
1196 | // Constructors and operators for anonymous aggregates do not have names. | ||||
1197 | if (!SP->getName().empty()) | ||||
1198 | addString(SPDie, dwarf::DW_AT_name, SP->getName()); | ||||
1199 | |||||
1200 | if (!SkipSPSourceLocation) | ||||
1201 | addSourceLine(SPDie, SP); | ||||
1202 | |||||
1203 | // Skip the rest of the attributes under -gmlt to save space. | ||||
1204 | if (SkipSPAttributes) | ||||
1205 | return; | ||||
1206 | |||||
1207 | // Add the prototype if we have a prototype and we have a C like | ||||
1208 | // language. | ||||
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 | // Add a DW_AT_calling_convention if this has an explicit convention. | ||||
1226 | if (CC && CC != dwarf::DW_CC_normal) | ||||
1227 | addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC); | ||||
1228 | |||||
1229 | // Add a return type. If this is a type like a C/C++ void type we don't add a | ||||
1230 | // return type. | ||||
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 | // Add arguments. Do not add arguments for subprogram definition. They will | ||||
1251 | // be handled while processing variables. | ||||
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 | // The LowerBound value defines the lower bounds which is typically zero for | ||||
1312 | // C/C++. The Count value is the number of elements. Values are 64 bit. If | ||||
1313 | // Count == -1 then the array is unbounded and we do not emit | ||||
1314 | // DW_AT_lower_bound and DW_AT_count attributes. | ||||
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 | // Construct an integer type to use for indexes. | ||||
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, /*Flags*/ 0); | ||||
1396 | return IndexTyDie; | ||||
1397 | } | ||||
1398 | |||||
1399 | /// Returns true if the vector's size differs from the sum of sizes of elements | ||||
1400 | /// the user specified. This can occur if the vector has been rounded up to | ||||
1401 | /// fit memory alignment constraints. | ||||
1402 | static bool hasVectorBeenPadded(const DICompositeType *CTy) { | ||||
1403 | assert(CTy && CTy->isVector() && "Composite type is not a vector")(static_cast <bool> (CTy && CTy->isVector() && "Composite type is not a vector") ? void (0) : __assert_fail ("CTy && CTy->isVector() && \"Composite type is not a vector\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1403, __extension__ __PRETTY_FUNCTION__)); | ||||
1404 | const uint64_t ActualSize = CTy->getSizeInBits(); | ||||
1405 | |||||
1406 | // Obtain the size of each element in the vector. | ||||
1407 | DIType *BaseTy = CTy->getBaseType(); | ||||
1408 | assert(BaseTy && "Unknown vector element type.")(static_cast <bool> (BaseTy && "Unknown vector element type." ) ? void (0) : __assert_fail ("BaseTy && \"Unknown vector element type.\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1408, __extension__ __PRETTY_FUNCTION__)); | ||||
1409 | const uint64_t ElementSize = BaseTy->getSizeInBits(); | ||||
1410 | |||||
1411 | // Locate the number of elements in the vector. | ||||
1412 | const DINodeArray Elements = CTy->getElements(); | ||||
1413 | assert(Elements.size() == 1 &&(static_cast <bool> (Elements.size() == 1 && Elements [0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange" ) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1415, __extension__ __PRETTY_FUNCTION__)) | ||||
1414 | Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&(static_cast <bool> (Elements.size() == 1 && Elements [0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange" ) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1415, __extension__ __PRETTY_FUNCTION__)) | ||||
1415 | "Invalid vector element array, expected one element of type subrange")(static_cast <bool> (Elements.size() == 1 && Elements [0]->getTag() == dwarf::DW_TAG_subrange_type && "Invalid vector element array, expected one element of type subrange" ) ? void (0) : __assert_fail ("Elements.size() == 1 && Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && \"Invalid vector element array, expected one element of type subrange\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1415, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // Ensure we found the element count and that the actual size is wide | ||||
1423 | // enough to contain the requested size. | ||||
1424 | assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size")(static_cast <bool> (ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size") ? void (0) : __assert_fail ("ActualSize >= (NumVecElements * ElementSize) && \"Invalid vector size\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1424, __extension__ __PRETTY_FUNCTION__)); | ||||
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_BIT8); | ||||
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 | // Emit the element type. | ||||
1481 | addType(Buffer, CTy->getBaseType()); | ||||
1482 | |||||
1483 | // Get an anonymous type for index type. | ||||
1484 | // FIXME: This type should be passed down from the front end | ||||
1485 | // as different languages may have different sizes for indexes. | ||||
1486 | DIE *IdxTy = getIndexTyDie(); | ||||
1487 | |||||
1488 | // Add subranges to array type. | ||||
1489 | DINodeArray Elements = CTy->getElements(); | ||||
1490 | for (DINode *E : Elements) { | ||||
1491 | // FIXME: Should this really be such a loose cast? | ||||
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 | // Add enumerators to enumeration type. | ||||
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 | // For C++, virtual base classes are not at fixed offset. Use following | ||||
1558 | // expression to extract appropriate offset from vtable. | ||||
1559 | // BaseAddr = ObAddr + *((*ObAddr) - Offset) | ||||
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 | // Handle bitfield, assume bytes are 8 bits. | ||||
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 | // We can't use DT->getAlignInBits() here: AlignInBits for member type | ||||
1586 | // is non-zero if and only if alignment was forced (e.g. _Alignas()), | ||||
1587 | // which can't be done with bitfields. Thus we use FieldSize here. | ||||
1588 | uint32_t AlignInBits = FieldSize; | ||||
1589 | uint32_t AlignMask = ~(AlignInBits - 1); | ||||
1590 | // The bits from the start of the storage unit to the start of the field. | ||||
1591 | uint64_t StartBitOffset = Offset - (Offset & AlignMask); | ||||
1592 | // The byte offset of the field's aligned storage unit inside the struct. | ||||
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 | // Maybe we need to work from the other end. | ||||
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 | // This is not a bitfield. | ||||
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 | // In DWARF v3, DW_FORM_data4/8 in DW_AT_data_member_location are | ||||
1624 | // interpreted as location-list pointers. Interpreting constants as | ||||
1625 | // pointers is not expected, so we use DW_FORM_udata to encode the | ||||
1626 | // constants here. | ||||
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 | // Otherwise C++ member and base classes are considered public. | ||||
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 | // Objective-C properties. | ||||
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 | // Construct the context before querying for the existence of the DIE in case | ||||
1667 | // such construction creates the DIE. | ||||
1668 | DIE *ContextDIE = getOrCreateContextDIE(DT->getScope()); | ||||
1669 | assert(dwarf::isType(ContextDIE->getTag()) &&(static_cast <bool> (dwarf::isType(ContextDIE->getTag ()) && "Static member should belong to a type.") ? void (0) : __assert_fail ("dwarf::isType(ContextDIE->getTag()) && \"Static member should belong to a type.\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1670, __extension__ __PRETTY_FUNCTION__)) | ||||
1670 | "Static member should belong to a type.")(static_cast <bool> (dwarf::isType(ContextDIE->getTag ()) && "Static member should belong to a type.") ? void (0) : __assert_fail ("dwarf::isType(ContextDIE->getTag()) && \"Static member should belong to a type.\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1670, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | // FIXME: We could omit private if the parent is a class_type, and | ||||
1686 | // public if the parent is something else. | ||||
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 | // Emit size of content not including length itself | ||||
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 | // DWARF v5 reorders the address size and adds a unit type. | ||||
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 | // We share one abbreviations table across all units so it's always at the | ||||
1731 | // start of the section. Use a relocatable offset where needed to ensure | ||||
1732 | // linking doesn't invalidate that offset. | ||||
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 | // In a skeleton type unit there is no type DIE so emit a zero offset. | ||||
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 | // Since there are no skeleton type units, all type units are dwo type units | ||||
1774 | // when split DWARF is being used. | ||||
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 &&(static_cast <bool> (DD->getDwarfVersion() >= 5 && "DW_AT_rnglists_base requires DWARF version 5 or later") ? void (0) : __assert_fail ("DD->getDwarfVersion() >= 5 && \"DW_AT_rnglists_base requires DWARF version 5 or later\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1805, __extension__ __PRETTY_FUNCTION__)) | ||||
1805 | "DW_AT_rnglists_base requires DWARF version 5 or later")(static_cast <bool> (DD->getDwarfVersion() >= 5 && "DW_AT_rnglists_base requires DWARF version 5 or later") ? void (0) : __assert_fail ("DD->getDwarfVersion() >= 5 && \"DW_AT_rnglists_base requires DWARF version 5 or later\"" , "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp" , 1805, __extension__ __PRETTY_FUNCTION__)); | ||||
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 | } |