[llvm-dwarfdump] - Add the support of parsing .debug_loclists.

[grimar]

Summary

This teaches llvm-dwarfdump to dump the content of .debug_loclists sections.

It converts the DWARFDebugLocDWO class to DWARFDebugLoclists,
teaches llvm-dwarfdump about .debug_loclists section and
adds the implementation for parsing the DW_LLE_offset_pair entries.

[grimar]

• Use base address when dumping the DW_LLE_offset_pair.
• Added support for dwarf::DW_LLE_start_length and dwarf::DW_LLE_base_address.

[probinson]

+wolfgang who has been working in this area also

[echristo]

LGTM. This code needs a lot of cleanup, but that's for another day.

[dblaikie]

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

222–226 ↗

(On Diff #170066)

This should lookup Value0 in the address pool, probably? I think I have that implemented for rnglists in my prototype/work-in-progress work there. (nothing I've sent out yet, but should be soon)

238–240 ↗

(On Diff #170066)

Probably worth implementing base_addressx too

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

161

Looks like this should probably be a ULEB128 too, according to DWARF5?

(2.6.2 Location Lists - DW_LLE_startx_length: "This is a form of bounded location description that has two unsigned ULEB operands. The first value is an address index (into the .debug_addr section) that indicates the beginning of the address range over which the location is valid. The second value is the length of the range. ")

[grimar]

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

222–226 ↗

(On Diff #170066)

Probably. That is also was the original code.

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

161

Yes, it was in my to-do list. That is the original code. I had no chance to prepare the test case + patch to fix it yet.

[wolfgangp]

I just wanted to let you know that I am currently working on a patch to refactor some of the rangelists code (see: https://reviews.llvm.org/D51081) with the objective to

1. fold the pre-v5 functionality (.debug_ranges) into DWARF5 so we can get rid of DebugRangelists.{cpp,.h}
2. templatize more of the DWARFListTable usage so it could be also used for location lists

Unfortunately the first submission attempt caused some problems with TSan tests that I don't have access to, so there is still some work to be done. Once I'm past this I would like to suggest basing the location list table handling on the same framework, if you are OK with that.

[echristo]

In D53364#1271569, @wolfgangp wrote:

I just wanted to let you know that I am currently working on a patch to refactor some of the rangelists code (see: https://reviews.llvm.org/D51081) with the objective to

1. fold the pre-v5 functionality (.debug_ranges) into DWARF5 so we can get rid of DebugRangelists.{cpp,.h}
2. templatize more of the DWARFListTable usage so it could be also used for location lists

Unfortunately the first submission attempt caused some problems with TSan tests that I don't have access to, so there is still some work to be done. Once I'm past this I would like to suggest basing the location list table handling on the same framework, if you are OK with that.

Sounds good to me :)

-eric

[grimar]

In D53364#1271569, @wolfgangp wrote:

I just wanted to let you know that I am currently working on a patch to refactor some of the rangelists code (see: https://reviews.llvm.org/D51081) with the objective to

1. fold the pre-v5 functionality (.debug_ranges) into DWARF5 so we can get rid of DebugRangelists.{cpp,.h}
2. templatize more of the DWARFListTable usage so it could be also used for location lists

Unfortunately the first submission attempt caused some problems with TSan tests that I don't have access to, so there is still some work to be done. Once I'm past this I would like to suggest basing the location list table handling on the same framework, if you are OK with that.

Sounds good, thanks!

llvm/trunk/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev")
 HANDLE_DWARF_SECTION(DebugAddr, ".debug_addr", "debug-addr")
 HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
 HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
 HANDLE_DWARF_SECTION(DebugLineStr, ".debug_line_str", "debug-line-str")
 HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
+HANDLE_DWARF_SECTION(DebugLoclists, ".debug_loclists", "debug-loclists")
 HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame")
 HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro")
 HANDLE_DWARF_SECTION(DebugNames, ".debug_names", "debug-names")
 HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames")
 HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes")
 HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames")
 HANDLE_DWARF_SECTION(DebugGnuPubtypes, ".debug_gnu_pubtypes", "debug-gnu-pubtypes")
 HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")

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

class DWARFContext : public DIContext {
   std::unique_ptr<DWARFDebugNames> Names;
   std::unique_ptr<AppleAcceleratorTable> AppleNames;
   std::unique_ptr<AppleAcceleratorTable> AppleTypes;
   std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
   std::unique_ptr<AppleAcceleratorTable> AppleObjC;
 
   DWARFUnitVector DWOUnits;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
-  std::unique_ptr<DWARFDebugLocDWO> LocDWO;
+  std::unique_ptr<DWARFDebugLoclists> LocDWO;
 
   /// The maximum DWARF version of all units.
   unsigned MaxVersion = 0;
 
   struct DWOFile {
     object::OwningBinary<object::ObjectFile> File;
     std::unique_ptr<DWARFContext> Context;
   };
public:
 
   /// Get a pointer to the parsed DebugLoc object.
   const DWARFDebugLoc *getDebugLoc();
 
   /// Get a pointer to the parsed dwo abbreviations object.
   const DWARFDebugAbbrev *getDebugAbbrevDWO();
 
   /// Get a pointer to the parsed DebugLoc object.
-  const DWARFDebugLocDWO *getDebugLocDWO();
+  const DWARFDebugLoclists *getDebugLocDWO();
 
   /// Get a pointer to the parsed DebugAranges object.
   const DWARFDebugAranges *getDebugAranges();
 
   /// Get a pointer to the parsed frame information object.
   const DWARFDebugFrame *getDebugFrame();
 
   /// Get a pointer to the parsed eh frame information object.

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

public:
 
   /// Return the location list at the given offset or nullptr.
   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
 
   Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
                                               uint32_t *Offset);
 };
 
-class DWARFDebugLocDWO {
+class DWARFDebugLoclists {
 public:
   struct Entry {
-    uint64_t Start;
-    uint32_t Length;
+    uint8_t Kind;
+    uint64_t Value0;
+    uint64_t Value1;
     SmallVector<char, 4> Loc;
   };
 
   struct LocationList {
     unsigned Offset;
     SmallVector<Entry, 2> Entries;
-    void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
-              const MCRegisterInfo *RegInfo, unsigned Indent) const;
+    void dump(raw_ostream &OS, uint64_t BaseAddr, bool IsLittleEndian,
+              unsigned AddressSize, const MCRegisterInfo *RegInfo,
+              unsigned Indent) const;
   };
 
 private:
   using LocationLists = SmallVector<LocationList, 4>;
 
   LocationLists Locations;
 
   unsigned AddressSize;
 
   bool IsLittleEndian;
 
 public:
   void parse(DataExtractor data);
-  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
+  void dump(raw_ostream &OS, uint64_t BaseAddr, const MCRegisterInfo *RegInfo,
             Optional<uint64_t> Offset) const;
 
   /// Return the location list at the given offset or nullptr.
   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
 
   static Optional<LocationList> parseOneLocationList(DataExtractor Data,
                                                      uint32_t *Offset);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

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

public:
   virtual ArrayRef<SectionName> getSectionNames() const { return {}; }
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const { llvm_unreachable("unimplemented"); }
   virtual const DWARFSection &getInfoSection() const { return Dummy; }
   virtual void
   forEachTypesSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual StringRef getAbbrevSection() const { return ""; }
   virtual const DWARFSection &getLocSection() const { return Dummy; }
+  virtual const DWARFSection &getLoclistsSection() const { return Dummy; }
   virtual StringRef getARangeSection() const { return ""; }
   virtual StringRef getDebugFrameSection() const { return ""; }
   virtual StringRef getEHFrameSection() const { return ""; }
   virtual const DWARFSection &getLineSection() const { return Dummy; }
   virtual StringRef getLineStringSection() const { return ""; }
   virtual StringRef getStringSection() const { return ""; }
   virtual const DWARFSection &getRangeSection() const { return Dummy; }
   virtual const DWARFSection &getRnglistsSection() const { return Dummy; }

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

if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
         break;
       Offset = TableOffset + Length;
     } else {
       Rnglists.dump(OS, LookupPooledAddress, DumpOpts);
     }
   }
 }
 
+static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
+                                DWARFDataExtractor Data,
+                                const MCRegisterInfo *MRI,
+                                Optional<uint64_t> DumpOffset) {
+  uint32_t Offset = 0;
+  DWARFDebugLoclists Loclists;
+
+  DWARFListTableHeader Header(".debug_loclists", "locations");
+  if (Error E = Header.extract(Data, &Offset)) {
+    WithColor::error() << toString(std::move(E)) << '\n';
+    return;
+  }
+
+  Header.dump(OS, DumpOpts);
+  DataExtractor LocData(Data.getData().drop_front(Offset),
+                        Data.isLittleEndian(), Header.getAddrSize());
+
+  Loclists.parse(LocData);
+  Loclists.dump(OS, 0, MRI, DumpOffset);
+}
+
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
 
   Optional<uint64_t> DumpOffset;
   uint64_t DumpType = DumpOpts.DumpType;
 
   StringRef Extension = sys::path::extension(DObj->getFileName());
if ((DumpType & DIDT_DebugTypes)) {
     if (ExplicitDWO || getNumDWOTypeUnits())
       dumpDebugType(".debug_types.dwo", dwo_types_section_units());
   }
 
   if (shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                  DObj->getLocSection().Data)) {
     getDebugLoc()->dump(OS, getRegisterInfo(), DumpOffset);
   }
+  if (shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
+                 DObj->getLoclistsSection().Data)) {
+    DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
+                            0);
+    dumpLoclistsSection(OS, DumpOpts, Data, getRegisterInfo(), DumpOffset);
+  }
   if (shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                  DObj->getLocDWOSection().Data)) {
-    getDebugLocDWO()->dump(OS, getRegisterInfo(), DumpOffset);
+    getDebugLocDWO()->dump(OS, 0, getRegisterInfo(), DumpOffset);
   }
 
   if (shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                  DObj->getDebugFrameSection()))
     getDebugFrame()->dump(OS, getRegisterInfo(), DumpOffset);
 
   if (shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
                  DObj->getEHFrameSection()))
