[DWARF parsers] - Add a way to get section indices when call DWARFUnit::collectAddressRanges()

[grimar]

Summary

For LLD --gdb-index patch (https://reviews.llvm.org/D25821) I need to write the address area. The address area is a sequence of address
entries, where each entrie contains low address, high address and CU index.

I can get this info (using DWARFUnit::collectAddressRanges())
from DW_AT_low_pc/DW_AT_high_pc attribute which are relocated addresses.
Problem is that there is no way to get section index these addresses refer to. At the moment of building
index I do not yet know the final input sections offsets and output section VA's, so I think
I need to store section index to use it later (that is how above patch do).

Patch do next things:

• We have RelocAddrMap, which is map of pairs [relocation width, relocation value]

and was declared both in DWARFContext.h and DWARFRelocMap.h. I leaved declaration only in DWARFRelocMap.h.
At fact first element of pair was never used in code. So I replaced it with section index.

• I modified content of DWARFAddressRangesVector to keep section index as well, so now it is possible to get

it via DWARFUnit::collectAddressRanges() call.

[clayborg]

Seems like a lot of work to include the section index everywhere. Can't the section index just be looked up using the ObjectFile given an address? Something like:

uint32_t ObjectFile::getSectionIndexForAddress(uint64_t addr);

[grimar]

In D25822#575566, @clayborg wrote:

Seems like a lot of work to include the section index everywhere. Can't the section index just be looked up using the ObjectFile given an address? Something like:

uint32_t ObjectFile::getSectionIndexForAddress(uint64_t addr);

Could you elaborate what addr should I use for such search ?
getAddressRanges() returns me LowPC/HighPC.

For example for gdb-index-a.elf from D24706, LowPC = 0x0, HighPC = 0xb, readelf shows:

Section Headers:
  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
  [ 1] .text             PROGBITS        0000000000000000 000040 00000b 00  AX  0   0  1
  [ 2] .data             PROGBITS        0000000000000000 00004b 000000 00  WA  0   0  1
  [ 3] .bss              NOBITS          0000000000000000 00004b 000000 00  WA  0   0  1
  [ 4] .debug_addr       PROGBITS        0000000000000000 00004b 000008 00      0   0  1
  [ 5] .rela.debug_addr  RELA            0000000000000000 000380 000018 18   I 23   4  8
.....

How having just there values I can know that section I am looking is .text ?

[clayborg]

In D25822#575786, @grimar wrote:

In D25822#575566, @clayborg wrote:

Seems like a lot of work to include the section index everywhere. Can't the section index just be looked up using the ObjectFile given an address? Something like:

uint32_t ObjectFile::getSectionIndexForAddress(uint64_t addr);

Could you elaborate what addr should I use for such search ?
getAddressRanges() returns me LowPC/HighPC.

For example for gdb-index-a.elf from D24706, LowPC = 0x0, HighPC = 0xb, readelf shows:

Section Headers:
  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
  [ 1] .text             PROGBITS        0000000000000000 000040 00000b 00  AX  0   0  1
  [ 2] .data             PROGBITS        0000000000000000 00004b 000000 00  WA  0   0  1
  [ 3] .bss              NOBITS          0000000000000000 00004b 000000 00  WA  0   0  1
  [ 4] .debug_addr       PROGBITS        0000000000000000 00004b 000008 00      0   0  1
  [ 5] .rela.debug_addr  RELA            0000000000000000 000380 000018 18   I 23   4  8
.....

How having just there values I can know that section I am looking is .text ?

You can see that .text has a size of 0xb and starts at 0x0. So the address would fall into the .text section. You would probably want to keep a table of the PROGBITS sections that also have AX permissions if you know you are looking for code addresses. Someone else more familiar with ELF .o files might be able to help.

[evgeny777]

You can see that .text has a size of 0xb and starts at 0x0. So the address would fall into the .text sectio

Things can be slightly more complex, like here (this is result of compilation with -ffunction-sections):

[ 2] .text             PROGBITS        0000000000000000 000040 000000 00  AX  0   0  4
[ 3] .text.f           PROGBITS        0000000000000000 000040 00000b 00  AX  0   0 16
[ 4] .text.g           PROGBITS        0000000000000000 000050 00000b 00  AX  0   0 16
[ 5] .text.h           PROGBITS        0000000000000000 000060 00000b 00  AX  0   0 16

[clayborg]

In D25822#576624, @evgeny777 wrote:

You can see that .text has a size of 0xb and starts at 0x0. So the address would fall into the .text sectio

Things can be slightly more complex, like here (this is result of compilation with -ffunction-sections):

[ 2] .text             PROGBITS        0000000000000000 000040 000000 00  AX  0   0  4
[ 3] .text.f           PROGBITS        0000000000000000 000040 00000b 00  AX  0   0 16
[ 4] .text.g           PROGBITS        0000000000000000 000050 00000b 00  AX  0   0 16
[ 5] .text.h           PROGBITS        0000000000000000 000060 00000b 00  AX  0   0 16

Is this just a raw dumper that isn't applying relocations? Do ELF .o files have bogus values in the address field of all sections in the section headers? Seems like there should be relocations that would fix these up no?

[clayborg]

After speaking with some local ELF experts over here, my proposed solution won't work. Would it be possible to encode the section index into the upper bits of any addresses that need to retain know their section? If not it seems weird to just be changing a few places that use high and low PC in a few areas of the DWARF parser. It would seem that we would need to change all places that can use addresses over to use some structure like:

struct FileAddress {
    uint64_t vmAddr;
    uint32_t sectIdx;
};

instead of just a "uint64_t" as a file address.

[grimar]

In D25822#576954, @clayborg wrote:

After speaking with some local ELF experts over here, my proposed solution won't work. Would it be possible to encode the section index into the upper bits of any addresses that need to retain know their section?

I think that would be not correct correct solution to mix address and section index in a variable.

If not it seems weird to just be changing a few places that use high and low PC in a few areas of the DWARF parser. It would seem that we would need to change all places that can use addresses over to use some structure like:

struct FileAddress {
    uint64_t vmAddr;
    uint32_t sectIdx;
};

instead of just a "uint64_t" as a file address.

It may be worth to do, but may be not. Looks generation of .gdb_index section in LLD was the first consumer who faced the absence of this API ? For now in LLD we only need it in this place and that seems to be enough.
So I am not sure we really need to change all the places to use this structure. That probably works for consistency, but also probably is just excessive. What the point to do that if nobody going to use it ?

[evgeny777]

In the current implementation of LLVM DWARF parser LowPC and HighPC are offsets from the start of the section. This causes problems when object file has comdat groups or was compiled with -ffunction-sections. I think that problem can be solved if LowPC and HighPC would offsets from the start of the file not section. This , to my understanding, can be done quite easily by adding sh_offset to R.Value in DWARFContextInMemory constructor. After that all SecNdx related stuff can be removed: section index can be easily reconstructed given file offset. What do you think?

[grimar]

In D25822#578766, @evgeny777 wrote:

In the current implementation of LLVM DWARF parser LowPC and HighPC are offsets from the start of the section. This causes problems when object file has comdat groups or was compiled with -ffunction-sections. I think that problem can be solved if LowPC and HighPC would offsets from the start of the file not section. This , to my understanding, can be done quite easily by adding sh_offset to R.Value in DWARFContextInMemory constructor. After that all SecNdx related stuff can be removed: section index can be easily reconstructed given file offset. What do you think?

I am not sure that is correct thing to do. From DWARF manual: "The value of the DW_AT_low_pc attribute is the relocated address of the first
instruction associated with the entity.". If we do the change you suggest we will end up with API that is called getLowAndHighPC() but returns the absolute values instead of relocatable values, so it will be a misnaming I think.
I also not sure that changing R.value will not break anything else (that not only used for lowPC/highPC), though that is different question.

Interesting to hear other opinions, but now I prefer either my or Greg's suggested solution to use FileAddress struct.

[grimar]

D25821 does not need that anymore.

[aprantl]

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

65

I think we typically spell this ~0ULL.

[grimar]

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

65

Thanks for comment, but this patch was abandoned already :)
Because D25821 implementation changed and now no need to change dwardf parsers anymore.

