llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

   1 //===- DwarfTransformer.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 "llvm/DebugInfo/DIContext.h"
  10 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
  11 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  12 #include "llvm/Support/Error.h"
  13 #include "llvm/Support/ThreadPool.h"
  14 #include "llvm/Support/raw_ostream.h"
  15
  16 #include "llvm/DebugInfo/GSYM/DwarfTransformer.h"
  17 #include "llvm/DebugInfo/GSYM/FunctionInfo.h"
  18 #include "llvm/DebugInfo/GSYM/GsymCreator.h"
  19 #include "llvm/DebugInfo/GSYM/GsymReader.h"
  20 #include "llvm/DebugInfo/GSYM/InlineInfo.h"
  21 #include "llvm/DebugInfo/GSYM/OutputAggregator.h"
  22
  23 #include <optional>
  24
  25 using namespace llvm;
  26 using namespace gsym;
  27
  28 struct llvm::gsym::CUInfo {
  29   const DWARFDebugLine::LineTable *LineTable;
  30   const char *CompDir;
  31   std::vector<uint32_t> FileCache;
  32   uint64_t Language = 0;
  33   uint8_t AddrSize = 0;
  34
  35   CUInfo(DWARFContext &DICtx, DWARFCompileUnit *CU) {
  36     LineTable = DICtx.getLineTableForUnit(CU);
  37     CompDir = CU->getCompilationDir();
  38     FileCache.clear();
  39     if (LineTable)
  40       FileCache.assign(LineTable->Prologue.FileNames.size() + 1, UINT32_MAX);
  41     DWARFDie Die = CU->getUnitDIE();
  42     Language = dwarf::toUnsigned(Die.find(dwarf::DW_AT_language), 0);
  43     AddrSize = CU->getAddressByteSize();
  44   }
  45
  46   /// Return true if Addr is the highest address for a given compile unit. The
  47   /// highest address is encoded as -1, of all ones in the address. These high
  48   /// addresses are used by some linkers to indicate that a function has been
  49   /// dead stripped or didn't end up in the linked executable.
  50   bool isHighestAddress(uint64_t Addr) const {
  51     if (AddrSize == 4)
  52       return Addr == UINT32_MAX;
  53     else if (AddrSize == 8)
  54       return Addr == UINT64_MAX;
  55     return false;
  56   }
  57
  58   /// Convert a DWARF compile unit file index into a GSYM global file index.
  59   ///
  60   /// Each compile unit in DWARF has its own file table in the line table
  61   /// prologue. GSYM has a single large file table that applies to all files
  62   /// from all of the info in a GSYM file. This function converts between the
  63   /// two and caches and DWARF CU file index that has already been converted so
  64   /// the first client that asks for a compile unit file index will end up
  65   /// doing the conversion, and subsequent clients will get the cached GSYM
  66   /// index.
  67   std::optional<uint32_t> DWARFToGSYMFileIndex(GsymCreator &Gsym,
  68                                                uint32_t DwarfFileIdx) {
  69     if (!LineTable || DwarfFileIdx >= FileCache.size())
  70       return std::nullopt;
  71     uint32_t &GsymFileIdx = FileCache[DwarfFileIdx];
  72     if (GsymFileIdx != UINT32_MAX)
  73       return GsymFileIdx;
  74     std::string File;
  75     if (LineTable->getFileNameByIndex(
  76             DwarfFileIdx, CompDir,
  77             DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File))
  78       GsymFileIdx = Gsym.insertFile(File);
  79     else
  80       GsymFileIdx = 0;
  81     return GsymFileIdx;
  82   }
  83 };
  84
  85
  86 static DWARFDie GetParentDeclContextDIE(DWARFDie &Die) {
  87   if (DWARFDie SpecDie =
  88           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_specification)) {
  89     if (DWARFDie SpecParent = GetParentDeclContextDIE(SpecDie))
  90       return SpecParent;
  91   }
  92   if (DWARFDie AbstDie =
  93           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin)) {
  94     if (DWARFDie AbstParent = GetParentDeclContextDIE(AbstDie))
  95       return AbstParent;
  96   }
  97
  98   // We never want to follow parent for inlined subroutine - that would
  99   // give us information about where the function is inlined, not what
 100   // function is inlined
 101   if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine)
 102     return DWARFDie();
 103
 104   DWARFDie ParentDie = Die.getParent();
 105   if (!ParentDie)
 106     return DWARFDie();
 107
 108   switch (ParentDie.getTag()) {
 109   case dwarf::DW_TAG_namespace:
 110   case dwarf::DW_TAG_structure_type:
 111   case dwarf::DW_TAG_union_type:
 112   case dwarf::DW_TAG_class_type:
 113   case dwarf::DW_TAG_subprogram:
 114     return ParentDie; // Found parent decl context DIE
 115   case dwarf::DW_TAG_lexical_block:
 116     return GetParentDeclContextDIE(ParentDie);
 117   default:
 118     break;
 119   }
 120
 121   return DWARFDie();
 122 }
 123
 124 /// Get the GsymCreator string table offset for the qualified name for the
 125 /// DIE passed in. This function will avoid making copies of any strings in
 126 /// the GsymCreator when possible. We don't need to copy a string when the
 127 /// string comes from our .debug_str section or is an inlined string in the
 128 /// .debug_info. If we create a qualified name string in this function by
 129 /// combining multiple strings in the DWARF string table or info, we will make
 130 /// a copy of the string when we add it to the string table.
 131 static std::optional<uint32_t>
 132 getQualifiedNameIndex(DWARFDie &Die, uint64_t Language, GsymCreator &Gsym) {
 133   // If the dwarf has mangled name, use mangled name
 134   if (auto LinkageName = Die.getLinkageName()) {
 135     // We have seen cases were linkage name is actually empty.
 136     if (strlen(LinkageName) > 0)
 137       return Gsym.insertString(LinkageName, /* Copy */ false);
 138   }
 139
 140   StringRef ShortName(Die.getName(DINameKind::ShortName));
 141   if (ShortName.empty())
 142     return std::nullopt;
 143
 144   // For C++ and ObjC, prepend names of all parent declaration contexts
 145   if (!(Language == dwarf::DW_LANG_C_plus_plus ||
 146         Language == dwarf::DW_LANG_C_plus_plus_03 ||
 147         Language == dwarf::DW_LANG_C_plus_plus_11 ||
 148         Language == dwarf::DW_LANG_C_plus_plus_14 ||
 149         Language == dwarf::DW_LANG_ObjC_plus_plus ||
 150         // This should not be needed for C, but we see C++ code marked as C
 151         // in some binaries. This should hurt, so let's do it for C as well
 152         Language == dwarf::DW_LANG_C))
 153     return Gsym.insertString(ShortName, /* Copy */ false);
 154
 155   // Some GCC optimizations create functions with names ending with .isra.<num>
 156   // or .part.<num> and those names are just DW_AT_name, not DW_AT_linkage_name
 157   // If it looks like it could be the case, don't add any prefix
 158   if (ShortName.starts_with("_Z") &&
 159       (ShortName.contains(".isra.") || ShortName.contains(".part.")))
 160     return Gsym.insertString(ShortName, /* Copy */ false);
 161
 162   DWARFDie ParentDeclCtxDie = GetParentDeclContextDIE(Die);
 163   if (ParentDeclCtxDie) {
 164     std::string Name = ShortName.str();
 165     while (ParentDeclCtxDie) {
 166       StringRef ParentName(ParentDeclCtxDie.getName(DINameKind::ShortName));
 167       if (!ParentName.empty()) {
 168         // "lambda" names are wrapped in < >. Replace with { }
 169         // to be consistent with demangled names and not to confuse with
 170         // templates
 171         if (ParentName.front() == '<' && ParentName.back() == '>')
 172           Name = "{" + ParentName.substr(1, ParentName.size() - 2).str() + "}" +
 173                 "::" + Name;
 174         else
 175           Name = ParentName.str() + "::" + Name;
 176       }
 177       ParentDeclCtxDie = GetParentDeclContextDIE(ParentDeclCtxDie);
 178     }
 179     // Copy the name since we created a new name in a std::string.
 180     return Gsym.insertString(Name, /* Copy */ true);
 181   }
 182   // Don't copy the name since it exists in the DWARF object file.
 183   return Gsym.insertString(ShortName, /* Copy */ false);
 184 }
 185
 186 static bool hasInlineInfo(DWARFDie Die, uint32_t Depth) {
 187   bool CheckChildren = true;
 188   switch (Die.getTag()) {
 189   case dwarf::DW_TAG_subprogram:
 190     // Don't look into functions within functions.
 191     CheckChildren = Depth == 0;
 192     break;
 193   case dwarf::DW_TAG_inlined_subroutine:
 194     return true;
 195   default:
 196     break;
 197   }
 198   if (!CheckChildren)
 199     return false;
 200   for (DWARFDie ChildDie : Die.children()) {
 201     if (hasInlineInfo(ChildDie, Depth + 1))
 202       return true;
 203   }
 204   return false;
 205 }
 206
 207 static AddressRanges
 208 ConvertDWARFRanges(const DWARFAddressRangesVector &DwarfRanges) {
 209   AddressRanges Ranges;
 210   for (const DWARFAddressRange &DwarfRange : DwarfRanges) {
 211     if (DwarfRange.LowPC < DwarfRange.HighPC)
 212       Ranges.insert({DwarfRange.LowPC, DwarfRange.HighPC});
 213   }
 214   return Ranges;
 215 }
 216
 217 static void parseInlineInfo(GsymCreator &Gsym, OutputAggregator &Out,
 218                             CUInfo &CUI, DWARFDie Die, uint32_t Depth,
 219                             FunctionInfo &FI, InlineInfo &Parent,
 220                             const AddressRanges &AllParentRanges,
 221                             bool &WarnIfEmpty) {
 222   if (!hasInlineInfo(Die, Depth))
 223     return;
 224
 225   dwarf::Tag Tag = Die.getTag();
 226   if (Tag == dwarf::DW_TAG_inlined_subroutine) {
 227     // create new InlineInfo and append to parent.children
 228     InlineInfo II;
 229     AddressRanges AllInlineRanges;
 230     Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
 231     if (RangesOrError) {
 232       AllInlineRanges = ConvertDWARFRanges(RangesOrError.get());
 233       uint32_t EmptyCount = 0;
 234       for (const AddressRange &InlineRange : AllInlineRanges) {
 235         // Check for empty inline range in case inline function was outlined
 236         // or has not code
 237         if (InlineRange.empty()) {
 238           ++EmptyCount;
 239         } else {
 240           if (Parent.Ranges.contains(InlineRange)) {
 241             II.Ranges.insert(InlineRange);
 242           } else {
 243             // Only warn if the current inline range is not within any of all
 244             // of the parent ranges. If we have a DW_TAG_subpgram with multiple
 245             // ranges we will emit a FunctionInfo for each range of that
 246             // function that only emits information within the current range,
 247             // so we only want to emit an error if the DWARF has issues, not
 248             // when a range currently just isn't in the range we are currently
 249             // parsing for.
 250             if (AllParentRanges.contains(InlineRange)) {
 251               WarnIfEmpty = false;
 252             } else
 253               Out.Report("Function DIE has uncontained address range",
 254                          [&](raw_ostream &OS) {
 255                            OS << "error: inlined function DIE at "
 256                               << HEX32(Die.getOffset()) << " has a range ["
 257                               << HEX64(InlineRange.start()) << " - "
 258                               << HEX64(InlineRange.end())
 259                               << ") that isn't contained in "
 260                               << "any parent address ranges, this inline range "
 261                                  "will be "
 262                                  "removed.\n";
 263                          });
 264           }
 265         }
 266       }
 267       // If we have all empty ranges for the inlines, then don't warn if we
 268       // have an empty InlineInfo at the top level as all inline functions
 269       // were elided.
 270       if (EmptyCount == AllInlineRanges.size())
 271         WarnIfEmpty = false;
 272     }
 273     if (II.Ranges.empty())
 274       return;
 275
 276     if (auto NameIndex = getQualifiedNameIndex(Die, CUI.Language, Gsym))
 277       II.Name = *NameIndex;
 278     const uint64_t DwarfFileIdx = dwarf::toUnsigned(
 279         Die.findRecursively(dwarf::DW_AT_call_file), UINT32_MAX);
 280     std::optional<uint32_t> OptGSymFileIdx =
 281         CUI.DWARFToGSYMFileIndex(Gsym, DwarfFileIdx);
 282     if (OptGSymFileIdx) {
 283       II.CallFile = OptGSymFileIdx.value();
 284       II.CallLine = dwarf::toUnsigned(Die.find(dwarf::DW_AT_call_line), 0);
 285       // parse all children and append to parent
 286       for (DWARFDie ChildDie : Die.children())
 287         parseInlineInfo(Gsym, Out, CUI, ChildDie, Depth + 1, FI, II,
 288                         AllInlineRanges, WarnIfEmpty);
 289       Parent.Children.emplace_back(std::move(II));
 290     } else
 291       Out.Report(
 292           "Inlined function die has invlaid file index in DW_AT_call_file",
 293           [&](raw_ostream &OS) {
 294             OS << "error: inlined function DIE at " << HEX32(Die.getOffset())
 295                << " has an invalid file index " << DwarfFileIdx
 296                << " in its DW_AT_call_file attribute, this inline entry and "
 297                   "all "
 298                << "children will be removed.\n";
 299           });
 300     return;
 301   }
 302   if (Tag == dwarf::DW_TAG_subprogram || Tag == dwarf::DW_TAG_lexical_block) {
 303     // skip this Die and just recurse down
 304     for (DWARFDie ChildDie : Die.children())
 305       parseInlineInfo(Gsym, Out, CUI, ChildDie, Depth + 1, FI, Parent,
 306                       AllParentRanges, WarnIfEmpty);
 307   }
 308 }
 309
 310 static void convertFunctionLineTable(OutputAggregator &Out, CUInfo &CUI,
 311                                      DWARFDie Die, GsymCreator &Gsym,
 312                                      FunctionInfo &FI) {
 313   std::vector<uint32_t> RowVector;
 314   const uint64_t StartAddress = FI.startAddress();
 315   const uint64_t EndAddress = FI.endAddress();
 316   const uint64_t RangeSize = EndAddress - StartAddress;
 317   const object::SectionedAddress SecAddress{
 318       StartAddress, object::SectionedAddress::UndefSection};
 319
 320
 321   if (!CUI.LineTable->lookupAddressRange(SecAddress, RangeSize, RowVector)) {
 322     // If we have a DW_TAG_subprogram but no line entries, fall back to using
 323     // the DW_AT_decl_file an d DW_AT_decl_line if we have both attributes.
 324     std::string FilePath = Die.getDeclFile(
 325         DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath);
 326     if (FilePath.empty()) {
 327       // If we had a DW_AT_decl_file, but got no file then we need to emit a
 328       // warning.
 329       Out.Report("Invalid file index in DW_AT_decl_file", [&](raw_ostream &OS) {
 330         const uint64_t DwarfFileIdx = dwarf::toUnsigned(
 331             Die.findRecursively(dwarf::DW_AT_decl_file), UINT32_MAX);
 332         OS << "error: function DIE at " << HEX32(Die.getOffset())
 333            << " has an invalid file index " << DwarfFileIdx
 334            << " in its DW_AT_decl_file attribute, unable to create a single "
 335            << "line entry from the DW_AT_decl_file/DW_AT_decl_line "
 336            << "attributes.\n";
 337       });
 338       return;
 339     }
 340     if (auto Line =
 341             dwarf::toUnsigned(Die.findRecursively({dwarf::DW_AT_decl_line}))) {
 342       LineEntry LE(StartAddress, Gsym.insertFile(FilePath), *Line);
 343       FI.OptLineTable = LineTable();
 344       FI.OptLineTable->push(LE);
 345     }
 346     return;
 347   }
 348
 349   FI.OptLineTable = LineTable();
 350   DWARFDebugLine::Row PrevRow;
 351   for (uint32_t RowIndex : RowVector) {
 352     // Take file number and line/column from the row.
 353     const DWARFDebugLine::Row &Row = CUI.LineTable->Rows[RowIndex];
 354     std::optional<uint32_t> OptFileIdx =
 355         CUI.DWARFToGSYMFileIndex(Gsym, Row.File);
 356     if (!OptFileIdx) {
 357       Out.Report(
 358           "Invalid file index in DWARF line table", [&](raw_ostream &OS) {
 359             OS << "error: function DIE at " << HEX32(Die.getOffset()) << " has "
 360                << "a line entry with invalid DWARF file index, this entry will "
 361                << "be removed:\n";
 362             Row.dumpTableHeader(OS, /*Indent=*/0);
 363             Row.dump(OS);
 364             OS << "\n";
 365           });
 366       continue;
 367     }
 368     const uint32_t FileIdx = OptFileIdx.value();
 369     uint64_t RowAddress = Row.Address.Address;
 370     // Watch out for a RowAddress that is in the middle of a line table entry
 371     // in the DWARF. If we pass an address in between two line table entries
 372     // we will get a RowIndex for the previous valid line table row which won't
 373     // be contained in our function. This is usually a bug in the DWARF due to
 374     // linker problems or LTO or other DWARF re-linking so it is worth emitting
 375     // an error, but not worth stopping the creation of the GSYM.
 376     if (!FI.Range.contains(RowAddress)) {
 377       if (RowAddress < FI.Range.start()) {
 378         Out.Report("Start address lies between valid Row table entries",
 379                    [&](raw_ostream &OS) {
 380                      OS << "error: DIE has a start address whose LowPC is "
 381                            "between the "
 382                            "line table Row["
 383                         << RowIndex << "] with address " << HEX64(RowAddress)
 384                         << " and the next one.\n";
 385                      Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 386                    });
 387         RowAddress = FI.Range.start();
 388       } else {
 389         continue;
 390       }
 391     }
 392
 393     LineEntry LE(RowAddress, FileIdx, Row.Line);
 394     if (RowIndex != RowVector[0] && Row.Address < PrevRow.Address) {
 395       // We have seen full duplicate line tables for functions in some
 396       // DWARF files. Watch for those here by checking the last
 397       // row was the function's end address (HighPC) and that the
 398       // current line table entry's address is the same as the first
 399       // line entry we already have in our "function_info.Lines". If
 400       // so break out after printing a warning.
 401       auto FirstLE = FI.OptLineTable->first();
 402       if (FirstLE && *FirstLE == LE)
 403         // if (Log && !Gsym.isQuiet()) { TODO <-- This looks weird
 404         Out.Report("Duplicate line table detected", [&](raw_ostream &OS) {
 405           OS << "warning: duplicate line table detected for DIE:\n";
 406           Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 407         });
 408       else
 409         Out.Report("Non-monotonically increasing addresses",
 410                    [&](raw_ostream &OS) {
 411                      OS << "error: line table has addresses that do not "
 412                         << "monotonically increase:\n";
 413                      for (uint32_t RowIndex2 : RowVector)
 414                        CUI.LineTable->Rows[RowIndex2].dump(OS);
 415                      Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 416                    });
 417       break;
 418     }
 419
 420     // Skip multiple line entries for the same file and line.
 421     auto LastLE = FI.OptLineTable->last();
 422     if (LastLE && LastLE->File == FileIdx && LastLE->Line == Row.Line)
 423         continue;
 424     // Only push a row if it isn't an end sequence. End sequence markers are
 425     // included for the last address in a function or the last contiguous
 426     // address in a sequence.
 427     if (Row.EndSequence) {
 428       // End sequence means that the next line entry could have a lower address
 429       // that the previous entries. So we clear the previous row so we don't
 430       // trigger the line table error about address that do not monotonically
 431       // increase.
 432       PrevRow = DWARFDebugLine::Row();
 433     } else {
 434       FI.OptLineTable->push(LE);
 435       PrevRow = Row;
 436     }
 437   }
 438   // If not line table rows were added, clear the line table so we don't encode
 439   // on in the GSYM file.
 440   if (FI.OptLineTable->empty())
 441     FI.OptLineTable = std::nullopt;
 442 }
 443
 444 void DwarfTransformer::handleDie(OutputAggregator &Out, CUInfo &CUI,
 445                                  DWARFDie Die) {
 446   switch (Die.getTag()) {
 447   case dwarf::DW_TAG_subprogram: {
 448     Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
 449     if (!RangesOrError) {
 450       consumeError(RangesOrError.takeError());
 451       break;
 452     }
 453     const DWARFAddressRangesVector &Ranges = RangesOrError.get();
 454     if (Ranges.empty())
 455       break;
 456     auto NameIndex = getQualifiedNameIndex(Die, CUI.Language, Gsym);
 457     if (!NameIndex) {
 458       Out.Report("Function has no name", [&](raw_ostream &OS) {
 459         OS << "error: function at " << HEX64(Die.getOffset())
 460            << " has no name\n ";
 461         Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 462       });
 463       break;
 464     }
 465     // All ranges for the subprogram DIE in case it has multiple. We need to
 466     // pass this down into parseInlineInfo so we don't warn about inline
 467     // ranges that are not in the current subrange of a function when they
 468     // actually are in another subgrange. We do this because when a function
 469     // has discontiguos ranges, we create multiple function entries with only
 470     // the info for that range contained inside of it.
 471     AddressRanges AllSubprogramRanges = ConvertDWARFRanges(Ranges);
 472
 473     // Create a function_info for each range
 474     for (const DWARFAddressRange &Range : Ranges) {
 475       // The low PC must be less than the high PC. Many linkers don't remove
 476       // DWARF for functions that don't get linked into the final executable.
 477       // If both the high and low pc have relocations, linkers will often set
 478       // the address values for both to the same value to indicate the function
 479       // has been remove. Other linkers have been known to set the one or both
 480       // PC values to a UINT32_MAX for 4 byte addresses and UINT64_MAX for 8
 481       // byte addresses to indicate the function isn't valid. The check below
 482       // tries to watch for these cases and abort if it runs into them.
 483       if (Range.LowPC >= Range.HighPC || CUI.isHighestAddress(Range.LowPC))
 484         break;
 485
 486       // Many linkers can't remove DWARF and might set the LowPC to zero. Since
 487       // high PC can be an offset from the low PC in more recent DWARF versions
 488       // we need to watch for a zero'ed low pc which we do using ValidTextRanges
 489       // below.
 490       if (!Gsym.IsValidTextAddress(Range.LowPC)) {
 491         // We expect zero and -1 to be invalid addresses in DWARF depending
 492         // on the linker of the DWARF. This indicates a function was stripped
 493         // and the debug info wasn't able to be stripped from the DWARF. If
 494         // the LowPC isn't zero or -1, then we should emit an error.
 495         if (Range.LowPC != 0) {
 496           if (!Gsym.isQuiet()) {
 497             // Unexpected invalid address, emit a warning
 498             Out.Report("Address range starts outside executable section",
 499                        [&](raw_ostream &OS) {
 500                          OS << "warning: DIE has an address range whose "
 501                                "start address "
 502                                "is not in any executable sections ("
 503                             << *Gsym.GetValidTextRanges()
 504                             << ") and will not be processed:\n";
 505                          Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 506                        });
 507           }
 508         }
 509         break;
 510       }
 511
 512       FunctionInfo FI;
 513       FI.Range = {Range.LowPC, Range.HighPC};
 514       FI.Name = *NameIndex;
 515       if (CUI.LineTable)
 516         convertFunctionLineTable(Out, CUI, Die, Gsym, FI);
 517
 518       if (hasInlineInfo(Die, 0)) {
 519         FI.Inline = InlineInfo();
 520         FI.Inline->Name = *NameIndex;
 521         FI.Inline->Ranges.insert(FI.Range);
 522         bool WarnIfEmpty = true;
 523         parseInlineInfo(Gsym, Out, CUI, Die, 0, FI, *FI.Inline,
 524                         AllSubprogramRanges, WarnIfEmpty);
 525         // Make sure we at least got some valid inline info other than just
 526         // the top level function. If we didn't then remove the inline info
 527         // from the function info. We have seen cases where LTO tries to modify
 528         // the DWARF for functions and it messes up the address ranges for
 529         // the inline functions so it is no longer valid.
 530         //
 531         // By checking if there are any valid children on the top level inline
 532         // information object, we will know if we got anything valid from the
 533         // debug info.
 534         if (FI.Inline->Children.empty()) {
 535           if (WarnIfEmpty && !Gsym.isQuiet())
 536             Out.Report("DIE contains inline functions with no valid ranges",
 537                        [&](raw_ostream &OS) {
 538                          OS << "warning: DIE contains inline function "
 539                                "information that has no valid ranges, removing "
 540                                "inline information:\n";
 541                          Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
 542                        });
 543           FI.Inline = std::nullopt;
 544         }
 545       }
 546
 547       // If dwarf-callsites flag is set, parse DW_TAG_call_site DIEs.
 548       if (LoadDwarfCallSites)
 549         parseCallSiteInfoFromDwarf(CUI, Die, FI);
 550
 551       Gsym.addFunctionInfo(std::move(FI));
 552     }
 553   } break;
 554   default:
 555     break;
 556   }
 557   for (DWARFDie ChildDie : Die.children())
 558     handleDie(Out, CUI, ChildDie);
 559 }
 560
 561 void DwarfTransformer::parseCallSiteInfoFromDwarf(CUInfo &CUI, DWARFDie Die,
 562                                                   FunctionInfo &FI) {
 563   // Parse all DW_TAG_call_site DIEs that are children of this subprogram DIE.
 564   // DWARF specification:
 565   // - DW_TAG_call_site can have DW_AT_call_return_pc for return address offset.
 566   // - DW_AT_call_origin might point to a DIE of the function being called.
 567   // For simplicity, we will just extract return_offset and possibly target name
 568   // if available.
 569
 570   CallSiteInfoCollection CSIC;
 571
 572   for (DWARFDie Child : Die.children()) {
 573     if (Child.getTag() != dwarf::DW_TAG_call_site)
 574       continue;
 575
 576     CallSiteInfo CSI;
 577     // DW_AT_call_return_pc: the return PC (address). We'll convert it to
 578     // offset relative to FI's start.
 579     auto ReturnPC =
 580         dwarf::toAddress(Child.findRecursively(dwarf::DW_AT_call_return_pc));
 581     if (!ReturnPC || !FI.Range.contains(*ReturnPC))
 582       continue;
 583
 584     CSI.ReturnOffset = *ReturnPC - FI.startAddress();
 585
 586     // Attempt to get function name from DW_AT_call_origin. If present, we can
 587     // insert it as a match regex.
 588     if (DWARFDie OriginDie =
 589             Child.getAttributeValueAsReferencedDie(dwarf::DW_AT_call_origin)) {
 590
 591       // Include the full unmangled name if available, otherwise the short name.
 592       if (const char *LinkName = OriginDie.getLinkageName()) {
 593         uint32_t LinkNameOff = Gsym.insertString(LinkName, /*Copy=*/false);
 594         CSI.MatchRegex.push_back(LinkNameOff);
 595       } else if (const char *ShortName = OriginDie.getShortName()) {
 596         uint32_t ShortNameOff = Gsym.insertString(ShortName, /*Copy=*/false);
 597         CSI.MatchRegex.push_back(ShortNameOff);
 598       }
 599     }
 600
 601     // For now, we won't attempt to deduce InternalCall/ExternalCall flags
 602     // from DWARF.
 603     CSI.Flags = CallSiteInfo::Flags::None;
 604
 605     CSIC.CallSites.push_back(CSI);
 606   }
 607
 608   if (!CSIC.CallSites.empty()) {
 609     if (!FI.CallSites)
 610       FI.CallSites = CallSiteInfoCollection();
 611     // Append parsed DWARF callsites:
 612     FI.CallSites->CallSites.insert(FI.CallSites->CallSites.end(),
 613                                    CSIC.CallSites.begin(),
 614                                    CSIC.CallSites.end());
 615   }
 616 }
 617
 618 Error DwarfTransformer::convert(uint32_t NumThreads, OutputAggregator &Out) {
 619   size_t NumBefore = Gsym.getNumFunctionInfos();
 620   auto getDie = [&](DWARFUnit &DwarfUnit) -> DWARFDie {
 621     DWARFDie ReturnDie = DwarfUnit.getUnitDIE(false);
 622     if (DwarfUnit.getDWOId()) {
 623       DWARFUnit *DWOCU = DwarfUnit.getNonSkeletonUnitDIE(false).getDwarfUnit();
 624       if (!DWOCU->isDWOUnit())
 625         Out.Report(
 626             "warning: Unable to retrieve DWO .debug_info section for some "
 627             "object files. (Remove the --quiet flag for full output)",
 628             [&](raw_ostream &OS) {
 629               std::string DWOName = dwarf::toString(
 630                   DwarfUnit.getUnitDIE().find(
 631                       {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
 632                   "");
 633               OS << "warning: Unable to retrieve DWO .debug_info section for "
 634                  << DWOName << "\n";
 635             });
 636       else {
 637         ReturnDie = DWOCU->getUnitDIE(false);
 638       }
 639     }
 640     return ReturnDie;
 641   };
 642   if (NumThreads == 1) {
 643     // Parse all DWARF data from this thread, use the same string/file table
 644     // for everything
 645     for (const auto &CU : DICtx.compile_units()) {
 646       DWARFDie Die = getDie(*CU);
 647       CUInfo CUI(DICtx, dyn_cast<DWARFCompileUnit>(CU.get()));
 648       handleDie(Out, CUI, Die);
 649     }
 650   } else {
 651     // LLVM Dwarf parser is not thread-safe and we need to parse all DWARF up
 652     // front before we start accessing any DIEs since there might be
 653     // cross compile unit references in the DWARF. If we don't do this we can
 654     // end up crashing.
 655
 656     // We need to call getAbbreviations sequentially first so that getUnitDIE()
 657     // only works with its local data.
 658     for (const auto &CU : DICtx.compile_units())
 659       CU->getAbbreviations();
 660
 661     // Now parse all DIEs in case we have cross compile unit references in a
 662     // thread pool.
 663     DefaultThreadPool pool(hardware_concurrency(NumThreads));
 664     for (const auto &CU : DICtx.compile_units())
 665       pool.async([&CU]() { CU->getUnitDIE(false /*CUDieOnly*/); });
 666     pool.wait();
 667
 668     // Now convert all DWARF to GSYM in a thread pool.
 669     std::mutex LogMutex;
 670     for (const auto &CU : DICtx.compile_units()) {
 671       DWARFDie Die = getDie(*CU);
 672       if (Die) {
 673         CUInfo CUI(DICtx, dyn_cast<DWARFCompileUnit>(CU.get()));
 674         pool.async([this, CUI, &LogMutex, &Out, Die]() mutable {
 675           std::string storage;
 676           raw_string_ostream StrStream(storage);
 677           OutputAggregator ThreadOut(Out.GetOS() ? &StrStream : nullptr);
 678           handleDie(ThreadOut, CUI, Die);
 679           // Print ThreadLogStorage lines into an actual stream under a lock
 680           std::lock_guard<std::mutex> guard(LogMutex);
 681           if (Out.GetOS()) {
 682             Out << storage;
 683           }
 684           Out.Merge(ThreadOut);
 685         });
 686       }
 687     }
 688     pool.wait();
 689   }
 690   size_t FunctionsAddedCount = Gsym.getNumFunctionInfos() - NumBefore;
 691   Out << "Loaded " << FunctionsAddedCount << " functions from DWARF.\n";
 692   return Error::success();
 693 }
 694
 695 llvm::Error DwarfTransformer::verify(StringRef GsymPath,
 696                                      OutputAggregator &Out) {
 697   Out << "Verifying GSYM file \"" << GsymPath << "\":\n";
 698
 699   auto Gsym = GsymReader::openFile(GsymPath);
 700   if (!Gsym)
 701     return Gsym.takeError();
 702
 703   auto NumAddrs = Gsym->getNumAddresses();
 704   DILineInfoSpecifier DLIS(
 705       DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
 706       DILineInfoSpecifier::FunctionNameKind::LinkageName);
 707   std::string gsymFilename;
 708   for (uint32_t I = 0; I < NumAddrs; ++I) {
 709     auto FuncAddr = Gsym->getAddress(I);
 710     if (!FuncAddr)
 711         return createStringError(std::errc::invalid_argument,
 712                                   "failed to extract address[%i]", I);
 713
 714     auto FI = Gsym->getFunctionInfo(*FuncAddr);
 715     if (!FI)
 716       return createStringError(
 717           std::errc::invalid_argument,
 718           "failed to extract function info for address 0x%" PRIu64, *FuncAddr);
 719
 720     for (auto Addr = *FuncAddr; Addr < *FuncAddr + FI->size(); ++Addr) {
 721       const object::SectionedAddress SectAddr{
 722           Addr, object::SectionedAddress::UndefSection};
 723       auto LR = Gsym->lookup(Addr);
 724       if (!LR)
 725         return LR.takeError();
 726
 727       auto DwarfInlineInfos =
 728           DICtx.getInliningInfoForAddress(SectAddr, DLIS);
 729       uint32_t NumDwarfInlineInfos = DwarfInlineInfos.getNumberOfFrames();
 730       if (NumDwarfInlineInfos == 0) {
 731         DwarfInlineInfos.addFrame(
 732             DICtx.getLineInfoForAddress(SectAddr, DLIS));
 733       }
 734
 735       // Check for 1 entry that has no file and line info
 736       if (NumDwarfInlineInfos == 1 &&
 737           DwarfInlineInfos.getFrame(0).FileName == "<invalid>") {
 738         DwarfInlineInfos = DIInliningInfo();
 739         NumDwarfInlineInfos = 0;
 740       }
 741       if (NumDwarfInlineInfos > 0 &&
 742           NumDwarfInlineInfos != LR->Locations.size()) {
 743         if (Out.GetOS()) {
 744           raw_ostream &Log = *Out.GetOS();
 745           Log << "error: address " << HEX64(Addr) << " has "
 746               << NumDwarfInlineInfos << " DWARF inline frames and GSYM has "
 747               << LR->Locations.size() << "\n";
 748           Log << "    " << NumDwarfInlineInfos << " DWARF frames:\n";
 749           for (size_t Idx = 0; Idx < NumDwarfInlineInfos; ++Idx) {
 750             const auto &dii = DwarfInlineInfos.getFrame(Idx);
 751             Log << "    [" << Idx << "]: " << dii.FunctionName << " @ "
 752                 << dii.FileName << ':' << dii.Line << '\n';
 753           }
 754           Log << "    " << LR->Locations.size() << " GSYM frames:\n";
 755           for (size_t Idx = 0, count = LR->Locations.size(); Idx < count;
 756                ++Idx) {
 757             const auto &gii = LR->Locations[Idx];
 758             Log << "    [" << Idx << "]: " << gii.Name << " @ " << gii.Dir
 759                 << '/' << gii.Base << ':' << gii.Line << '\n';
 760           }
 761           Gsym->dump(Log, *FI);
 762         }
 763         continue;
 764       }
 765
 766       for (size_t Idx = 0, count = LR->Locations.size(); Idx < count;
 767             ++Idx) {
 768         const auto &gii = LR->Locations[Idx];
 769         if (Idx < NumDwarfInlineInfos) {
 770           const auto &dii = DwarfInlineInfos.getFrame(Idx);
 771           gsymFilename = LR->getSourceFile(Idx);
 772           // Verify function name
 773           if (dii.FunctionName.find(gii.Name.str()) != 0)
 774             Out << "error: address " << HEX64(Addr) << " DWARF function \""
 775                 << dii.FunctionName.c_str()
 776                 << "\" doesn't match GSYM function \"" << gii.Name << "\"\n";
 777
 778           // Verify source file path
 779           if (dii.FileName != gsymFilename)
 780             Out << "error: address " << HEX64(Addr) << " DWARF path \""
 781                 << dii.FileName.c_str() << "\" doesn't match GSYM path \""
 782                 << gsymFilename.c_str() << "\"\n";
 783           // Verify source file line
 784           if (dii.Line != gii.Line)
 785             Out << "error: address " << HEX64(Addr) << " DWARF line "
 786                 << dii.Line << " != GSYM line " << gii.Line << "\n";
 787         }
 788       }
 789     }
 790   }
 791   return Error::success();
 792 }