[DebugInfo] Use absolute addresses in location lists

[JDevlieghere]

Summary

Rather than relying on the user to do the address calculating in
DW_AT_location we should just dump the absolute address.

rdar://problem/38513870

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

111–115

Might be able to replace "BaseAddr" with "U->getBaseAddress().getValueOr(0)" ?

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

578–586

This implementation has the unfortunate property of not caching the result when the result is negative/empty. Is that worth worrying about/fixing/addressing? Probably not, I guess. Not a really big cost, and not having a base address is a corner/uncomomn case. (debug info for modules - that only contain type information, and no code/addresses, would be one such situation where there's a CU with no base address)

[JDevlieghere]

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

111–115

I think that wouldn't work here because the Optional wraps the struct rather than the unsigned?

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

111–115

Ah, sure enough. Could do "getValueOr(BaseAddress())" but that might be going further than is useful. Up to you.

[aprantl]

Thanks, this was very confusing!

[JDevlieghere]

Thanks for the reviews, I'll keep it as is for now.

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

public:
   struct LocationList {
     /// The beginning offset where this location list is stored in the debug_loc
     /// section.
     unsigned Offset;
     /// All the locations in which the variable is stored.
     SmallVector<Entry, 2> Entries;
     /// Dump this list on OS.
     void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
-              const MCRegisterInfo *MRI, unsigned Indent) const;
+              const MCRegisterInfo *MRI, uint64_t BaseAddress,
+              unsigned Indent) const;
   };
 
 private:
   using LocationLists = SmallVector<LocationList, 4>;
 
   /// A list of all the variables in the debug_loc section, each one describing
   /// the locations in which the variable is stored.
   LocationLists Locations;

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

case dwarf::DW_UT_split_compile:
       return 20;
     case dwarf::DW_UT_type:
     case dwarf::DW_UT_split_type:
       return 24;
     }
     llvm_unreachable("Invalid UnitType.");
   }
 
-  llvm::Optional<BaseAddress> getBaseAddress() const { return BaseAddr; }
-
-  void setBaseAddress(BaseAddress BaseAddr) { this->BaseAddr = BaseAddr; }
+  llvm::Optional<BaseAddress> getBaseAddress();
 
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
     extractDIEsIfNeeded(ExtractUnitDIEOnly);
     if (DieArray.empty())
       return DWARFDie();
     return DWARFDie(this, &DieArray[0]);
   }
 

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

static void dumpExpression(raw_ostream &OS, ArrayRef<char> Data,
   DWARFDataExtractor Extractor(StringRef(Data.data(), Data.size()),
                                IsLittleEndian, AddressSize);
   DWARFExpression(Extractor, dwarf::DWARF_VERSION, AddressSize).print(OS, MRI);
 }
 
 void DWARFDebugLoc::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
                                        unsigned AddressSize,
                                        const MCRegisterInfo *MRI,
+                                       uint64_t BaseAddress,
                                        unsigned Indent) const {
   for (const Entry &E : Entries) {
     OS << '\n';
     OS.indent(Indent);
     OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2,
-                 E.Begin)
-       << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, E.End);
+                 BaseAddress + E.Begin);
+    OS << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2,
+                 BaseAddress + E.End);
     OS << ": ";
 
     dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
   }
 }
 
 DWARFDebugLoc::LocationList const *
 DWARFDebugLoc::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 DWARFDebugLoc::dump(raw_ostream &OS, 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, 12);
+    L.dump(OS, IsLittleEndian, AddressSize, MRI, 0, 12);
     OS << "\n\n";
   };
 
   if (Offset) {
     if (auto *L = getLocationListAtOffset(*Offset))
       DumpLocationList(*L);
     return;
   }

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
     return;
   }
 
   FormValue.dump(OS, DumpOpts);
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     const DWARFSection &LocSection = Obj.getLocSection();
     const DWARFSection &LocDWOSection = Obj.getLocDWOSection();
     uint32_t Offset = *FormValue.getAsSectionOffset();
-
     if (!LocSection.Data.empty()) {
       DWARFDebugLoc DebugLoc;
       DWARFDataExtractor Data(Obj, LocSection, Ctx.isLittleEndian(),
                               Obj.getAddressSize());
       auto LL = DebugLoc.parseOneLocationList(Data, &Offset);
-      if (LL)
-        LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
-      else
+      if (LL) {
+        uint64_t BaseAddr = 0;
+        if (Optional<BaseAddress> BA = U->getBaseAddress())
+          BaseAddr = BA->Address;
+        LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, BaseAddr,
+                 Indent);
+      } else
         OS << "error extracting location list.";
     } else if (!LocDWOSection.Data.empty()) {
       DataExtractor Data(LocDWOSection.Data, Ctx.isLittleEndian(), 0);
       auto LL = DWARFDebugLocDWO::parseOneLocationList(Data, &Offset);
       if (LL)
         LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
       else
         OS << "error extracting location list.";

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 
   if (DieArray.empty())
     return 0;
 
   // If CU DIE was just parsed, copy several attribute values from it.
   if (!HasCUDie) {
     DWARFDie UnitDie = getUnitDIE();
-    Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
-    if (Optional<uint64_t> Addr = toAddress(PC))
-        setBaseAddress({*Addr, PC->getSectionIndex()});
-
     if (!isDWO) {
       assert(AddrOffsetSectionBase == 0);
       assert(RangeSectionBase == 0);
       AddrOffsetSectionBase =
           toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base), 0);
       RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0);
     }
 

 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
   if (!Abbrevs)
     Abbrevs = Abbrev->getAbbreviationDeclarationSet(Header.getAbbrOffset());
   return Abbrevs;
 }
 
