Add support for DebugFission to DWARF parser

[samsonov]

Summary

1. Make llvm-symbolizer properly symbolize

files with split debug info (by using stanalone .dwo files).

2. Make DWARFCompileUnit parse and store corresponding .dwo file,

if necessary.

3. Make bits of DWARF parsing more CompileUnit-oriented.

[samsonov]

Oh, and I would appreciate advice on writing tests for split-dwarf. Looks like debug info in the binaries built with -gsplit-dwarf always contains absolute paths to .dwo files, so checking in pre-built binaries is problematic... Generating .dwo files requires a fresh enough objcopy. Also, building binaries from source (or bytecode) in test cases would make it hard to predict the resulting object file layout and build (input, expected output) pairs for llvm-symbolizer...

[samsonov]

(ping)

[echristo]

Totally missed this. I'll look today. Sorry about that.

[echristo]

Few questions inline, otherwise looks pretty good.

include/llvm/DebugInfo/DIContext.h

127 ↗

(On Diff #2864)

Unfortunate naming in english. How about CK_DWARF?

lib/DebugInfo/DWARFContext.h

30 ↗

(On Diff #2864)

Consider breaking this part out first in a separate patch? Also, since there's a single DWO for a single compile unit I'm not sure about the change to pointer as far as relevance to this patch. Can you give a bit more explanation here?

[samsonov]

Reduced version of the patch.

[samsonov]

I've commited minor parts of this patch as r187790, r187792, and mailed http://llvm-reviews.chandlerc.com/D1298 separately.

include/llvm/DebugInfo/DIContext.h

127 ↗

(On Diff #2864)

Done (RTTI part commited in r187790).

[samsonov]

Remove obsolete debugging code.

[samsonov]

(ping)

[echristo]

This is fine. I'm not really happy with the IsDWOIndex and might want to just put the form type in, but I'm not wedded to either idea. Thanks.

[dblaikie]

In D1164#1, @samsonov wrote:

Oh, and I would appreciate advice on writing tests for split-dwarf. Looks like debug info in the binaries built with -gsplit-dwarf always contains absolute paths to .dwo files, so checking in pre-built binaries is problematic... Generating .dwo files requires a fresh enough objcopy. Also, building binaries from source (or bytecode) in test cases would make it hard to predict the resulting object file layout and build (input, expected output) pairs for llvm-symbolizer...

Rafael recently (temporarily) broke some of this code while doing some unique_ptr refactoring and we were both a bit surprised by the lack of test coverage. You make a good point though, that this isn't easy to test, but let's see if there's some way:

What would happen if we build a dwo file somewhat manually - generating the assembly from Clang/LLVM, then hand-hacking the dwo file path (or just using clang -cc1 and specifying the dwo file name manually) as a relative path, rather than an absolute one. Would that produce a reusable test case we could commit to the lit suite?

Otherwise, at least, it'd be useful to have some manual test steps written down somewhere (maybe in the test/ directory, just in the form of a text file with a FIXME and manual steps).

[samsonov]

Right, I was able to forge the test case by hacking -fdebug-compilation-dir in clang-cc1 invocation. The fix by Rafael was incorrect, and I had to debug nasty memory corruption (ASan FTW). Which is one more proof of "never-compromise-the-testing" rule. Sigh.

include/llvm/DebugInfo/DWARFFormValue.h

 namespace llvm {
 
 class DWARFCompileUnit;
 class raw_ostream;
 
 class DWARFFormValue {
 public:
   struct ValueType {
-    ValueType() : data(NULL) {
+    ValueType() : data(NULL), IsDWOIndex(false) {
       uval = 0;
     }
 
     union {
       uint64_t uval;
       int64_t sval;
       const char* cstr;
     };
     const uint8_t* data;
+    bool IsDWOIndex;
   };
 
   enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
public:
   uint64_t getReference(const DWARFCompileUnit* cu) const;
 
   /// Resolve any compile unit specific references so that we don't need
   /// the compile unit at a later time in order to work with the form
   /// value.
   bool resolveCompileUnitReferences(const DWARFCompileUnit* cu);
   uint64_t getUnsigned() const { return Value.uval; }
   int64_t getSigned() const { return Value.sval; }
-  const char *getAsCString(const DataExtractor *debug_str_data_ptr) const;
-  const char *getIndirectCString(const DataExtractor *,
-                                 const DataExtractor *) const;
-  uint64_t getIndirectAddress(const DataExtractor *,
-                              const DWARFCompileUnit *) const;
+  const char *getAsCString(const DWARFCompileUnit *CU) const;
+  uint64_t getAsAddress(const DWARFCompileUnit *CU) const;
   bool skipValue(DataExtractor debug_info_data, uint32_t *offset_ptr,
                  const DWARFCompileUnit *cu) const;
   static bool skipValue(uint16_t form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, const DWARFCompileUnit *cu);
   static bool isBlockForm(uint16_t form);
   static bool isDataForm(uint16_t form);
   static const uint8_t *getFixedFormSizes(uint8_t AddrSize, uint16_t Version);
 };
 
 }
 
 #endif

lib/DebugInfo/DWARFCompileUnit.h

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFCOMPILEUNIT_H
 #define LLVM_DEBUGINFO_DWARFCOMPILEUNIT_H
 
+#include "llvm/ADT/OwningPtr.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDebugRangeList.h"
 #include "DWARFRelocMap.h"
 #include <vector>
 
 namespace llvm {
 
+namespace object {
+class ObjectFile;
+}
+
 class DWARFDebugAbbrev;
 class StringRef;
 class raw_ostream;
 
 class DWARFCompileUnit {
+  DWARFCompileUnit(DWARFCompileUnit const &) LLVM_DELETED_FUNCTION;
+  DWARFCompileUnit &operator=(DWARFCompileUnit const &) LLVM_DELETED_FUNCTION;
+
   const DWARFDebugAbbrev *Abbrev;
   StringRef InfoSection;
   StringRef AbbrevSection;
   StringRef RangeSection;
+  uint32_t RangeSectionBase;
   StringRef StringSection;
   StringRef StringOffsetSection;
   StringRef AddrOffsetSection;
+  uint32_t AddrOffsetSectionBase;
   const RelocAddrMap *RelocMap;
   bool isLittleEndian;
 
   uint32_t Offset;
   uint32_t Length;
   uint16_t Version;
   const DWARFAbbreviationDeclarationSet *Abbrevs;
   uint8_t AddrSize;
   uint64_t BaseAddr;
   // The compile unit debug information entry items.
   std::vector<DWARFDebugInfoEntryMinimal> DieArray;
+
+  class DWOHolder {
+    OwningPtr<object::ObjectFile> DWOFile;
+    OwningPtr<DWARFContext> DWOContext;
+    DWARFCompileUnit *DWOCU;
+  public:
+    DWOHolder(object::ObjectFile *DWOFile);
+    DWARFCompileUnit *getCU() const { return DWOCU; }
+  };
+  OwningPtr<DWOHolder> DWO;
+
 public:
 
   DWARFCompileUnit(const DWARFDebugAbbrev *DA, StringRef IS, StringRef AS,
                    StringRef RS, StringRef SS, StringRef SOS, StringRef AOS,
                    const RelocAddrMap *M, bool LE) :
     Abbrev(DA), InfoSection(IS), AbbrevSection(AS),
     RangeSection(RS), StringSection(SS), StringOffsetSection(SOS),
     AddrOffsetSection(AOS), RelocMap(M), isLittleEndian(LE) {
     clear();
   }
 
   StringRef getStringSection() const { return StringSection; }
   StringRef getStringOffsetSection() const { return StringOffsetSection; }
-  StringRef getAddrOffsetSection() const { return AddrOffsetSection; }
+  void setAddrOffsetSection(StringRef AOS, uint32_t Base) {
+    AddrOffsetSection = AOS;
+    AddrOffsetSectionBase = Base;
+  }
+  void setRangesSection(StringRef RS, uint32_t Base) {
+    RangeSection = RS;
+    RangeSectionBase = Base;
+  }
+
+  bool getAddrOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
+  // FIXME: Result should be uint64_t in DWARF64.
+  bool getStringOffsetSectionItem(uint32_t Index, uint32_t &Result) const;
+
+  DataExtractor getDebugInfoExtractor() const {
+    return DataExtractor(InfoSection, isLittleEndian, AddrSize);
+  }
+  DataExtractor getStringExtractor() const {
+    return DataExtractor(StringSection, false, 0);
+  }
+
   const RelocAddrMap *getRelocMap() const { return RelocMap; }
-  DataExtractor getDebugInfoExtractor() const;
 
   bool extract(DataExtractor debug_info, uint32_t* offset_ptr);
   uint32_t extract(uint32_t offset, DataExtractor debug_info_data,
                    const DWARFAbbreviationDeclarationSet *abbrevs);
 
   /// extractDIEsIfNeeded - Parses a compile unit and indexes its DIEs if it
   /// hasn't already been done. Returns the number of DIEs parsed at this call.
   size_t extractDIEsIfNeeded(bool CUDieOnly);
public:
 
   const DWARFDebugInfoEntryMinimal *
   getCompileUnitDIE(bool extract_cu_die_only = true) {
     extractDIEsIfNeeded(extract_cu_die_only);
     return DieArray.empty() ? NULL : &DieArray[0];
   }
 
   const char *getCompilationDir();
+  uint64_t getDWOId();
 
   /// setDIERelations - We read in all of the DIE entries into our flat list
   /// of DIE entries and now we need to go back through all of them and set the
   /// parent, sibling and child pointers for quick DIE navigation.
   void setDIERelations();
 
   void buildAddressRangeTable(DWARFDebugAranges *debug_aranges,
-                              bool clear_dies_if_already_not_parsed);
+                              bool clear_dies_if_already_not_parsed,
+                              uint32_t CUOffsetInAranges);
 
   /// getInlinedChainForAddress - fetches inlined chain for a given address.
   /// Returns empty chain if there is no subprogram containing address. The
   /// chain is valid as long as parsed compile unit DIEs are not cleared.
   DWARFDebugInfoEntryInlinedChain getInlinedChainForAddress(uint64_t Address);
 
 private:
   /// extractDIEsToVector - Appends all parsed DIEs to a vector.
   void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
                            std::vector<DWARFDebugInfoEntryMinimal> &DIEs) const;
   /// clearDIEs - Clear parsed DIEs to keep memory usage low.
   void clearDIEs(bool KeepCUDie);
+
+  /// parseDWO - Parses .dwo file for current compile unit. Returns true if
+  /// it was actually constructed.
+  bool parseDWO();
+
+  /// getSubprogramForAddress - Returns subprogram DIE with address range
+  /// encompassing the provided address. The pointer is alive as long as parsed
+  /// compile unit DIEs are not cleared.
+  const DWARFDebugInfoEntryMinimal *getSubprogramForAddress(uint64_t Address);
 };
 
 }
 
 #endif

lib/DebugInfo/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFCompileUnit.h"
 #include "DWARFContext.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;
 
-DataExtractor DWARFCompileUnit::getDebugInfoExtractor() const {
-  return DataExtractor(InfoSection, isLittleEndian, AddrSize);
+bool DWARFCompileUnit::getAddrOffsetSectionItem(uint32_t Index,
+                                                uint64_t &Result) const {
+  uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
+  if (AddrOffsetSection.size() < Offset + AddrSize)
+    return false;
+  DataExtractor DA(AddrOffsetSection, isLittleEndian, AddrSize);
+  Result = DA.getAddress(&Offset);
+  return true;
+}
+
+bool DWARFCompileUnit::getStringOffsetSectionItem(uint32_t Index,
+                                                  uint32_t &Result) const {
+  // FIXME: string offset section entries are 8-byte for DWARF64.
+  const uint32_t ItemSize = 4;
+  uint32_t Offset = Index * ItemSize;
+  if (StringOffsetSection.size() < Offset + ItemSize)
+    return false;
+  DataExtractor DA(StringOffsetSection, isLittleEndian, 0);
+  Result = DA.getU32(&Offset);
+  return true;
 }
 
 bool DWARFCompileUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
   clear();
 
   Offset = *offset_ptr;
 
   if (debug_info.isValidOffset(*offset_ptr)) {
DWARFCompileUnit::extract(uint32_t offset, DataExtractor debug_info_data,
   return 0;
 }
 
 bool DWARFCompileUnit::extractRangeList(uint32_t RangeListOffset,
                                         DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(DieArray.size() > 0);
   DataExtractor RangesData(RangeSection, isLittleEndian, AddrSize);
-  return RangeList.extract(RangesData, &RangeListOffset);
+  uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
+  return RangeList.extract(RangesData, &ActualRangeListOffset);
 }
 
 void DWARFCompileUnit::clear() {
   Offset = 0;
   Length = 0;
   Version = 0;
   Abbrevs = 0;
   AddrSize = 0;
   BaseAddr = 0;
+  RangeSectionBase = 0;
+  AddrOffsetSectionBase = 0;
   clearDIEs(false);
+  DWO.reset();
 }
 
 void DWARFCompileUnit::dump(raw_ostream &OS) {
   OS << format("0x%08x", Offset) << ": Compile Unit:"
      << " length = " << format("0x%08x", Length)
      << " version = " << format("0x%04x", Version)
      << " abbr_offset = " << format("0x%04x", Abbrevs->getOffset())
      << " addr_size = " << format("0x%02x", AddrSize)
      << " (next CU at " << format("0x%08x", getNextCompileUnitOffset())
      << ")\n";
 
   const DWARFDebugInfoEntryMinimal *CU = getCompileUnitDIE(false);
   assert(CU && "Null Compile Unit?");
   CU->dump(OS, this, -1U);
 }
 
 const char *DWARFCompileUnit::getCompilationDir() {
   extractDIEsIfNeeded(true);
   if (DieArray.empty())
     return 0;
   return DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, 0);
 }
 
+uint64_t DWARFCompileUnit::getDWOId() {
+  extractDIEsIfNeeded(true);
+  const uint64_t FailValue = -1ULL;
+  if (DieArray.empty())
+    return FailValue;
+  return DieArray[0]
+      .getAttributeValueAsUnsigned(this, DW_AT_GNU_dwo_id, FailValue);
+}
+
 void DWARFCompileUnit::setDIERelations() {
   if (DieArray.empty())
     return;
   DWARFDebugInfoEntryMinimal *die_array_begin = &DieArray.front();
   DWARFDebugInfoEntryMinimal *die_array_end = &DieArray.back();
   DWARFDebugInfoEntryMinimal *curr_die;
   // We purposely are skipping the last element in the array in the loop below
   // so that we can always have a valid next item
fprintf(stderr, "warning: DWARF compile unit extends beyond its "
                     "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), Offset);
 }
 
 size_t DWARFCompileUnit::extractDIEsIfNeeded(bool CUDieOnly) {
   if ((CUDieOnly && DieArray.size() > 0) ||
       DieArray.size() > 1)
     return 0; // Already parsed.
 
-  extractDIEsToVector(DieArray.empty(), !CUDieOnly, DieArray);
+  bool HasCUDie = DieArray.size() > 0;
+  extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 
-  // Set the base address of current compile unit.
-  if (!DieArray.empty()) {
+  if (DieArray.empty())
+    return 0;
+
+  // If CU DIE was just parsed, copy several attribute values from it.
+  if (!HasCUDie) {
     uint64_t BaseAddr =
       DieArray[0].getAttributeValueAsUnsigned(this, DW_AT_low_pc, -1U);
     if (BaseAddr == -1U)
       BaseAddr = DieArray[0].getAttributeValueAsUnsigned(this, DW_AT_entry_pc, 0);
     setBaseAddress(BaseAddr);
+    AddrOffsetSectionBase =
+        DieArray[0].getAttributeValueAsReference(this, DW_AT_GNU_addr_base, 0);
+    RangeSectionBase =
+        DieArray[0].getAttributeValueAsReference(this, DW_AT_GNU_ranges_base, 0);
   }
 
   setDIERelations();
   return DieArray.size();
 }
 
+DWARFCompileUnit::DWOHolder::DWOHolder(object::ObjectFile *DWOFile)
+    : DWOFile(DWOFile),
+      DWOContext(cast<DWARFContext>(DIContext::getDWARFContext(DWOFile))),
+      DWOCU(0) {
+  if (DWOContext->getNumDWOCompileUnits() > 0)
+    DWOCU = DWOContext->getDWOCompileUnitAtIndex(0);
+}
+
+bool DWARFCompileUnit::parseDWO() {
+  if (DWO.get() != 0)
+    return false;
+  extractDIEsIfNeeded(true);
+  if (DieArray.empty())
+    return false;
+  const char *DWOFileName =
+      DieArray[0].getAttributeValueAsString(this, DW_AT_GNU_dwo_name, 0);
+  if (DWOFileName == 0)
+    return false;
+  const char *CompilationDir =
+      DieArray[0].getAttributeValueAsString(this, DW_AT_comp_dir, 0);
+  SmallString<16> AbsolutePath;
+  if (sys::path::is_relative(DWOFileName) && CompilationDir != 0) {
+    sys::path::append(AbsolutePath, CompilationDir);
+  }
+  sys::path::append(AbsolutePath, DWOFileName);
+  object::ObjectFile *DWOFile =
+      object::ObjectFile::createObjectFile(AbsolutePath);
+  if (!DWOFile)
+    return false;
+  // Reset DWOHolder.
+  DWO.reset(new DWOHolder(DWOFile));
+  DWARFCompileUnit *DWOCU = DWO->getCU();
+  // Verify that compile unit in .dwo file is valid.
+  if (DWOCU == 0 || DWOCU->getDWOId() != getDWOId()) {
+    DWO.reset();
+    return false;
+  }
+  // Share .debug_addr and .debug_ranges section with compile unit in .dwo
+  DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
+  DWOCU->setRangesSection(RangeSection, RangeSectionBase);
+  return true;
+}
+
 void DWARFCompileUnit::clearDIEs(bool KeepCUDie) {
   if (DieArray.size() > (unsigned)KeepCUDie) {
     // std::vectors never get any smaller when resized to a smaller size,
     // or when clear() or erase() are called, the size will report that it
     // is smaller, but the memory allocated remains intact (call capacity()
     // to see this). So we need to create a temporary vector and swap the
     // contents which will cause just the internal pointers to be swapped
     // so that when temporary vector goes out of scope, it will destroy the
     // contents.
     std::vector<DWARFDebugInfoEntryMinimal> TmpArray;
     DieArray.swap(TmpArray);
     // Save at least the compile unit DIE
     if (KeepCUDie)
       DieArray.push_back(TmpArray.front());
   }
 }
 
 void
 DWARFCompileUnit::buildAddressRangeTable(DWARFDebugAranges *debug_aranges,
-                                         bool clear_dies_if_already_not_parsed){
+                                         bool clear_dies_if_already_not_parsed,
+                                         uint32_t CUOffsetInAranges) {
   // This function is usually called if there in no .debug_aranges section
   // in order to produce a compile unit level set of address ranges that
   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
   // all compile units to stay loaded when they weren't needed. So we can end
   // up parsing the DWARF and then throwing them all away to keep memory usage
   // down.
   const bool clear_dies = extractDIEsIfNeeded(false) > 1 &&
                           clear_dies_if_already_not_parsed;
-  DieArray[0].buildAddressRangeTable(this, debug_aranges);
+  DieArray[0].buildAddressRangeTable(this, debug_aranges, CUOffsetInAranges);
+  bool DWOCreated = parseDWO();
+  if (DWO.get()) {
+    // If there is a .dwo file for this compile unit, then skeleton CU DIE
+    // doesn't have children, and we should instead build address range table
+    // from DIEs in the .debug_info.dwo section of .dwo file.
+    DWO->getCU()->buildAddressRangeTable(
+        debug_aranges, clear_dies_if_already_not_parsed, CUOffsetInAranges);
+  }
+  if (DWOCreated && clear_dies_if_already_not_parsed)
+    DWO.reset();
 
   // Keep memory down by clearing DIEs if this generate function
   // caused them to be parsed.
   if (clear_dies)
     clearDIEs(true);
 }
 
+const DWARFDebugInfoEntryMinimal *
+DWARFCompileUnit::getSubprogramForAddress(uint64_t Address) {
+  extractDIEsIfNeeded(false);
+  for (size_t i = 0, n = DieArray.size(); i != n; i++)
+    if (DieArray[i].isSubprogramDIE() &&
+        DieArray[i].addressRangeContainsAddress(this, Address)) {
+      return &DieArray[i];
+    }
+  return 0;
+}
+
 DWARFDebugInfoEntryInlinedChain
 DWARFCompileUnit::getInlinedChainForAddress(uint64_t Address) {
   // First, find a subprogram that contains the given address (the root
   // of inlined chain).
-  extractDIEsIfNeeded(false);
-  const DWARFDebugInfoEntryMinimal *SubprogramDIE = 0;
-  for (size_t i = 0, n = DieArray.size(); i != n; i++) {
-    if (DieArray[i].isSubprogramDIE() &&
-        DieArray[i].addressRangeContainsAddress(this, Address)) {
-      SubprogramDIE = &DieArray[i];
-      break;
+  const DWARFCompileUnit *ChainCU = 0;
+  const DWARFDebugInfoEntryMinimal *SubprogramDIE =
+      getSubprogramForAddress(Address);
+  if (SubprogramDIE) {
+    ChainCU = this;
+  } else {
+    // Try to look for subprogram DIEs in the DWO file.
+    parseDWO();
+    if (DWO.get()) {
+      SubprogramDIE = DWO->getCU()->getSubprogramForAddress(Address);
+      if (SubprogramDIE)
+        ChainCU = DWO->getCU();
     }
   }
+
   // Get inlined chain rooted at this subprogram DIE.
   if (!SubprogramDIE)
     return DWARFDebugInfoEntryInlinedChain();
-  return SubprogramDIE->getInlinedChainForAddress(this, Address);
+  return SubprogramDIE->getInlinedChainForAddress(ChainCU, Address);
  }

lib/DebugInfo/DWARFDebugAranges.cpp

 
 bool DWARFDebugAranges::generate(DWARFContext *ctx) {
   if (ctx) {
     const uint32_t num_compile_units = ctx->getNumCompileUnits();
     for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
       if (DWARFCompileUnit *cu = ctx->getCompileUnitAtIndex(cu_idx)) {
         uint32_t CUOffset = cu->getOffset();
         if (ParsedCUOffsets.insert(CUOffset).second)
-          cu->buildAddressRangeTable(this, true);
+          cu->buildAddressRangeTable(this, true, CUOffset);
       }
     }
   }
   sort(true, /* overlap size */ 0);
   return !isEmpty();
 }
 
 void DWARFDebugAranges::dump(raw_ostream &OS) const {

lib/DebugInfo/DWARFDebugInfoEntry.h

public:
   uint32_t getAttributeValue(const DWARFCompileUnit *cu,
                              const uint16_t attr, DWARFFormValue &formValue,
                              uint32_t *end_attr_offset_ptr = 0) const;
 
   const char* getAttributeValueAsString(const DWARFCompileUnit* cu,
                                         const uint16_t attr,
                                         const char *fail_value) const;
 
+  uint64_t getAttributeValueAsAddress(const DWARFCompileUnit *CU,
+                                      const uint16_t Attr,
+                                      uint64_t FailValue) const;
+
   uint64_t getAttributeValueAsUnsigned(const DWARFCompileUnit *cu,
                                        const uint16_t attr,
                                        uint64_t fail_value) const;
 
   uint64_t getAttributeValueAsReference(const DWARFCompileUnit *cu,
                                         const uint16_t attr,
                                         uint64_t fail_value) const;
 
   int64_t getAttributeValueAsSigned(const DWARFCompileUnit* cu,
                                     const uint16_t attr,
                                     int64_t fail_value) const;
 
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
   bool getLowAndHighPC(const DWARFCompileUnit *CU,
                        uint64_t &LowPC, uint64_t &HighPC) const;
 
   void buildAddressRangeTable(const DWARFCompileUnit *CU,
-                              DWARFDebugAranges *DebugAranges) const;
+                              DWARFDebugAranges *DebugAranges,
+                              uint32_t CUOffsetInAranges) const;
 
   bool addressRangeContainsAddress(const DWARFCompileUnit *CU,
                                    const uint64_t Address) const;
 
   /// If a DIE represents a subprogram (or inlined subroutine),
   /// returns its mangled name (or short name, if mangled is missing).
   /// This name may be fetched from specification or abstract origin
   /// for this subprogram. Returns null if no name is found.

lib/DebugInfo/DWARFDebugInfoEntry.cpp

if (attr_idx != -1U) {
         return attr_offset;
       }
     }
   }
 
   return 0;
 }
 
-const char*
-DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
-                                                     const DWARFCompileUnit* cu,
-                                                     const uint16_t attr,
-                                                     const char* fail_value)
-                                                     const {
-  DWARFFormValue form_value;
-  if (getAttributeValue(cu, attr, form_value)) {
-    DataExtractor stringExtractor(cu->getStringSection(), false, 0);
-    return form_value.getAsCString(&stringExtractor);
+const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
+    const DWARFCompileUnit *CU, const uint16_t Attr,
+    const char *FailValue) const {
+  DWARFFormValue FormValue;
+  if (getAttributeValue(CU, Attr, FormValue))
+    return FormValue.getAsCString(CU);
+  return FailValue;
+}
+
+uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
+    const DWARFCompileUnit *CU, const uint16_t Attr, uint64_t FailValue) const {
+  DWARFFormValue FormValue;
+  if (getAttributeValue(CU, Attr, FormValue))
+    return FormValue.getAsAddress(CU);
+  return FailValue;
+}
+
+uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsigned(
+    const DWARFCompileUnit *CU, const uint16_t Attr, uint64_t FailValue) const {
+  DWARFFormValue FormValue;
+  if (getAttributeValue(CU, Attr, FormValue)) {
+    return FormValue.getUnsigned();
   }
-  return fail_value;
-}
-
-uint64_t
-DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsigned(
-                                                    const DWARFCompileUnit* cu,
-                                                    const uint16_t attr,
-                                                    uint64_t fail_value) const {
-  DWARFFormValue form_value;
-  if (getAttributeValue(cu, attr, form_value))
-      return form_value.getUnsigned();
-  return fail_value;
+  return FailValue;
 }
 
 int64_t
 DWARFDebugInfoEntryMinimal::getAttributeValueAsSigned(
                                                      const DWARFCompileUnit* cu,
                                                      const uint16_t attr,
                                                      int64_t fail_value) const {
   DWARFFormValue form_value;
if (getAttributeValue(cu, attr, form_value))
       return form_value.getReference(cu);
   return fail_value;
 }
 
 bool DWARFDebugInfoEntryMinimal::getLowAndHighPC(const DWARFCompileUnit *CU,
                                                  uint64_t &LowPC,
                                                  uint64_t &HighPC) const {
   HighPC = -1ULL;
-  LowPC = getAttributeValueAsUnsigned(CU, DW_AT_low_pc, -1ULL);
+  LowPC = getAttributeValueAsAddress(CU, DW_AT_low_pc, -1ULL);
   if (LowPC != -1ULL)
-    HighPC = getAttributeValueAsUnsigned(CU, DW_AT_high_pc, -1ULL);
+    HighPC = getAttributeValueAsAddress(CU, DW_AT_high_pc, -1ULL);
   return (HighPC != -1ULL);
 }
 
 void
 DWARFDebugInfoEntryMinimal::buildAddressRangeTable(const DWARFCompileUnit *CU,
-                                               DWARFDebugAranges *DebugAranges)
+                                               DWARFDebugAranges *DebugAranges,
+                                               uint32_t CUOffsetInAranges)
                                                    const {
   if (AbbrevDecl) {
     if (isSubprogramDIE()) {
       uint64_t LowPC, HighPC;
-      if (getLowAndHighPC(CU, LowPC, HighPC)) {
-        DebugAranges->appendRange(CU->getOffset(), LowPC, HighPC);
-      }
+      if (getLowAndHighPC(CU, LowPC, HighPC))
+        DebugAranges->appendRange(CUOffsetInAranges, LowPC, HighPC);
       // FIXME: try to append ranges from .debug_ranges section.
     }
 
-    const DWARFDebugInfoEntryMinimal *child = getFirstChild();
-    while (child) {
-      child->buildAddressRangeTable(CU, DebugAranges);
-      child = child->getSibling();
+    const DWARFDebugInfoEntryMinimal *Child = getFirstChild();
+    while (Child) {
+      Child->buildAddressRangeTable(CU, DebugAranges, CUOffsetInAranges);
+      Child = Child->getSibling();
     }
   }
 }
 
 bool
 DWARFDebugInfoEntryMinimal::addressRangeContainsAddress(
                                                      const DWARFCompileUnit *CU,
                                                      const uint64_t Address)

lib/DebugInfo/DWARFFormValue.cpp

do {
     }
     case DW_FORM_flag_present:
       Value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       Value.uval = data.getU64(offset_ptr);
       break;
     case DW_FORM_GNU_addr_index:
-      Value.uval = data.getULEB128(offset_ptr);
-      break;
     case DW_FORM_GNU_str_index:
       Value.uval = data.getULEB128(offset_ptr);
+      Value.IsDWOIndex = true;
       break;
     default:
       return false;
     }
   } while (indirect);
 
   if (is_block) {
     StringRef str = data.getData().substr(*offset_ptr, Value.uval);
DWARFFormValue::dump(raw_ostream &OS, const DWARFCompileUnit *cu) const {
   DataExtractor debug_str_data(cu->getStringSection(), true, 0);
   DataExtractor debug_str_offset_data(cu->getStringOffsetSection(), true, 0);
   uint64_t uvalue = getUnsigned();
   bool cu_relative_offset = false;
 
   switch (Form) {
   case DW_FORM_addr:      OS << format("0x%016" PRIx64, uvalue); break;
   case DW_FORM_GNU_addr_index: {
-    StringRef AddrOffsetSec = cu->getAddrOffsetSection();
     OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue);
-    if (AddrOffsetSec.size() != 0) {
-      DataExtractor DA(AddrOffsetSec, true, cu->getAddressByteSize());
-      OS << format("0x%016" PRIx64, getIndirectAddress(&DA, cu));
-    } else
+    uint64_t Address;
+    if (cu->getAddrOffsetSectionItem(uvalue, Address))
+      OS << format("0x%016" PRIx64, Address);
+    else
       OS << "<no .debug_addr section>";
     break;
   }
   case DW_FORM_flag_present: OS << "true"; break;
   case DW_FORM_flag:
   case DW_FORM_data1:     OS << format("0x%02x", (uint8_t)uvalue); break;
   case DW_FORM_data2:     OS << format("0x%04x", (uint16_t)uvalue); break;
   case DW_FORM_data4:     OS << format("0x%08x", (uint32_t)uvalue); break;
if (uvalue > 0) {
         OS << "NULL";
     }
     break;
 
   case DW_FORM_sdata:     OS << getSigned();   break;
   case DW_FORM_udata:     OS << getUnsigned(); break;
   case DW_FORM_strp: {
     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
-    const char* dbg_str = getAsCString(&debug_str_data);
+    const char* dbg_str = getAsCString(cu);
     if (dbg_str) {
       OS << '"';
       OS.write_escaped(dbg_str);
       OS << '"';
     }
     break;
   }
   case DW_FORM_GNU_str_index: {
     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
-    const char *dbg_str = getIndirectCString(&debug_str_data,
-                                             &debug_str_offset_data);
+    const char *dbg_str = getAsCString(cu);
     if (dbg_str) {
       OS << '"';
       OS.write_escaped(dbg_str);
       OS << '"';
     }
     break;
   }
   case DW_FORM_ref_addr:
default:
     break;
   }
 
   if (cu_relative_offset)
     OS << format(" => {0x%8.8" PRIx64 "}", uvalue + (cu ? cu->getOffset() : 0));
 }
 
 const char*
