[DWARF] - Make collectAddressRanges() return section index in addition to Low/High PC

[grimar]

Summary

This change is intended to use for LLD in D33183.
Problem we have in LLD when building .gdb_index is that we need to know section which address range belongs to.

Previously it was solved on LLD side by providing fake section addresses with use of llvm::LoadedObjectInfo
interface. We assigned file offsets as addressed. Then after obtaining ranges lists, for each range we had to find section ID's.
That not only was slow, but also complicated implementation and was the reason of incorrect behavior when
sections share the same offsets, like D33176 shows.

This patch makes DWARF parsers to return section index as well. That solves problem mentioned above.

[aprantl]

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

28 ↗

(On Diff #98973)

I'm assuming that this is the "official" name used in the specification? Then this name is fine, otherwise I would prefer to call this field SectionIndex.

48 ↗

(On Diff #98973)

If you find the time, it would be nice to convert all these to /// in a separate commit.

lib/DebugInfo/DWARF/DWARFContext.cpp

949 ↗

(On Diff #98973)

return {Ret, RSec->getIndex()};

1124 ↗

(On Diff #98973)

{}

lib/DebugInfo/DWARF/DWARFUnit.cpp

355 ↗

(On Diff #98973)

(--B)->second.first:

Would it make sense to replace some std::pairs with structs for better readability?

lib/Object/COFFObjectFile.cpp

298 ↗

(On Diff #98973)

Why does this return -1 and the others 0 for not found? Should it return an optional?

[dblaikie]

+1 to Rafael

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

25–27 ↗

(On Diff #98973)

This should probably be called DWARFAddressRange since it represents more than a single address (or possibly no addresses, if the range is empty) - and I think that's the right terminology in DWARF (that a contiguous range is a 'range' and a series of ranges is a 'range list').

[dblaikie]

+1 to Rafael's comment about separating the renaming/un-pair-ification from the semantic change/addition. Also probably the addition of the RelocAddrEntry class would be good to be done in a separate preliminary commit too.

[grimar]

• Addressed review comments.

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

25–27 ↗

(On Diff #98973)

Done in rL303163.

28 ↗

(On Diff #98973)

No, "SecNdx" was something from my head. Does not seem that specification mentions section index for address range in any way. Renamed to SectionIndex here and below.

48 ↗

(On Diff #98973)

Done in rL303241.

lib/DebugInfo/DWARF/DWARFContext.cpp

949 ↗

(On Diff #98973)

I changed code around, made Ret to be pair like it probably should be to match return value and this issue was gone.

1124 ↗

(On Diff #98973)

Done.

lib/DebugInfo/DWARF/DWARFUnit.cpp

355 ↗

(On Diff #98973)

I think yes, I'll try to take a look while I am here changing DWARF code around.

lib/Object/COFFObjectFile.cpp

298 ↗

(On Diff #98973)

Others ? I am returning -1 in all getSectionIndex() implementations because 0 can be an index of valid section in theory. Since numeration starts from zero.

I would not return Optional. Because that would be an overcomplication of code I think. If we pass
some existent DataRefImpl Sec, then we should be able to find it's index.

I probably can't imagine code that would have real benefits from Optional. We return uint64_t in
getSectionAddress() and getSectionSize() below, so it is also a consistent solution.

As an althernative solution I was thinking about just placing llvm_unreachable() here and then store section address only for ELF objects in getSymbolInfo(). Would it be better ?

[• rafael]

include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

20 ↗

(On Diff #99261)

Please rebase, as Width was removed.

include/llvm/Object/ELFObjectFile.h

652 ↗

(On Diff #99261)

I think you can assert in here.

This function is passed a section, so whatever found it must have looked in the section table.

lib/Object/COFFObjectFile.cpp

297 ↗

(On Diff #99261)

This should be trivial to implement:

toSec(Sec) - SectionTable.

lib/Object/MachOObjectFile.cpp

1824 ↗

(On Diff #99261)

This is just "return Sec.d.a"

lib/Object/WasmObjectFile.cpp

748 ↗

(On Diff #99261)

This is just Sec.d.a;

[grimar]

• Addressed review comments.

include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

20 ↗

(On Diff #99261)

Done.

include/llvm/Object/ELFObjectFile.h

652 ↗

(On Diff #99261)

Done.

lib/Object/COFFObjectFile.cpp

297 ↗

(On Diff #99261)

Cool, thanks ! I just do not know anything about non-ELF so did not even try to implement getSectionIndex() for those types.

lib/Object/MachOObjectFile.cpp

1824 ↗

(On Diff #99261)

Done.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

50 ↗

(On Diff #99413)

Should this go inside the union, with the uval (wrapping the two together in a struct (anonymous would be OK if that's possible, but I'm not sure if anonymous structs are portable here, etc))? (I mean, it doesn't change the size of this structure, I guess - but seems like it'd make the intent clearer with regard to which elements are 'active' together, etc)

62 ↗

(On Diff #99413)

Presumably this should assert that the type is an address form? Though I guess the other accessors don't have such assertions, so maybe that's OK.

include/llvm/Object/ELFObjectFile.h

653 ↗

(On Diff #99413)

Yeah, as Rafael said - 'assert(false)' isn't appropriate in LLVM (llvm_unreachable is used instead - though as you point out, this isn't 100% adhered to/fixed/etc but generally should be the goal)

As for the error handling, llvm::Error has a special function for "ignore any errors here": llvm::consumeError(SectionsOrErr). Alternatively, you could handle the error with an assert:

handleAllErrors(std::move(SectionsOrErr.getError()), [](const ErrorInfoBase &) { llvm_unreachable("There should always be sections here, since a section was passed into getSectionIndex in the first place"); });

Or the like.

656 ↗

(On Diff #99413)

Use -> rather than (*x).y

lib/DebugInfo/DWARF/DWARFContext.cpp

911 ↗

(On Diff #99413)

seems like it might be cheap enough to introduce a struct here with named parameters, rather than a std::pair. I mean it's file local so the reader doesn't have to go far to check what the first/second are, but equally - seems pretty cheap to avoid them needing to (& might make the implementation easier to read too)

Actually regarding the implementation - might be easier to have two named variables, and stuff them into the result (be it a std::pair, or named struct) at the end.

1114 ↗

(On Diff #99413)

should be able to use -> here:

SymInfoOrErr->first

1121 ↗

(On Diff #99413)

and here

[grimar]

• Addressed review comments.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

50 ↗

(On Diff #99413)

Your idea looks reasonable to me, but unfortunately use of unnamed struct looks to be not portable solution, at least I am using MSVS 2015 and it reports:
warning C4201: nonstandard extension used: nameless struct/union
when I am trying to do that :(

And use of named struct sure works here, but requires much more changes in code (particullary in DWARFFormValue.cpp) and I probably would not do that.

62 ↗

(On Diff #99413)

Yes, here I would also be consistent and go without assert.

I actually was thinking about removing setters/getters here. Not sure I understand why do we need getRawUValue()/setUValue() pair for example. But that would be different patch.

include/llvm/Object/ELFObjectFile.h

653 ↗

(On Diff #99413)

Done. I used handleAllErrors and a shorter message because I really do not expect anyone see it..

656 ↗

(On Diff #99413)

Done.

lib/DebugInfo/DWARF/DWARFContext.cpp

911 ↗

(On Diff #99413)

Done. I agree that sometimes std::pairs looks weak in compare with struct for readability. Since here value is used for caching too, it is looks better probably to have named values.

1114 ↗

(On Diff #99413)

Done.

1121 ↗

(On Diff #99413)

Done.

[dblaikie]

Seems good to me.

[grimar]

In D33184#764716, @dblaikie wrote:

Seems good to me.

Thanks ! I'll be happy to land it once LLVM svn gets back alive. It is down at least few hours already for me :`(

[grimar]

Had a bot failure in COFF code when tried to commit today, it revealed one more issue, that can be probably fixed easily.
My suggestion how to fix is below in comment.

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

1008

I suggest to do

Ret.SectionIndex = (RSec != Obj.section_end()) ? RSec->getIndex() : -1LL;

here ? (motivation is in comment below)
So return -1LL for absolute values. At first I thought about Optional value,
but it seems an overkill here for me.

llvm/trunk/lib/Object/COFFObjectFile.cpp

297

This is the reason of BB fail:

******************** TEST 'LLVM :: DebugInfo/X86/dbg-value-regmask-clobber.ll' FAILED ********************
...
LLVM ERROR: Section was outside of section table.
********************

Code where is fails is:

  const coff_section *Addr = reinterpret_cast<const coff_section*>(Ref.p);

#ifndef NDEBUG
  // Verify that the section points to a valid entry in the section table.
  if (Addr < SectionTable || Addr >= (SectionTable + getNumberOfSections()))
    report_fatal_error("Section was outside of section table.");

And reason is that during call (from getSymbolInfo()):

Ret.SectionIndex = RSec->getIndex();

RSec was still Obj.section_end(), what looks fine for absolute values.

[grimar]

• Updated diff in according to my latest suggestion.
• Also contains fix for testcase compilation I had to perform.

[• rafael]

LGTM

include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

20 ↗

(On Diff #100411)

Document that it is -1 if the relocation points to an absolute symbol.

lib/DebugInfo/DWARF/DWARFContext.cpp

966 ↗

(On Diff #100411)

Document that it is -1 if the symbol is absolute.

[uweigand]

This seems to have caused a failure in the SystemZ build bot:
http://lab.llvm.org:8011/builders/clang-s390x-linux/builds/8750

/home/uweigand/sandbox/buildbot/clang-s390x-linux/llvm/test/tools/sanstats/elf.test:28:10: error: expected string not found in input
# CHECK: /tmp{{[/\\]}}f.c:1 f1 cfi-vcall 1
         ^
<stdin>:1:1: note: scanning from here
<invalid>:0 f1 cfi-vcall 1
^

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFContext.h

 namespace llvm {
 
 class MemoryBuffer;
 class raw_ostream;
 
 /// Reads a value from data extractor and applies a relocation to the result if
 /// one exists for the given offset.
 uint64_t getRelocatedValue(const DataExtractor &Data, uint32_t Size,
-                           uint32_t *Off, const RelocAddrMap *Relocs);
+                           uint32_t *Off, const RelocAddrMap *Relocs,
+                           uint64_t *SecNdx = nullptr);
 
 /// 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;

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

 
 namespace llvm {
 
 class raw_ostream;
 
 struct DWARFAddressRange {
   uint64_t LowPC;
   uint64_t HighPC;
+  uint64_t SectionIndex;
 };
 
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
 typedef std::vector<DWARFAddressRange> 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.
     uint64_t StartAddress;
     /// An ending address offset. This address offset again 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 first
     /// address past the end of the address range. The ending address must
     /// be greater than or equal to the beginning address.
     uint64_t EndAddress;
+    /// A section index this range belongs to.
+    uint64_t SectionIndex;
 
     /// The end of any given range 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.
     bool isEndOfListEntry() const {
       return (StartAddress == 0) && (EndAddress == 0);
     }
 

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   /// attribute.
   ///
   /// \param LowPC the low PC that might be needed to calculate the high PC.
   /// \returns an optional address value for the attribute.
   Optional<uint64_t> getHighPC(uint64_t LowPC) const;
 
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
-  bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const;
+  bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
+                       uint64_t &SectionIndex) const;
 
   /// Get the address ranges for this DIE.
   ///
   /// Get the hi/low PC range if both attributes are available or exrtracts the
   /// non-contiguous address ranges from the DW_AT_ranges attribute.
   ///
   /// Extracts the range information from this DIE only. This call doesn't look
   /// for the range in any DW_AT_specification or DW_AT_abstract_origin DIEs.

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

struct ValueType {
     ValueType() { uval = 0; }
 
     union {
       uint64_t uval;
       int64_t sval;
       const char *cstr;
     };
     const uint8_t *data = nullptr;
+    uint64_t SectionIndex;      /// Section index for reference forms.
   };
 
   dwarf::Form Form;             /// Form for this value.
   ValueType Value;              /// Contains all data for the form.
   const DWARFUnit *U = nullptr; /// Remember the DWARFUnit at extract time.
 
 public:
   DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}
 
   dwarf::Form getForm() const { return Form; }
   uint64_t getRawUValue() const { return Value.uval; }
+  uint64_t getSectionIndex() const { return Value.SectionIndex; }
   void setForm(dwarf::Form F) { Form = F; }
   void setUValue(uint64_t V) { Value.uval = V; }
   void setSValue(int64_t V) { Value.sval = V; }
   void setPValue(const char *V) { Value.cstr = V; }
 
   void setBlockValue(const ArrayRef<uint8_t> &Data) {
     Value.data = Data.data();
     setUValue(Data.size());

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

 #define LLVM_DEBUGINFO_DWARF_DWARFRELOCMAP_H
 
 #include "llvm/ADT/DenseMap.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
+/// RelocAddrEntry contains relocated value and section index.
+/// Section index is -1LL if relocation points to absolute symbol.
 struct RelocAddrEntry {
+  uint64_t SectionIndex;
   uint64_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;
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFRELOCMAP_H

llvm/trunk/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;

llvm/trunk/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 {
+  auto SectionsOrErr = EF.sections();
+  handleAllErrors(std::move(SectionsOrErr.takeError()),
+                  [](const ErrorInfoBase &) {
+                    llvm_unreachable("unable to get section index");
+                  });
+  const Elf_Shdr *First = SectionsOrErr->begin();
+  return getSection(Sec) - First;
+}
+
+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 {

llvm/trunk/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;

llvm/trunk/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:
 
   // 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);
 }
 

llvm/trunk/include/llvm/Object/Wasm.h

public:
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 
   // Overrides from SectionRef.
   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;

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

 
 #define DEBUG_TYPE "dwarf"
 
 typedef DWARFDebugLine::LineTable DWARFLineTable;
 typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;
 typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
 
 uint64_t llvm::getRelocatedValue(const DataExtractor &Data, uint32_t Size,
-                                 uint32_t *Off, const RelocAddrMap *Relocs) {
+                                 uint32_t *Off, const RelocAddrMap *Relocs,
+                                 uint64_t *SectionIndex) {
   if (!Relocs)
     return Data.getUnsigned(Off, Size);
   RelocAddrMap::const_iterator AI = Relocs->find(*Off);
   if (AI == Relocs->end())
     return Data.getUnsigned(Off, Size);
+  if (SectionIndex)
+    *SectionIndex = AI->second.SectionIndex;
   return Data.getUnsigned(Off, Size) + AI->second.Value;
 }
 
 static void dumpAccelSection(raw_ostream &OS, StringRef Name,
                              const DWARFSection& Section, StringRef StringSection,
                              bool LittleEndian) {
   DataExtractor AccelSection(Section.Data, LittleEndian, 0);
   DataExtractor StrData(StringSection, LittleEndian, 0);
DWARFContext::getDWOContext(StringRef AbsolutePath) {
   return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
 }
 
 static Error createError(const Twine &Reason, llvm::Error E) {
   return make_error<StringError>(Reason + toString(std::move(E)),
                                  inconvertibleErrorCode());
 }
 
-/// Returns the address of symbol relocation used against. Used for futher
-/// relocations computation. Symbol's section load address is taken in account if
-/// LoadedObjectInfo interface is provided.
-static Expected<uint64_t>
-getSymbolAddress(const object::ObjectFile &Obj, const RelocationRef &Reloc,
+/// SymInfo contains information about symbol: it's address
+/// and section index which is -1LL for absolute symbols.
+struct SymInfo {
+  uint64_t Address;
+  uint64_t SectionIndex;
+};
+
+/// Returns the address of symbol relocation used against and a section index.
+/// Used for futher relocations computation. Symbol's section load address is
+static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj,
+                                       const RelocationRef &Reloc,
                                        const LoadedObjectInfo *L,
-                 std::map<SymbolRef, uint64_t> &Cache) {
-  uint64_t Ret = 0;
+                                       std::map<SymbolRef, SymInfo> &Cache) {
+  SymInfo Ret;
   object::section_iterator RSec = Obj.section_end();
   object::symbol_iterator Sym = Reloc.getSymbol();
 
-  std::map<SymbolRef, uint64_t>::iterator CacheIt = Cache.end();
+  std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
   // First calculate the address of the symbol or section as it appears
   // in the object file
   if (Sym != Obj.symbol_end()) {
     bool New;
-    std::tie(CacheIt, New) = Cache.insert({*Sym, 0});
+    std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}});
     if (!New)
       return CacheIt->second;
 
     Expected<uint64_t> SymAddrOrErr = Sym->getAddress();
     if (!SymAddrOrErr)
       return createError("error: failed to compute symbol address: ",
                          SymAddrOrErr.takeError());
 
     // Also remember what section this symbol is in for later
     auto SectOrErr = Sym->getSection();
     if (!SectOrErr)
       return createError("error: failed to get symbol section: ",
                          SectOrErr.takeError());
 
     RSec = *SectOrErr;
-    Ret = *SymAddrOrErr;
+    Ret.Address = *SymAddrOrErr;
   } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
     RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
-    Ret = RSec->getAddress();
+    Ret.Address = RSec->getAddress();
   }
 
+  Ret.SectionIndex = (RSec != Obj.section_end()) ? RSec->getIndex() : -1LL;
+
   // If we are given load addresses for the sections, we need to adjust:
   // SymAddr = (Address of Symbol Or Section in File) -
   //           (Address of Section in File) +
   //           (Load Address of Section)
   // RSec is now either the section being targeted or the section
   // containing the symbol being targeted. In either case,
   // we need to perform the same computation.
   if (L && RSec != Obj.section_end())
     if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec))
-      Ret += SectionLoadAddress - RSec->getAddress();
+      Ret.Address += SectionLoadAddress - RSec->getAddress();
 
   if (CacheIt != Cache.end())
     CacheIt->second = Ret;
 
   return Ret;
 }
 
 static bool isRelocScattered(const object::ObjectFile &Obj,
for (const SectionRef &Section : Obj.sections()) {
     if (IsVirtual)
       continue;
     StringRef data;
 
     section_iterator RelocatedSection = Section.getRelocatedSection();
     // Try to obtain an already relocated version of this section.
     // Else use the unrelocated section from the object file. We'll have to
     // apply relocations ourselves later.
-    if (!L || !L->getLoadedSectionContents(*RelocatedSection,data))
+    if (!L || !L->getLoadedSectionContents(*RelocatedSection, data))
       Section.getContents(data);
 
     if (auto Err = maybeDecompress(Section, name, data)) {
       errs() << "error: failed to decompress '" + name + "', " +
                     toString(std::move(Err))
              << '\n';
       continue;
     }
for (const SectionRef &Section : Obj.sections()) {
 
     StringRef RelSecName;
     StringRef RelSecData;
     RelocatedSection->getName(RelSecName);
 
     // If the section we're relocating was relocated already by the JIT,
     // then we used the relocated version above, so we do not need to process
     // relocations for it now.
-    if (L && L->getLoadedSectionContents(*RelocatedSection,RelSecData))
+    if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData))
       continue;
 
     // In Mach-o files, the relocations do not need to be applied if
     // there is no load offset to apply. The value read at the
     // relocation point already factors in the section address
     // (actually applying the relocations will produce wrong results
     // as the section address will be added twice).
     if (!L && isa<MachOObjectFile>(&Obj))
if (!Map) {
         Map = &TypesDWOSections[*RelocatedSection].Relocs;
       else
         continue;
     }
 
     if (Section.relocation_begin() == Section.relocation_end())
       continue;
 
-    std::map<SymbolRef, uint64_t> AddrCache;
+    // Symbol to [address, section index] cache mapping.
+    std::map<SymbolRef, SymInfo> AddrCache;
     for (const RelocationRef &Reloc : Section.relocations()) {
       // FIXME: it's not clear how to correctly handle scattered
       // relocations.
       if (isRelocScattered(Obj, Reloc))
         continue;
 
-      Expected<uint64_t> SymAddrOrErr =
-          getSymbolAddress(Obj, Reloc, L, AddrCache);
-      if (!SymAddrOrErr) {
-        errs() << toString(SymAddrOrErr.takeError()) << '\n';
+      Expected<SymInfo> SymInfoOrErr = getSymbolInfo(Obj, Reloc, L, AddrCache);
+      if (!SymInfoOrErr) {
+        errs() << toString(SymInfoOrErr.takeError()) << '\n';
         continue;
       }
 
       object::RelocVisitor V(Obj);
-      uint64_t Val = V.visit(Reloc.getType(), Reloc, *SymAddrOrErr);
+      uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address);
       if (V.error()) {
         SmallString<32> Name;
         Reloc.getTypeName(Name);
         errs() << "error: failed to compute relocation: " << Name << "\n";
         continue;
       }
-      Map->insert({Reloc.getOffset(), {Val}});
+      llvm::RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
+      Map->insert({Reloc.getOffset(), Rel});
     }
   }
 }
 
 DWARFContextInMemory::DWARFContextInMemory(
     const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, uint8_t AddrSize,
     bool isLittleEndian)
     : IsLittleEndian(isLittleEndian), AddressSize(AddrSize) {

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

if (!data.isValidOffset(*offset_ptr))
     return false;
   AddressSize = data.getAddressSize();
   if (AddressSize != 4 && AddressSize != 8)
     return false;
   Offset = *offset_ptr;
   while (true) {
     RangeListEntry entry;
     uint32_t prev_offset = *offset_ptr;
-    entry.StartAddress =
-        getRelocatedValue(data, AddressSize, offset_ptr, &Relocs);
+    entry.StartAddress = getRelocatedValue(data, AddressSize, offset_ptr,
+                                           &Relocs, &entry.SectionIndex);
     entry.EndAddress =
         getRelocatedValue(data, AddressSize, offset_ptr, &Relocs);
 
     // Check that both values were extracted correctly.
     if (*offset_ptr != prev_offset + 2 * AddressSize) {
       clear();
       return false;
     }

 
 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(
-          {BaseAddress + RLE.StartAddress, BaseAddress + RLE.EndAddress});
+      Res.push_back({BaseAddress + RLE.StartAddress,
+                     BaseAddress + RLE.EndAddress, RLE.SectionIndex});
     }
   }
   return Res;
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFDie.cpp

if (auto FormValue = find(DW_AT_high_pc)) {
     if (auto Offset = FormValue->getAsUnsignedConstant()) {
       // High PC is an offset from LowPC.
       return LowPC + *Offset;
     }
   }
   return None;
 }
 
-bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const {
-  auto LowPcAddr = toAddress(find(DW_AT_low_pc));
+bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
+                               uint64_t &SectionIndex) const {
+  auto F = find(DW_AT_low_pc);
+  auto LowPcAddr = toAddress(F);
   if (!LowPcAddr)
     return false;
   if (auto HighPcAddr = getHighPC(*LowPcAddr)) {
     LowPC = *LowPcAddr;
     HighPC = *HighPcAddr;
+    SectionIndex = F->getSectionIndex();
     return true;
   }
   return false;
 }
 
 DWARFAddressRangesVector
 DWARFDie::getAddressRanges() const {
   if (isNULL())
     return DWARFAddressRangesVector();
   // Single range specified by low/high PC.
-  uint64_t LowPC, HighPC;
-  if (getLowAndHighPC(LowPC, HighPC))
-    return {{LowPC, HighPC}};
+  uint64_t LowPC, HighPC, Index;
+  if (getLowAndHighPC(LowPC, HighPC, Index))
+    return {{LowPC, HighPC, Index}};
 
   // Multiple ranges from .debug_ranges section.
   auto RangesOffset = toSectionOffset(find(DW_AT_ranges));
   if (RangesOffset) {
     DWARFDebugRangeList RangeList;
     if (U->extractRangeList(*RangesOffset, RangeList))
       return RangeList.getAbsoluteRanges(U->getBaseAddress());
   }

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

do {
     Indirect = false;
     switch (Form) {
     case DW_FORM_addr:
     case DW_FORM_ref_addr: {
       if (!U)
         return false;
       uint16_t AddrSize = (Form == DW_FORM_addr) ? U->getAddressByteSize()
                                                  : U->getRefAddrByteSize();
-      Value.uval =
-          getRelocatedValue(Data, AddrSize, OffsetPtr, U->getRelocMap());
+      Value.uval = getRelocatedValue(Data, AddrSize, OffsetPtr,
+                                     U->getRelocMap(), &Value.SectionIndex);
       break;
     }
     case DW_FORM_exprloc:
     case DW_FORM_block:
       Value.uval = Data.getULEB128(OffsetPtr);
       IsBlock = true;
       break;
     case DW_FORM_block1:

llvm/trunk/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 toSec(Sec) - SectionTable;
+}
+
 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;

llvm/trunk/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 Sec.d.a;
+}
+
 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;
 

llvm/trunk/lib/Object/WasmObjectFile.cpp

default:
     return object_error::invalid_section_index;
   }
 #undef ECase
   return std::error_code();
 }
 
 uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
 
+uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
+  return Sec.d.a;
+}
+
 uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
   const WasmSection &S = Sections[Sec.d.a];
   return S.Content.size();
 }
 
 std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
                                                    StringRef &Res) const {
   const WasmSection &S = Sections[Sec.d.a];

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

template <uint16_t Version, class AddrType> void TestAddresses() {
   // Verify the number of compile units is correct.
   uint32_t NumCUs = DwarfContext.getNumCompileUnits();
   EXPECT_EQ(NumCUs, 1u);
   DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
   
   // Get the compile unit DIE is valid.
   auto DieDG = U->getUnitDIE(false);
   EXPECT_TRUE(DieDG.isValid());
-  
-  uint64_t LowPC, HighPC;
+  uint64_t LowPC, HighPC, SectionIndex;
   Optional<uint64_t> OptU64;
   // Verify the that our subprogram with no PC value fails appropriately when
   // asked for any PC values.
   auto SubprogramDieNoPC = DieDG.getFirstChild();
   EXPECT_TRUE(SubprogramDieNoPC.isValid());
   EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_low_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
-  EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
+  EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toUnsigned(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
   EXPECT_FALSE((bool)OptU64);
-  EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
+  EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
  
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowPC.isValid());
   EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_low_pc));
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualLowPC);
   OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toUnsigned(SubprogramDieLowPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = SubprogramDieLowPC.getHighPC(ActualLowPC);
   EXPECT_FALSE((bool)OptU64);
-  EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC));
+  EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
 
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowHighPC = SubprogramDieLowPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
   EXPECT_EQ(SubprogramDieLowHighPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieLowHighPC.find(DW_AT_low_pc));
template <uint16_t Version, class AddrType> void TestAddresses() {
   } else {
     EXPECT_FALSE((bool)OptU64);
   }
 
   OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC);
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualHighPC);
 
-  EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC));
+  EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   EXPECT_EQ(LowPC, ActualLowPC);
   EXPECT_EQ(HighPC, ActualHighPC);
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Addresses) {
   // Test that we can decode address values in DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;