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.empty())
 130     return;
 131   DWARFDebugInfoEntryMinimal *die_array_begin = &DieArray.front();
 132   DWARFDebugInfoEntryMinimal *die_array_end = &DieArray.back();
 133   DWARFDebugInfoEntryMinimal *curr_die;
 134   // We purposely are skipping the last element in the array in the loop below
 135   // so that we can always have a valid next item
 136   for (curr_die = die_array_begin; curr_die < die_array_end; ++curr_die) {
 137     // Since our loop doesn't include the last element, we can always
 138     // safely access the next die in the array.
 139     DWARFDebugInfoEntryMinimal *next_die = curr_die + 1;
 140
 141     const DWARFAbbreviationDeclaration *curr_die_abbrev =
 142       curr_die->getAbbreviationDeclarationPtr();
 143
 144     if (curr_die_abbrev) {
 145       // Normal DIE
 146       if (curr_die_abbrev->hasChildren())
 147         next_die->setParent(curr_die);
 148       else
 149         curr_die->setSibling(next_die);
 150     } else {
 151       // NULL DIE that terminates a sibling chain
 152       DWARFDebugInfoEntryMinimal *parent = curr_die->getParent();
 153       if (parent)
 154         parent->setSibling(next_die);
 155     }
 156   }
 157
 158   // Since we skipped the last element, we need to fix it up!
 159   if (die_array_begin < die_array_end)
 160     curr_die->setParent(die_array_begin);
 161 }
 162
 163 void DWARFUnit::extractDIEsToVector(
 164     bool AppendCUDie, bool AppendNonCUDies,
 165     std::vector<DWARFDebugInfoEntryMinimal> &Dies) const {
 166   if (!AppendCUDie && !AppendNonCUDies)
 167     return;
 168
 169   // Set the offset to that of the first DIE and calculate the start of the
 170   // next compilation unit header.
 171   uint32_t Offset = getFirstDIEOffset();
 172   uint32_t NextCUOffset = getNextUnitOffset();
 173   DWARFDebugInfoEntryMinimal DIE;
 174   uint32_t Depth = 0;
 175   bool IsCUDie = true;
 176
 177   while (Offset < NextCUOffset && DIE.extractFast(this, &Offset)) {
 178     if (IsCUDie) {
 179       if (AppendCUDie)
 180         Dies.push_back(DIE);
 181       if (!AppendNonCUDies)
 182         break;
 183       // The average bytes per DIE entry has been seen to be
 184       // around 14-20 so let's pre-reserve the needed memory for
 185       // our DIE entries accordingly.
 186       Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
 187       IsCUDie = false;
 188     } else {
 189       Dies.push_back(DIE);
 190     }
 191
 192     const DWARFAbbreviationDeclaration *AbbrDecl =
 193       DIE.getAbbreviationDeclarationPtr();
 194     if (AbbrDecl) {
 195       // Normal DIE
 196       if (AbbrDecl->hasChildren())
 197         ++Depth;
 198     } else {
 199       // NULL DIE.
 200       if (Depth > 0)
 201         --Depth;
 202       if (Depth == 0)
 203         break;  // We are done with this compile unit!
 204     }
 205   }
 206
 207   // Give a little bit of info if we encounter corrupt DWARF (our offset
 208   // should always terminate at or before the start of the next compilation
 209   // unit header).
 210   if (Offset > NextCUOffset)
 211     fprintf(stderr, "warning: DWARF compile unit extends beyond its "
 212                     "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), Offset);
 213 }
 214
 215 size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
 216   if ((CUDieOnly && DieArray.size() > 0) ||
 217       DieArray.size() > 1)
 218     return 0; // Already parsed.
 219
 220   bool HasCUDie = DieArray.size() > 0;
 221   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 222
 223   if (DieArray.empty())
 224     return 0;
 225
 226   // If CU DIE was just parsed, copy several attribute values from it.
 227   if (!HasCUDie) {
 228     uint64_t BaseAddr =
 229         DieArray[0].getAttributeValueAsAddress(this, DW_AT_low_pc, -1ULL);
 230     if (BaseAddr == -1ULL)
 231       BaseAddr = DieArray[0].getAttributeValueAsAddress(this, DW_AT_entry_pc, 0);
 232     setBaseAddress(BaseAddr);
 233     AddrOffsetSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
 234         this, DW_AT_GNU_addr_base, 0);
 235     RangeSectionBase = DieArray[0].getAttributeValueAsSectionOffset(
 236         this, DW_AT_GNU_ranges_base, 0);
 237   }
 238
 239   setDIERelations();
 240   return DieArray.size();
 241 }
 242
 243 DWARFUnit::DWOHolder::DWOHolder(object::ObjectFile *DWOFile)
 244     : DWOFile(DWOFile),
 245       DWOContext(cast<DWARFContext>(DIContext::getDWARFContext(DWOFile))),
 246       DWOU(nullptr) {
 247   if (DWOContext->getNumDWOCompileUnits() > 0)
 248     DWOU = DWOContext->getDWOCompileUnitAtIndex(0);
 249 }
 250
 251 bool DWARFUnit::parseDWO() {
 252   if (DWO.get())
 253     return false;
 254   extractDIEsIfNeeded(true);
 255   if (DieArray.empty())
 256     return false;
 257   const char *DWOFileName =
 258       DieArray[0].getAttributeValueAsString(this, DW_AT_GNU_dwo_name, nullptr);
 259   if (!DWOFileName)
 260     return false;
 261   const char *CompilationDir =
 262       DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, nullptr);
 263   SmallString<16> AbsolutePath;
 264   if (sys::path::is_relative(DWOFileName) && CompilationDir != nullptr) {
 265     sys::path::append(AbsolutePath, CompilationDir);
 266   }
 267   sys::path::append(AbsolutePath, DWOFileName);
 268   ErrorOr<object::ObjectFile *> DWOFile =
 269       object::ObjectFile::createObjectFile(AbsolutePath);
 270   if (!DWOFile)
 271     return false;
 272   // Reset DWOHolder.
 273   DWO.reset(new DWOHolder(DWOFile.get()));
 274   DWARFUnit *DWOCU = DWO->getUnit();
 275   // Verify that compile unit in .dwo file is valid.
 276   if (!DWOCU || DWOCU->getDWOId() != getDWOId()) {
 277     DWO.reset();
 278     return false;
 279   }
 280   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
 281   DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
 282   DWOCU->setRangesSection(RangeSection, RangeSectionBase);
 283   return true;
 284 }
 285
 286 void DWARFUnit::clearDIEs(bool KeepCUDie) {
 287   if (DieArray.size() > (unsigned)KeepCUDie) {
 288     // std::vectors never get any smaller when resized to a smaller size,
 289     // or when clear() or erase() are called, the size will report that it
 290     // is smaller, but the memory allocated remains intact (call capacity()
 291     // to see this). So we need to create a temporary vector and swap the
 292     // contents which will cause just the internal pointers to be swapped
 293     // so that when temporary vector goes out of scope, it will destroy the
 294     // contents.
 295     std::vector<DWARFDebugInfoEntryMinimal> TmpArray;
 296     DieArray.swap(TmpArray);
 297     // Save at least the compile unit DIE
 298     if (KeepCUDie)
 299       DieArray.push_back(TmpArray.front());
 300   }
 301 }
 302
 303 void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
 304   // First, check if CU DIE describes address ranges for the unit.
 305   const auto &CUDIERanges = getCompileUnitDIE()->getAddressRanges(this);
 306   if (!CUDIERanges.empty()) {
 307     CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
 308     return;
 309   }
 310
 311   // This function is usually called if there in no .debug_aranges section
 312   // in order to produce a compile unit level set of address ranges that
 313   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
 314   // all compile units to stay loaded when they weren't needed. So we can end
 315   // up parsing the DWARF and then throwing them all away to keep memory usage
 316   // down.
 317   const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
 318   DieArray[0].collectChildrenAddressRanges(this, CURanges);
 319
 320   // Collect address ranges from DIEs in .dwo if necessary.
 321   bool DWOCreated = parseDWO();
 322   if (DWO.get())
 323     DWO->getUnit()->collectAddressRanges(CURanges);
 324   if (DWOCreated)
 325     DWO.reset();
 326
 327   // Keep memory down by clearing DIEs if this generate function
 328   // caused them to be parsed.
 329   if (ClearDIEs)
 330     clearDIEs(true);
 331 }
 332
 333 const DWARFDebugInfoEntryMinimal *
 334 DWARFUnit::getSubprogramForAddress(uint64_t Address) {
 335   extractDIEsIfNeeded(false);
 336   for (const DWARFDebugInfoEntryMinimal &DIE : DieArray) {
 337     if (DIE.isSubprogramDIE() &&
 338         DIE.addressRangeContainsAddress(this, Address)) {
 339       return &DIE;
 340     }
 341   }
 342   return nullptr;
 343 }
 344
 345 DWARFDebugInfoEntryInlinedChain
 346 DWARFUnit::getInlinedChainForAddress(uint64_t Address) {
 347   // First, find a subprogram that contains the given address (the root
 348   // of inlined chain).
 349   const DWARFUnit *ChainCU = nullptr;
 350   const DWARFDebugInfoEntryMinimal *SubprogramDIE =
 351       getSubprogramForAddress(Address);
 352   if (SubprogramDIE) {
 353     ChainCU = this;
 354   } else {
 355     // Try to look for subprogram DIEs in the DWO file.
 356     parseDWO();
 357     if (DWO.get()) {
 358       SubprogramDIE = DWO->getUnit()->getSubprogramForAddress(Address);
 359       if (SubprogramDIE)
 360         ChainCU = DWO->getUnit();
 361     }
 362   }
 363
 364   // Get inlined chain rooted at this subprogram DIE.
 365   if (!SubprogramDIE)
 366     return DWARFDebugInfoEntryInlinedChain();
 367   return SubprogramDIE->getInlinedChainForAddress(ChainCU, Address);
 368 }