LCOV - code coverage report
Current view: top level - lib/DebugInfo/DWARF - DWARFUnit.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 310 322 96.3 %
Date: 2018-06-17 00:07:59 Functions: 32 32 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/ADT/SmallString.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/DWARFDebugRnglists.h"
      18             : #include "llvm/DebugInfo/DWARF/DWARFDie.h"
      19             : #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
      20             : #include "llvm/Support/DataExtractor.h"
      21             : #include "llvm/Support/Path.h"
      22             : #include "llvm/Support/WithColor.h"
      23             : #include <algorithm>
      24             : #include <cassert>
      25             : #include <cstddef>
      26             : #include <cstdint>
      27             : #include <cstdio>
      28             : #include <utility>
      29             : #include <vector>
      30             : 
      31             : using namespace llvm;
      32             : using namespace dwarf;
      33             : 
      34        3998 : void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
      35             :   const DWARFObject &D = C.getDWARFObj();
      36       15992 :   parseImpl(C, D, Section, C.getDebugAbbrev(), &D.getRangeSection(),
      37        7996 :             D.getStringSection(), D.getStringOffsetSection(),
      38       11994 :             &D.getAddrSection(), D.getLineSection(), D.isLittleEndian(), false,
      39        3998 :             false);
      40        3998 : }
      41             : 
      42         758 : void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
      43             :                                     const DWARFSection &DWOSection, bool Lazy) {
      44             :   const DWARFObject &D = C.getDWARFObj();
      45        3790 :   parseImpl(C, D, DWOSection, C.getDebugAbbrevDWO(), &D.getRangeDWOSection(),
      46        1516 :             D.getStringDWOSection(), D.getStringOffsetDWOSection(),
      47        1516 :             &D.getAddrSection(), D.getLineDWOSection(), C.isLittleEndian(),
      48         758 :             true, Lazy);
      49         758 : }
      50             : 
      51        5020 : DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
      52             :                      const DWARFUnitHeader &Header,
      53             :                      const DWARFDebugAbbrev *DA, const DWARFSection *RS,
      54             :                      StringRef SS, const DWARFSection &SOS,
      55             :                      const DWARFSection *AOS, const DWARFSection &LS, bool LE,
      56        5020 :                      bool IsDWO, const DWARFUnitSectionBase &UnitSection)
      57             :     : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA),
      58             :       RangeSection(RS), LineSection(LS), StringSection(SS),
      59             :       StringOffsetSection(SOS),  AddrOffsetSection(AOS), isLittleEndian(LE),
      60       10040 :       isDWO(IsDWO), UnitSection(UnitSection) {
      61        5020 :   clear();
      62        5020 : }
      63             : 
      64             : DWARFUnit::~DWARFUnit() = default;
      65             : 
      66       73180 : DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
      67      146360 :   return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
      68      146360 :                             getAddressByteSize());
      69             : }
      70             : 
      71         106 : bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
      72             :                                                 uint64_t &Result) const {
      73         212 :   uint32_t Offset = AddrOffsetSectionBase + Index * getAddressByteSize();
      74         212 :   if (AddrOffsetSection->Data.size() < Offset + getAddressByteSize())
      75             :     return false;
      76          91 :   DWARFDataExtractor DA(Context.getDWARFObj(), *AddrOffsetSection,
      77          91 :                         isLittleEndian, getAddressByteSize());
      78          91 :   Result = DA.getRelocatedAddress(&Offset);
      79          91 :   return true;
      80             : }
      81             : 
      82        1077 : bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
      83             :                                            uint64_t &Result) const {
      84        1077 :   if (!StringOffsetsTableContribution)
      85             :     return false;
      86        1076 :   unsigned ItemSize = getDwarfStringOffsetsByteSize();
      87        1076 :   uint32_t Offset = getStringOffsetsBase() + Index * ItemSize;
      88        2152 :   if (StringOffsetSection.Data.size() < Offset + ItemSize)
      89             :     return false;
      90        1076 :   DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection,
      91        1076 :                         isLittleEndian, 0);
      92        1076 :   Result = DA.getRelocatedValue(ItemSize, &Offset);
      93        1076 :   return true;
      94             : }
      95             : 
      96        5044 : bool DWARFUnitHeader::extract(DWARFContext &Context,
      97             :                               const DWARFDataExtractor &debug_info,
      98             :                               uint32_t *offset_ptr,
      99             :                               DWARFSectionKind SectionKind,
     100             :                               const DWARFUnitIndex *Index) {
     101        5044 :   Offset = *offset_ptr;
     102        5044 :   IndexEntry = Index ? Index->getFromOffset(*offset_ptr) : nullptr;
     103        5044 :   Length = debug_info.getU32(offset_ptr);
     104             :   // FIXME: Support DWARF64.
     105             :   unsigned SizeOfLength = 4;
     106        5044 :   FormParams.Format = DWARF32;
     107        5044 :   FormParams.Version = debug_info.getU16(offset_ptr);
     108        5044 :   if (FormParams.Version >= 5) {
     109          76 :     UnitType = debug_info.getU8(offset_ptr);
     110          76 :     FormParams.AddrSize = debug_info.getU8(offset_ptr);
     111          76 :     AbbrOffset = debug_info.getU32(offset_ptr);
     112             :   } else {
     113        4968 :     AbbrOffset = debug_info.getRelocatedValue(4, offset_ptr);
     114        4968 :     FormParams.AddrSize = debug_info.getU8(offset_ptr);
     115             :     // Fake a unit type based on the section type.  This isn't perfect,
     116             :     // but distinguishing compile and type units is generally enough.
     117        4968 :     if (SectionKind == DW_SECT_TYPES)
     118          45 :       UnitType = DW_UT_type;
     119             :     else
     120        4923 :       UnitType = DW_UT_compile;
     121             :   }
     122        5044 :   if (IndexEntry) {
     123          37 :     if (AbbrOffset)
     124             :       return false;
     125          37 :     auto *UnitContrib = IndexEntry->getOffset();
     126          37 :     if (!UnitContrib || UnitContrib->Length != (Length + 4))
     127             :       return false;
     128          37 :     auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV);
     129          37 :     if (!AbbrEntry)
     130             :       return false;
     131          37 :     AbbrOffset = AbbrEntry->Offset;
     132             :   }
     133       10088 :   if (isTypeUnit()) {
     134          59 :     TypeHash = debug_info.getU64(offset_ptr);
     135          59 :     TypeOffset = debug_info.getU32(offset_ptr);
     136        4985 :   } else if (UnitType == DW_UT_split_compile || UnitType == DW_UT_skeleton)
     137           8 :     DWOId = debug_info.getU64(offset_ptr);
     138             : 
     139             :   // Header fields all parsed, capture the size of this unit header.
     140             :   assert(*offset_ptr - Offset <= 255 && "unexpected header size");
     141        5044 :   Size = uint8_t(*offset_ptr - Offset);
     142             : 
     143             :   // Type offset is unit-relative; should be after the header and before
     144             :   // the end of the current unit.
     145             :   bool TypeOffsetOK =
     146        5044 :       !isTypeUnit()
     147        5044 :           ? true
     148          59 :           : TypeOffset >= Size && TypeOffset < getLength() + SizeOfLength;
     149       10088 :   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
     150        5044 :   bool VersionOK = DWARFContext::isSupportedVersion(getVersion());
     151        5044 :   bool AddrSizeOK = getAddressByteSize() == 4 || getAddressByteSize() == 8;
     152             : 
     153        5044 :   if (!LengthOK || !VersionOK || !AddrSizeOK || !TypeOffsetOK)
     154             :     return false;
     155             : 
     156             :   // Keep track of the highest DWARF version we encounter across all units.
     157             :   Context.setMaxVersionIfGreater(getVersion());
     158             :   return true;
     159             : }
     160             : 
     161             : // Parse the rangelist table header, including the optional array of offsets
     162             : // following it (DWARF v5 and later).
     163             : static Expected<DWARFDebugRnglistTable>
     164          73 : parseRngListTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
     165             :   // TODO: Support DWARF64
     166             :   // We are expected to be called with Offset 0 or pointing just past the table
     167             :   // header, which is 12 bytes long for DWARF32.
     168          73 :   if (Offset > 0) {
     169           3 :     if (Offset < 12U) {
     170             :       std::string Buffer;
     171           1 :       raw_string_ostream Stream(Buffer);
     172           1 :       Stream << format(
     173             :           "Did not detect a valid range list table with base = 0x%x", Offset);
     174           2 :       return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
     175             :     }
     176           2 :     Offset -= 12U;
     177             :   }
     178          72 :   llvm::DWARFDebugRnglistTable Table;
     179         144 :   if (Error E = Table.extractHeaderAndOffsets(DA, &Offset))
     180             :     return std::move(E);
     181             :   return Table;
     182             : }
     183             : 
     184        1162 : bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
     185             :                                  DWARFDebugRangeList &RangeList) const {
     186             :   // Require that compile unit is extracted.
     187             :   assert(!DieArray.empty());
     188        1162 :   DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
     189        1162 :                                 isLittleEndian, getAddressByteSize());
     190        1162 :   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
     191        1162 :   return RangeList.extract(RangesData, &ActualRangeListOffset);
     192             : }
     193             : 
     194        5020 : void DWARFUnit::clear() {
     195        5020 :   Abbrevs = nullptr;
     196             :   BaseAddr.reset();
     197        5020 :   RangeSectionBase = 0;
     198        5020 :   AddrOffsetSectionBase = 0;
     199        5020 :   clearDIEs(false);
     200             :   DWO.reset();
     201        5020 : }
     202             : 
     203        3526 : const char *DWARFUnit::getCompilationDir() {
     204        7052 :   return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
     205             : }
     206             : 
     207        4591 : void DWARFUnit::extractDIEsToVector(
     208             :     bool AppendCUDie, bool AppendNonCUDies,
     209             :     std::vector<DWARFDebugInfoEntry> &Dies) const {
     210        4591 :   if (!AppendCUDie && !AppendNonCUDies)
     211           0 :     return;
     212             : 
     213             :   // Set the offset to that of the first DIE and calculate the start of the
     214             :   // next compilation unit header.
     215        4591 :   uint32_t DIEOffset = getOffset() + getHeaderSize();
     216             :   uint32_t NextCUOffset = getNextUnitOffset();
     217        4591 :   DWARFDebugInfoEntry DIE;
     218        4591 :   DWARFDataExtractor DebugInfoData = getDebugInfoExtractor();
     219             :   uint32_t Depth = 0;
     220             :   bool IsCUDie = true;
     221             : 
     222       38619 :   while (DIE.extractFast(*this, &DIEOffset, DebugInfoData, NextCUOffset,
     223             :                          Depth)) {
     224       37955 :     if (IsCUDie) {
     225        4581 :       if (AppendCUDie)
     226        3834 :         Dies.push_back(DIE);
     227        4581 :       if (!AppendNonCUDies)
     228             :         break;
     229             :       // The average bytes per DIE entry has been seen to be
     230             :       // around 14-20 so let's pre-reserve the needed memory for
     231             :       // our DIE entries accordingly.
     232        4240 :       Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
     233             :       IsCUDie = false;
     234             :     } else {
     235       33374 :       Dies.push_back(DIE);
     236             :     }
     237             : 
     238       35494 :     if (const DWARFAbbreviationDeclaration *AbbrDecl =
     239       35494 :             DIE.getAbbreviationDeclarationPtr()) {
     240             :       // Normal DIE
     241       28498 :       if (AbbrDecl->hasChildren())
     242        6977 :         ++Depth;
     243             :     } else {
     244             :       // NULL DIE.
     245        6996 :       if (Depth > 0)
     246        6974 :         --Depth;
     247        6996 :       if (Depth == 0)
     248             :         break;  // We are done with this compile unit!
     249             :     }
     250             :   }
     251             : 
     252             :   // Give a little bit of info if we encounter corrupt DWARF (our offset
     253             :   // should always terminate at or before the start of the next compilation
     254             :   // unit header).
     255        4591 :   if (DIEOffset > NextCUOffset)
     256          15 :     WithColor::warning() << format("DWARF compile unit extends beyond its "
     257             :                                    "bounds cu 0x%8.8x at 0x%8.8x\n",
     258             :                                    getOffset(), DIEOffset);
     259             : }
     260             : 
     261       29854 : size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
     262       62172 :   if ((CUDieOnly && !DieArray.empty()) ||
     263       14109 :       DieArray.size() > 1)
     264             :     return 0; // Already parsed.
     265             : 
     266             :   bool HasCUDie = !DieArray.empty();
     267        4591 :   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
     268             : 
     269        4591 :   if (DieArray.empty())
     270             :     return 0;
     271             : 
     272             :   // If CU DIE was just parsed, copy several attribute values from it.
     273        4581 :   if (!HasCUDie) {
     274        3834 :     DWARFDie UnitDie = getUnitDIE();
     275        7668 :     if (Optional<uint64_t> DWOId = toUnsigned(UnitDie.find(DW_AT_GNU_dwo_id)))
     276         175 :       Header.setDWOId(*DWOId);
     277        3834 :     if (!isDWO) {
     278             :       assert(AddrOffsetSectionBase == 0);
     279             :       assert(RangeSectionBase == 0);
     280        3731 :       AddrOffsetSectionBase =
     281        7462 :           toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base), 0);
     282        7462 :       RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0);
     283             :     }
     284             : 
     285             :     // In general, in DWARF v5 and beyond we derive the start of the unit's
     286             :     // contribution to the string offsets table from the unit DIE's
     287             :     // DW_AT_str_offsets_base attribute. Split DWARF units do not use this
     288             :     // attribute, so we assume that there is a contribution to the string
     289             :     // offsets table starting at offset 0 of the debug_str_offsets.dwo section.
     290             :     // In both cases we need to determine the format of the contribution,
     291             :     // which may differ from the unit's format.
     292             :     uint64_t StringOffsetsContributionBase =
     293        7668 :         isDWO ? 0 : toSectionOffset(UnitDie.find(DW_AT_str_offsets_base), 0);
     294        3834 :     auto IndexEntry = Header.getIndexEntry();
     295        3834 :     if (IndexEntry)
     296          37 :       if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
     297          34 :         StringOffsetsContributionBase += C->Offset;
     298             : 
     299        3834 :     DWARFDataExtractor DA(Context.getDWARFObj(), StringOffsetSection,
     300        3834 :                           isLittleEndian, 0);
     301        3834 :     if (isDWO)
     302             :       StringOffsetsTableContribution =
     303         206 :           determineStringOffsetsTableContributionDWO(
     304             :               DA, StringOffsetsContributionBase);
     305        3731 :     else if (getVersion() >= 5)
     306         112 :       StringOffsetsTableContribution = determineStringOffsetsTableContribution(
     307             :           DA, StringOffsetsContributionBase);
     308             : 
     309             :     // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to
     310             :     // describe address ranges.
     311        3834 :     if (getVersion() >= 5) {
     312          73 :       if (isDWO)
     313          34 :         setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
     314             :       else
     315         112 :         setRangesSection(&Context.getDWARFObj().getRnglistsSection(),
     316         112 :                          toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0));
     317             :       // Parse the range list table header. Individual range lists are
     318             :       // extracted lazily.
     319          73 :       DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
     320          73 :                                   isLittleEndian, 0);
     321          73 :       if (auto TableOrError =
     322         146 :               parseRngListTableHeader(RangesDA, RangeSectionBase))
     323             :         RngListTable = TableOrError.get();
     324             :       else
     325          70 :         WithColor::error() << "parsing a range list table: "
     326         210 :                            << toString(TableOrError.takeError())
     327             :                            << '\n';
     328             : 
     329             :       // In a split dwarf unit, there is no DW_AT_rnglists_base attribute.
     330             :       // Adjust RangeSectionBase to point past the table header.
     331          73 :       if (isDWO && RngListTable)
     332           2 :         RangeSectionBase = RngListTable->getHeaderSize();
     333             :     }
     334             : 
     335             :     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
     336             :     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
     337             :   }
     338             : 
     339        9162 :   return DieArray.size();
     340             : }
     341             : 
     342        1262 : bool DWARFUnit::parseDWO() {
     343        1262 :   if (isDWO)
     344             :     return false;
     345        1257 :   if (DWO.get())
     346             :     return false;
     347        1254 :   DWARFDie UnitDie = getUnitDIE();
     348             :   if (!UnitDie)
     349             :     return false;
     350        2508 :   auto DWOFileName = dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
     351        1254 :   if (!DWOFileName)
     352             :     return false;
     353          64 :   auto CompilationDir = dwarf::toString(UnitDie.find(DW_AT_comp_dir));
     354             :   SmallString<16> AbsolutePath;
     355          96 :   if (sys::path::is_relative(*DWOFileName) && CompilationDir &&
     356          32 :       *CompilationDir) {
     357          32 :     sys::path::append(AbsolutePath, *CompilationDir);
     358             :   }
     359          64 :   sys::path::append(AbsolutePath, *DWOFileName);
     360             :   auto DWOId = getDWOId();
     361          32 :   if (!DWOId)
     362             :     return false;
     363          64 :   auto DWOContext = Context.getDWOContext(AbsolutePath);
     364          32 :   if (!DWOContext)
     365             :     return false;
     366             : 
     367          19 :   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
     368          19 :   if (!DWOCU)
     369             :     return false;
     370             :   DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
     371             :   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
     372          19 :   DWO->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
     373          19 :   if (getVersion() >= 5) {
     374           0 :     DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
     375           0 :     DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
     376           0 :                                 isLittleEndian, 0);
     377           0 :     if (auto TableOrError = parseRngListTableHeader(RangesDA, RangeSectionBase))
     378             :       DWO->RngListTable = TableOrError.get();
     379             :     else
     380           0 :       WithColor::error() << "parsing a range list table: "
     381           0 :                          << toString(TableOrError.takeError())
     382             :                          << '\n';
     383           0 :     if (DWO->RngListTable)
     384           0 :       DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
     385             :   } else {
     386          19 :     auto DWORangesBase = UnitDie.getRangesBaseAttribute();
     387          19 :     DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
     388             :   }
     389             : 
     390             :   return true;
     391             : }
     392             : 
     393        5038 : void DWARFUnit::clearDIEs(bool KeepCUDie) {
     394       10076 :   if (DieArray.size() > (unsigned)KeepCUDie) {
     395          18 :     DieArray.resize((unsigned)KeepCUDie);
     396             :     DieArray.shrink_to_fit();
     397             :   }
     398        5038 : }
     399             : 
     400        1166 : DWARFAddressRangesVector DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
     401        1166 :   if (getVersion() <= 4) {
     402             :     DWARFDebugRangeList RangeList;
     403        1162 :     if (extractRangeList(Offset, RangeList))
     404        1160 :       return RangeList.getAbsoluteRanges(getBaseAddress());
     405             :     return DWARFAddressRangesVector();
     406             :   }
     407           4 :   if (RngListTable) {
     408           3 :     DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
     409           3 :                                   isLittleEndian, RngListTable->getAddrSize());
     410           3 :     if (auto RangeList = RngListTable->findRangeList(RangesData, Offset))
     411           3 :       return RangeList->getAbsoluteRanges(getBaseAddress());
     412             :   }
     413             :   return DWARFAddressRangesVector();
     414             : }
     415             : 
     416           3 : DWARFAddressRangesVector DWARFUnit::findRnglistFromIndex(uint32_t Index) {
     417           3 :   if (auto Offset = getRnglistOffset(Index))
     418           2 :     return findRnglistFromOffset(*Offset + RangeSectionBase);
     419             :   return DWARFAddressRangesVector();
     420             : }
     421             : 
     422        2324 : void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
     423        2324 :   DWARFDie UnitDie = getUnitDIE();
     424             :   if (!UnitDie)
     425        1784 :     return;
     426             :   // First, check if unit DIE describes address ranges for the whole unit.
     427        2324 :   const auto &CUDIERanges = UnitDie.getAddressRanges();
     428        2324 :   if (!CUDIERanges.empty()) {
     429        1784 :     CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
     430             :     return;
     431             :   }
     432             : 
     433             :   // This function is usually called if there in no .debug_aranges section
     434             :   // in order to produce a compile unit level set of address ranges that
     435             :   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
     436             :   // all compile units to stay loaded when they weren't needed. So we can end
     437             :   // up parsing the DWARF and then throwing them all away to keep memory usage
     438             :   // down.
     439         540 :   const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
     440         540 :   getUnitDIE().collectChildrenAddressRanges(CURanges);
     441             : 
     442             :   // Collect address ranges from DIEs in .dwo if necessary.
     443         540 :   bool DWOCreated = parseDWO();
     444         540 :   if (DWO)
     445           5 :     DWO->collectAddressRanges(CURanges);
     446         540 :   if (DWOCreated)
     447             :     DWO.reset();
     448             : 
     449             :   // Keep memory down by clearing DIEs if this generate function
     450             :   // caused them to be parsed.
     451         540 :   if (ClearDIEs)
     452          18 :     clearDIEs(true);
     453             : }
     454             : 
     455       21987 : void DWARFUnit::updateAddressDieMap(DWARFDie Die) {
     456       21987 :   if (Die.isSubroutineDIE()) {
     457        7548 :     for (const auto &R : Die.getAddressRanges()) {
     458             :       // Ignore 0-sized ranges.
     459         324 :       if (R.LowPC == R.HighPC)
     460             :         continue;
     461             :       auto B = AddrDieMap.upper_bound(R.LowPC);
     462         501 :       if (B != AddrDieMap.begin() && R.LowPC < (--B)->second.first) {
     463             :         // The range is a sub-range of existing ranges, we need to split the
     464             :         // existing range.
     465          59 :         if (R.HighPC < B->second.first)
     466          56 :           AddrDieMap[R.HighPC] = B->second;
     467          59 :         if (R.LowPC > B->first)
     468          30 :           AddrDieMap[B->first].first = R.LowPC;
     469             :       }
     470         648 :       AddrDieMap[R.LowPC] = std::make_pair(R.HighPC, Die);
     471             :     }
     472             :   }
     473             :   // Parent DIEs are added to the AddrDieMap prior to the Children DIEs to
     474             :   // simplify the logic to update AddrDieMap. The child's range will always
     475             :   // be equal or smaller than the parent's range. With this assumption, when
     476             :   // adding one range into the map, it will at most split a range into 3
     477             :   // sub-ranges.
     478       43815 :   for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling())
     479       21828 :     updateAddressDieMap(Child);
     480       21987 : }
     481             : 
     482         725 : DWARFDie DWARFUnit::getSubroutineForAddress(uint64_t Address) {
     483         725 :   extractDIEsIfNeeded(false);
     484         725 :   if (AddrDieMap.empty())
     485         159 :     updateAddressDieMap(getUnitDIE());
     486             :   auto R = AddrDieMap.upper_bound(Address);
     487         725 :   if (R == AddrDieMap.begin())
     488          26 :     return DWARFDie();
     489             :   // upper_bound's previous item contains Address.
     490             :   --R;
     491         699 :   if (Address >= R->second.first)
     492           5 :     return DWARFDie();
     493         694 :   return R->second.second;
     494             : }
     495             : 
     496             : void
     497         722 : DWARFUnit::getInlinedChainForAddress(uint64_t Address,
     498             :                                      SmallVectorImpl<DWARFDie> &InlinedChain) {
     499             :   assert(InlinedChain.empty());
     500             :   // Try to look for subprogram DIEs in the DWO file.
     501         722 :   parseDWO();
     502             :   // First, find the subroutine that contains the given address (the leaf
     503             :   // of inlined chain).
     504             :   DWARFDie SubroutineDIE =
     505         722 :       (DWO ? DWO.get() : this)->getSubroutineForAddress(Address);
     506             : 
     507             :   if (!SubroutineDIE)
     508          31 :     return;
     509             : 
     510          61 :   while (!SubroutineDIE.isSubprogramDIE()) {
     511          61 :     if (SubroutineDIE.getTag() == DW_TAG_inlined_subroutine)
     512          55 :       InlinedChain.push_back(SubroutineDIE);
     513          61 :     SubroutineDIE  = SubroutineDIE.getParent();
     514             :   }
     515         691 :   InlinedChain.push_back(SubroutineDIE);
     516             : }
     517             : 
     518         702 : const DWARFUnitIndex &llvm::getDWARFUnitIndex(DWARFContext &Context,
     519             :                                               DWARFSectionKind Kind) {
     520         702 :   if (Kind == DW_SECT_INFO)
     521         689 :     return Context.getCUIndex();
     522             :   assert(Kind == DW_SECT_TYPES);
     523          13 :   return Context.getTUIndex();
     524             : }
     525             : 
     526          76 : DWARFDie DWARFUnit::getParent(const DWARFDebugInfoEntry *Die) {
     527          76 :   if (!Die)
     528           0 :     return DWARFDie();
     529          76 :   const uint32_t Depth = Die->getDepth();
     530             :   // Unit DIEs always have a depth of zero and never have parents.
     531          76 :   if (Depth == 0)
     532           5 :     return DWARFDie();
     533             :   // Depth of 1 always means parent is the compile/type unit.
     534          71 :   if (Depth == 1)
     535             :     return getUnitDIE();
     536             :   // Look for previous DIE with a depth that is one less than the Die's depth.
     537          66 :   const uint32_t ParentDepth = Depth - 1;
     538          88 :   for (uint32_t I = getDIEIndex(Die) - 1; I > 0; --I) {
     539         176 :     if (DieArray[I].getDepth() == ParentDepth)
     540          66 :       return DWARFDie(this, &DieArray[I]);
     541             :   }
     542           0 :   return DWARFDie();
     543             : }
     544             : 
     545       34312 : DWARFDie DWARFUnit::getSibling(const DWARFDebugInfoEntry *Die) {
     546       34312 :   if (!Die)
     547           0 :     return DWARFDie();
     548       34312 :   uint32_t Depth = Die->getDepth();
     549             :   // Unit DIEs always have a depth of zero and never have siblings.
     550       34312 :   if (Depth == 0)
     551           1 :     return DWARFDie();
     552             :   // NULL DIEs don't have siblings.
     553       34311 :   if (Die->getAbbreviationDeclarationPtr() == nullptr)
     554        5764 :     return DWARFDie();
     555             : 
     556             :   // Find the next DIE whose depth is the same as the Die's depth.
     557      104130 :   for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
     558             :        ++I) {
     559       52064 :     if (DieArray[I].getDepth() == Depth)
     560       28546 :       return DWARFDie(this, &DieArray[I]);
     561             :   }
     562           1 :   return DWARFDie();
     563             : }
     564             : 
     565       32241 : DWARFDie DWARFUnit::getFirstChild(const DWARFDebugInfoEntry *Die) {
     566       32241 :   if (!Die->hasChildren())
     567       24341 :     return DWARFDie();
     568             : 
     569             :   // We do not want access out of bounds when parsing corrupted debug data.
     570        7900 :   size_t I = getDIEIndex(Die) + 1;
     571       15800 :   if (I >= DieArray.size())
     572           1 :     return DWARFDie();
     573        7899 :   return DWARFDie(this, &DieArray[I]);
     574             : }
     575             : 
     576       31650 : const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
     577       31650 :   if (!Abbrevs)
     578        3833 :     Abbrevs = Abbrev->getAbbreviationDeclarationSet(Header.getAbbrOffset());
     579       31650 :   return Abbrevs;
     580             : }
     581             : 
     582        1321 : llvm::Optional<BaseAddress> DWARFUnit::getBaseAddress() {
     583        1321 :   if (BaseAddr)
     584             :     return BaseAddr;
     585             : 
     586        1232 :   DWARFDie UnitDie = getUnitDIE();
     587        1232 :   Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
     588        1232 :   if (Optional<uint64_t> Addr = toAddress(PC))
     589        1223 :     BaseAddr = {*Addr, PC->getSectionIndex()};
     590             : 
     591             :   return BaseAddr;
     592             : }
     593             : 
     594             : Optional<StrOffsetsContributionDescriptor>
     595          47 : StrOffsetsContributionDescriptor::validateContributionSize(
     596             :     DWARFDataExtractor &DA) {
     597             :   uint8_t EntrySize = getDwarfOffsetByteSize();
     598             :   // In order to ensure that we don't read a partial record at the end of
     599             :   // the section we validate for a multiple of the entry size.
     600          47 :   uint64_t ValidationSize = alignTo(Size, EntrySize);
     601             :   // Guard against overflow.
     602          47 :   if (ValidationSize >= Size)
     603          47 :     if (DA.isValidOffsetForDataOfSize((uint32_t)Base, ValidationSize))
     604             :       return *this;
     605             :   return Optional<StrOffsetsContributionDescriptor>();
     606             : }
     607             : 
     608             : // Look for a DWARF64-formatted contribution to the string offsets table
     609             : // starting at a given offset and record it in a descriptor.
     610             : static Optional<StrOffsetsContributionDescriptor>
     611          22 : parseDWARF64StringOffsetsTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
     612          22 :   if (!DA.isValidOffsetForDataOfSize(Offset, 16))
     613             :     return Optional<StrOffsetsContributionDescriptor>();
     614             : 
     615          19 :   if (DA.getU32(&Offset) != 0xffffffff)
     616             :     return Optional<StrOffsetsContributionDescriptor>();
     617             : 
     618           2 :   uint64_t Size = DA.getU64(&Offset);
     619           2 :   uint8_t Version = DA.getU16(&Offset);
     620           2 :   (void)DA.getU16(&Offset); // padding
     621             :   // The encoded length includes the 2-byte version field and the 2-byte
     622             :   // padding, so we need to subtract them out when we populate the descriptor.
     623           2 :   return StrOffsetsContributionDescriptor(Offset, Size - 4, Version, DWARF64);
     624             :   //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
     625             : }
     626             : 
     627             : // Look for a DWARF32-formatted contribution to the string offsets table
     628             : // starting at a given offset and record it in a descriptor.
     629             : static Optional<StrOffsetsContributionDescriptor>
     630          49 : parseDWARF32StringOffsetsTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
     631          49 :   if (!DA.isValidOffsetForDataOfSize(Offset, 8))
     632             :     return Optional<StrOffsetsContributionDescriptor>();
     633          46 :   uint32_t ContributionSize = DA.getU32(&Offset);
     634          46 :   if (ContributionSize >= 0xfffffff0)
     635             :     return Optional<StrOffsetsContributionDescriptor>();
     636          45 :   uint8_t Version = DA.getU16(&Offset);
     637          45 :   (void)DA.getU16(&Offset); // padding
     638             :   // The encoded length includes the 2-byte version field and the 2-byte
     639             :   // padding, so we need to subtract them out when we populate the descriptor.
     640          45 :   return StrOffsetsContributionDescriptor(Offset, ContributionSize - 4, Version,
     641             :                                           DWARF32);
     642             :   //return Optional<StrOffsetsContributionDescriptor>(Descriptor);
     643             : }
     644             : 
     645             : Optional<StrOffsetsContributionDescriptor>
     646          56 : DWARFUnit::determineStringOffsetsTableContribution(DWARFDataExtractor &DA,
     647             :                                                    uint64_t Offset) {
     648             :   Optional<StrOffsetsContributionDescriptor> Descriptor;
     649             :   // Attempt to find a DWARF64 contribution 16 bytes before the base.
     650          56 :   if (Offset >= 16)
     651             :     Descriptor =
     652          10 :         parseDWARF64StringOffsetsTableHeader(DA, (uint32_t)Offset - 16);
     653             :   // Try to find a DWARF32 contribution 8 bytes before the base.
     654          56 :   if (!Descriptor && Offset >= 8)
     655          64 :     Descriptor = parseDWARF32StringOffsetsTableHeader(DA, (uint32_t)Offset - 8);
     656         112 :   return Descriptor ? Descriptor->validateContributionSize(DA) : Descriptor;
     657             : }
     658             : 
     659             : Optional<StrOffsetsContributionDescriptor>
     660         103 : DWARFUnit::determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA,
     661             :                                                       uint64_t Offset) {
     662         103 :   if (getVersion() >= 5) {
     663             :     // Look for a valid contribution at the given offset.
     664             :     auto Descriptor =
     665          17 :         parseDWARF64StringOffsetsTableHeader(DA, (uint32_t)Offset);
     666          17 :     if (!Descriptor)
     667          34 :       Descriptor = parseDWARF32StringOffsetsTableHeader(DA, (uint32_t)Offset);
     668          17 :     return Descriptor ? Descriptor->validateContributionSize(DA) : Descriptor;
     669             :   }
     670             :   // Prior to DWARF v5, we derive the contribution size from the
     671             :   // index table (in a package file). In a .dwo file it is simply
     672             :   // the length of the string offsets section.
     673             :   uint64_t Size = 0;
     674          86 :   auto IndexEntry = Header.getIndexEntry();
     675          86 :   if (!IndexEntry)
     676          53 :     Size = StringOffsetSection.Data.size();
     677          33 :   else if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
     678          30 :     Size = C->Length;
     679             :   // Return a descriptor with the given offset as base, version 4 and
     680             :   // DWARF32 format.
     681             :   //return Optional<StrOffsetsContributionDescriptor>(
     682             :       //StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32));
     683             :   return StrOffsetsContributionDescriptor(Offset, Size, 4, DWARF32);
     684             : }

Generated by: LCOV version 1.13