| 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 | |
| 17 | using namespace llvm; |
| 18 | using namespace dwarf_linker; |
| 19 | using namespace dwarf_linker::parallel; |
| 20 | |
| 21 | Error 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 | |
| 38 | void 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 | |
| 63 | static dwarf::Attribute TypeAttr[] = {dwarf::DW_AT_type}; |
| 64 | Error 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 | |
| 114 | Error 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 | |
| 133 | Error 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 | |
| 162 | void 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. |
| 172 | static std::optional<UnitEntryPairTy> |
| 173 | getTypeDeduplicationCandidate(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 | |
| 198 | Error 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 | |
| 243 | void 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 | |
| 267 | void 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 | |
| 281 | Expected<std::optional<UnitEntryPairTy>> |
| 282 | SyntheticTypeNameBuilder::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 | |
| 298 | Error 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 | |
| 305 | Error 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 | |
| 332 | Error 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 | |
| 417 | Error 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 | |
| 458 | Error 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 | |
| 502 | Error 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 | |
| 533 | void 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 | |
| 766 | OrderedChildrenIndexAssigner::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 | |
| 822 | std::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 | |
| 861 | std::optional<std::pair<size_t, size_t>> |
| 862 | OrderedChildrenIndexAssigner::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 | |