include/llvm/DebugInfo/DWARF/DWARFContext.h

 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
+#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 
 namespace llvm {
 
-// In place of applying the relocations to the data we've read from disk we use
-// a separate mapping table to the side and checking that at locations in the
-// dwarf where we expect relocated values. This adds a bit of complexity to the
-// dwarf parsing/extraction at the benefit of not allocating memory for the
-// entire size of the debug info sections.
-typedef DenseMap<uint64_t, std::pair<uint8_t, int64_t> > RelocAddrMap;
-
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through pure virtual
 /// methods that a concrete implementation provides.
 class DWARFContext : public DIContext {
 
   DWARFUnitSection<DWARFCompileUnit> CUs;
   std::deque<DWARFUnitSection<DWARFTypeUnit>> TUs;

include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h

public:
 
   bool getAttributeValue(const DWARFUnit *U, const uint16_t Attr,
                          DWARFFormValue &FormValue) const;
 
   const char *getAttributeValueAsString(const DWARFUnit *U, const uint16_t Attr,
                                         const char *FailValue) const;
 
   uint64_t getAttributeValueAsAddress(const DWARFUnit *U, const uint16_t Attr,
-                                      uint64_t FailValue) const;
+                                      uint64_t FailValue,
+                                      uint64_t *SecNdx = nullptr) const;
 
   uint64_t getAttributeValueAsUnsignedConstant(const DWARFUnit *U,
                                                const uint16_t Attr,
                                                uint64_t FailValue) const;
 
   uint64_t getAttributeValueAsReference(const DWARFUnit *U, const uint16_t Attr,
                                         uint64_t FailValue) const;
 
   uint64_t getAttributeValueAsSectionOffset(const DWARFUnit *U,
                                             const uint16_t Attr,
                                             uint64_t FailValue) const;
 
   uint64_t getRangesBaseAttribute(const DWARFUnit *U, uint64_t FailValue) const;
 
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
-  bool getLowAndHighPC(const DWARFUnit *U, uint64_t &LowPC,
-                       uint64_t &HighPC) const;
+  bool getLowAndHighPC(const DWARFUnit *U, uint64_t &LowPC, uint64_t &HighPC,
+                       uint64_t &SecNdx) const;
 
   DWARFAddressRangesVector getAddressRanges(const DWARFUnit *U) const;
 
   void collectChildrenAddressRanges(const DWARFUnit *U,
                                     DWARFAddressRangesVector &Ranges) const;
 
   bool addressRangeContainsAddress(const DWARFUnit *U,
                                    const uint64_t Address) const;

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

 
 #include "llvm/Support/DataExtractor.h"
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
+struct DWARFAddress {
+  uint64_t LowPC;
+  uint64_t HighPC;
+  uint64_t SecNdx;
+};
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
-typedef std::vector<std::pair<uint64_t, uint64_t>> DWARFAddressRangesVector;
+typedef std::vector<DWARFAddress> DWARFAddressRangesVector;
 
 class DWARFDebugRangeList {
 public:
   struct RangeListEntry {
     // A beginning address offset. This address offset has the size of an
     // address and is relative to the applicable base address of the
     // compilation unit referencing this range list. It marks the beginning
     // of an address range.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

enum FormClass {
     FC_Reference,
     FC_Indirect,
     FC_SectionOffset,
     FC_Exprloc
   };
 
 private:
   struct ValueType {
-    ValueType() : data(nullptr) {
-      uval = 0;
-    }
+    ValueType() : data(nullptr), SecNdx((uint64_t)-1) { uval = 0; }
 
     union {
       uint64_t uval;
       int64_t sval;
       const char* cstr;
     };
     const uint8_t* data;
+
+    uint64_t SecNdx; // Section index for reference forms.
   };
 
   uint16_t Form;   // Form for this value.
   ValueType Value; // Contains all data for the form.
 
 public:
   DWARFFormValue(uint16_t Form = 0) : Form(Form) {}
   uint16_t getForm() const { return Form; }
public:
   }
 
   /// getAsFoo functions below return the extracted value as Foo if only
   /// DWARFFormValue has form class is suitable for representing Foo.
   Optional<uint64_t> getAsReference(const DWARFUnit *U) const;
   Optional<uint64_t> getAsUnsignedConstant() const;
   Optional<int64_t> getAsSignedConstant() const;
   Optional<const char *> getAsCString(const DWARFUnit *U) const;
-  Optional<uint64_t> getAsAddress(const DWARFUnit *U) const;
+  Optional<uint64_t> getAsAddress(const DWARFUnit *U,
+                                  uint64_t *SecNdx = nullptr) const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() const;
 
   bool skipValue(DataExtractor debug_info_data, uint32_t *offset_ptr,
                  const DWARFUnit *u) const;
   static bool skipValue(uint16_t form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, const DWARFUnit *u);
   static bool skipValue(uint16_t form, DataExtractor debug_info_data,

include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

 //===-- DWARFRelocMap.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_LIB_DEBUGINFO_DWARFRELOCMAP_H
 #define LLVM_LIB_DEBUGINFO_DWARFRELOCMAP_H
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
-typedef DenseMap<uint64_t, std::pair<uint8_t, int64_t> > RelocAddrMap;
+struct RelocAddrEntry {
+  uint64_t SecNdx;
+  int64_t Value;
+};
+
+// In place of applying the relocations to the data we've read from disk we use
+// a separate mapping table to the side and checking that at locations in the
+// dwarf where we expect relocated values. This adds a bit of complexity to the
+// dwarf parsing/extraction at the benefit of not allocating memory for the
+// entire size of the debug info sections.
+typedef DenseMap<uint64_t, RelocAddrEntry> RelocAddrMap;
 
 } // namespace llvm
 
 #endif
-

include/llvm/Object/COFF.h

protected:
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
   void moveSectionNext(DataRefImpl &Sec) const override;
   std::error_code getSectionName(DataRefImpl Sec,
                                  StringRef &Res) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   std::error_code getSectionContents(DataRefImpl Sec,
                                      StringRef &Res) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;

include/llvm/Object/ELFObjectFile.h

protected:
   Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb,
                                               const Elf_Shdr *SymTab) const;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   std::error_code getSectionName(DataRefImpl Sec,
                                  StringRef &Res) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   std::error_code getSectionContents(DataRefImpl Sec,
                                      StringRef &Res) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;

 }
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
   return getSection(Sec)->sh_addr;
 }
 
 template <class ELFT>
+uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const {
+  return getSection(Sec) - EF.section_begin();
+}
+
+template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const {
   return getSection(Sec)->sh_size;
 }
 
 template <class ELFT>
 std::error_code
 ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec,
                                         StringRef &Result) const {

include/llvm/Object/MachO.h

public:
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
   unsigned getSymbolSectionID(SymbolRef Symb) const;
   unsigned getSectionID(SectionRef Sec) const;
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   std::error_code getSectionName(DataRefImpl Sec,
                                  StringRef &Res) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   std::error_code getSectionContents(DataRefImpl Sec,
                                      StringRef &Res) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;

include/llvm/Object/ObjectFile.h

public:
   bool operator==(const SectionRef &Other) const;
   bool operator!=(const SectionRef &Other) const;
   bool operator<(const SectionRef &Other) const;
 
   void moveNext();
 
   std::error_code getName(StringRef &Result) const;
   uint64_t getAddress() const;
+  uint64_t getIndex() const;
   uint64_t getSize() const;
   std::error_code getContents(StringRef &Result) const;
 
   /// @brief Get the alignment of this section as the actual value (not log 2).
   uint64_t getAlignment() const;
 
   bool isCompressed() const;
   bool isText() const;
protected:
   getSymbolSection(DataRefImpl Symb) const = 0;
 
   // Same as above for SectionRef.
   friend class SectionRef;
   virtual void moveSectionNext(DataRefImpl &Sec) const = 0;
   virtual std::error_code getSectionName(DataRefImpl Sec,
                                          StringRef &Res) const = 0;
   virtual uint64_t getSectionAddress(DataRefImpl Sec) const = 0;
+  virtual uint64_t getSectionIndex(DataRefImpl Sec) const = 0;
   virtual uint64_t getSectionSize(DataRefImpl Sec) const = 0;
   virtual std::error_code getSectionContents(DataRefImpl Sec,
                                              StringRef &Res) const = 0;
   virtual uint64_t getSectionAlignment(DataRefImpl Sec) const = 0;
   virtual bool isSectionCompressed(DataRefImpl Sec) const = 0;
   virtual bool isSectionText(DataRefImpl Sec) const = 0;
   virtual bool isSectionData(DataRefImpl Sec) const = 0;
   virtual bool isSectionBSS(DataRefImpl Sec) const = 0;

 inline std::error_code SectionRef::getName(StringRef &Result) const {
   return OwningObject->getSectionName(SectionPimpl, Result);
 }
 
 inline uint64_t SectionRef::getAddress() const {
   return OwningObject->getSectionAddress(SectionPimpl);
 }
 
+inline uint64_t SectionRef::getIndex() const {
+  return OwningObject->getSectionIndex(SectionPimpl);
+}
+
 inline uint64_t SectionRef::getSize() const {
   return OwningObject->getSectionSize(SectionPimpl);
 }
 
 inline std::error_code SectionRef::getContents(StringRef &Result) const {
   return OwningObject->getSectionContents(SectionPimpl, Result);
 }
 

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
       if (!AccelSection.isValidOffset(DataOffset)) {
         OS << "    Invalid section offset\n";
         continue;
       }
       while (AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
         unsigned StringOffset = AccelSection.getU32(&DataOffset);
         RelocAddrMap::const_iterator Reloc = Relocs.find(DataOffset-4);
         if (Reloc != Relocs.end())
-          StringOffset += Reloc->second.second;
+          StringOffset += Reloc->second.Value;
         if (!StringOffset)
           break;
         OS << format("    Name: %08x \"%s\"\n", StringOffset,
                      StringSection.getCStr(&StringOffset));
         unsigned NumData = AccelSection.getU32(&DataOffset);
         for (unsigned Data = 0; Data < NumData; ++Data) {
           OS << format("    Data[%d] => ", Data);
           unsigned i = 0;

lib/DebugInfo/DWARF/DWARFContext.cpp

//                        << ", Section: " << Section.getRawDataRefImpl() << "\n";
           errs() << "error: can't handle a relocation of more than 8 bytes at "
                     "a time.\n";
           continue;
         }
         DEBUG(dbgs() << "Writing " << format("%p", R.Value)
                      << " at " << format("%p", Address)
                      << " with width " << format("%d", R.Width)
                      << "\n");
-        Map->insert(std::make_pair(Address, std::make_pair(R.Width, R.Value)));
+
+        llvm::RelocAddrEntry Rel = {RSec->getIndex(), R.Value};
+        Map->insert(std::make_pair(Address, Rel));
       }
     }
   }
 }
 
 void DWARFContextInMemory::anchor() { }

lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

void DWARFDebugAranges::generate(DWARFContext *CTX) {
   // it may describe only a small subset of compilation units, so we need to
   // manually build aranges for the rest of them.
   for (const auto &CU : CTX->compile_units()) {
     uint32_t CUOffset = CU->getOffset();
     if (ParsedCUOffsets.insert(CUOffset).second) {
       DWARFAddressRangesVector CURanges;
       CU->collectAddressRanges(CURanges);
       for (const auto &R : CURanges) {
-        appendRange(CUOffset, R.first, R.second);
+        appendRange(CUOffset, R.LowPC, R.HighPC);
       }
     }
   }
 
   construct();
 }
 
 void DWARFDebugAranges::clear() {

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
                        unsigned AddressSize, unsigned Indent) {
   if (Ranges.empty())
     return;
 
   for (const auto &Range: Ranges) {
     OS << '\n';
     OS.indent(Indent);
     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
-                 AddressSize*2, Range.first,
-                 AddressSize*2, Range.second);
+                 AddressSize*2, Range.LowPC,
+                 AddressSize*2, Range.HighPC);
   }
 }
 
 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
                                                DWARFUnit *u,
                                                uint32_t *offset_ptr,
                                                uint16_t attr, uint16_t form,
                                                unsigned indent) const {
const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<const char *> Result = FormValue.getAsCString(U);
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
-    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
+    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue,
+    uint64_t *SecNdx) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
-  Optional<uint64_t> Result = FormValue.getAsAddress(U);
+  Optional<uint64_t> Result = FormValue.getAsAddress(U, SecNdx);
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
     const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