+llvm::Optional<BaseAddress> DWARFUnit::getBaseAddress() {
+  if (BaseAddr)
+    return BaseAddr;
+
+  DWARFDie UnitDie = getUnitDIE();
+  Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
+  if (Optional<uint64_t> Addr = toAddress(PC))
+    BaseAddr = {*Addr, PC->getSectionIndex()};
+
+  return BaseAddr;
+}
+
 Optional<StrOffsetsContributionDescriptor>
 StrOffsetsContributionDescriptor::validateContributionSize(
     DWARFDataExtractor &DA) {
   uint8_t EntrySize = getDwarfOffsetByteSize();
   // In order to ensure that we don't read a partial record at the end of
   // the section we validate for a multiple of the entry size.
   uint64_t ValidationSize = alignTo(Size, EntrySize);
   // Guard against overflow.

llvm/test/DebugInfo/X86/debug-loc-offset.ll

 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_linkage_name [DW_FORM_strp]{{.*}}"_Z3baz1A"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
-; CHECK-NEXT:    [0x00000000, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
-; CHECK-NEXT:    [0x00000017, 0x00000043): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
+; CHECK-NEXT:    [0x00000020, 0x00000037): DW_OP_breg0 EAX+0, DW_OP_deref
+; CHECK-NEXT:    [0x00000037, 0x00000063): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 ; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"a"
 
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_location [DW_FORM_exprloc]
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_low_pc {{.*}} (0x0000000000000000)

llvm/test/tools/dsymutil/X86/basic-lto-dw4-linking-x86.test

 CHECK:      DW_AT_high_pc (0x0000000100000f87)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name ("foo")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_prototyped (true)
 CHECK:      DW_AT_type (0x000000a1
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_location (0x00000000
-CHECK:          [0x0000000000000000, 0x000000000000000c): DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [0x0000000100000f50, 0x0000000100000f5c): DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name ("arg")
 CHECK:        DW_AT_type (0x000000a1
 CHECK:      DW_TAG_inlined_subroutine
 CHECK:        DW_AT_abstract_origin (0x000000d2 "inc")
 CHECK:        DW_AT_low_pc (0x0000000100000f61)
 CHECK:        DW_AT_high_pc (0x0000000100000f70)
 CHECK:      NULL
 CHECK:    NULL

 CHECK:      DW_AT_inline (DW_INL_inlined)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_low_pc (0x0000000100000f90)
 CHECK:      DW_AT_high_pc (0x0000000100000fb4)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name ("bar")
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_location (0x00000025
-CHECK:          [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK:          [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [0x0000000100000f90, 0x0000000100000f9f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK:          [0x0000000100000fa9, 0x0000000100000fad): DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name ("arg")
 CHECK:      DW_TAG_inlined_subroutine
 CHECK:        DW_AT_abstract_origin (0x0000015f "inc")
 CHECK:        DW_AT_ranges (0x00000000
 CHECK:           [0x0000000100000f94, 0x0000000100000f9a)
 CHECK:           [0x0000000100000f9f, 0x0000000100000fa7))
 
 CHECK:      NULL

llvm/test/tools/dsymutil/X86/basic-lto-linking-x86.test

 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_low_pc (0x0000000100000f50)
 CHECK:      DW_AT_high_pc (0x0000000100000f89)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
 CHECK:        DW_AT_type (0x0000000000000063
 CHECK:        DW_AT_location (0x00000000
-CHECK:          [0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [0x0000000100000f50, 0x0000000100000f5e): DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:[[INC1:0x[0-9a-f]*]]{{.*}}DW_TAG_inlined_subroutine
 CHECK:        DW_AT_abstract_origin (0x00000128 "inc")
 CHECK:        DW_AT_low_pc (0x0000000100000f63)
 CHECK:        DW_AT_high_pc (0x0000000100000f72)
 CHECK:        DW_AT_call_line (20)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")

 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_low_pc (0x0000000100000f90)
 CHECK:      DW_AT_high_pc (0x0000000100000fb4)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
 CHECK:        DW_AT_type (0x0000000000000063
 CHECK:        DW_AT_location (0x00000025
-CHECK:          [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK:          [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [0x0000000100000f90, 0x0000000100000f9f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK:          [0x0000000100000fa9, 0x0000000100000fad): DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_lexical_block
 CHECK:        DW_AT_low_pc (0x0000000100000f94)
 CHECK:        DW_AT_high_pc (0x0000000100000fa7)
 CHECK:[[INC2:0x[0-9a-f]*]]{{.*}}DW_TAG_inlined_subroutine
 CHECK:          DW_AT_abstract_origin (0x000001d4 "inc")
 CHECK:          DW_AT_ranges (0x00000000
 CHECK:             [0x0000000100000f94, 0x0000000100000f9a)
 CHECK:             [0x0000000100000f9f, 0x0000000100000fa7))