const DWARFDebugLoc *DWARFContext::getDebugLoc() {
   if (getNumCompileUnits()) {
     DWARFDataExtractor LocData(*DObj, DObj->getLocSection(), isLittleEndian(),
                                getUnitAtIndex(0)->getAddressByteSize());
     Loc->parse(LocData);
   }
   return Loc.get();
 }
 
-const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
+const DWARFDebugLoclists *DWARFContext::getDebugLocDWO() {
   if (LocDWO)
     return LocDWO.get();
 
-  LocDWO.reset(new DWARFDebugLocDWO());
+  LocDWO.reset(new DWARFDebugLoclists());
   // Assume all compile units have the same address byte size.
   // FIXME: We don't need AddressSize for split DWARF since relocatable
   // addresses cannot appear there. At the moment DWARFExpression requires it.
   DataExtractor LocData(DObj->getLocDWOSection().Data, isLittleEndian(), 4);
   LocDWO->parse(LocData);
   return LocDWO.get();
 }
 
class DWARFObjInMemory final : public DWARFObject {
   using TypeSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
                                    std::map<object::SectionRef, unsigned>>;
 
   TypeSectionMap TypesSections;
   TypeSectionMap TypesDWOSections;
 
   DWARFSectionMap InfoSection;
   DWARFSectionMap LocSection;
+  DWARFSectionMap LocListsSection;
   DWARFSectionMap LineSection;
   DWARFSectionMap RangeSection;
   DWARFSectionMap RnglistsSection;
   DWARFSectionMap StringOffsetSection;
   DWARFSectionMap InfoDWOSection;
   DWARFSectionMap LineDWOSection;
   DWARFSectionMap LocDWOSection;
   DWARFSectionMap StringOffsetDWOSection;
   DWARFSectionMap RangeDWOSection;
   DWARFSectionMap RnglistsDWOSection;
   DWARFSectionMap AddrSection;
   DWARFSectionMap AppleNamesSection;
   DWARFSectionMap AppleTypesSection;
   DWARFSectionMap AppleNamespacesSection;
   DWARFSectionMap AppleObjCSection;
   DWARFSectionMap DebugNamesSection;
 
   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
     return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_info", &InfoSection)
         .Case("debug_loc", &LocSection)
+        .Case("debug_loclists", &LocListsSection)
         .Case("debug_line", &LineSection)
         .Case("debug_str_offsets", &StringOffsetSection)
         .Case("debug_ranges", &RangeSection)
         .Case("debug_rnglists", &RnglistsSection)
         .Case("debug_info.dwo", &InfoDWOSection)
         .Case("debug_loc.dwo", &LocDWOSection)
         .Case("debug_line.dwo", &LineDWOSection)
         .Case("debug_names", &DebugNamesSection)
public:
   void forEachTypesDWOSections(
       function_ref<void(const DWARFSection &)> F) const override {
     for (auto &P : TypesDWOSections)
       F(P.second);
   }
 