uint64_t Result =
       getAttributeValueAsSectionOffset(U, DW_AT_ranges_base, -1ULL);
   if (Result != -1ULL)
     return Result;
   return getAttributeValueAsSectionOffset(U, DW_AT_GNU_ranges_base, FailValue);
 }
 
 bool DWARFDebugInfoEntryMinimal::getLowAndHighPC(const DWARFUnit *U,
                                                  uint64_t &LowPC,
-                                                 uint64_t &HighPC) const {
-  LowPC = getAttributeValueAsAddress(U, DW_AT_low_pc, -1ULL);
+                                                 uint64_t &HighPC,
+                                                 uint64_t &SecNdx) const {
+  LowPC = getAttributeValueAsAddress(U, DW_AT_low_pc, -1ULL, &SecNdx);
   if (LowPC == -1ULL)
     return false;
   HighPC = getAttributeValueAsAddress(U, DW_AT_high_pc, -1ULL);
   if (HighPC == -1ULL) {
     // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case
     // it represents function size.
     HighPC = getAttributeValueAsUnsignedConstant(U, DW_AT_high_pc, -1ULL);
     if (HighPC != -1ULL)
       HighPC += LowPC;
   }
   return (HighPC != -1ULL);
 }
 
 DWARFAddressRangesVector
 DWARFDebugInfoEntryMinimal::getAddressRanges(const DWARFUnit *U) const {
   if (isNULL())
     return DWARFAddressRangesVector();
   // Single range specified by low/high PC.
-  uint64_t LowPC, HighPC;
-  if (getLowAndHighPC(U, LowPC, HighPC)) {
-    return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC));
-  }
+  uint64_t LowPC, HighPC, SecNdx;
+  if (getLowAndHighPC(U, LowPC, HighPC, SecNdx))
+    return DWARFAddressRangesVector(1, {LowPC, HighPC, SecNdx});
+
   // Multiple ranges from .debug_ranges section.
   uint32_t RangesOffset =
       getAttributeValueAsSectionOffset(U, DW_AT_ranges, -1U);
   if (RangesOffset != -1U) {
     DWARFDebugRangeList RangeList;
     if (U->extractRangeList(RangesOffset, RangeList))
       return RangeList.getAbsoluteRanges(U->getBaseAddress());
   }
