contrib/llvm/lib/DebugInfo/DWARF/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 "llvm/ADT/SmallString.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
  14 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  15 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
  16 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
  17 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
  18 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
  19 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
  20 #include "llvm/Object/ObjectFile.h"
  21 #include "llvm/Support/Casting.h"
  22 #include "llvm/Support/DataExtractor.h"
  23 #include "llvm/Support/Path.h"
  24 #include <algorithm>
  25 #include <cassert>
  26 #include <cstddef>
  27 #include <cstdint>
  28 #include <cstdio>
  29 #include <vector>
  30
  31 using namespace llvm;
  32 using namespace dwarf;
  33
  34 void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
  35   parseImpl(C, Section, C.getDebugAbbrev(), &C.getRangeSection(),
  36             C.getStringSection(), StringRef(), C.getAddrSection(),
  37             C.getLineSection().Data, C.isLittleEndian(), false);
  38 }
  39
  40 void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
  41                                     const DWARFSection &DWOSection,
  42                                     DWARFUnitIndex *Index) {
  43   parseImpl(C, DWOSection, C.getDebugAbbrevDWO(), &C.getRangeDWOSection(),
  44             C.getStringDWOSection(), C.getStringOffsetDWOSection(),
  45             C.getAddrSection(), C.getLineDWOSection().Data, C.isLittleEndian(),
  46             true);
  47 }
  48
  49 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
  50                      const DWARFDebugAbbrev *DA, const DWARFSection *RS,
  51                      StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
  52                      bool LE, bool IsDWO,
  53                      const DWARFUnitSectionBase &UnitSection,
  54                      const DWARFUnitIndex::Entry *IndexEntry)
  55     : Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
  56       LineSection(LS), StringSection(SS), StringOffsetSection([&]() {
  57         if (IndexEntry)
  58           if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
  59             return SOS.slice(C->Offset, C->Offset + C->Length);
  60         return SOS;
  61       }()),
  62       AddrOffsetSection(AOS), isLittleEndian(LE), isDWO(IsDWO),
  63       UnitSection(UnitSection), IndexEntry(IndexEntry) {
  64   clear();
  65 }
  66
  67 DWARFUnit::~DWARFUnit() = default;
  68
  69 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
  70                                                 uint64_t &Result) const {
  71   uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
  72   if (AddrOffsetSection.size() < Offset + AddrSize)
  73     return false;
  74   DataExtractor DA(AddrOffsetSection, isLittleEndian, AddrSize);
  75   Result = DA.getAddress(&Offset);
  76   return true;
  77 }
  78
  79 bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
  80                                                   uint32_t &Result) const {
  81   // FIXME: string offset section entries are 8-byte for DWARF64.
  82   const uint32_t ItemSize = 4;
  83   uint32_t Offset = Index * ItemSize;
  84   if (StringOffsetSection.size() < Offset + ItemSize)
  85     return false;
  86   DataExtractor DA(StringOffsetSection, isLittleEndian, 0);
  87   Result = DA.getU32(&Offset);
  88   return true;
  89 }
  90
  91 bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) {
  92   Length = debug_info.getU32(offset_ptr);
  93   Version = debug_info.getU16(offset_ptr);
  94   uint64_t AbbrOffset;
  95   if (Version >= 5) {
  96     UnitType = debug_info.getU8(offset_ptr);
  97     AddrSize = debug_info.getU8(offset_ptr);
  98     AbbrOffset = debug_info.getU32(offset_ptr);
  99   } else {
 100     AbbrOffset = debug_info.getU32(offset_ptr);
 101     AddrSize = debug_info.getU8(offset_ptr);
 102   }
 103   if (IndexEntry) {
 104     if (AbbrOffset)
 105       return false;
 106     auto *UnitContrib = IndexEntry->getOffset();
 107     if (!UnitContrib || UnitContrib->Length != (Length + 4))
 108       return false;
 109     auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV);
 110     if (!AbbrEntry)
 111       return false;
 112     AbbrOffset = AbbrEntry->Offset;
 113   }
 114
 115   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
 116   bool VersionOK = DWARFContext::isSupportedVersion(Version);
 117   bool AddrSizeOK = AddrSize == 4 || AddrSize == 8;
 118
 119   if (!LengthOK || !VersionOK || !AddrSizeOK)
 120     return false;
 121
 122   Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset);
 123   return Abbrevs != nullptr;
 124 }
 125
 126 bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
 127   clear();
 128
 129   Offset = *offset_ptr;
 130
 131   if (debug_info.isValidOffset(*offset_ptr)) {
 132     if (extractImpl(debug_info, offset_ptr))
 133       return true;
 134
 135     // reset the offset to where we tried to parse from if anything went wrong
 136     *offset_ptr = Offset;
 137   }
 138
 139   return false;
 140 }
 141
 142 bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
 143                                         DWARFDebugRangeList &RangeList) const {
 144   // Require that compile unit is extracted.
 145   assert(!DieArray.empty());
 146   DataExtractor RangesData(RangeSection->Data, isLittleEndian, AddrSize);
 147   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
 148   return RangeList.extract(RangesData, &ActualRangeListOffset,
 149                            RangeSection->Relocs);
 150 }
 151
 152 void DWARFUnit::clear() {
 153   Offset = 0;
 154   Length = 0;
 155   Version = 0;
 156   Abbrevs = nullptr;
 157   AddrSize = 0;
 158   BaseAddr = 0;
 159   RangeSectionBase = 0;
 160   AddrOffsetSectionBase = 0;
 161   clearDIEs(false);
 162   DWO.reset();
 163 }
 164
 165 const char *DWARFUnit::getCompilationDir() {
 166   return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
 167 }
 168
 169 Optional<uint64_t> DWARFUnit::getDWOId() {
 170   return toUnsigned(getUnitDIE().find(DW_AT_GNU_dwo_id));
 171 }
 172
 173 void DWARFUnit::extractDIEsToVector(
 174     bool AppendCUDie, bool AppendNonCUDies,
 175     std::vector<DWARFDebugInfoEntry> &Dies) const {
 176   if (!AppendCUDie && !AppendNonCUDies)
 177     return;
 178
 179   // Set the offset to that of the first DIE and calculate the start of the
 180   // next compilation unit header.
 181   uint32_t DIEOffset = Offset + getHeaderSize();
 182   uint32_t NextCUOffset = getNextUnitOffset();
 183   DWARFDebugInfoEntry DIE;
 184   DataExtractor DebugInfoData = getDebugInfoExtractor();
 185   uint32_t Depth = 0;
 186   bool IsCUDie = true;
 187
 188   while (DIE.extractFast(*this, &DIEOffset, DebugInfoData, NextCUOffset,
 189                          Depth)) {
 190     if (IsCUDie) {
 191       if (AppendCUDie)
 192         Dies.push_back(DIE);
 193       if (!AppendNonCUDies)
 194         break;
 195       // The average bytes per DIE entry has been seen to be
 196       // around 14-20 so let's pre-reserve the needed memory for
 197       // our DIE entries accordingly.
 198       Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
 199       IsCUDie = false;
 200     } else {
 201       Dies.push_back(DIE);
 202     }
 203
 204     if (const DWARFAbbreviationDeclaration *AbbrDecl =
 205             DIE.getAbbreviationDeclarationPtr()) {
 206       // Normal DIE
 207       if (AbbrDecl->hasChildren())
 208         ++Depth;
 209     } else {
 210       // NULL DIE.
 211       if (Depth > 0)
 212         --Depth;
 213       if (Depth == 0)
 214         break;  // We are done with this compile unit!
 215     }
 216   }
 217
 218   // Give a little bit of info if we encounter corrupt DWARF (our offset
 219   // should always terminate at or before the start of the next compilation
 220   // unit header).
 221   if (DIEOffset > NextCUOffset)
 222     fprintf(stderr, "warning: DWARF compile unit extends beyond its "
 223                     "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), DIEOffset);
 224 }
 225
 226 size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
 227   if ((CUDieOnly && !DieArray.empty()) ||
 228       DieArray.size() > 1)
 229     return 0; // Already parsed.
 230
 231   bool HasCUDie = !DieArray.empty();
 232   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 233
 234   if (DieArray.empty())
 235     return 0;
 236
 237   // If CU DIE was just parsed, copy several attribute values from it.
 238   if (!HasCUDie) {
 239     DWARFDie UnitDie = getUnitDIE();
 240     auto BaseAddr = toAddress(UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc}));
 241     if (BaseAddr)
 242       setBaseAddress(*BaseAddr);
 243     AddrOffsetSectionBase = toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base), 0);
 244     RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0);
 245     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
 246     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
 247   }
 248
 249   return DieArray.size();
 250 }
 251
 252 DWARFUnit::DWOHolder::DWOHolder(StringRef DWOPath) {
 253   auto Obj = object::ObjectFile::createObjectFile(DWOPath);
 254   if (!Obj) {
 255     // TODO: Actually report errors helpfully.
 256     consumeError(Obj.takeError());
 257     return;
 258   }
 259   DWOFile = std::move(Obj.get());
 260   DWOContext.reset(
 261       cast<DWARFContext>(new DWARFContextInMemory(*DWOFile.getBinary())));
 262   if (DWOContext->getNumDWOCompileUnits() > 0)
 263     DWOU = DWOContext->getDWOCompileUnitAtIndex(0);
 264 }
 265
 266 bool DWARFUnit::parseDWO() {
 267   if (isDWO)
 268     return false;
 269   if (DWO.get())
 270     return false;
 271   DWARFDie UnitDie = getUnitDIE();
 272   if (!UnitDie)
 273     return false;
 274   auto DWOFileName = dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
 275   if (!DWOFileName)
 276     return false;
 277   auto CompilationDir = dwarf::toString(UnitDie.find(DW_AT_comp_dir));
 278   SmallString<16> AbsolutePath;
 279   if (sys::path::is_relative(*DWOFileName) && CompilationDir &&
 280       *CompilationDir) {
 281     sys::path::append(AbsolutePath, *CompilationDir);
 282   }
 283   sys::path::append(AbsolutePath, *DWOFileName);
 284   DWO = llvm::make_unique<DWOHolder>(AbsolutePath);
 285   DWARFUnit *DWOCU = DWO->getUnit();
 286   // Verify that compile unit in .dwo file is valid.
 287   if (!DWOCU || DWOCU->getDWOId() != getDWOId()) {
 288     DWO.reset();
 289     return false;
 290   }
 291   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
 292   DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
 293   auto DWORangesBase = UnitDie.getRangesBaseAttribute();
 294   DWOCU->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
 295   return true;
 296 }
 297
 298 void DWARFUnit::clearDIEs(bool KeepCUDie) {
 299   if (DieArray.size() > (unsigned)KeepCUDie) {
 300     // std::vectors never get any smaller when resized to a smaller size,
 301     // or when clear() or erase() are called, the size will report that it
 302     // is smaller, but the memory allocated remains intact (call capacity()
 303     // to see this). So we need to create a temporary vector and swap the
 304     // contents which will cause just the internal pointers to be swapped
 305     // so that when temporary vector goes out of scope, it will destroy the
 306     // contents.
 307     std::vector<DWARFDebugInfoEntry> TmpArray;
 308     DieArray.swap(TmpArray);
 309     // Save at least the compile unit DIE
 310     if (KeepCUDie)
 311       DieArray.push_back(TmpArray.front());
 312   }
 313 }
 314
 315 void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
 316   DWARFDie UnitDie = getUnitDIE();
 317   if (!UnitDie)
 318     return;
 319   // First, check if unit DIE describes address ranges for the whole unit.
 320   const auto &CUDIERanges = UnitDie.getAddressRanges();
 321   if (!CUDIERanges.empty()) {
 322     CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
 323     return;
 324   }
 325
 326   // This function is usually called if there in no .debug_aranges section
 327   // in order to produce a compile unit level set of address ranges that
 328   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
 329   // all compile units to stay loaded when they weren't needed. So we can end
 330   // up parsing the DWARF and then throwing them all away to keep memory usage
 331   // down.
 332   const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
 333   getUnitDIE().collectChildrenAddressRanges(CURanges);
 334
 335   // Collect address ranges from DIEs in .dwo if necessary.
 336   bool DWOCreated = parseDWO();
 337   if (DWO.get())
 338     DWO->getUnit()->collectAddressRanges(CURanges);
 339   if (DWOCreated)
 340     DWO.reset();
 341
 342   // Keep memory down by clearing DIEs if this generate function
 343   // caused them to be parsed.
 344   if (ClearDIEs)
 345     clearDIEs(true);
 346 }
 347
 348 void DWARFUnit::updateAddressDieMap(DWARFDie Die) {
 349   if (Die.isSubroutineDIE()) {
 350     for (const auto &R : Die.getAddressRanges()) {
 351       // Ignore 0-sized ranges.
 352       if (R.LowPC == R.HighPC)
 353         continue;
 354       auto B = AddrDieMap.upper_bound(R.LowPC);
 355       if (B != AddrDieMap.begin() && R.LowPC < (--B)->second.first) {
 356         // The range is a sub-range of existing ranges, we need to split the
 357         // existing range.
 358         if (R.HighPC < B->second.first)
 359           AddrDieMap[R.HighPC] = B->second;
 360         if (R.LowPC > B->first)
 361           AddrDieMap[B->first].first = R.LowPC;
 362       }
 363       AddrDieMap[R.LowPC] = std::make_pair(R.HighPC, Die);
 364     }
 365   }
 366   // Parent DIEs are added to the AddrDieMap prior to the Children DIEs to
 367   // simplify the logic to update AddrDieMap. The child's range will always
 368   // be equal or smaller than the parent's range. With this assumption, when
 369   // adding one range into the map, it will at most split a range into 3
 370   // sub-ranges.
 371   for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling())
 372     updateAddressDieMap(Child);
 373 }
 374
 375 DWARFDie DWARFUnit::getSubroutineForAddress(uint64_t Address) {
 376   extractDIEsIfNeeded(false);
 377   if (AddrDieMap.empty())
 378     updateAddressDieMap(getUnitDIE());
 379   auto R = AddrDieMap.upper_bound(Address);
 380   if (R == AddrDieMap.begin())
 381     return DWARFDie();
 382   // upper_bound's previous item contains Address.
 383   --R;
 384   if (Address >= R->second.first)
 385     return DWARFDie();
 386   return R->second.second;
 387 }
 388
 389 void
 390 DWARFUnit::getInlinedChainForAddress(uint64_t Address,
 391                                      SmallVectorImpl<DWARFDie> &InlinedChain) {
 392   assert(InlinedChain.empty());
 393   // Try to look for subprogram DIEs in the DWO file.
 394   parseDWO();
 395   // First, find the subroutine that contains the given address (the leaf
 396   // of inlined chain).
 397   DWARFDie SubroutineDIE =
 398       (DWO ? DWO->getUnit() : this)->getSubroutineForAddress(Address);
 399
 400   while (SubroutineDIE) {
 401     if (SubroutineDIE.isSubroutineDIE())
 402       InlinedChain.push_back(SubroutineDIE);
 403     SubroutineDIE  = SubroutineDIE.getParent();
 404   }
 405 }
 406
 407 const DWARFUnitIndex &llvm::getDWARFUnitIndex(DWARFContext &Context,
 408                                               DWARFSectionKind Kind) {
 409   if (Kind == DW_SECT_INFO)
 410     return Context.getCUIndex();
 411   assert(Kind == DW_SECT_TYPES);
 412   return Context.getTUIndex();
 413 }
 414
 415 DWARFDie DWARFUnit::getParent(const DWARFDebugInfoEntry *Die) {
 416   if (!Die)
 417     return DWARFDie();
 418   const uint32_t Depth = Die->getDepth();
 419   // Unit DIEs always have a depth of zero and never have parents.
 420   if (Depth == 0)
 421     return DWARFDie();
 422   // Depth of 1 always means parent is the compile/type unit.
 423   if (Depth == 1)
 424     return getUnitDIE();
 425   // Look for previous DIE with a depth that is one less than the Die's depth.
 426   const uint32_t ParentDepth = Depth - 1;
 427   for (uint32_t I = getDIEIndex(Die) - 1; I > 0; --I) {
 428     if (DieArray[I].getDepth() == ParentDepth)
 429       return DWARFDie(this, &DieArray[I]);
 430   }
 431   return DWARFDie();
 432 }
 433
 434 DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) {
 435   if (!Die)
 436     return DWARFDie();
 437   uint32_t Depth = Die->getDepth();
 438   // Unit DIEs always have a depth of zero and never have siblings.
 439   if (Depth == 0)
 440     return DWARFDie();
 441   // NULL DIEs don't have siblings.
 442   if (Die->getAbbreviationDeclarationPtr() == nullptr)
 443     return DWARFDie();
 444
 445   // Find the next DIE whose depth is the same as the Die's depth.
 446   for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
 447        ++I) {
 448     if (DieArray[I].getDepth() == Depth)
 449       return DWARFDie(this, &DieArray[I]);
 450   }
 451   return DWARFDie();
 452 }