lib/DebugInfo/DWARFUnit.cpp

   1 //===-- DWARFUnit.cpp -----------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "DWARFUnit.h"
  11 #include "DWARFContext.h"
  12 #include "llvm/DebugInfo/DWARFFormValue.h"
  13 #include "llvm/Support/Dwarf.h"
  14 #include "llvm/Support/Path.h"
  15 #include <cstdio>
  16
  17 using namespace llvm;
  18 using namespace dwarf;
  19
  20 DWARFUnit::DWARFUnit(const DWARFDebugAbbrev *DA, StringRef IS, StringRef RS,
  21                      StringRef SS, StringRef SOS, StringRef AOS,
  22                      const RelocAddrMap *M, bool LE)
  23     : Abbrev(DA), InfoSection(IS), RangeSection(RS), StringSection(SS),
  24       StringOffsetSection(SOS), AddrOffsetSection(AOS), RelocMap(M),
  25       isLittleEndian(LE) {
  26   clear();
  27 }
  28
  29 DWARFUnit::~DWARFUnit() {
  30 }
  31
  32 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
  33                                                 uint64_t &Result) const {
  34   uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
  35   if (AddrOffsetSection.size() < Offset + AddrSize)
  36     return false;
  37   DataExtractor DA(AddrOffsetSection, isLittleEndian, AddrSize);
  38   Result = DA.getAddress(&Offset);
  39   return true;
  40 }
  41
  42 bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
  43                                                   uint32_t &Result) const {
  44   // FIXME: string offset section entries are 8-byte for DWARF64.
  45   const uint32_t ItemSize = 4;
  46   uint32_t Offset = Index * ItemSize;
  47   if (StringOffsetSection.size() < Offset + ItemSize)
  48     return false;
  49   DataExtractor DA(StringOffsetSection, isLittleEndian, 0);
  50   Result = DA.getU32(&Offset);
  51   return true;
  52 }
  53
  54 bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) {
  55   Length = debug_info.getU32(offset_ptr);
  56   Version = debug_info.getU16(offset_ptr);
  57   uint64_t AbbrOffset = debug_info.getU32(offset_ptr);
  58   AddrSize = debug_info.getU8(offset_ptr);
  59
  60   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
  61   bool VersionOK = DWARFContext::isSupportedVersion(Version);
  62   bool AddrSizeOK = AddrSize == 4 || AddrSize == 8;
  63
  64   if (!LengthOK || !VersionOK || !AddrSizeOK)
  65     return false;
  66
  67   Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset);
  68   if (Abbrevs == nullptr)
  69     return false;
  70
  71   return true;
  72 }
  73
  74 bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
  75   clear();
  76
  77   Offset = *offset_ptr;
  78
  79   if (debug_info.isValidOffset(*offset_ptr)) {
  80     if (extractImpl(debug_info, offset_ptr))
  81       return true;
  82
  83     // reset the offset to where we tried to parse from if anything went wrong
  84     *offset_ptr = Offset;
  85   }
  86
  87   return false;
  88 }
  89
  90 bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
  91                                         DWARFDebugRangeList &RangeList) const {
  92   // Require that compile unit is extracted.
  93   assert(DieArray.size() > 0);
  94   DataExtractor RangesData(RangeSection, isLittleEndian, AddrSize);
  95   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
  96   return RangeList.extract(RangesData, &ActualRangeListOffset);
  97 }
  98
  99 void DWARFUnit::clear() {
 100   Offset = 0;
 101   Length = 0;
 102   Version = 0;
 103   Abbrevs = nullptr;
 104   AddrSize = 0;
 105   BaseAddr = 0;
 106   RangeSectionBase = 0;
 107   AddrOffsetSectionBase = 0;
 108   clearDIEs(false);
 109   DWO.reset();
 110 }
 111
 112 const char *DWARFUnit::getCompilationDir() {
 113   extractDIEsIfNeeded(true);
 114   if (DieArray.empty())
 115     return nullptr;
 116   return DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, nullptr);
 117 }
 118
 119 uint64_t DWARFUnit::getDWOId() {
 120   extractDIEsIfNeeded(true);
 121   const uint64_t FailValue = -1ULL;
 122   if (DieArray.empty())
 123     return FailValue;
 124   return DieArray[0]
 125       .getAttributeValueAsUnsignedConstant(this, DW_AT_GNU_dwo_id, FailValue);
 126 }
 127
 128 void DWARFUnit::setDIERelations() {
 129   if (DieArray.size() <= 1)
 130     return;
 131
 132   std::vector<DWARFDebugInfoEntryMinimal *> ParentChain;
 133   DWARFDebugInfoEntryMinimal *SiblingChain = nullptr;
 134   for (auto &DIE : DieArray) {
 135     if (SiblingChain) {
 136       SiblingChain->setSibling(&DIE);
 137     }
 138     if (const DWARFAbbreviationDeclaration *AbbrDecl =
 139             DIE.getAbbreviationDeclarationPtr()) {
 140       // Normal DIE.
 141       if (AbbrDecl->hasChildren()) {
 142         ParentChain.push_back(&DIE);
 143         SiblingChain = nullptr;
 144       } else {
 145         SiblingChain = &DIE;
 146       }
 147     } else {
 148       // NULL entry terminates the sibling chain.
 149       SiblingChain = ParentChain.back();
 150       ParentChain.pop_back();
 151     }
 152   }
 153   assert(SiblingChain == nullptr || SiblingChain == &DieArray[0]);
 154   assert(ParentChain.empty());
 155 }
 156
 157 void DWARFUnit::extractDIEsToVector(
 158     bool AppendCUDie, bool AppendNonCUDies,
 159     std::vector<DWARFDebugInfoEntryMinimal> &Dies) const {
 160   if (!AppendCUDie && !AppendNonCUDies)
 161     return;
 162
 163   // Set the offset to that of the first DIE and calculate the start of the
 164   // next compilation unit header.
 165   uint32_t DIEOffset = Offset + getHeaderSize();
 166   uint32_t NextCUOffset = getNextUnitOffset();
 167   DWARFDebugInfoEntryMinimal DIE;
 168   uint32_t Depth = 0;
 169   bool IsCUDie = true;
 170
 171   while (DIEOffset < NextCUOffset && DIE.extractFast(this, &DIEOffset)) {
 172     if (IsCUDie) {
 173       if (AppendCUDie)
 174         Dies.push_back(DIE);
 175       if (!AppendNonCUDies)
 176         break;
 177       // The average bytes per DIE entry has been seen to be
 178       // around 14-20 so let's pre-reserve the needed memory for
 179       // our DIE entries accordingly.
 180       Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
 181       IsCUDie = false;
 182     } else {
 183       Dies.push_back(DIE);
 184     }
 185
 186     if (const DWARFAbbreviationDeclaration *AbbrDecl =
 187             DIE.getAbbreviationDeclarationPtr()) {
 188       // Normal DIE
 189       if (AbbrDecl->hasChildren())
 190         ++Depth;
 191     } else {
 192       // NULL DIE.
 193       if (Depth > 0)
 194         --Depth;
 195       if (Depth == 0)
 196         break;  // We are done with this compile unit!
 197     }
 198   }
 199
 200   // Give a little bit of info if we encounter corrupt DWARF (our offset
 201   // should always terminate at or before the start of the next compilation
 202   // unit header).
 203   if (DIEOffset > NextCUOffset)
 204     fprintf(stderr, "warning: DWARF compile unit extends beyond its "
 205                     "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), DIEOffset);
 206 }
 207
 208 size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
 209   if ((CUDieOnly && DieArray.size() > 0) ||
 210       DieArray.size() > 1)
 211     return 0; // Already parsed.
 212
 213   bool HasCUDie = DieArray.size() > 0;
 214   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 215
 216   if (DieArray.empty())
 217     return 0;
 218
 219   // If CU DIE was just parsed, copy several attribute values from it.
 220   if (!HasCUDie) {
 221     uint64_t BaseAddr =
 222         DieArray[0].getAttributeValueAsAddress(this, DW_AT_low_pc, -1ULL);
 223     if (BaseAddr == -1ULL)
 224       BaseAddr = DieArray[0].getAttributeValueAsAddress(this, DW_AT_entry_pc, 0);
 225     setBaseAddress(BaseAddr);
 226     AddrOffsetSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
 227         this, DW_AT_GNU_addr_base, 0);
 228     RangeSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
 229         this, DW_AT_ranges_base, 0);
 230     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
 231     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
 232   }
 233
 234   setDIERelations();
 235   return DieArray.size();
 236 }
 237
 238 DWARFUnit::DWOHolder::DWOHolder(std::unique_ptr<object::ObjectFile> DWOFile)
 239     : DWOFile(std::move(DWOFile)),
 240       DWOContext(
 241           cast<DWARFContext>(DIContext::getDWARFContext(*this->DWOFile))),
 242       DWOU(nullptr) {
 243   if (DWOContext->getNumDWOCompileUnits() > 0)
 244     DWOU = DWOContext->getDWOCompileUnitAtIndex(0);
 245 }
 246
 247 bool DWARFUnit::parseDWO() {
 248   if (DWO.get())
 249     return false;
 250   extractDIEsIfNeeded(true);
 251   if (DieArray.empty())
 252     return false;
 253   const char *DWOFileName =
 254       DieArray[0].getAttributeValueAsString(this, DW_AT_GNU_dwo_name, nullptr);
 255   if (!DWOFileName)
 256     return false;
 257   const char *CompilationDir =
 258       DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, nullptr);
 259   SmallString<16> AbsolutePath;
 260   if (sys::path::is_relative(DWOFileName) && CompilationDir != nullptr) {
 261     sys::path::append(AbsolutePath, CompilationDir);
 262   }
 263   sys::path::append(AbsolutePath, DWOFileName);
 264   ErrorOr<object::OwningBinary<object::ObjectFile>> DWOFile =
 265       object::ObjectFile::createObjectFile(AbsolutePath);
 266   if (!DWOFile)
 267     return false;
 268   // Reset DWOHolder.
 269   DWO = llvm::make_unique<DWOHolder>(std::move(DWOFile->getBinary()));
 270   DWARFUnit *DWOCU = DWO->getUnit();
 271   // Verify that compile unit in .dwo file is valid.
 272   if (!DWOCU || DWOCU->getDWOId() != getDWOId()) {
 273     DWO.reset();
 274     return false;
 275   }
 276   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
 277   DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
 278   uint32_t DWORangesBase = DieArray[0].getRangesBaseAttribute(this, 0);
 279   DWOCU->setRangesSection(RangeSection, DWORangesBase);
 280   return true;
 281 }
 282
 283 void DWARFUnit::clearDIEs(bool KeepCUDie) {
 284   if (DieArray.size() > (unsigned)KeepCUDie) {
 285     // std::vectors never get any smaller when resized to a smaller size,
 286     // or when clear() or erase() are called, the size will report that it
 287     // is smaller, but the memory allocated remains intact (call capacity()
 288     // to see this). So we need to create a temporary vector and swap the
 289     // contents which will cause just the internal pointers to be swapped
 290     // so that when temporary vector goes out of scope, it will destroy the
 291     // contents.
 292     std::vector<DWARFDebugInfoEntryMinimal> TmpArray;
 293     DieArray.swap(TmpArray);
 294     // Save at least the compile unit DIE
 295     if (KeepCUDie)
 296       DieArray.push_back(TmpArray.front());
 297   }
 298 }
 299
 300 void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
 301   // First, check if CU DIE describes address ranges for the unit.
 302   const auto &CUDIERanges = getCompileUnitDIE()->getAddressRanges(this);
 303   if (!CUDIERanges.empty()) {
 304     CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
 305     return;
 306   }
 307
 308   // This function is usually called if there in no .debug_aranges section
 309   // in order to produce a compile unit level set of address ranges that
 310   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
 311   // all compile units to stay loaded when they weren't needed. So we can end
 312   // up parsing the DWARF and then throwing them all away to keep memory usage
 313   // down.
 314   const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
 315   DieArray[0].collectChildrenAddressRanges(this, CURanges);
 316
 317   // Collect address ranges from DIEs in .dwo if necessary.
 318   bool DWOCreated = parseDWO();
 319   if (DWO.get())
 320     DWO->getUnit()->collectAddressRanges(CURanges);
 321   if (DWOCreated)
 322     DWO.reset();
 323
 324   // Keep memory down by clearing DIEs if this generate function
 325   // caused them to be parsed.
 326   if (ClearDIEs)
 327     clearDIEs(true);
 328 }
 329
 330 const DWARFDebugInfoEntryMinimal *
 331 DWARFUnit::getSubprogramForAddress(uint64_t Address) {
 332   extractDIEsIfNeeded(false);
 333   for (const DWARFDebugInfoEntryMinimal &DIE : DieArray) {
 334     if (DIE.isSubprogramDIE() &&
 335         DIE.addressRangeContainsAddress(this, Address)) {
 336       return &DIE;
 337     }
 338   }
 339   return nullptr;
 340 }
 341
 342 DWARFDebugInfoEntryInlinedChain
 343 DWARFUnit::getInlinedChainForAddress(uint64_t Address) {
 344   // First, find a subprogram that contains the given address (the root
 345   // of inlined chain).
 346   const DWARFUnit *ChainCU = nullptr;
 347   const DWARFDebugInfoEntryMinimal *SubprogramDIE =
 348       getSubprogramForAddress(Address);
 349   if (SubprogramDIE) {
 350     ChainCU = this;
 351   } else {
 352     // Try to look for subprogram DIEs in the DWO file.
 353     parseDWO();
 354     if (DWO.get()) {
 355       SubprogramDIE = DWO->getUnit()->getSubprogramForAddress(Address);
 356       if (SubprogramDIE)
 357         ChainCU = DWO->getUnit();
 358     }
 359   }
 360
 361   // Get inlined chain rooted at this subprogram DIE.
 362   if (!SubprogramDIE)
 363     return DWARFDebugInfoEntryInlinedChain();
 364   return SubprogramDIE->getInlinedChainForAddress(ChainCU, Address);
 365 }