while (Child) {
     Child->collectChildrenAddressRanges(U, Ranges);
     Child = Child->getSibling();
   }
 }
 
 bool DWARFDebugInfoEntryMinimal::addressRangeContainsAddress(
     const DWARFUnit *U, const uint64_t Address) const {
   for (const auto& R : getAddressRanges(U)) {
-    if (R.first <= Address && Address < R.second)
+    if (R.LowPC <= Address && Address < R.HighPC)
       return true;
   }
   return false;
 }
 
 const char *
 DWARFDebugInfoEntryMinimal::getSubroutineName(const DWARFUnit *U,
                                               DINameKind Kind) const {

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

if (opcode == 0) {
         // machine. Set the address register to the value given by the
         // relocatable address. All of the other statement program opcodes
         // that affect the address register add a delta to it. This instruction
         // stores a relocatable value into it instead.
         {
           // If this address is in our relocation map, apply the relocation.
           RelocAddrMap::const_iterator AI = RMap->find(*offset_ptr);
           if (AI != RMap->end()) {
-            const std::pair<uint8_t, int64_t> &R = AI->second;
+            const RelocAddrEntry &R = AI->second;
             State.Row.Address =
-                debug_line_data.getAddress(offset_ptr) + R.second;
+                debug_line_data.getAddress(offset_ptr) + R.Value;
           } else
             State.Row.Address = debug_line_data.getAddress(offset_ptr);
         }
         break;
 
       case DW_LNE_define_file:
         // Takes 4 arguments. The first is a null terminated string containing
         // a source file name. The second is an unsigned LEB128 number

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

while (data.isValidOffset(Offset+AddressSize-1)) {
     // 2.6.2 Location Lists
     // A location list entry consists of:
     while (true) {
       Entry E;
       RelocAddrMap::const_iterator AI = RelocMap.find(Offset);
       // 1. A beginning address offset. ...
       E.Begin = data.getUnsigned(&Offset, AddressSize);
       if (AI != RelocMap.end())
-        E.Begin += AI->second.second;
+        E.Begin += AI->second.Value;
 
       AI = RelocMap.find(Offset);
       // 2. An ending address offset. ...
       E.End = data.getUnsigned(&Offset, AddressSize);
       if (AI != RelocMap.end())
-        E.End += AI->second.second;
+        E.End += AI->second.Value;
 
       // The end of any given location list is marked by an end of list entry,
       // which consists of a 0 for the beginning address offset and a 0 for the
       // ending address offset.
       if (E.Begin == 0 && E.End == 0)
         break;
 
       unsigned Bytes = data.getU16(&Offset);

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

 
 DWARFAddressRangesVector
 DWARFDebugRangeList::getAbsoluteRanges(uint64_t BaseAddress) const {
   DWARFAddressRangesVector Res;
   for (const RangeListEntry &RLE : Entries) {
     if (RLE.isBaseAddressSelectionEntry(AddressSize)) {
       BaseAddress = RLE.EndAddress;
     } else {
-      Res.push_back(std::make_pair(BaseAddress + RLE.StartAddress,
-                                   BaseAddress + RLE.EndAddress));
+      Res.push_back({BaseAddress + RLE.StartAddress,
+                     BaseAddress + RLE.EndAddress, (uint64_t)-1});
     }
   }
   return Res;
 }

lib/DebugInfo/DWARF/DWARFFormValue.cpp

case DW_FORM_ref_addr: {
       if (!cu)
         return false;
       uint16_t AddrSize =
           (Form == DW_FORM_addr)
               ? cu->getAddressByteSize()
               : getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
       if (AI != cu->getRelocMap()->end()) {
-        const std::pair<uint8_t, int64_t> &R = AI->second;
-        Value.uval = data.getUnsigned(offset_ptr, AddrSize) + R.second;
+        const RelocAddrEntry &R = AI->second;
+        Value.SecNdx = R.SecNdx;
+        Value.uval = data.getUnsigned(offset_ptr, AddrSize) + R.Value;
       } else
         Value.uval = data.getUnsigned(offset_ptr, AddrSize);
       break;
     }
     case DW_FORM_exprloc:
     case DW_FORM_block:
       Value.uval = data.getULEB128(offset_ptr);
       is_block = true;
case DW_FORM_ref2:
       break;
     case DW_FORM_data4:
     case DW_FORM_ref4: {
       Value.uval = data.getU32(offset_ptr);
       if (!cu)
         break;
       RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr-4);
       if (AI != cu->getRelocMap()->end())
-        Value.uval += AI->second.second;
+        Value.uval += AI->second.Value;
       break;
     }
     case DW_FORM_data8:
     case DW_FORM_ref8:
       Value.uval = data.getU64(offset_ptr);
       break;
     case DW_FORM_sdata:
       Value.sval = data.getSLEB128(offset_ptr);
do {
     case DW_FORM_GNU_strp_alt: {
       // FIXME: This is 64-bit for DWARF64.
       Value.uval = data.getU32(offset_ptr);
       if (!cu)
         break;
       RelocAddrMap::const_iterator AI =
           cu->getRelocMap()->find(*offset_ptr - 4);
       if (AI != cu->getRelocMap()->end())
-        Value.uval += AI->second.second;
+        Value.uval += AI->second.Value;
       break;
     }
     case DW_FORM_flag_present:
       Value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       Value.uval = data.getU64(offset_ptr);
       break;
if (Form == DW_FORM_GNU_str_index) {
     Offset = StrOffset;
   }
   if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
     return Str;
   }
   return None;
 }
 
-Optional<uint64_t> DWARFFormValue::getAsAddress(const DWARFUnit *U) const {
+Optional<uint64_t> DWARFFormValue::getAsAddress(const DWARFUnit *U,
+                                                uint64_t *SecNdx) const {
   if (!isFormClass(FC_Address))
     return None;
   if (Form == DW_FORM_GNU_addr_index) {
     uint32_t Index = Value.uval;
     uint64_t Result;
     if (!U || !U->getAddrOffsetSectionItem(Index, Result))
       return None;
     return Result;
   }
+  if (SecNdx)
+    *SecNdx = Value.SecNdx;
   return Value.uval;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsReference(const DWARFUnit *U) const {
   if (!isFormClass(FC_Reference))
     return None;
   switch (Form) {
   case DW_FORM_ref1:

lib/Object/COFFObjectFile.cpp

uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Ref) const {
   uint64_t Result = Sec->VirtualAddress;
 
   // The section VirtualAddress does not include ImageBase, and we want to
   // return virtual addresses.
   Result += getImageBase();
   return Result;
 }
 
+uint64_t COFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
+  return (uint64_t)-1;
+}
+
 uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const {
   return getSectionSize(toSec(Ref));
 }
 
 std::error_code COFFObjectFile::getSectionContents(DataRefImpl Ref,
                                                    StringRef &Result) const {
   const coff_section *Sec = toSec(Ref);
   ArrayRef<uint8_t> Res;

lib/Object/MachOObjectFile.cpp

 }
 
 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
   if (is64Bit())
     return getSection64(Sec).addr;
   return getSection(Sec).addr;
 }
 
+uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
+  return (uint64_t)-1;
+}
+
 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
   // In the case if a malformed Mach-O file where the section offset is past
   // the end of the file or some part of the section size is past the end of
   // the file return a size of zero or a size that covers the rest of the file
   // but does not extend past the end of the file.
   uint32_t SectOffset, SectType;
   uint64_t SectSize;