1//===- SyntheticTypeNameBuilder.cpp ---------------------------------------===//
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#include "SyntheticTypeNameBuilder.h"
10#include "DWARFLinkerCompileUnit.h"
11#include "llvm/DWARFLinker/Utils.h"
12#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
13#include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
14#include "llvm/DebugInfo/DWARF/DWARFDie.h"
15#include "llvm/Support/xxhash.h"
16
17using namespace llvm;
18using namespace dwarf_linker;
19using namespace dwarf_linker::parallel;
20
21Error SyntheticTypeNameBuilder::assignName(
22 UnitEntryPairTy InputUnitEntryPair,
23 std::optional<std::pair<size_t, size_t>> ChildIndex) {
24 [[maybe_unused]] const CompileUnit::DIEInfo &Info =
25 InputUnitEntryPair.CU->getDIEInfo(Entry: InputUnitEntryPair.DieEntry);
26 assert(Info.needToPlaceInTypeTable() &&
27 "Cann't assign name for non-type DIE");
28
29 if (InputUnitEntryPair.CU->getDieTypeEntry(InputDieEntry: InputUnitEntryPair.DieEntry) !=
30 nullptr)
31 return Error::success();
32
33 SyntheticName.truncate(Size: 0);
34 RecursionDepth = 0;
35 return addDIETypeName(InputUnitEntryPair, ChildIndex, AssignNameToTypeDescriptor: true);
36}
37
38void SyntheticTypeNameBuilder::addArrayDimension(
39 UnitEntryPairTy InputUnitEntryPair) {
40 for (const DWARFDebugInfoEntry *CurChild =
41 InputUnitEntryPair.CU->getFirstChildEntry(
42 Die: InputUnitEntryPair.DieEntry);
43 CurChild && CurChild->getAbbreviationDeclarationPtr();
44 CurChild = InputUnitEntryPair.CU->getSiblingEntry(Die: CurChild)) {
45 if (CurChild->getTag() == dwarf::DW_TAG_subrange_type ||
46 CurChild->getTag() == dwarf::DW_TAG_generic_subrange) {
47 SyntheticName += "[";
48 if (std::optional<DWARFFormValue> Val =
49 InputUnitEntryPair.CU->find(Die: CurChild, Attrs: dwarf::DW_AT_count)) {
50 if (std::optional<uint64_t> ConstVal = Val->getAsUnsignedConstant()) {
51 SyntheticName += std::to_string(val: *ConstVal);
52 } else if (std::optional<int64_t> ConstVal =
53 Val->getAsSignedConstant()) {
54 SyntheticName += std::to_string(val: *ConstVal);
55 }
56 }
57
58 SyntheticName += "]";
59 }
60 }
61}
62
63static dwarf::Attribute TypeAttr[] = {dwarf::DW_AT_type};
64Error SyntheticTypeNameBuilder::addSignature(UnitEntryPairTy InputUnitEntryPair,
65 bool addTemplateParameters) {
66 // Add entry type.
67 if (Error Err = addReferencedODRDies(InputUnitEntryPair, AssignNameToTypeDescriptor: false, ODRAttrs: TypeAttr))
68 return Err;
69 SyntheticName += ':';
70
71 SmallVector<const DWARFDebugInfoEntry *, 10> TemplateParameters;
72 SmallVector<const DWARFDebugInfoEntry *, 20> FunctionParameters;
73 for (const DWARFDebugInfoEntry *CurChild =
74 InputUnitEntryPair.CU->getFirstChildEntry(
75 Die: InputUnitEntryPair.DieEntry);
76 CurChild && CurChild->getAbbreviationDeclarationPtr();
77 CurChild = InputUnitEntryPair.CU->getSiblingEntry(Die: CurChild)) {
78 dwarf::Tag ChildTag = CurChild->getTag();
79 if (addTemplateParameters &&
80 (ChildTag == dwarf::DW_TAG_template_type_parameter ||
81 ChildTag == dwarf::DW_TAG_template_value_parameter))
82 TemplateParameters.push_back(Elt: CurChild);
83 else if (ChildTag == dwarf::DW_TAG_formal_parameter ||
84 ChildTag == dwarf::DW_TAG_unspecified_parameters)
85 FunctionParameters.push_back(Elt: CurChild);
86 else if (addTemplateParameters &&
87 ChildTag == dwarf::DW_TAG_GNU_template_parameter_pack) {
88 for (const DWARFDebugInfoEntry *CurGNUChild =
89 InputUnitEntryPair.CU->getFirstChildEntry(Die: CurChild);
90 CurGNUChild && CurGNUChild->getAbbreviationDeclarationPtr();
91 CurGNUChild = InputUnitEntryPair.CU->getSiblingEntry(Die: CurGNUChild))
92 TemplateParameters.push_back(Elt: CurGNUChild);
93 } else if (ChildTag == dwarf::DW_TAG_GNU_formal_parameter_pack) {
94 for (const DWARFDebugInfoEntry *CurGNUChild =
95 InputUnitEntryPair.CU->getFirstChildEntry(Die: CurChild);
96 CurGNUChild && CurGNUChild->getAbbreviationDeclarationPtr();
97 CurGNUChild = InputUnitEntryPair.CU->getSiblingEntry(Die: CurGNUChild))
98 FunctionParameters.push_back(Elt: CurGNUChild);
99 }
100 }
101
102 // Add parameters.
103 if (Error Err = addParamNames(CU&: *InputUnitEntryPair.CU, FunctionParameters))
104 return Err;
105
106 // Add template parameters.
107 if (Error Err =
108 addTemplateParamNames(CU&: *InputUnitEntryPair.CU, TemplateParameters))
109 return Err;
110
111 return Error::success();
112}
113
114Error SyntheticTypeNameBuilder::addParamNames(
115 CompileUnit &CU,
116 SmallVector<const DWARFDebugInfoEntry *, 20> &FunctionParameters) {
117 size_t ParamsStart = SyntheticName.size();
118 SyntheticName += '(';
119 for (const DWARFDebugInfoEntry *FunctionParameter : FunctionParameters) {
120 if (SyntheticName.size() != ParamsStart + 1)
121 SyntheticName += ", ";
122 if (dwarf::toUnsigned(V: CU.find(Die: FunctionParameter, Attrs: dwarf::DW_AT_artificial),
123 Default: 0))
124 SyntheticName += "^";
125 if (Error Err = addReferencedODRDies(
126 InputUnitEntryPair: UnitEntryPairTy{&CU, FunctionParameter}, AssignNameToTypeDescriptor: false, ODRAttrs: TypeAttr))
127 return Err;
128 }
129 SyntheticName += ')';
130 return Error::success();
131}
132
133Error SyntheticTypeNameBuilder::addTemplateParamNames(
134 CompileUnit &CU,
135 SmallVector<const DWARFDebugInfoEntry *, 10> &TemplateParameters) {
136 if (!TemplateParameters.empty()) {
137 size_t ParamsStart = SyntheticName.size();
138 SyntheticName += '<';
139 for (const DWARFDebugInfoEntry *Parameter : TemplateParameters) {
140 if (SyntheticName.size() != ParamsStart + 1)
141 SyntheticName += ", ";
142
143 if (Parameter->getTag() == dwarf::DW_TAG_template_value_parameter) {
144 if (std::optional<DWARFFormValue> Val =
145 CU.find(Die: Parameter, Attrs: dwarf::DW_AT_const_value)) {
146 if (std::optional<uint64_t> ConstVal = Val->getAsUnsignedConstant())
147 SyntheticName += std::to_string(val: *ConstVal);
148 else if (std::optional<int64_t> ConstVal = Val->getAsSignedConstant())
149 SyntheticName += std::to_string(val: *ConstVal);
150 }
151 }
152
153 if (Error Err = addReferencedODRDies(InputUnitEntryPair: UnitEntryPairTy{&CU, Parameter},
154 AssignNameToTypeDescriptor: false, ODRAttrs: TypeAttr))
155 return Err;
156 }
157 SyntheticName += '>';
158 }
159 return Error::success();
160}
161
162void SyntheticTypeNameBuilder::addOrderedName(
163 std::pair<size_t, size_t> ChildIdx) {
164 std::string Name;
165 llvm::raw_string_ostream stream(Name);
166 stream << format_hex_no_prefix(N: ChildIdx.first, Width: ChildIdx.second);
167 SyntheticName += Name;
168}
169
170// Examine DIE and return type deduplication candidate: some DIEs could not be
171// deduplicated, namespace may refer to another namespace.
172static std::optional<UnitEntryPairTy>
173getTypeDeduplicationCandidate(UnitEntryPairTy UnitEntryPair) {
174 switch (UnitEntryPair.DieEntry->getTag()) {
175 case dwarf::DW_TAG_null:
176 case dwarf::DW_TAG_compile_unit:
177 case dwarf::DW_TAG_partial_unit:
178 case dwarf::DW_TAG_type_unit:
179 case dwarf::DW_TAG_skeleton_unit: {
180 return std::nullopt;
181 }
182 case dwarf::DW_TAG_namespace: {
183 // Check if current namespace refers another.
184 if (UnitEntryPair.CU->find(Die: UnitEntryPair.DieEntry, Attrs: dwarf::DW_AT_extension))
185 UnitEntryPair = UnitEntryPair.getNamespaceOrigin();
186
187 // Content of anonimous namespaces should not be deduplicated.
188 if (!UnitEntryPair.CU->find(Die: UnitEntryPair.DieEntry, Attrs: dwarf::DW_AT_name))
189 llvm_unreachable("Cann't deduplicate anonimous namespace");
190
191 return UnitEntryPair;
192 }
193 default:
194 return UnitEntryPair;
195 }
196}
197
198Error SyntheticTypeNameBuilder::addParentName(
199 UnitEntryPairTy &InputUnitEntryPair) {
200 std::optional<UnitEntryPairTy> UnitEntryPair = InputUnitEntryPair.getParent();
201 if (!UnitEntryPair)
202 return Error::success();
203
204 UnitEntryPair = getTypeDeduplicationCandidate(UnitEntryPair: *UnitEntryPair);
205 if (!UnitEntryPair)
206 return Error::success();
207
208 if (TypeEntry *ImmediateParentName =
209 UnitEntryPair->CU->getDieTypeEntry(InputDieEntry: UnitEntryPair->DieEntry)) {
210 SyntheticName.appendRef(Entry: ImmediateParentName);
211 SyntheticName += ".";
212 return Error::success();
213 }
214
215 // Collect parent entries.
216 SmallVector<UnitEntryPairTy, 10> Parents;
217 do {
218 Parents.push_back(Elt: *UnitEntryPair);
219
220 UnitEntryPair = UnitEntryPair->getParent();
221 if (!UnitEntryPair)
222 break;
223
224 UnitEntryPair = getTypeDeduplicationCandidate(UnitEntryPair: *UnitEntryPair);
225 if (!UnitEntryPair)
226 break;
227
228 } while (!UnitEntryPair->CU->getDieTypeEntry(InputDieEntry: UnitEntryPair->DieEntry));
229
230 // Assign name for each parent entry.
231 size_t NameStart = SyntheticName.size();
232 for (UnitEntryPairTy Parent : reverse(C&: Parents)) {
233 SyntheticName.truncate(Size: NameStart);
234 if (Error Err = addDIETypeName(InputUnitEntryPair: Parent, ChildIndex: std::nullopt, AssignNameToTypeDescriptor: true))
235 return Err;
236 }
237
238 // Add parents delimiter.
239 SyntheticName += ".";
240 return Error::success();
241}
242
243void SyntheticTypeNameBuilder::addDieNameFromDeclFileAndDeclLine(
244 UnitEntryPairTy &InputUnitEntryPair, bool &HasDeclFileName) {
245 if (std::optional<DWARFFormValue> DeclFileVal = InputUnitEntryPair.CU->find(
246 Die: InputUnitEntryPair.DieEntry, Attrs: dwarf::DW_AT_decl_file)) {
247 if (std::optional<DWARFFormValue> DeclLineVal = InputUnitEntryPair.CU->find(
248 Die: InputUnitEntryPair.DieEntry, Attrs: dwarf::DW_AT_decl_line)) {
249 if (std::optional<std::pair<StringRef, StringRef>> DirAndFilename =
250 InputUnitEntryPair.CU->getDirAndFilenameFromLineTable(
251 FileIdxValue: *DeclFileVal)) {
252 SyntheticName += DirAndFilename->first;
253 SyntheticName += DirAndFilename->second;
254
255 if (std::optional<uint64_t> DeclLineIntVal =
256 dwarf::toUnsigned(V: *DeclLineVal)) {
257 SyntheticName += " ";
258 SyntheticName += utohexstr(X: *DeclLineIntVal);
259 }
260
261 HasDeclFileName = true;
262 }
263 }
264 }
265}
266
267void SyntheticTypeNameBuilder::addValueName(UnitEntryPairTy InputUnitEntryPair,
268 dwarf::Attribute Attr) {
269 if (std::optional<DWARFFormValue> Val =
270 InputUnitEntryPair.CU->find(Die: InputUnitEntryPair.DieEntry, Attrs: Attr)) {
271 if (std::optional<uint64_t> ConstVal = Val->getAsUnsignedConstant()) {
272 SyntheticName += " ";
273 SyntheticName += std::to_string(val: *ConstVal);
274 } else if (std::optional<int64_t> ConstVal = Val->getAsSignedConstant()) {
275 SyntheticName += " ";
276 SyntheticName += std::to_string(val: *ConstVal);
277 }
278 }
279}
280
281Expected<std::optional<UnitEntryPairTy>>
282SyntheticTypeNameBuilder::resolveReference(UnitEntryPairTy InputUnitEntryPair,
283 dwarf::Attribute Attr) {
284 std::optional<DWARFFormValue> AttrValue =
285 InputUnitEntryPair.CU->find(Die: InputUnitEntryPair.DieEntry, Attrs: Attr);
286 if (!AttrValue)
287 return std::nullopt;
288
289 std::optional<UnitEntryPairTy> RefDie =
290 InputUnitEntryPair.CU->resolveDIEReference(
291 RefValue: *AttrValue, CanResolveInterCUReferences: ResolveInterCUReferencesMode::Resolve);
292 if (RefDie && !RefDie->DieEntry)
293 return createStringError(EC: std::errc::invalid_argument,
294 Fmt: "cannot resolve DIE reference");
295 return RefDie;
296}
297
298Error SyntheticTypeNameBuilder::incrementRecursionDepth() {
299 if (++RecursionDepth > MaxRecursionDepth)
300 return createStringError(EC: std::errc::invalid_argument,
301 Fmt: "cannot parse input DWARF: recursive dependence");
302 return Error::success();
303}
304
305Error SyntheticTypeNameBuilder::addReferencedODRDies(
306 UnitEntryPairTy InputUnitEntryPair, bool AssignNameToTypeDescriptor,
307 ArrayRef<dwarf::Attribute> ODRAttrs) {
308 bool FirstIteration = true;
309 for (dwarf::Attribute Attr : ODRAttrs) {
310 Expected<std::optional<UnitEntryPairTy>> RefDie =
311 resolveReference(InputUnitEntryPair, Attr);
312 if (!RefDie)
313 return RefDie.takeError();
314 if (!*RefDie)
315 continue;
316
317 if (!FirstIteration)
318 SyntheticName += ",";
319
320 if (Error Err = incrementRecursionDepth())
321 return Err;
322 if (Error Err =
323 addDIETypeName(InputUnitEntryPair: **RefDie, ChildIndex: std::nullopt, AssignNameToTypeDescriptor))
324 return Err;
325 RecursionDepth--;
326 FirstIteration = false;
327 }
328
329 return Error::success();
330}
331
332Error SyntheticTypeNameBuilder::addTypeName(UnitEntryPairTy InputUnitEntryPair,
333 bool AddParentNames) {
334 bool HasLinkageName = false;
335 bool HasShortName = false;
336 bool HasTemplatesInShortName = false;
337 bool HasDeclFileName = false;
338
339 // Try to get name from the DIE.
340 if (std::optional<DWARFFormValue> Val = InputUnitEntryPair.CU->find(
341 Die: InputUnitEntryPair.DieEntry,
342 Attrs: {dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_AT_linkage_name})) {
343 // Firstly check for linkage name.
344 SyntheticName += dwarf::toStringRef(V: Val);
345 HasLinkageName = true;
346 } else if (std::optional<DWARFFormValue> Val = InputUnitEntryPair.CU->find(
347 Die: InputUnitEntryPair.DieEntry, Attrs: dwarf::DW_AT_name)) {
348 // Then check for short name.
349 StringRef Name = dwarf::toStringRef(V: Val);
350 SyntheticName += Name;
351
352 HasShortName = true;
353 HasTemplatesInShortName =
354 Name.ends_with(Suffix: ">") && Name.count(Str: "<") != 0 && !Name.ends_with(Suffix: "<=>");
355 } else {
356 // Finally check for declaration attributes.
357 addDieNameFromDeclFileAndDeclLine(InputUnitEntryPair, HasDeclFileName);
358
359 // Unnamed types declared on one line differ only in their contents.
360 if (HasDeclFileName)
361 if (Error Err = addUnnamedTypeContents(InputUnitEntryPair))
362 return Err;
363 }
364
365 // Add additional name parts for some DIEs.
366 switch (InputUnitEntryPair.DieEntry->getTag()) {
367 case dwarf::DW_TAG_union_type:
368 case dwarf::DW_TAG_interface_type:
369 case dwarf::DW_TAG_class_type:
370 case dwarf::DW_TAG_structure_type:
371 case dwarf::DW_TAG_subroutine_type:
372 case dwarf::DW_TAG_subprogram: {
373 if (InputUnitEntryPair.CU->find(Die: InputUnitEntryPair.DieEntry,
374 Attrs: dwarf::DW_AT_artificial))
375 SyntheticName += "^";
376
377 // No need to add signature information for linkage name,
378 // also no need to add template parameters name if short name already
379 // includes them.
380 if (!HasLinkageName)
381 if (Error Err =
382 addSignature(InputUnitEntryPair, addTemplateParameters: !HasTemplatesInShortName))
383 return Err;
384 } break;
385 case dwarf::DW_TAG_coarray_type:
386 case dwarf::DW_TAG_array_type: {
387 addArrayDimension(InputUnitEntryPair);
388 } break;
389 case dwarf::DW_TAG_subrange_type: {
390 addValueName(InputUnitEntryPair, Attr: dwarf::DW_AT_count);
391 } break;
392 case dwarf::DW_TAG_template_value_parameter: {
393 if (!HasTemplatesInShortName) {
394 // TODO add support for DW_AT_location
395 addValueName(InputUnitEntryPair, Attr: dwarf::DW_AT_const_value);
396 }
397 } break;
398 default: {
399 // Nothing to do.
400 } break;
401 }
402
403 // If name for the DIE is not determined yet or if the DIE is a typedef, add
404 // referenced types to the name.
405 if ((!HasLinkageName && !HasShortName && !HasDeclFileName) ||
406 InputUnitEntryPair.DieEntry->getTag() == dwarf::DW_TAG_typedef) {
407 if (InputUnitEntryPair.CU->find(Die: InputUnitEntryPair.DieEntry,
408 Attrs: getODRAttributes()))
409 if (Error Err = addReferencedODRDies(InputUnitEntryPair, AssignNameToTypeDescriptor: AddParentNames,
410 ODRAttrs: getODRAttributes()))
411 return Err;
412 }
413
414 return Error::success();
415}
416
417Error SyntheticTypeNameBuilder::addDIETypeName(
418 UnitEntryPairTy InputUnitEntryPair,
419 std::optional<std::pair<size_t, size_t>> ChildIndex,
420 bool AssignNameToTypeDescriptor) {
421 std::optional<UnitEntryPairTy> UnitEntryPair =
422 getTypeDeduplicationCandidate(UnitEntryPair: InputUnitEntryPair);
423 if (!UnitEntryPair)
424 return Error::success();
425
426 TypeEntry *TypeEntryPtr =
427 InputUnitEntryPair.CU->getDieTypeEntry(InputDieEntry: InputUnitEntryPair.DieEntry);
428 // Check if DIE already has a name.
429 if (!TypeEntryPtr) {
430 size_t NameStart = SyntheticName.size();
431 // Prepend the parent scope so this key matches the entry the type is
432 // assigned once it has one. Otherwise the same type gets different keys
433 // depending on whether it already has a pool entry, which races under
434 // parallel assignment and breaks deterministic deduplication.
435 if (Error Err = addParentName(InputUnitEntryPair&: *UnitEntryPair))
436 return Err;
437 addTypePrefix(CU&: *UnitEntryPair->CU, DieEntry: UnitEntryPair->DieEntry);
438
439 if (ChildIndex) {
440 addOrderedName(ChildIdx: *ChildIndex);
441 } else {
442 if (Error Err = addTypeName(InputUnitEntryPair: *UnitEntryPair, AddParentNames: AssignNameToTypeDescriptor))
443 return Err;
444 }
445
446 // Intern unassigned keys too, since references point at interned entries.
447 TypeEntryPtr = TypePoolRef.insert(Name: SyntheticName.str().substr(Start: NameStart));
448 if (AssignNameToTypeDescriptor)
449 InputUnitEntryPair.CU->setDieTypeEntry(InputDieEntry: InputUnitEntryPair.DieEntry,
450 Entry: TypeEntryPtr);
451 SyntheticName.truncate(Size: NameStart);
452 }
453 SyntheticName.appendRef(Entry: TypeEntryPtr);
454
455 return Error::success();
456}
457
458Error SyntheticTypeNameBuilder::addUnnamedTypeContents(
459 UnitEntryPairTy InputUnitEntryPair) {
460 if (!isIdentifiedByChildren(Tag: InputUnitEntryPair.DieEntry->getTag()))
461 return Error::success();
462
463 auto It = ContentsDigests.find(Val: InputUnitEntryPair.DieEntry);
464 if (It != ContentsDigests.end()) {
465 SyntheticName += It->second;
466 return Error::success();
467 }
468
469 CompileUnit &CU = *InputUnitEntryPair.CU;
470 size_t ContentsStart = SyntheticName.size();
471 SyntheticName += '(';
472 for (const DWARFDebugInfoEntry *CurChild =
473 CU.getFirstChildEntry(Die: InputUnitEntryPair.DieEntry);
474 CurChild && CurChild->getAbbreviationDeclarationPtr();
475 CurChild = CU.getSiblingEntry(Die: CurChild)) {
476 if (!isIdentifyingChild(Die: DWARFDie(&CU.getOrigUnit(), CurChild)))
477 continue;
478
479 if (SyntheticName.size() != ContentsStart + 1)
480 SyntheticName += ", ";
481 addTypePrefix(CU, DieEntry: CurChild);
482 if (std::optional<DWARFFormValue> Val =
483 CU.find(Die: CurChild, Attrs: dwarf::DW_AT_name))
484 SyntheticName += dwarf::toStringRef(V: Val);
485 if (Error Err = addUnqualifiedTypeName(InputUnitEntryPair: UnitEntryPairTy{&CU, CurChild}))
486 return Err;
487 }
488 SyntheticName += ')';
489
490 // Replace the contents with a fixed-size digest, so the names of the types
491 // referring to this one do not grow with its size or nesting depth.
492 StringRef Contents = SyntheticName.str().substr(Start: ContentsStart);
493 XXH128_hash_t Hash = xxh3_128bits(data: arrayRefFromStringRef<uint8_t>(Input: Contents));
494 std::string Digest = "<" + utohexstr(X: Hash.high64, LowerCase: true, Width: 16) +
495 utohexstr(X: Hash.low64, LowerCase: true, Width: 16) + ">";
496 SyntheticName.truncate(Size: ContentsStart);
497 SyntheticName += Digest;
498 ContentsDigests.try_emplace(Key: InputUnitEntryPair.DieEntry, Args: std::move(Digest));
499 return Error::success();
500}
501
502Error SyntheticTypeNameBuilder::addUnqualifiedTypeName(
503 UnitEntryPairTy InputUnitEntryPair) {
504 Expected<std::optional<UnitEntryPairTy>> RefDie =
505 resolveReference(InputUnitEntryPair, Attr: dwarf::DW_AT_type);
506 if (!RefDie)
507 return RefDie.takeError();
508 if (!*RefDie)
509 return Error::success();
510
511 if (Error Err = incrementRecursionDepth())
512 return Err;
513
514 UnitEntryPairTy Type = **RefDie;
515 SyntheticName += ':';
516 addTypePrefix(CU&: *Type.CU, DieEntry: Type.DieEntry);
517 if (std::optional<DWARFFormValue> Val =
518 Type.CU->find(Die: Type.DieEntry, Attrs: dwarf::DW_AT_name)) {
519 SyntheticName += dwarf::toStringRef(V: Val);
520 } else {
521 if (Type.DieEntry->getTag() == dwarf::DW_TAG_array_type)
522 addArrayDimension(InputUnitEntryPair: Type);
523 if (Error Err = addUnnamedTypeContents(InputUnitEntryPair: Type))
524 return Err;
525 if (Error Err = addUnqualifiedTypeName(InputUnitEntryPair: Type))
526 return Err;
527 }
528
529 RecursionDepth--;
530 return Error::success();
531}
532
533void SyntheticTypeNameBuilder::addTypePrefix(
534 CompileUnit &CU, const DWARFDebugInfoEntry *DieEntry) {
535 switch (DieEntry->getTag()) {
536 case dwarf::DW_TAG_base_type: {
537 SyntheticName += "{0}";
538 } break;
539 case dwarf::DW_TAG_namespace: {
540 SyntheticName += "{1}";
541 } break;
542 case dwarf::DW_TAG_formal_parameter: {
543 SyntheticName += "{2}";
544 } break;
545 // dwarf::DW_TAG_unspecified_parameters have the same prefix as before.
546 case dwarf::DW_TAG_unspecified_parameters: {
547 SyntheticName += "{2}";
548 } break;
549 case dwarf::DW_TAG_template_type_parameter: {
550 SyntheticName += "{3}";
551 } break;
552 // dwarf::DW_TAG_template_value_parameter have the same prefix as before.
553 case dwarf::DW_TAG_template_value_parameter: {
554 SyntheticName += "{3}";
555 } break;
556 case dwarf::DW_TAG_GNU_formal_parameter_pack: {
557 SyntheticName += "{4}";
558 } break;
559 case dwarf::DW_TAG_GNU_template_parameter_pack: {
560 SyntheticName += "{5}";
561 } break;
562 case dwarf::DW_TAG_inheritance: {
563 SyntheticName += "{6}";
564 } break;
565 case dwarf::DW_TAG_array_type: {
566 SyntheticName += "{7}";
567 } break;
568 case dwarf::DW_TAG_class_type: {
569 SyntheticName += "{8}";
570 } break;
571 case dwarf::DW_TAG_enumeration_type: {
572 SyntheticName += "{9}";
573 } break;
574 case dwarf::DW_TAG_imported_declaration: {
575 SyntheticName += "{A}";
576 } break;
577 case dwarf::DW_TAG_member: {
578 // Treat a static data member the same way regardless of whether it's
579 // described as a DW_TAG_member or a DW_TAG_variable.
580 if (isStaticDataMember(Die: DWARFDie(&CU.getOrigUnit(), DieEntry)))
581 SyntheticName += "{d}";
582 else
583 SyntheticName += "{B}";
584 } break;
585 case dwarf::DW_TAG_pointer_type: {
586 SyntheticName += "{C}";
587 } break;
588 case dwarf::DW_TAG_reference_type: {
589 SyntheticName += "{D}";
590 } break;
591 case dwarf::DW_TAG_string_type: {
592 SyntheticName += "{E}";
593 } break;
594 case dwarf::DW_TAG_structure_type: {
595 SyntheticName += "{F}";
596 } break;
597 case dwarf::DW_TAG_subroutine_type: {
598 SyntheticName += "{G}";
599 } break;
600 case dwarf::DW_TAG_typedef: {
601 SyntheticName += "{H}";
602 } break;
603 case dwarf::DW_TAG_union_type: {
604 SyntheticName += "{I}";
605 } break;
606 case dwarf::DW_TAG_variant: {
607 SyntheticName += "{J}";
608 } break;
609 case dwarf::DW_TAG_inlined_subroutine: {
610 SyntheticName += "{K}";
611 } break;
612 case dwarf::DW_TAG_module: {
613 SyntheticName += "{L}";
614 } break;
615 case dwarf::DW_TAG_ptr_to_member_type: {
616 SyntheticName += "{M}";
617 } break;
618 case dwarf::DW_TAG_set_type: {
619 SyntheticName += "{N}";
620 } break;
621 case dwarf::DW_TAG_subrange_type: {
622 SyntheticName += "{O}";
623 } break;
624 case dwarf::DW_TAG_with_stmt: {
625 SyntheticName += "{P}";
626 } break;
627 case dwarf::DW_TAG_access_declaration: {
628 SyntheticName += "{Q}";
629 } break;
630 case dwarf::DW_TAG_catch_block: {
631 SyntheticName += "{R}";
632 } break;
633 case dwarf::DW_TAG_const_type: {
634 SyntheticName += "{S}";
635 } break;
636 case dwarf::DW_TAG_constant: {
637 SyntheticName += "{T}";
638 } break;
639 case dwarf::DW_TAG_enumerator: {
640 SyntheticName += "{U}";
641 } break;
642 case dwarf::DW_TAG_file_type: {
643 SyntheticName += "{V}";
644 } break;
645 case dwarf::DW_TAG_friend: {
646 SyntheticName += "{W}";
647 } break;
648 case dwarf::DW_TAG_namelist: {
649 SyntheticName += "{X}";
650 } break;
651 case dwarf::DW_TAG_namelist_item: {
652 SyntheticName += "{Y}";
653 } break;
654 case dwarf::DW_TAG_packed_type: {
655 SyntheticName += "{Z}";
656 } break;
657 case dwarf::DW_TAG_subprogram: {
658 SyntheticName += "{a}";
659 } break;
660 case dwarf::DW_TAG_thrown_type: {
661 SyntheticName += "{b}";
662 } break;
663 case dwarf::DW_TAG_variant_part: {
664 SyntheticName += "{c}";
665 } break;
666 case dwarf::DW_TAG_variable: {
667 SyntheticName += "{d}";
668 } break;
669 case dwarf::DW_TAG_volatile_type: {
670 SyntheticName += "{e}";
671 } break;
672 case dwarf::DW_TAG_dwarf_procedure: {
673 SyntheticName += "{f}";
674 } break;
675 case dwarf::DW_TAG_restrict_type: {
676 SyntheticName += "{g}";
677 } break;
678 case dwarf::DW_TAG_interface_type: {
679 SyntheticName += "{h}";
680 } break;
681 case dwarf::DW_TAG_imported_module: {
682 SyntheticName += "{i}";
683 } break;
684 case dwarf::DW_TAG_unspecified_type: {
685 SyntheticName += "{j}";
686 } break;
687 case dwarf::DW_TAG_imported_unit: {
688 SyntheticName += "{k}";
689 } break;
690 case dwarf::DW_TAG_condition: {
691 SyntheticName += "{l}";
692 } break;
693 case dwarf::DW_TAG_shared_type: {
694 SyntheticName += "{m}";
695 } break;
696 case dwarf::DW_TAG_rvalue_reference_type: {
697 SyntheticName += "{n}";
698 } break;
699 case dwarf::DW_TAG_template_alias: {
700 SyntheticName += "{o}";
701 } break;
702 case dwarf::DW_TAG_coarray_type: {
703 SyntheticName += "{p}";
704 } break;
705 case dwarf::DW_TAG_generic_subrange: {
706 SyntheticName += "{q}";
707 } break;
708 case dwarf::DW_TAG_dynamic_type: {
709 SyntheticName += "{r}";
710 } break;
711 case dwarf::DW_TAG_atomic_type: {
712 SyntheticName += "{s}";
713 } break;
714 case dwarf::DW_TAG_call_site: {
715 SyntheticName += "{t}";
716 } break;
717 case dwarf::DW_TAG_call_site_parameter: {
718 SyntheticName += "{u}";
719 } break;
720 case dwarf::DW_TAG_immutable_type: {
721 SyntheticName += "{v}";
722 } break;
723 case dwarf::DW_TAG_entry_point: {
724 SyntheticName += "{w}";
725 } break;
726 case dwarf::DW_TAG_label: {
727 SyntheticName += "{x}";
728 } break;
729 case dwarf::DW_TAG_lexical_block: {
730 SyntheticName += "{y}";
731 } break;
732 case dwarf::DW_TAG_common_block: {
733 SyntheticName += "{z}";
734 } break;
735 case dwarf::DW_TAG_common_inclusion: {
736 SyntheticName += "{|}";
737 } break;
738 case dwarf::DW_TAG_try_block: {
739 SyntheticName += "{~}";
740 } break;
741
742 case dwarf::DW_TAG_null: {
743 llvm_unreachable("No type prefix for DW_TAG_null");
744 } break;
745 case dwarf::DW_TAG_compile_unit: {
746 llvm_unreachable("No type prefix for DW_TAG_compile_unit");
747 } break;
748 case dwarf::DW_TAG_partial_unit: {
749 llvm_unreachable("No type prefix for DW_TAG_partial_unit");
750 } break;
751 case dwarf::DW_TAG_type_unit: {
752 llvm_unreachable("No type prefix for DW_TAG_type_unit");
753 } break;
754 case dwarf::DW_TAG_skeleton_unit: {
755 llvm_unreachable("No type prefix for DW_TAG_skeleton_unit");
756 } break;
757
758 default: {
759 SyntheticName += "{~~";
760 SyntheticName += utohexstr(X: DieEntry->getTag());
761 SyntheticName += "}";
762 } break;
763 }
764}
765
766OrderedChildrenIndexAssigner::OrderedChildrenIndexAssigner(
767 CompileUnit &CU, const DWARFDebugInfoEntry *DieEntry) {
768 switch (DieEntry->getTag()) {
769 case dwarf::DW_TAG_array_type:
770 case dwarf::DW_TAG_coarray_type:
771 case dwarf::DW_TAG_class_type:
772 case dwarf::DW_TAG_common_block:
773 case dwarf::DW_TAG_lexical_block:
774 case dwarf::DW_TAG_structure_type:
775 case dwarf::DW_TAG_subprogram:
776 case dwarf::DW_TAG_subroutine_type:
777 case dwarf::DW_TAG_union_type:
778 case dwarf::DW_TAG_GNU_template_template_param:
779 case dwarf::DW_TAG_GNU_formal_parameter_pack:
780 case dwarf::DW_TAG_GNU_template_parameter_pack: {
781 NeedCountChildren = true;
782 } break;
783 case dwarf::DW_TAG_enumeration_type: {
784 // TODO : do we need to add condition
785 NeedCountChildren = true;
786 } break;
787 default: {
788 // Nothing to do.
789 }
790 }
791
792 // Calculate maximal index value
793 if (NeedCountChildren) {
794 for (const DWARFDebugInfoEntry *CurChild = CU.getFirstChildEntry(Die: DieEntry);
795 CurChild && CurChild->getAbbreviationDeclarationPtr();
796 CurChild = CU.getSiblingEntry(Die: CurChild)) {
797 std::optional<size_t> ArrayIndex = tagToArrayIndex(CU, DieEntry: CurChild);
798 if (!ArrayIndex)
799 continue;
800
801 assert((*ArrayIndex < ChildIndexesWidth.size()) &&
802 "Wrong index for ChildIndexesWidth");
803 ChildIndexesWidth[*ArrayIndex]++;
804 }
805
806 // Calculate index field width(number of digits in hexadecimal
807 // representation).
808 for (size_t &Width : ChildIndexesWidth) {
809 size_t digitsCounter = 1;
810 size_t NumToCompare = 15;
811
812 while (NumToCompare < Width) {
813 NumToCompare <<= 4;
814 digitsCounter++;
815 }
816
817 Width = digitsCounter;
818 }
819 }
820}
821
822std::optional<size_t> OrderedChildrenIndexAssigner::tagToArrayIndex(
823 CompileUnit &CU, const DWARFDebugInfoEntry *DieEntry) {
824 if (!NeedCountChildren)
825 return std::nullopt;
826
827 switch (DieEntry->getTag()) {
828 case dwarf::DW_TAG_unspecified_parameters:
829 case dwarf::DW_TAG_formal_parameter:
830 return 0;
831 case dwarf::DW_TAG_template_value_parameter:
832 case dwarf::DW_TAG_template_type_parameter:
833 case dwarf::DW_TAG_GNU_template_template_param:
834 return 1;
835 case dwarf::DW_TAG_enumeration_type:
836 if (std::optional<uint32_t> ParentIdx = DieEntry->getParentIdx()) {
837 if (*ParentIdx && CU.getDebugInfoEntry(Index: *ParentIdx)->getTag() ==
838 dwarf::DW_TAG_array_type)
839 return 2;
840 }
841 return std::nullopt;
842 case dwarf::DW_TAG_subrange_type:
843 return 3;
844 case dwarf::DW_TAG_generic_subrange:
845 return 4;
846 case dwarf::DW_TAG_enumerator:
847 return 5;
848 case dwarf::DW_TAG_namelist_item:
849 return 6;
850 case dwarf::DW_TAG_member:
851 // Treat a static data member the same way regardless of whether it's
852 // described as a DW_TAG_member or a DW_TAG_variable.
853 if (isStaticDataMember(Die: DWARFDie(&CU.getOrigUnit(), DieEntry)))
854 return std::nullopt;
855 return 7;
856 default:
857 return std::nullopt;
858 };
859}
860
861std::optional<std::pair<size_t, size_t>>
862OrderedChildrenIndexAssigner::getChildIndex(
863 CompileUnit &CU, const DWARFDebugInfoEntry *ChildDieEntry) {
864 std::optional<size_t> ArrayIndex = tagToArrayIndex(CU, DieEntry: ChildDieEntry);
865 if (!ArrayIndex)
866 return std::nullopt;
867
868 assert((*ArrayIndex < OrderedChildIdxs.size()) &&
869 "Wrong index for ChildIndexesWidth");
870 assert(ChildIndexesWidth[*ArrayIndex] < 16 &&
871 "Index width exceeds 16 digits.");
872
873 std::pair<size_t, size_t> Result = std::make_pair(
874 x&: OrderedChildIdxs[*ArrayIndex], y&: ChildIndexesWidth[*ArrayIndex]);
875 OrderedChildIdxs[*ArrayIndex]++;
876 return Result;
877}
878