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