   StringRef getAbbrevSection() const override { return AbbrevSection; }
   const DWARFSection &getLocSection() const override { return LocSection; }
+  const DWARFSection &getLoclistsSection() const override { return LocListsSection; }
   StringRef getARangeSection() const override { return ARangeSection; }
   StringRef getDebugFrameSection() const override { return DebugFrameSection; }
   StringRef getEHFrameSection() const override { return EHFrameSection; }
   const DWARFSection &getLineSection() const override { return LineSection; }
   StringRef getStringSection() const override { return StringSection; }
   const DWARFSection &getRangeSection() const override { return RangeSection; }
   const DWARFSection &getRnglistsSection() const override {
     return RnglistsSection;

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

if (auto LL = parseOneLocationList(data, &Offset))
       Locations.push_back(std::move(*LL));
     else
       break;
   }
   if (data.isValidOffset(Offset))
     WithColor::error() << "failed to consume entire .debug_loc section\n";
 }
 
-Optional<DWARFDebugLocDWO::LocationList>
-DWARFDebugLocDWO::parseOneLocationList(DataExtractor Data, unsigned *Offset) {
+Optional<DWARFDebugLoclists::LocationList>
+DWARFDebugLoclists::parseOneLocationList(DataExtractor Data, unsigned *Offset) {
   LocationList LL;
   LL.Offset = *Offset;
 
   // dwarf::DW_LLE_end_of_list_entry is 0 and indicates the end of the list.
   while (auto Kind =
              static_cast<dwarf::LocationListEntry>(Data.getU8(Offset))) {
-    if (Kind != dwarf::DW_LLE_startx_length) {
+
+    Entry E;
+    E.Kind = Kind;
+    switch (Kind) {
+    case dwarf::DW_LLE_startx_length:
+      E.Value0 = Data.getULEB128(Offset);
+      E.Value1 = Data.getU32(Offset);
+      break;
+    case dwarf::DW_LLE_start_length:
+      E.Value0 = Data.getAddress(Offset);
+      E.Value1 = Data.getULEB128(Offset);
+      break;
+    case dwarf::DW_LLE_offset_pair:
+      E.Value0 = Data.getULEB128(Offset);
+      E.Value1 = Data.getULEB128(Offset);
+      break;
+    case dwarf::DW_LLE_base_address:
+      E.Value0 = Data.getAddress(Offset);
+      break;
+    default:
       WithColor::error() << "dumping support for LLE of kind " << (int)Kind
                          << " not implemented\n";
       return None;
     }
 
-    Entry E;
-    E.Start = Data.getULEB128(Offset);
-    E.Length = Data.getU32(Offset);
-
     unsigned Bytes = Data.getU16(Offset);
     // A single location description describing the location of the object...
     StringRef str = Data.getData().substr(*Offset, Bytes);
     *Offset += Bytes;
     E.Loc.resize(str.size());
     std::copy(str.begin(), str.end(), E.Loc.begin());
 
     LL.Entries.push_back(std::move(E));
   }
   return LL;
 }
 
-void DWARFDebugLocDWO::parse(DataExtractor data) {
+void DWARFDebugLoclists::parse(DataExtractor data) {
   IsLittleEndian = data.isLittleEndian();
   AddressSize = data.getAddressSize();
 
   uint32_t Offset = 0;
   while (data.isValidOffset(Offset)) {
     if (auto LL = parseOneLocationList(data, &Offset))
       Locations.push_back(std::move(*LL));
     else
       return;
   }
 }
 
-DWARFDebugLocDWO::LocationList const *
-DWARFDebugLocDWO::getLocationListAtOffset(uint64_t Offset) const {
+DWARFDebugLoclists::LocationList const *
+DWARFDebugLoclists::getLocationListAtOffset(uint64_t Offset) const {
   auto It = std::lower_bound(
       Locations.begin(), Locations.end(), Offset,
       [](const LocationList &L, uint64_t Offset) { return L.Offset < Offset; });
   if (It != Locations.end() && It->Offset == Offset)
     return &(*It);
   return nullptr;
 }
 
-void DWARFDebugLocDWO::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
+void DWARFDebugLoclists::LocationList::dump(raw_ostream &OS, uint64_t BaseAddr,
+                                            bool IsLittleEndian,
                                             unsigned AddressSize,
                                             const MCRegisterInfo *MRI,
                                             unsigned Indent) const {
   for (const Entry &E : Entries) {
+    switch (E.Kind) {
+    case dwarf::DW_LLE_startx_length:
       OS << '\n';
       OS.indent(Indent);
-    OS << "Addr idx " << E.Start << " (w/ length " << E.Length << "): ";
+      OS << "Addr idx " << E.Value0 << " (w/ length " << E.Value1 << "): ";
+      break;
+    case dwarf::DW_LLE_start_length:
+      OS << '\n';
+      OS.indent(Indent);
+      OS << format("[0x%8.8x, 0x%8.8x): ", E.Value0, E.Value0 + E.Value1);
+      break;
+    case dwarf::DW_LLE_offset_pair:
+      OS << '\n';
+      OS.indent(Indent);
+      OS << format("[0x%8.8x, 0x%8.8x): ", BaseAddr + E.Value0,
+                   BaseAddr + E.Value1);
+      break;
+    case dwarf::DW_LLE_base_address:
+      BaseAddr = E.Value0;
+      break;
+    default:
+      llvm_unreachable("unreachable locations list kind");
+    }
+
     dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
   }
 }
 
-void DWARFDebugLocDWO::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+void DWARFDebugLoclists::dump(raw_ostream &OS, uint64_t BaseAddr,
+                              const MCRegisterInfo *MRI,
                               Optional<uint64_t> Offset) const {
   auto DumpLocationList = [&](const LocationList &L) {
     OS << format("0x%8.8x: ", L.Offset);
-    L.dump(OS, IsLittleEndian, AddressSize, MRI, /*Indent=*/12);
+    L.dump(OS, BaseAddr, IsLittleEndian, AddressSize, MRI, /*Indent=*/12);
     OS << "\n\n";
   };
 
   if (Offset) {
     if (auto *L = getLocationListAtOffset(*Offset))
       DumpLocationList(*L);
     return;
   }
 
   for (const LocationList &L : Locations) {
     DumpLocationList(L);
   }
 }

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

if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
     DWARFExpression(Data, U->getVersion(), U->getAddressByteSize())
         .print(OS, MRI);
     return;
   }
 
   FormValue.dump(OS, DumpOpts);
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     uint32_t Offset = *FormValue.getAsSectionOffset();
-    if (!U->isDWOUnit()) {
+    if (!U->isDWOUnit() && !U->getLocSection()->Data.empty()) {
       DWARFDebugLoc DebugLoc;
       DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
                               Obj.getAddressSize());
       auto LL = DebugLoc.parseOneLocationList(Data, &Offset);
       if (LL) {
         uint64_t BaseAddr = 0;
         if (Optional<SectionedAddress> BA = U->getBaseAddress())
           BaseAddr = BA->Address;
         LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, BaseAddr,
                  Indent);
       } else
         OS << "error extracting location list.";
-    } else {
-      DataExtractor Data(U->getLocSectionData(), Ctx.isLittleEndian(), 0);
-      auto LL = DWARFDebugLocDWO::parseOneLocationList(Data, &Offset);
+      return;
+    }
+
+    StringRef LoclistsSectionData =
+        U->isDWOUnit() ? U->getLocSectionData() : Obj.getLoclistsSection().Data;
+    if (!LoclistsSectionData.empty()) {
+      DataExtractor Data(LoclistsSectionData, Ctx.isLittleEndian(),
+                         Obj.getAddressSize());
+      auto LL = DWARFDebugLoclists::parseOneLocationList(Data, &Offset);
+
+      uint64_t BaseAddr = 0;
+      if (Optional<SectionedAddress> BA = U->getBaseAddress())
+        BaseAddr = BA->Address;
+
       if (LL)
-        LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
+        LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI,
+                 Indent);
       else
         OS << "error extracting location list.";
     }
   }
 }
 
 /// Dump the name encoded in the type tag.
 static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {

llvm/trunk/test/DebugInfo/X86/dwarfdump-debug-loclists.test

+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
+# RUN: llvm-dwarfdump -v %t.o | FileCheck %s
+
+# CHECK:      .debug_info
+# CHECK:       DW_AT_name{{.*}}"stub"
+# CHECK:       DW_AT_location [DW_FORM_sec_offset]   (0x0000000c
+# CHECK-NEXT:    [0x00000010, 0x00000020): DW_OP_breg5 RDI+0
+# CHECK-NEXT:    [0x00000530, 0x00000540): DW_OP_breg6 RBP-8, DW_OP_deref
+# CHECK-NEXT:    [0x00000700, 0x00000710): DW_OP_breg5 RDI+0
+
+# CHECK:      .debug_loclists contents:
+# CHECK-NEXT: 0x00000000: locations list header: length = 0x00000031, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# CHECK-NEXT: 0x00000000:
+# CHECK-NEXT:   [0x00000000, 0x00000010): DW_OP_breg5 RDI+0
+# CHECK-NEXT:   [0x00000530, 0x00000540): DW_OP_breg6 RBP-8, DW_OP_deref
+# CHECK-NEXT:   [0x00000700, 0x00000710): DW_OP_breg5 RDI+0
+
+.section  .debug_str,"MS",@progbits,1
+  .asciz  "stub"
+
+.section  .debug_str_offsets,"",@progbits
+  .long  68
+  .short  5
+  .short  0
+.Lstr_offsets_base0:
+  .zero 64
+
+.section  .debug_loclists,"",@progbits
+  .long  .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0
+.Ldebug_loclist_table_start0:
+ .short 5                        # Version.
+ .byte 8                         # Address size.
+ .byte 0                         # Segmen selector size.
+ .long 0                         # Offset entry count.
+.Lloclists_table_base0:
+.Ldebug_loc0:
+  .byte  4                       # DW_LLE_offset_pair
+  .uleb128 0x0                   #   starting offset
+  .uleb128 0x10                  #   ending offset
+  .short  2                      # Loc expr size
+  .byte  117                     # DW_OP_breg5
+  .byte  0                       # 0
+  
+  .byte  6                       # DW_LLE_base_address
+  .quad  0x500                   # Some address
+  .short  0                      # Loc expr size = 0.
+  
+  .byte  4                       # DW_LLE_offset_pair
+  .uleb128 0x30                  #   starting offset
+  .uleb128 0x40                  #   ending offset
+  .short  3                      # Loc expr size
+  .byte  118                     # DW_OP_breg6
+  .byte  120                     # -8
+  .byte  6                       # DW_OP_deref
+
+  .byte  8                       # DW_LLE_start_length
+  .quad  0x700                   # Some address
+  .uleb128 0x10                  #   length
+  .short  2                      # Loc expr size
+  .byte  117                     # DW_OP_breg5
+  .byte  0                       # 0
+  
+  .byte  0                       # DW_LLE_end_of_list
+
+.Ldebug_loclist_table_end0:
+
+.section  .debug_abbrev,"",@progbits
+  .byte  1                       # Abbreviation Code
+  .byte  17                      # DW_TAG_compile_unit
+  .byte  1                       # DW_CHILDREN_yes
+  .byte  37                      # DW_AT_producer
+  .byte  37                      # DW_FORM_strx1
+  .byte  19                      # DW_AT_language
+  .byte  5                       # DW_FORM_data2
+  .byte  3                       # DW_AT_name
+  .byte  37                      # DW_FORM_strx1
+  .byte  114                     # DW_AT_str_offsets_base
+  .byte  23                      # DW_FORM_sec_offset
+  .byte  16                      # DW_AT_stmt_list
+  .byte  23                      # DW_FORM_sec_offset
+  .byte  27                      # DW_AT_comp_dir
+  .byte  37                      # DW_FORM_strx1
+  .byte  17                      # DW_AT_low_pc
+  .byte  1                       # DW_FORM_addr
+  .byte  18                      # DW_AT_high_pc
+  .byte  6                       # DW_FORM_data4
+  .ascii  "\214\001"             # DW_AT_loclists_base
+  .byte  23                      # DW_FORM_sec_offset
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  2                       # Abbreviation Code
+  .byte  46                      # DW_TAG_subprogram
+  .byte  1                       # DW_CHILDREN_yes
+  .byte  17                      # DW_AT_low_pc
+  .byte  1                       # DW_FORM_addr
+  .byte  18                      # DW_AT_high_pc
+  .byte  6                       # DW_FORM_data4
+  .byte  64                      # DW_AT_frame_base
+  .byte  24                      # DW_FORM_exprloc
+  .byte  110                     # DW_AT_linkage_name
+  .byte  37                      # DW_FORM_strx1
+  .byte  3                       # DW_AT_name
+  .byte  37                      # DW_FORM_strx1
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  63                      # DW_AT_external
+  .byte  25                      # DW_FORM_flag_present
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  3                       # Abbreviation Code
+  .byte  52                      # DW_TAG_variable
+  .byte  0                       # DW_CHILDREN_no
+  .byte  2                       # DW_AT_location
+  .byte  23                      # DW_FORM_sec_offset
+  .byte  3                       # DW_AT_name
+  .byte  37                      # DW_FORM_strx1
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  73                      # DW_AT_type
+  .byte  19                      # DW_FORM_ref4
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  0                       # EOM(3)
+
+.section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long  70                      # Length of Unit
+  .short  5                      # DWARF version number
+  .byte  1                       # DWARF Unit Type
+  .byte  8                       # Address Size (in bytes)
+  .long  .debug_abbrev           # Offset Into Abbrev. Section
+  .byte  1                       # Abbrev [1] 0xc:0xef DW_TAG_compile_unit
+  .byte  0                       # DW_AT_producer
+  .short  4                      # DW_AT_language
+  .byte  1                       # DW_AT_name
+  .long  .Lstr_offsets_base0     # DW_AT_str_offsets_base
+  .long  .Lline_table_start0     # DW_AT_stmt_list
+  .byte  2                       # DW_AT_comp_dir
+  .quad  0x10                    # DW_AT_low_pc
+  .long  0                       # DW_AT_high_pc
+  .long  .Lloclists_table_base0  # DW_AT_loclists_base
+  .byte  2                       # Abbrev [2] 0x2a:0x20 DW_TAG_subprogram
+  .quad  0                       # DW_AT_low_pc
+  .long  0                       # DW_AT_high_pc
+  .byte  1                       # DW_AT_frame_base
+  .byte  86
+  .byte  11                      # DW_AT_linkage_name
+  .byte  12                      # DW_AT_name
+  .byte  1                       # DW_AT_decl_file
+  .byte  6                       # DW_AT_decl_line
+                                 # DW_AT_external
+  .byte 3                        # Abbrev [3] 0x40:0xb DW_TAG_variable
+  .long .Ldebug_loc0             # DW_AT_location
+  .byte 7                        # DW_AT_name
+  .byte 1                        # DW_AT_decl_file
+  .byte 6                        # DW_AT_decl_line
+  .long 76                       # DW_AT_type
+  .byte 0                        # End Of Children Mark
+  .byte 0                        # End Of Children Mark
+  .byte  0                       # End Of Children Mark
+
+.section .debug_line,"",@progbits
+.Lline_table_start0:
+