-DWARFFormValue::getAsCString(const DataExtractor *debug_str_data_ptr) const {
-  if (isInlinedCStr()) {
+DWARFFormValue::getAsCString(const DWARFCompileUnit *CU) const {
+  if (isInlinedCStr())
     return Value.cstr;
-  } else if (debug_str_data_ptr) {
-    uint32_t offset = Value.uval;
-    return debug_str_data_ptr->getCStr(&offset);
-  }
+  if (!CU)
+    return NULL;
+  uint32_t Offset = Value.uval;
+  if (Value.IsDWOIndex) {
+    uint32_t StrOffset;
+    if (!CU->getStringOffsetSectionItem(Offset, StrOffset))
       return NULL;
+    Offset = StrOffset;
   }
-
-const char*
-DWARFFormValue::getIndirectCString(const DataExtractor *DS,
-                                   const DataExtractor *DSO) const {
-  if (!DS || !DSO) return NULL;
-
-  uint32_t offset = Value.uval * 4;
-  uint32_t soffset = DSO->getU32(&offset);
-  return DS->getCStr(&soffset);
+  return CU->getStringExtractor().getCStr(&Offset);
 }
 
 uint64_t
-DWARFFormValue::getIndirectAddress(const DataExtractor *DA,
-                                   const DWARFCompileUnit *cu) const {
-  if (!DA) return 0;
-
-  uint32_t offset = Value.uval * cu->getAddressByteSize();
-  return DA->getAddress(&offset);
+DWARFFormValue::getAsAddress(const DWARFCompileUnit *CU) const {
+  if (!CU)
+    return 0;
+  if (Value.IsDWOIndex) {
+    uint32_t Index = Value.uval;
+    uint64_t Address;
+    if (!CU->getAddrOffsetSectionItem(Index, Address))
+      return 0;
+    return Address;
+  }
+  return Value.uval;
 }
 
 uint64_t DWARFFormValue::getReference(const DWARFCompileUnit *cu) const {
   uint64_t die_offset = Value.uval;
   switch (Form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4: