DWARFDebugLoc(v4): Add an incremental parsing function

[labath]

Summary

This adds a visitLocationList function to the DWARF v4 location lists,
similar to what already exists for DWARF v5. It follows the approach
outlined in previous patches (D69672), where the parsed form is always
stored in the DWARF v5 format, which makes it easier for generic code to
be built on top of that. v4 location lists are "upgraded" during
parsing, and then this upgrade is undone while dumping.

Both "inline" and section-based dumping is rewritten to reuse the
existing "generic" location list dumper. This means that the output
format is consistent for all location lists (the only thing one needs to
implement is the function which prints the "raw" form of a location
list), and that debug_loc dumping correctly processes base address
selection entries, etc.

The previous existing debug_loc functionality (e.g.,
parseOneLocationList) is rewritten on top of the new API, but it is not
removed as there is still code which uses them. This will be done in
follow-up patches, after I build the API to access the "interpreted"
location lists in a generic way (as that is what those users really
want).

[labath]

I ran into a bit of a snag a couple of patches down this direction. I'm going to do a small course correction and then get back to this. I'll explain more in the other patches.

[labath]

• rebase on master
• reuse the new generic dumping mechanism

[labath]

requesting re-review, as the this patch has changed/expanded substantially

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

140–142

One thing I'm not sure of it's the syntax of these "raw" entries. The () syntax is sort of similar to the DW_LLE(x,y) syntax, but at same time, it's easy to miss that one is looking at the "raw" dump as the difference is only one character. OTOH, the v4 loclists don't have any fancy encodings, so the "raw" format is nearly the same as the "interpreted" format anyway...

Maybe we could use curly brackets here or something?

[JDevlieghere]

A few nits inline, but otherwise this LGTM.

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

107

Can we have a more meaningful name than F?

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

161

Nit: given that we have the comments in both branches, maybe it's worth having a named temporary variable?

184

Any reason you prefer this over while(true) with a break? Just asking out of curiosity.

[labath]

Thanks for the review. I'll incorporate the comments before committing.

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

184

I think I was influenced by the other loops in this patch which do some extra work after setting the "continue" flag. while(true) seems fine here.

[SouraVX]

Hi Pavel, a bug from debug_loc.dwo emission might has gone up here.
Now please correcting me if I'm wrong.
It's originating from the emission part of debug_loc.dwo. -- I tried pointing / correcting it in D69462.

Consider the below snippet at the end of emitDebugLocDWO() function
Asm->emitInt8(dwarf::DW_LLE_end_of_list); -- now this piece of code is causing to emit DW_LLE_end_of_list in a debug_loc.dwo which has no notion of this form. amidst it has it's own way of representing end of list.

I corrected this as --

Asm->OutStreamer->EmitIntValue(0, Size);  -- where Size = Asm->MAI->getCodePointerSize()
Asm->OutStreamer->EmitIntValue(0, Size);

@dblaikie also did something same for marking termination of list in function emitRangeList at the very end while emitting in non-split debug_loc section.

Now the undesirable behavior, after correcting this -- Since this patch already add visitLocationList and some sort of verbose printing of DW_LLE* for debug_loc.dwo, which I suppose llvm-dwardump is using.
For typical case of location list {loc.dwo} -- with latest master

llvm-dwarfdump --debug-loc test.dwo
.debug_loc.dwo contents:
0x00000000:
            DW_LLE_startx_length   (0x00000000, 0x00000004): DW_OP_reg5 RDI
            DW_LLE_startx_length   (0x00000003, 0x00000014): DW_OP_reg3 RBX
            DW_LLE_end_of_list     ()

0x00000013:
            DW_LLE_startx_length   (0x00000001, 0x00000006): DW_OP_reg5 RDI
            DW_LLE_end_of_list     ()

0x0000001d:
            DW_LLE_startx_length   (0x00000001, 0x0000000b): DW_OP_reg4 RSI
            DW_LLE_end_of_list     ()

Now if, I correct it --

llvm-dwarfdump --debug-loc test.dwo
debug_loc.dwo contents:
0x00000000:
            DW_LLE_startx_length   (0x00000000, 0x00000004): DW_OP_reg5 RDI
            DW_LLE_startx_length   (0x00000003, 0x00000014): DW_OP_reg3 RBX
            DW_LLE_end_of_list     ()

0x00000013:
            DW_LLE_end_of_list     ()
..... + a lot of DW_LLE_end_of_list     ()

0x00000022:
            DW_LLE_startx_length   (0x00000001, 0x00000006): DW_OP_reg5 RDI
            DW_LLE_end_of_list     ()
..... + a lot of DW_LLE_end_of_list     ()

0x0000003b:
            DW_LLE_startx_length   (0x00000001, 0x0000000b): DW_OP_reg4 RSI
            DW_LLE_end_of_list     ()
..... + a lot of DW_LLE_end_of_list     ()

I'm suspecting, the changed representation of termination list might not be appropriately handled{Anyway, you were not aware of this, at that point} here in DWARFDebugLoc::visitLocationList.

Why this bothering me ?? I think, I also started out a discussion in D70081 that why we are adding this verbosity and stuff to debug_loc.dwo
you answered.

You're absolutely right, and I am planning to do that. I already have a patch which does just that -- I just need to clean it up before submission (I'll do that today or tomorrow).

Untill now loc printing is mostly ranges, so we don't worry about form DW_LLE*, but I'm suspecting this handling of forms, specially termination of list, you might run into un-necessary trouble.

I think, it's fine if we just dump ranges for pre-dwarf5 stuff.
Please share your thoughts on this, As @dblaikie in D69462 already asked to put a separate patch for this, which I suspect invites rework on DWARFDebugLoc::visitLocationList.
My Apologies, if this is too big / self explanatory.

[labath]

I'm sorry, but I'm confused. Are you saying that the .debug_loc.dwo (i.e. non-standardized dwarf4 fission) location lists should be terminated with a classical .debug_loc double-zero entry ? That doesn't seem right -- the .debug_loc.dwo lists are in reality very different from .debug_loc (they use DW_LLE_*** constants and everything), and are really more similar to .debug_loclists(.dwo) than .debug_loc (though there are some subtle differences). It also doesn't seem to be what gcc is doing now -- this is a typical location list I get from gcc-9 -gsplit-dwarf (comments added by me):

        .section        .debug_loc.dwo,"e",@progbits
.Ldebug_loc0:
.LVUS0: # gcc "view" stuff -- ignore that
        .uleb128 .LVU2
        .uleb128 0
.LLST0: # DW_AT_location points here
        .byte   0x3                  # DW_LLE_startx_length
        .uleb128 0x1                 # index
        .long   .LFE0-.LVL0          # length
        .value  0x5                  # expression length
        .byte   0x75
        .sleb128 0
        .byte   0x31
        .byte   0x24
        .byte   0x9f
        .byte   0                # DW_LLE_end_of_list
.LVUS1: # next "view" starts here

In practice, changing the .byte 0 to two word-sized zeroes probably won't change anything, as the first byte of that will terminate the location list anyway. However, I don't think that's the right thing to do, and I think llvm-dwarfdump is right to display a bunch of end_of_list entries for something like that.

[SouraVX]

In D69847#1753190, @labath wrote:

I'm sorry, but I'm confused. Are you saying that the .debug_loc.dwo (i.e. non-standardized dwarf4 fission) location lists should be terminated with a classical .debug_loc double-zero entry ? That doesn't seem right -- the .debug_loc.dwo lists are in reality very different from .debug_loc (they use DW_LLE_*** constants and everything), and are really more similar to .debug_loclists(.dwo) than .debug_loc (though there are some subtle differences). It also doesn't seem to be what gcc is doing now -- this is a typical location list I get from gcc-9 -gsplit-dwarf (comments added by me):

Thanks for sharing, this I'm also sceptical here, as to what approach we should follow. You're comments seems reasonable here, But If you just try dumping this{GCC, compiled binary} -- again using llvm-dwarfdump you'll notice lots of DW_LLE_end_of_list. I'm not pointing you're wrong -- it's just the dump that the end user will see -- will not make sense{atleast confuses me} to him.

        .section        .debug_loc.dwo,"e",@progbits
.Ldebug_loc0:
.LVUS0: # gcc "view" stuff -- ignore that
        .uleb128 .LVU2
        .uleb128 0
.LLST0: # DW_AT_location points here
        .byte   0x3                  # DW_LLE_startx_length
        .uleb128 0x1                 # index
        .long   .LFE0-.LVL0          # length
        .value  0x5                  # expression length
        .byte   0x75
        .sleb128 0
        .byte   0x31
        .byte   0x24
        .byte   0x9f
        .byte   0                # DW_LLE_end_of_list
.LVUS1: # next "view" starts here

In practice, changing the .byte 0 to two word-sized zeroes probably won't change anything, as the first byte of that will terminate the location list anyway. However, I don't think that's the right thing to do, and I think llvm-dwarfdump is right to display a bunch of end_of_list entries for something like that.

[labath]

In D69847#1753244, @SouraVX wrote:

In D69847#1753190, @labath wrote:

I'm sorry, but I'm confused. Are you saying that the .debug_loc.dwo (i.e. non-standardized dwarf4 fission) location lists should be terminated with a classical .debug_loc double-zero entry ? That doesn't seem right -- the .debug_loc.dwo lists are in reality very different from .debug_loc (they use DW_LLE_*** constants and everything), and are really more similar to .debug_loclists(.dwo) than .debug_loc (though there are some subtle differences). It also doesn't seem to be what gcc is doing now -- this is a typical location list I get from gcc-9 -gsplit-dwarf (comments added by me):

Thanks for sharing, this I'm also sceptical here, as to what approach we should follow. You're comments seems reasonable here, But If you just try dumping this{GCC, compiled binary} -- again using llvm-dwarfdump you'll notice lots of DW_LLE_end_of_list. I'm not pointing you're wrong -- it's just the dump that the end user will see -- will not make sense{atleast confuses me} to him.

Could you share this binary or some instructions how to produce it. I know there are some issues with dumping gcc-produced range/location lists, but I don't think this has to do with how they are terminated. The for instance, if I tried to do a section-based dump ("inline dumps" work fine, but they don't show end-of-list entries) of the location list from https://reviews.llvm.org/D69847#1753190, then I'd get an error like "error: LLE of kind 2 not supported". However this is due to the "view" blurbs that gcc inserts and not about location lists per se. (Which kind of ties in to the discussion of how should we actually perform section dumps -- there's an opinion that just scanning through the section and printing location lists (i.e. what llvm-dwarfdump -debug-loc is doing now) is not correct/legal, and that one should always start from the debug_info section and follow references from there. Gcc apparently exploits this fact to insert some custom data into the debug_loc/range sections)

[SouraVX]

Could you share this binary or some instructions how to produce it. I know there are some issues with dumping gcc-produced range/location lists, but I don't think this has to do with how they are terminated. The for instance, if I tried to do a section-based dump ("inline dumps" work fine, but they don't show end-of-list entries) of the location list from https://reviews.llvm.org/D69847#1753190, then I'd get an error like "error: LLE of kind 2 not supported". However this is due to the "view" blurbs that gcc inserts and not about location lists per se. (Which kind of ties in to the discussion of how should we actually perform section dumps -- there's an opinion that just scanning through the section and printing location lists (i.e. what llvm-dwarfdump -debug-loc is doing now) is not correct/legal, and that one should always start from the debug_info section and follow references from there. Gcc apparently exploits this fact to insert some custom data into the debug_loc/range sections)

Ah, Did I communicated intentions here, this problem of multiple spurious DW_LLE* will arise if, I placed or fix it that way,
Asm->OutStreamer->EmitIntValue(0, Size) -- not needed, I suppose after this discussion. thank you for clarifying this.

But remain with GCC compiled binaries--
test case--
compiled with
gcc -O2 -gdwarf-4 -gsplit-dwarf test.c GCC version 9.2.0

int func(int* ptr){
        printf("%d\n",*ptr);     return *ptr + 5;
}
int main(){
        int a = 4;     int* ptr_a = &a;
        int b = func(ptr_a);
        return 0;
}

llvm-dwarfdump --debug-loc test.dwo
.debug_loc.dwo contents:
0x00000000:
            DW_LLE_end_of_list     ()
+... DW_LLE_end_of_list

0x00000004:
            DW_LLE_startx_length   (0x00000000, 0x0000000e): DW_OP_reg5 RDI
            DW_LLE_startx_length   (0x00000002, 0x0000000e): DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value
            DW_LLE_end_of_list     ()
+... DW_LLE_end_of_list
... like wise

[dblaikie]

In D69847#1753190, @labath wrote:

I'm sorry, but I'm confused. Are you saying that the .debug_loc.dwo (i.e. non-standardized dwarf4 fission) location lists should be terminated with a classical .debug_loc double-zero entry ? That doesn't seem right -- the .debug_loc.dwo lists are in reality very different from .debug_loc (they use DW_LLE_*** constants and everything), and are really more similar to .debug_loclists(.dwo) than .debug_loc (though there are some subtle differences). It also doesn't seem to be what gcc is doing now -- this is a typical location list I get from gcc-9 -gsplit-dwarf (comments added by me):

        .section        .debug_loc.dwo,"e",@progbits
.Ldebug_loc0:
.LVUS0: # gcc "view" stuff -- ignore that
        .uleb128 .LVU2
        .uleb128 0
.LLST0: # DW_AT_location points here
        .byte   0x3                  # DW_LLE_startx_length
        .uleb128 0x1                 # index
        .long   .LFE0-.LVL0          # length
        .value  0x5                  # expression length
        .byte   0x75
        .sleb128 0
        .byte   0x31
        .byte   0x24
        .byte   0x9f
        .byte   0                # DW_LLE_end_of_list
.LVUS1: # next "view" starts here

In practice, changing the .byte 0 to two word-sized zeroes probably won't change anything, as the first byte of that will terminate the location list anyway. However, I don't think that's the right thing to do, and I think llvm-dwarfdump is right to display a bunch of end_of_list entries for something like that.

Hmm, I'm not seeing these extra ulebs in GCC's output in this example: https://godbolt.org/z/x5RvMY - am I missing something in the reproduction or not reading it accurately?

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

140–142

Few thoughts:

• I think I mentioned in a related review that we could use the same thing as the range dumping - that includes the section name/number (though that's only done in verbose mode? And wouldn't help with pure offset-pair/base-relative dumping in the absence of a base address anyway - because there's no way to know the section...)

• {} sound OK to me (maybe we could change the DW_LLE to that too, since the (), espceially with the whitespace between the LL and the '(' are a bit ambiguous too, I think? But I'm not sure/don't have a strong leaning either way there.

• Could write something like "base + " before the pair in cases where the base is unknown - but I guess that means most traditional location lists (ones that don't use any base addresses/constant zero base address) would print with "base + " which isn't super great

So... "{}" I guess? It'd be good to look at v4 range dumping too & come up with a decision we're OK with for both cases, I think.

Hmm, I am sort of coming back to maybe printing these as [x, y) isn't /so/ bad. In the unrelocated object file we would have the section info (because we'd have relocations) maybe we could print that like the verbose range dumping but even in non-verbose mode when section dumping & not having the base address? & we could ignore the base address part... that's how we print v4 range lists currently? Either in objects where the CU has a relocated base address, or in linked executables where the range list no longer contains relocations (but also doesn't contain apparently overlapping ranges all starting at zero - because now they're all relocated). I guess we could print "base + " as a separate line at the start of the list to make it clear that they're all relative to any potential CU base...

Eh, would love to hear other people's ideas/preferences here. How much shuold the dumping output be unambiguous/? How much is skipping things like "base+" useful to us folks who already work on DWARF and understand that the code we're looking at doesn't start at address zero, so of course ranges starting at zero must be either unresolved relocations (well, in that case it's easy to print something nice about the section) or relative to a base address?

[labath]

In D69847#1753814, @dblaikie wrote:

Hmm, I'm not seeing these extra ulebs in GCC's output in this example: https://godbolt.org/z/x5RvMY - am I missing something in the reproduction or not reading it accurately?

It looks like you need to add -gvariable-location-views to the command line. I'm not sure what's the difference, but my build of gcc seems to have it on by default, and godbolt's doesn't.

I'm going to reply to the other comment tomorrow.

[dblaikie]

In D69847#1753935, @labath wrote:

In D69847#1753814, @dblaikie wrote:

Hmm, I'm not seeing these extra ulebs in GCC's output in this example: https://godbolt.org/z/x5RvMY - am I missing something in the reproduction or not reading it accurately?

It looks like you need to add -gvariable-location-views to the command line. I'm not sure what's the difference, but my build of gcc seems to have it on by default, and godbolt's doesn't.

Ah, that is a curious switch indeed. And, yeah, the existence of that feature sounds like a very solid justification that we should consider moving in the direction of not trying to parse arbitrary parts of non-debug_info sections (only those referenced from debug_info itself) except /maybe/ in a very exploratory debugging mode, and/or phrased differently in terms of "attempted to parse hole in debug_loc [offset1:offset2), but failed: <reason>"

I'm going to reply to the other comment tomorrow.

Ah, sure - that was a comment I didn't realize I'd written a while back and had failed to hit "send" on, feel free to ignore it if it doesn't make any more sense today or the like.

[labath]

In D69847#1754282, @dblaikie wrote:

Ah, sure - that was a comment I didn't realize I'd written a while back and had failed to hit "send" on, feel free to ignore it if it doesn't make any more sense today or the like.

It's still relevant. The deed is now kind of done, so changing that would mean re-updating every test, but it still can be done. And you did remind me that I still want to add support for parsing/dumping of the section indexes, so this would be a good opportunity to revisit that..

Overall, I don't think the format of debug_loc matters that much. They (unlike loclists) are very simple, and so printing them as [a,b) could be fine even if they are not real ranges. I sort of like how the leading ( subtly hints that this is not a real range, but that hint may be too subtle/confusing. If I take the consistency with debug_loclists into consideration, then I think that {} might be the best -- debug_loc could be printed as {a, b}, and debug_loclists as {DW_LLE_whatever, a, b}. It would be good to hear if anyone else has an opinion too, to avoid flipping this back and forth.

I also want to address the range/loclist discrepancy somehow, but I first want to finish the work with the location lists. The two things that I know I'm still missing are: parsing section indices; and parsing other DW_LLE_ forms.

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

public:
   DWARFLocationTable(DWARFDataExtractor Data) : Data(std::move(Data)) {}
   virtual ~DWARFLocationTable() = default;
 
   /// Call the user-provided callback for each entry (including the end-of-list
   /// entry) in the location list starting at \p Offset. The callback can return
   /// false to terminate the iteration early. Returns an error if it was unable
   /// to parse the entire location list correctly. Upon successful termination
   /// \p Offset will be updated point past the end of the list.
-  virtual Error
-  visitLocationList(uint64_t *Offset,
-                    function_ref<bool(const DWARFLocationEntry &)> F) const = 0;
+  virtual Error visitLocationList(
+      uint64_t *Offset,
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const = 0;
 
   /// Dump the location list at the given \p Offset. The function returns true
   /// iff it has successfully reched the end of the list. This means that one
   /// can attempt to parse another list after the current one (\p Offset will be
   /// updated to point past the end of the current list).
   bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                         Optional<object::SectionedAddress> BaseAddr,
                         const MCRegisterInfo *MRI, DWARFUnit *U,
                         DIDumpOptions DumpOpts, unsigned Indent) const;
 
 protected:
   DWARFDataExtractor Data;
 
   virtual void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                             unsigned Indent) const = 0;
 };
 
-class DWARFDebugLoc {
+class DWARFDebugLoc final : public DWARFLocationTable {
 public:
-  /// A single location within a location list.
-  struct Entry {
-    /// The beginning address of the instruction range.
-    uint64_t Begin;
-    /// The ending address of the instruction range.
-    uint64_t End;
-    /// The location of the variable within the specified range.
-    SmallVector<uint8_t, 4> Loc;
-  };
-
   /// A list of locations that contain one variable.
   struct LocationList {
     /// The beginning offset where this location list is stored in the debug_loc
     /// section.
     uint64_t Offset;
     /// All the locations in which the variable is stored.
-    SmallVector<Entry, 2> Entries;
-    /// Dump this list on OS.
-    void dump(raw_ostream &OS, uint64_t BaseAddress, bool IsLittleEndian,
-              unsigned AddressSize, const MCRegisterInfo *MRI, DWARFUnit *U,
-              DIDumpOptions DumpOpts,
-              unsigned Indent) const;
+    SmallVector<DWARFLocationEntry, 2> Entries;
   };
 
 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;
 
-  unsigned AddressSize;
-
-  bool IsLittleEndian;
-
 public:
+  DWARFDebugLoc(DWARFDataExtractor Data)
+      : DWARFLocationTable(std::move(Data)) {}
+
   /// Print the location lists found within the debug_loc section.
   void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo, DIDumpOptions DumpOpts,
             Optional<uint64_t> Offset) const;
 
-  /// Parse the debug_loc section accessible via the 'data' parameter using the
-  /// address size also given in 'data' to interpret the address ranges.
-  void parse(const DWARFDataExtractor &data);
+  /// Parse the debug_loc section.
+  void parse();
 
   /// Return the location list at the given offset or nullptr.
   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
 
-  Expected<LocationList>
-  parseOneLocationList(const DWARFDataExtractor &Data, uint64_t *Offset);
+  Error visitLocationList(
+      uint64_t *Offset,
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
+
+  Expected<LocationList> parseOneLocationList(uint64_t *Offset);
+
+protected:
+  void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
+                    unsigned Indent) const override;
 };
 
 class DWARFDebugLoclists final : public DWARFLocationTable {
 public:
   DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)
       : DWARFLocationTable(std::move(Data)), Version(Version) {}
 
   Error visitLocationList(
       uint64_t *Offset,
-      function_ref<bool(const DWARFLocationEntry &)> F) const override;
+      function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
   /// Dump all location lists within the given range.
   void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,
                  const MCRegisterInfo *MRI, DIDumpOptions DumpOpts);
 
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent) const override;
 
 private:
   uint16_t Version;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

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

class DWARFUnit {
   /// Section containing this DWARFUnit.
   const DWARFSection &InfoSection;
 
   DWARFUnitHeader Header;
   const DWARFDebugAbbrev *Abbrev;
   const DWARFSection *RangeSection;
   uint64_t RangeSectionBase;
 
-  /// Section containing the location lists of this unit used for non-split
-  /// DWARF<=v4 units.
-  const DWARFSection *LocSection;
-
-  /// Location table of this unit. Used for DWARF v5 and DWO units.
+  /// Location table of this unit.
   std::unique_ptr<DWARFLocationTable> LocTable;
 
   const DWARFSection &LineSection;
   StringRef StringSection;
   const DWARFSection &StringOffsetSection;
   const DWARFSection *AddrOffsetSection;
   uint32_t AddrOffsetSectionBase = 0;
   bool isLittleEndian;
DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFSection &LS, bool LE, bool IsDWO,
             const DWARFUnitVector &UnitVector);
 
   virtual ~DWARFUnit();
 
   bool isDWOUnit() const { return IsDWO; }
   DWARFContext& getContext() const { return Context; }
   const DWARFSection &getInfoSection() const { return InfoSection; }
-  const DWARFSection *getLocSection() const { return LocSection; }
   uint64_t getOffset() const { return Header.getOffset(); }
   const dwarf::FormParams &getFormParams() const {
     return Header.getFormParams();
   }
   uint16_t getVersion() const { return Header.getVersion(); }
   uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   uint8_t getDwarfOffsetByteSize() const {
public:
   Optional<uint64_t> getStringOffsetSectionItem(uint32_t Index) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
-  const DWARFLocationTable *getLocationTable() { return LocTable.get(); }
+  const DWARFLocationTable &getLocationTable() { return *LocTable; }
 
   /// Extract the range list referenced by this compile unit from the
   /// .debug_ranges section. If the extraction is unsuccessful, an error
   /// is returned. Successful extraction requires that the compile unit
   /// has already been extracted.
   Error extractRangeList(uint64_t RangeListOffset,
                          DWARFDebugRangeList &RangeList) const;
   void clear();

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
   AbbrevDWO->extract(abbrData);
   return AbbrevDWO.get();
 }
 
 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
   if (Loc)
     return Loc.get();
 
-  Loc.reset(new DWARFDebugLoc);
   // Assume all units have the same address byte size.
-  if (getNumCompileUnits()) {
-    DWARFDataExtractor LocData(*DObj, DObj->getLocSection(), isLittleEndian(),
-                               getUnitAtIndex(0)->getAddressByteSize());
-    Loc->parse(LocData);
-  }
+  auto LocData =
+      getNumCompileUnits()
+          ? DWARFDataExtractor(*DObj, DObj->getLocSection(), isLittleEndian(),
+                               getUnitAtIndex(0)->getAddressByteSize())
+          : DWARFDataExtractor("", isLittleEndian(), 0);
+  Loc.reset(new DWARFDebugLoc(std::move(LocData)));
+  Loc->parse();
   return Loc.get();
 }
 
 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
   if (Aranges)
     return Aranges.get();
 
   Aranges.reset(new DWARFDebugAranges());

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

if (E) {
     OS << "\n";
     OS.indent(Indent);
     OS << "error: " << toString(std::move(E));
     return false;
   }
   return true;
 }
 
-void DWARFDebugLoc::LocationList::dump(raw_ostream &OS, uint64_t BaseAddress,
-                                       bool IsLittleEndian,
-                                       unsigned AddressSize,
-                                       const MCRegisterInfo *MRI, DWARFUnit *U,
-                                       DIDumpOptions DumpOpts,
-                                       unsigned Indent) const {
-  for (const Entry &E : Entries) {
-    OS << '\n';
-    OS.indent(Indent);
-    OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2,
-                 BaseAddress + E.Begin);
-    OS << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2,
-                 BaseAddress + E.End);
-    OS << ": ";
-
-    dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI, U);
-  }
-}
-
 DWARFDebugLoc::LocationList const *
 DWARFDebugLoc::getLocationListAtOffset(uint64_t Offset) const {
   auto It = partition_point(
       Locations, [=](const LocationList &L) { return L.Offset < Offset; });
   if (It != Locations.end() && It->Offset == Offset)
     return &(*It);
   return nullptr;
 }
 
-void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI, DIDumpOptions DumpOpts,
-                         Optional<uint64_t> Offset) const {
-  auto DumpLocationList = [&](const LocationList &L) {
-    OS << format("0x%8.8" PRIx64 ": ", L.Offset);
-    L.dump(OS, 0, IsLittleEndian, AddressSize, MRI, nullptr, DumpOpts, 12);
-    OS << "\n";
-  };
-
-  if (Offset) {
-    if (auto *L = getLocationListAtOffset(*Offset))
-      DumpLocationList(*L);
-    return;
-  }
+void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+                         DIDumpOptions DumpOpts,
+                         Optional<uint64_t> DumpOffset) const {
+  auto BaseAddr = None;
+  unsigned Indent = 12;
+  if (DumpOffset) {
+    dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, nullptr, DumpOpts,
+                     Indent);
+  } else {
+    uint64_t Offset = 0;
+    StringRef Separator;
+    bool CanContinue = true;
+    while (CanContinue && Data.isValidOffset(Offset)) {
+      OS << Separator;
+      Separator = "\n";
 
-  for (const LocationList &L : Locations) {
-    DumpLocationList(L);
-    if (&L != &Locations.back())
+      CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, nullptr,
+                                     DumpOpts, Indent);
       OS << '\n';
     }
   }
+}
 
-Expected<DWARFDebugLoc::LocationList>
-DWARFDebugLoc::parseOneLocationList(const DWARFDataExtractor &Data,
-                                    uint64_t *Offset) {
-  LocationList LL;
-  LL.Offset = *Offset;
-  AddressSize = Data.getAddressSize();
+Error DWARFDebugLoc::visitLocationList(
+    uint64_t *Offset,
+    function_ref<bool(const DWARFLocationEntry &)> Callback) const {
   DataExtractor::Cursor C(*Offset);
-
-  // 2.6.2 Location Lists
-  // A location list entry consists of:
   while (true) {
-    Entry E;
-
-    // 1. A beginning address offset. ...
-    E.Begin = Data.getRelocatedAddress(C);
+    uint64_t Value0 = Data.getRelocatedAddress(C);
+    uint64_t Value1 = Data.getRelocatedAddress(C);
 
-    // 2. An ending address offset. ...
-    E.End = Data.getRelocatedAddress(C);
-
-    if (Error Err = C.takeError())
-      return std::move(Err);
+    DWARFLocationEntry E;
 
     // 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) {
-      *Offset = C.tell();
-      return LL;
-    }
-
-    if (E.Begin != (AddressSize == 4 ? -1U : -1ULL)) {
+    // ending address offset. A beginning offset of 0xff...f marks the base
+    // address selection entry.
+    if (Value0 == 0 && Value1 == 0) {
+      E.Kind = dwarf::DW_LLE_end_of_list;
+    } else if (Value0 == (Data.getAddressSize() == 4 ? -1U : -1ULL)) {
+      E.Kind = dwarf::DW_LLE_base_address;
+      E.Value0 = Value1;
+    } else {
+      E.Kind = dwarf::DW_LLE_offset_pair;
+      E.Value0 = Value0;
+      E.Value1 = Value1;
       unsigned Bytes = Data.getU16(C);
       // A single location description describing the location of the object...
       Data.getU8(C, E.Loc, Bytes);
     }
 
-    LL.Entries.push_back(std::move(E));
+    if (!C)
+      return C.takeError();
+    if (!Callback(E) || E.Kind == dwarf::DW_LLE_end_of_list)
+      break;
   }
+  *Offset = C.tell();
+  return Error::success();
 }
 
-void DWARFDebugLoc::parse(const DWARFDataExtractor &data) {
-  IsLittleEndian = data.isLittleEndian();
-  AddressSize = data.getAddressSize();
+Expected<DWARFDebugLoc::LocationList>
+DWARFDebugLoc::parseOneLocationList(uint64_t *Offset) {
+  LocationList LL;
+  LL.Offset = *Offset;
+
+  Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
+    LL.Entries.push_back(E);
+    return true;
+  });
+  if (E)
+    return std::move(E);
+  return std::move(LL);
+}
 
+void DWARFDebugLoc::parse() {
   uint64_t Offset = 0;
-  while (Offset < data.getData().size()) {
-    if (auto LL = parseOneLocationList(data, &Offset))
+  while (Offset < Data.getData().size()) {
+    if (auto LL = parseOneLocationList(&Offset))
       Locations.push_back(std::move(*LL));
     else {
       logAllUnhandledErrors(LL.takeError(), WithColor::error());
       break;
     }
   }
 }
 
+void DWARFDebugLoc::dumpRawEntry(const DWARFLocationEntry &Entry,
+                                 raw_ostream &OS, unsigned Indent) const {
+  uint64_t Value0, Value1;
+  switch (Entry.Kind) {
+  case dwarf::DW_LLE_base_address:
+    Value0 = Data.getAddressSize() == 4 ? -1U : -1ULL;
+    Value1 = Entry.Value0;
+    break;
+  case dwarf::DW_LLE_offset_pair:
+    Value0 = Entry.Value0;
+    Value1 = Entry.Value1;
+    break;
+  case dwarf::DW_LLE_end_of_list:
+    Value0 = Value1 = 0;
+    return;
+  default:
+    llvm_unreachable("Not possible in DWARF4!");
+  }
+  OS << '\n';
+  OS.indent(Indent);
+  OS << '(' << format_hex(Value0, 2 + Data.getAddressSize() * 2) << ", "
+     << format_hex(Value1, 2 + Data.getAddressSize() * 2) << ')';
+}
+
 Error DWARFDebugLoclists::visitLocationList(
     uint64_t *Offset, function_ref<bool(const DWARFLocationEntry &)> F) const {
 
   DataExtractor::Cursor C(*Offset);
   bool Continue = true;
   while (Continue) {
     DWARFLocationEntry E;
     E.Kind = Data.getU8(C);

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

for (const DWARFAddressRange &R : Ranges) {
     DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, R.SectionIndex);
   }
 }
 
 static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
                          DWARFUnit *U, unsigned Indent,
                          DIDumpOptions DumpOpts) {
   DWARFContext &Ctx = U->getContext();
-  const DWARFObject &Obj = Ctx.getDWARFObj();
   const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
   if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
       FormValue.isFormClass(DWARFFormValue::FC_Exprloc)) {
     ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();
     DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
                        Ctx.isLittleEndian(), 0);
     DWARFExpression(Data, U->getVersion(), U->getAddressByteSize())
         .print(OS, MRI, U);
     return;
   }
 
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     auto LLDumpOpts = DumpOpts;
     LLDumpOpts.Verbose = false;
 
     uint64_t Offset = *FormValue.getAsSectionOffset();
 
-    if (const DWARFLocationTable *LT = U->getLocationTable()) {
-      LT->dumpLocationList(&Offset, OS, U->getBaseAddress(), MRI, U, LLDumpOpts,
-                           Indent);
-      return;
-    }
-
-    DWARFDebugLoc DebugLoc;
-    DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
-                            Obj.getAddressSize());
-
-    FormValue.dump(OS, DumpOpts);
-    OS << ": ";
-
-    if (Expected<DWARFDebugLoc::LocationList> LL =
-            DebugLoc.parseOneLocationList(Data, &Offset)) {
-      uint64_t BaseAddr = 0;
-      if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
-        BaseAddr = BA->Address;
-      LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, U,
-               LLDumpOpts, Indent);
-    } else {
-      OS << '\n';
-      OS.indent(Indent);
-      OS << formatv("error extracting location list: {0}",
-                    fmt_consume(LL.takeError()));
-    }
+    U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(),
+                                           MRI, U, LLDumpOpts, Indent);
     return;
   }
 
   FormValue.dump(OS, DumpOpts);
 }
 
 /// Dump the name encoded in the type tag.
 static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

 
 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      const DWARFUnitHeader &Header, const DWARFDebugAbbrev *DA,
                      const DWARFSection *RS, const DWARFSection *LocSection,
                      StringRef SS, const DWARFSection &SOS,
                      const DWARFSection *AOS, const DWARFSection &LS, bool LE,
                      bool IsDWO, const DWARFUnitVector &UnitVector)
     : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA),
-      RangeSection(RS), LocSection(LocSection), LineSection(LS),
-      StringSection(SS), StringOffsetSection(SOS), AddrOffsetSection(AOS),
-      isLittleEndian(LE), IsDWO(IsDWO), UnitVector(UnitVector) {
+      RangeSection(RS), LineSection(LS), StringSection(SS),
+      StringOffsetSection(SOS), AddrOffsetSection(AOS), isLittleEndian(LE),
+      IsDWO(IsDWO), UnitVector(UnitVector) {
   clear();
   if (IsDWO) {
     // If we are reading a package file, we need to adjust the location list
     // data based on the index entries.
     StringRef Data = LocSection->Data;
     if (auto *IndexEntry = Header.getIndexEntry())
       if (const auto *C = IndexEntry->getOffset(DW_SECT_LOC))
         Data = Data.substr(C->Offset, C->Length);
     LocTable = std::make_unique<DWARFDebugLoclists>(
         DWARFDataExtractor(Data, isLittleEndian, getAddressByteSize()),
         Header.getVersion());
   } else if (Header.getVersion() >= 5) {
     LocTable = std::make_unique<DWARFDebugLoclists>(
         DWARFDataExtractor(Context.getDWARFObj(),
                            Context.getDWARFObj().getLoclistsSection(),
                            isLittleEndian, getAddressByteSize()),
         Header.getVersion());
+  } else {
+    LocTable = std::make_unique<DWARFDebugLoc>(
+        DWARFDataExtractor(Context.getDWARFObj(), *LocSection, isLittleEndian,
+                           getAddressByteSize()));
   }
 }
 
 DWARFUnit::~DWARFUnit() = default;
 
 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
   return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
                             getAddressByteSize());

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) {
     // Inlined location.
     if (ContainsInterestingOperators(*Expr))
       return true;
   } else if (Optional<uint64_t> Offset = Location->getAsSectionOffset()) {
     // Location list.
     if (const DWARFDebugLoc *DebugLoc = DCtx.getDebugLoc()) {
       if (const DWARFDebugLoc::LocationList *LocList =
               DebugLoc->getLocationListAtOffset(*Offset)) {
-        if (any_of(LocList->Entries, [&](const DWARFDebugLoc::Entry &E) {
+        if (any_of(LocList->Entries, [&](const DWARFLocationEntry &E) {
               return ContainsInterestingOperators(E.Loc);
             }))
           return true;
       }
     }
   }
   return false;
 }

llvm/test/CodeGen/ARM/debug-info-sreg2.ll

 ; RUN: llc < %s - -filetype=obj | llvm-dwarfdump -debug-loc - | FileCheck %s
 ; Radar 9376013
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
 target triple = "thumbv7-apple-macosx10.6.7"
 
 ; Just making sure the first part of the location isn't a repetition
 ; of the size of the location description.
 
 ; CHECK: 0x00000000:
-; CHECK-NEXT:        [0x{{[0-9]*[a-f]*}}, 0x{{[0-9]*[a-f]*}}): DW_OP_regx D8
+; CHECK-NEXT:        (0x{{[0-9]*[a-f]*}}, 0x{{[0-9]*[a-f]*}}): DW_OP_regx D8
 
 define void @_Z3foov() optsize ssp !dbg !1 {
 entry:
   %call = tail call float @_Z3barv() optsize, !dbg !11
   tail call void @llvm.dbg.value(metadata float %call, metadata !5, metadata !DIExpression()), !dbg !11
   %call16 = tail call float @_Z2f2v() optsize, !dbg !12
   %cmp7 = fcmp olt float %call, %call16, !dbg !12
   br i1 %cmp7, label %for.body, label %for.end, !dbg !12

llvm/test/DebugInfo/Sparc/subreg.ll

 ; RUN: llc -filetype=obj -O0 < %s -mtriple sparc64-unknown-linux-gnu | llvm-dwarfdump - --debug-loc | FileCheck %s
 ; The undescribable 128-bit register should be split into two 64-bit registers.
-; CHECK: [{{.*}}, {{.*}}): DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8
+; CHECK: ({{.*}}, {{.*}}): DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8
 
 target datalayout = "E-m:e-i64:64-n32:64-S128"
 target triple = "sparc64"
 
 ; Function Attrs: nounwind readnone
 define void @fn1(fp128 %b) local_unnamed_addr !dbg !7 {
 entry:
   tail call void @llvm.dbg.value(metadata fp128 %b, i64 0, metadata !13, metadata !18), !dbg !17

llvm/test/DebugInfo/X86/PR26148.ll

 ; int main() { return 0; }
 ;
 ; This is similar to the bug in test/DebugInfo/ARM/PR26163.ll, except that there is an
 ; extra non-overlapping range first. Thus, we make sure that the backend actually looks
 ; at all expressions when determining whether to merge ranges, not just the first one.
 ; AS in 26163, we only expect one range as the first one is zero sized.
 ;
 ;
-; CHECK: [0x0000000000000000, 0x000000000000000f): DW_OP_lit3, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_piece 0x4
+; CHECK: (0x0000000000000000, 0x000000000000000f): DW_OP_lit3, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_piece 0x4
 
 source_filename = "test/DebugInfo/X86/PR26148.ll"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 %struct.S0 = type { i16, i32 }
 
 @a = common global %struct.S0 zeroinitializer, align 4, !dbg !0

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

 # CHECK-NOT: DW_TAG
 # CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
 # CHECK-NEXT:    [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
 # CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value)
 # CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"b"
 #
 # CHECK: .debug_loc contents:
 # CHECK:       0x00000000:
-# CHECK-NEXT:    [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
-# CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value
+# CHECK-NEXT:    (0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
+# CHECK-NEXT:    (0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value
 # CHECK:       0x00000022:
-# CHECK-NEXT:    [0x00000009, 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:    (0x00000009, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
+# CHECK-NEXT:    (0x00000017, 0x00000043): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 --- |
   target triple = "i386-unknown-linux-gnu"
   
   %struct.A = type { i32 (...)**, i32 }
   
   ; Function Attrs: nounwind
   define i32 @_Z3bari(i32 %b) #0 !dbg !10 {
   entry:

llvm/test/DebugInfo/X86/dw_op_minus_direct.ll

 
 ; DWARF2: .debug_info
 ; DWARF2: DW_TAG_formal_parameter
 ; DWARF2-NEXT: DW_AT_name {{.*}}"i"
 ; DWARF2-NOT:      DW_AT_location
 
 ; CHECK: .debug_loc contents:
 ; CHECK: 0x00000000:
-; CHECK-NEXT:   [0x0000000000000003, 0x0000000000000004): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_lit1, DW_OP_minus, DW_OP_stack_value
+; CHECK-NEXT:   (0x0000000000000003, 0x0000000000000004): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_lit1, DW_OP_minus, DW_OP_stack_value
 ;        rax+0, constu 0xffffffff, and, constu 0x00000001, minus, stack-value
 
 source_filename = "minus.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 define i32 @inc(i32 %i) local_unnamed_addr #1 !dbg !7 {
 entry:

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-error-cases.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux --defsym CASE6=0 -o %t6.o
 # RUN: llvm-dwarfdump -debug-loc %t6.o 2>&1 | FileCheck %s
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux --defsym CASE7=0 -o %t7.o
 # RUN: llvm-dwarfdump -debug-loc %t7.o 2>&1 | FileCheck %s --check-prefix=UNKNOWN-REG
 
 # CHECK: error: unexpected end of data
 
-# UNKNOWN-REG: [0x0000000000000000,  0x0000000000000001): DW_OP_regx 0xdeadbeef
+# UNKNOWN-REG: (0x0000000000000000,  0x0000000000000001): DW_OP_regx 0xdeadbeef
 
 .section  .debug_loc,"",@progbits
 .ifdef CASE1
   .byte  1                       # bogus
 .endif
 .ifdef CASE2
   .quad  0                       # starting offset
 .endif

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-error-cases2.s

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: llvm-dwarfdump %t | FileCheck %s
 
 # CHECK:      DW_AT_name        ("x0")
 # CHECK-NEXT: DW_AT_location    (0x00000000
 # CHECK-NEXT:    [0x0000000000000000,  0x0000000000000002): DW_OP_reg5 RDI
 # CHECK-NEXT:    [0x0000000000000002,  0x0000000000000003): DW_OP_reg0 RAX)
 
 # CHECK:      DW_AT_name        ("x1")
 # CHECK-NEXT: DW_AT_location    (0xdeadbeef
-# CHECK-NEXT:    error extracting location list: unexpected end of data)
+# CHECK-NEXT:    error: unexpected end of data)
 
 # CHECK:      DW_AT_name        ("x2")
 # CHECK-NEXT: DW_AT_location    (0x00000036
-# CHECK-NEXT:    error extracting location list: unexpected end of data)
+# CHECK-NEXT:    error: unexpected end of data)
 
 
         .type   f,@function
 f:                                      # @f
 .Lfunc_begin0:
         movl    %edi, %eax
 .Ltmp0:
         retq
.Ldebug_loc2:
         .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   14                      # DW_FORM_strp
         .byte   19                      # DW_AT_language
         .byte   5                       # DW_FORM_data2
+        .byte   17                      # DW_AT_low_pc
+        .byte   1                       # DW_FORM_addr
+        .byte   18                      # DW_AT_high_pc
+        .byte   6                       # DW_FORM_data4
         .byte   0                       # EOM(1)
         .byte   0                       # EOM(2)
         .byte   2                       # Abbreviation Code
         .byte   46                      # DW_TAG_subprogram
         .byte   1                       # DW_CHILDREN_yes
         .byte   3                       # DW_AT_name
         .byte   14                      # DW_FORM_strp
         .byte   0                       # EOM(1)
.Lcu_begin0:
         .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
 .Ldebug_info_start0:
         .short  4                       # DWARF version number
         .long   .debug_abbrev           # Offset Into Abbrev. Section
         .byte   8                       # Address Size (in bytes)
         .byte   1                       # Abbrev [1] 0xb:0x50 DW_TAG_compile_unit
         .long   .Linfo_string0          # DW_AT_producer
         .short  12                      # DW_AT_language
+        .quad   0                       # DW_AT_low_pc
+        .long   0x100                   # DW_AT_high_pc
         .byte   2                       # Abbrev [2] 0x2a:0x29 DW_TAG_subprogram
         .long   .Linfo_string3          # DW_AT_name
         .byte   3                       # Abbrev [3] DW_TAG_formal_parameter
         .long   .Lx0                    # DW_AT_name
         .long   .Ldebug_loc0            # DW_AT_location
         .byte   3                       # Abbrev [3] DW_TAG_formal_parameter
         .long   .Lx1                    # DW_AT_name
         .long   0xdeadbeef              # DW_AT_location
         .byte   3                       # Abbrev [3] DW_TAG_formal_parameter
         .long   .Lx2                    # DW_AT_name
         .long   .Ldebug_loc2            # DW_AT_location
         .byte   0                       # End Of Children Mark
         .byte   0                       # End Of Children Mark
 .Ldebug_info_end0:

llvm/test/DebugInfo/X86/dwarfdump-debug-loc-simple.test

 CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9a-f]*]]
 CHECK-NEXT:    [0x00000000, 0x00000020): DW_OP_reg0 EAX
 CHECK-NEXT:    [0x00000020, 0x0000005d): DW_OP_breg5 EBP-12)
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: [[F_LOC]]:
 this is actually the wrong location due to PR14763, but that doesn't matter for
 the purposes of testing dwarfdump
-CHECK-NEXT:             [0x00000000, 0x00000023): DW_OP_reg1 ECX
-CHECK-NEXT:             [0x00000023, 0x0000005d): DW_OP_breg5 EBP-16
+CHECK-NEXT:             (0x00000000, 0x00000023): DW_OP_reg1 ECX
+CHECK-NEXT:             (0x00000023, 0x0000005d): DW_OP_breg5 EBP-16
 CHECK: [[G_LOC]]:
-CHECK-NEXT:             [0x00000000, 0x00000020): DW_OP_reg0 EAX
-CHECK-NEXT:             [0x00000020, 0x0000005d): DW_OP_breg5 EBP-12
+CHECK-NEXT:             (0x00000000, 0x00000020): DW_OP_reg0 EAX
+CHECK-NEXT:             (0x00000020, 0x0000005d): DW_OP_breg5 EBP-12

llvm/test/DebugInfo/X86/live-debug-variables.ll

 ;          F(a,b,c,d,e) +
 ;          F(a,b,c,d,e) +
 ;          F(a,b,c,d,e);
 ; }
 
 ; CHECK:      .debug_loc contents:
 ; CHECK-NEXT: 0x00000000:
 ;   We currently emit an entry for the function prologue, too, which could be optimized away.
-; CHECK:              [0x0000000000000010, 0x0000000000000072): DW_OP_reg3 RBX
+; CHECK:              (0x0000000000000010, 0x0000000000000072): DW_OP_reg3 RBX
 ;   We should only have one entry inside the function.
 ; CHECK-NOT: :
 
 declare i32 @foobar(i32, i32, i32, i32, i32)
 
 define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) !dbg !25 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !41

llvm/test/DebugInfo/X86/pieces-1.ll

 ;    int foo(S s) {
 ;            return s.b;
 ;    }
 ;
 ;
 ; CHECK: .debug_loc contents:
 ;
 
-; CHECK: [0x0000000000000000, 0x[[LTMP3:.*]]): DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_OP_piece 0x4
+; CHECK: (0x0000000000000000, 0x[[LTMP3:.*]]): DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_OP_piece 0x4
 ; 0x0000000000000006 - 0x0000000000000008: rbp-8, piece 0x8, rax, piece 0x4 )
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @foo(i64 %s.coerce0, i32 %s.coerce1) #0 !dbg !4 {
 entry:

llvm/test/DebugInfo/X86/sret.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v -all %t | FileCheck %s --check-prefix=CHECK-DWO
 
 ; Based on the debuginfo-tests/sret.cpp code.
 
 ; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
 ; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
 
 ; RUN: llc -O0 -fast-isel=true -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; RUN: llc -O0 -fast-isel=false -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; CHECK: _ZN1B9AInstanceEv
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (0x00000000
-; CHECK-NEXT:     [0xffffffffffffffff, {{.*}}): {{$}}
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg5 RDI+0
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg6 RBP-24, DW_OP_deref)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"a"
 
 %class.A = type { i32 (...)**, i32 }
 %class.B = type { i8 }
 
 @_ZTV1A = linkonce_odr unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD0Ev to i8*)]

llvm/test/DebugInfo/X86/stack-value-piece.ll

-; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump -debug-info -debug-loc - | FileCheck %s
 ; Test that DW_OP_piece is emitted for constants.
 ;
 ; // Generated from:
 ; typedef struct { int a, b; } I;
 ; I i(int i) {
 ;   I r = {i, 0};
 ;   return r;
 ; }
 ;
 ; typedef struct { float a, b; } F;
 ; F f(float f) {
 ;   F r = {f, 0};
 ;   return r;
 ; }
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_name {{.*}} "i"
+; CHECK:   DW_AT_name ("i")
 ; CHECK:   DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location {{.*}} ([[I:0x[0-9a-f]+]]
+; CHECK-NEXT:   DW_AT_location ([[I:0x[0-9a-f]+]]
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
-; CHECK-NEXT:   DW_AT_name {{.*}} "r"
+; CHECK-NEXT:   DW_AT_name ("r")
 ;
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_name {{.*}} "f"
+; CHECK:   DW_AT_name ("f")
 ; CHECK:   DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location {{.*}} ([[F:0x[0-9a-f]+]]
+; CHECK-NEXT:   DW_AT_location ([[F:0x[0-9a-f]+]]
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 ; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
-; CHECK-NEXT:   DW_AT_name {{.*}} "r"
+; CHECK-NEXT:   DW_AT_name ("r")
 ;
 ; CHECK: .debug_loc contents:
 ; CHECK:      [[I]]:
-; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
+; CHECK-NEXT:   ({{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 ; CHECK:      [[F]]:
-; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
+; CHECK-NEXT:   ({{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 
 source_filename = "stack-value-piece.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 %struct.I = type { i32, i32 }
 %struct.F = type { float, float }
 

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

 CHECK:           [0x0000000100000f9f, 0x0000000100000fa7))
 
 CHECK:      NULL
 CHECK:    NULL
 
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x00000000:
-CHECK-NEXT:              [0x0000000000000000, 0x000000000000000c): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000000, 0x000000000000000c): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
-CHECK-NEXT:              [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK-NEXT:              [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 
 CHECK: .debug_aranges contents:
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f40,  0x0000000100000f4b)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000077, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f87)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00

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

 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:    NULL
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x00000000:
-CHECK-NEXT:              [0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
-CHECK-NEXT:              [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK-NEXT:              [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              (0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 CHECK: .debug_aranges contents:
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f40, 0x0000000100000f4b)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f89)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 

llvm/test/tools/dsymutil/X86/debug-loc-base-addr.test

 }
 __attribute__((nodebug)) void f2() {
 }
 int main() {
   return 0;
 }
 
 CHECK: .debug_loc contents:
-CHECK: [0xffffffffffffffff,  0x0000000100000f90):
-CHECK: [0x0000000000000004,  0x0000000000000007): DW_OP_consts +3, DW_OP_stack_value
-CHECK: [0x0000000000000007,  0x0000000000000009): DW_OP_consts +4, DW_OP_stack_value
+CHECK: [0x0000000100000f94,  0x0000000100000f97): DW_OP_consts +3, DW_OP_stack_value
+CHECK: [0x0000000100000f97,  0x0000000100000f99): DW_OP_consts +4, DW_OP_stack_value
 
-CHECK: [0xffffffffffffffff,  0x0000000100000f90):
-CHECK: [0x0000000000000004,  0x0000000000000007): DW_OP_consts +5, DW_OP_stack_value
+CHECK: [0x0000000100000f94,  0x0000000100000f97): DW_OP_consts +5, DW_OP_stack_value
 
-CHECK: [0xffffffffffffffff,  0x0000000100000f90):
-CHECK: [0x0000000000000007,  0x0000000000000009): DW_OP_reg0 RAX
+CHECK: [0x0000000100000f97,  0x0000000100000f99): DW_OP_reg0 RAX

llvm/test/tools/llvm-dwarfdump/X86/debug_loc-OP_addr.s

 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
 #
 # CHECK: DW_TAG_variable
 # CHECK-NEXT: DW_AT_name ("a")
 # CHECK-NEXT: DW_AT_location
-# CHECK-NEXT: [0x0000000000000000,  0x0000000000000001): DW_OP_addr 0xdeadbeefbaadf00d
+# CHECK-NEXT: (0x0000000000000000,  0x0000000000000001): DW_OP_addr 0xdeadbeefbaadf00d
 
   .section  .debug_str,"MS",@progbits,1
 .Linfo_producer:
   .asciz  "hand-written DWARF"
 .Lname_a:
   .asciz  "a"
 
   .section  .debug_loc,"",@progbits

llvm/test/tools/llvm-dwarfdump/X86/debug_loc_base_address.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
-# RUN: llvm-dwarfdump --debug-loc %t.o | FileCheck %s
+# RUN: llvm-dwarfdump --debug-loc -v %t.o | FileCheck %s
 
 # CHECK:         .debug_loc contents:
 # CHECK-NEXT:    0x00000000:
-# CHECK-NEXT:    [0xffffffffffffffff, 0x000000000000002a):
-# CHECK-NEXT:    [0x0000000000000003, 0x0000000000000007): DW_OP_consts +3, DW_OP_stack_value
+# CHECK-NEXT:    (0xffffffffffffffff, 0x000000000000002a)
+# CHECK-NEXT:    (0x0000000000000003, 0x0000000000000007)
+# CHECK-NEXT:        => [0x000000000000002d, 0x0000000000000031): DW_OP_consts +3, DW_OP_stack_value
 
   .section  .debug_loc,"",@progbits
   .quad 0xffffffffffffffff
   .quad 42
   .quad 3
   .quad 7
   .short  3                       # Loc expr size
   .byte 17                      # DW_OP_consts

llvm/test/tools/llvm-dwarfdump/X86/debug_loc_offset.test

 RUN: llvm-mc %S/debugloc.s -filetype obj -triple x86_64-linux-elf -o - \
 RUN: | llvm-dwarfdump --debug-loc=0 - \
 RUN: | FileCheck %s --check-prefix=CHECK-A
 
 # CHECK-A: .debug_loc contents:
 # CHECK-A: 0x00000000:
-# CHECK-A-NEXT: [0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
-# CHECK-A-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
+# CHECK-A-NEXT: (0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
+# CHECK-A-NEXT: (0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
 
 RUN: llvm-mc %S/debugloc.s -filetype obj -triple x86_64-linux-elf -o - \
 RUN: | llvm-dwarfdump --debug-loc=0x36 - \
 RUN: | FileCheck %s --check-prefix=CHECK-B
 
 # CHECK-B: .debug_loc contents:
 # CHECK-B: 0x00000036:
-# CHECK-B-NEXT: [0x0000000000000010, 0x0000000000000013): DW_OP_reg5 RDI
-# CHECK-B-NEXT: [0x0000000000000013, 0x0000000000000014): DW_OP_reg0 RAX
+# CHECK-B-NEXT: (0x0000000000000010, 0x0000000000000013): DW_OP_reg5 RDI
+# CHECK-B-NEXT: (0x0000000000000013, 0x0000000000000014): DW_OP_reg0 RAX

llvm/test/tools/llvm-dwarfdump/X86/debugloc.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-linux-elf -o - \
 # RUN: | llvm-dwarfdump --debug-loc - \
 # RUN: | FileCheck %s
 
 # RUN: llvm-mc %s -filetype obj -triple x86_64-linux-elf -o - \
 # RUN: | llvm-dwarfdump --verify - \
 # RUN: | FileCheck %s --check-prefix VERIFY
 
 # CHECK: .debug_loc contents:
 
 # CHECK: 0x00000000:
-# CHECK-NEXT: [0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
-# CHECK-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
+# CHECK-NEXT: (0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
+# CHECK-NEXT: (0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
 
 # CHECK: 0x00000036:
-# CHECK-NEXT: [0x0000000000000010, 0x0000000000000013): DW_OP_reg5 RDI
-# CHECK-NEXT: [0x0000000000000013, 0x0000000000000014): DW_OP_reg0 RAX
+# CHECK-NEXT: (0x0000000000000010, 0x0000000000000013): DW_OP_reg5 RDI
+# CHECK-NEXT: (0x0000000000000013, 0x0000000000000014): DW_OP_reg0 RAX
 
 # VERIFY: Verifying .debug_info Unit Header Chain
 # VERIFY-NOT: DIE has invalid DW_AT_location encoding
 
 # Source:
 #   int* foo(int* i) { return i; }
 #   int* bar(int* i) { return i; }
 # Compile with:

llvm/tools/llvm-dwarfdump/Statistics.cpp

if (Die.find(dwarf::DW_AT_const_value)) {
     }
     // Handle variables and function arguments.
     auto FormValue = Die.find(dwarf::DW_AT_location);
     HasLoc = FormValue.hasValue();
     if (HasLoc) {
       // Get PC coverage.
       if (auto DebugLocOffset = FormValue->getAsSectionOffset()) {
         auto *DebugLoc = Die.getDwarfUnit()->getContext().getDebugLoc();
+        // TODO: This code does not handle DWARF5 nor DWARF4 base address
+        // selection entries. This should use a higher-level API which abstracts
+        // these away.
         if (auto List = DebugLoc->getLocationListAtOffset(*DebugLocOffset)) {
-          for (auto Entry : List->Entries) {
-            uint64_t BytesEntryCovered = Entry.End - Entry.Begin;
+          ArrayRef<DWARFLocationEntry> Entries = List->Entries;
+          // Ignore end-of-list entries
+          Entries = Entries.drop_back();
+
+          for (auto Entry : Entries) {
+            uint64_t BytesEntryCovered = Entry.Value1 - Entry.Value0;
             BytesCovered += BytesEntryCovered;
             if (IsEntryValue(Entry.Loc))
               BytesEntryValuesCovered += BytesEntryCovered;
           }
-          if (List->Entries.size()) {
-            uint64_t FirstDef = List->Entries[0].Begin;
+          if (Entries.size()) {
+            uint64_t FirstDef = Entries[0].Value0;
             uint64_t UnitOfs = UnitLowPC; 
             // Ranges sometimes start before the lexical scope.
             if (UnitOfs + FirstDef >= ScopeLowPC)
               OffsetToFirstDefinition = UnitOfs + FirstDef - ScopeLowPC;
             // Or even after it. Count that as a failure.
             if (OffsetToFirstDefinition > BytesInScope)
               OffsetToFirstDefinition = 0;
           }