[dwarfdump] Pretty print location expressions and location lists

[aprantl]

Summary

With that change the locations exrpessions are pretty printed inline in the
DIE tree. The output looks like this for debug_loc entries:

DW_AT_location [DW_FORM_data4]        (0x00000000
   0x0000000000000001 - 0x000000000000000b: OP_consts +3
   0x000000000000000b - 0x0000000000000012: OP_consts +7
   0x0000000000000012 - 0x000000000000001b: OP_reg0 RAX, OP_piece 0x00000004
   0x000000000000001b - 0x0000000000000024: OP_breg5 RDI+0)

And like this for debug_loc.dwo entries:

DW_AT_location [DW_FORM_sec_offset]   (0x00000000
  Addr idx 2 (w/ length 190): OP_consts +0, OP_stack_value
  Addr idx 3 (w/ length 23): OP_reg0 RAX, OP_piece 0x00000004)

Simple locations wihtout ranges are sumped inlie to:

DW_AT_location [DW_FORM_block1]       (OP_reg4 RSI, OP_piece 0x00000004, OP_bit_piece 0x00000020 0x00000000)

The debug_loc(.dwo) dumping in changed accordingly to factor the code.

I've been sitting on this for much too long, and I'm not totally satisfied
with the code. For example, the detection of wether to use DWO or standard
lcoations in DebugInfoEntryMinimal doesn't look right. Ideas welcome (one
idea would be to have virtual DebugLoc objects and to store that in the
DWARFUnitSection, but it feels slightly over-engineered for the purpose).
The patch also isn't ready to apply as-is. It requires a few preliminary
patches like landing D6243 and adding a MCRegisterInfo in the DWARFContext,
but I've left that out here in favor of the dumping related changes.

Happy Christmas!

[dblaikie]

This'd be nice to have, certainly - but the patch is a bit too big for me to swap in right now. If you're inclined to press on with this, it might be easier to review in smaller pieces (perhaps by skipping the DWO case initially? not sure - maybe there's other ways to break it down)

[friss]

I could commit the DWARFDebugLoc refactoring (without the pretty printing) separately, but this is about all that can be split out. This patch really has 4 parts that are reviewable separately (but that don't really make sense as separate):

• The refactoring in DWARFDebugLoc.{cpp/h}: This I could commit separately leaving the new pretty-printing out.
• The new DWARFExpression.cpp/h}: The bulk of the patch logic. Pretty self contained it interacts with the outside world through just 1 function. Can be reviewed separately.
• The integration into the DIE/DebugLoc dumpers.
• The tests updates.

Leaving out the DWO case would spare maybe 10 lines, I don't think this will really make it more digestible for you...

[dblaikie]

lib/DebugInfo/DWARFContext.h

134 ↗

(On Diff #17601)

Where does this case come up? It looks like the calls to getCompileUnitAtIndex are protected by a getNumCompileUnits check first, no?

lib/DebugInfo/DWARFDebugLoc.cpp

143–146

This would leave an extra element in the Locations container, wouldn't it? (Could be avoided with the return-by-value I was suggesting:

if (Optional<LocationList> o = parseOneLocationList(...))
  Locations.push_back(std::move(*o));
else
  return;

or similar)

151

leading newline seems a surprising contract - but maybe that's convention here, I haven't looked.

lib/DebugInfo/DWARFDebugLoc.h

63 ↗

(On Diff #17601)

Would it make sense for this to return the LocationList, rather than use an out parameter?

90 ↗

(On Diff #17601)

Possibly return Optional<LocationList> here

lib/DebugInfo/DWARFExpression.cpp

69

Not sure if this needs a class, rather than just a global const vector, and a function to construct and return it for initialization.

243

If this is meant to be resilient to failure/corrupted files, you'd probably need this not to be an assertion. (again, not sure - but I assume if you guys want to ship this it should be pretty robust & corrupt files shouldn't just assert fail/UB (& should be tested))

244

If we're going to skip the DW_ prefix here, should we skip it elsewhere (tags, attributes, and forms)?

256

Breaking out this switch into a function might help readability

301

Favor llvm_unreachable over assert(0)

test/DebugInfo/X86/dbg-value-const-byref.ll

25

The prior version of this test didn't hardcode the address offsets - it'd be good to preserve that to make the test resilient to minor changes (like instruction selection, etc).

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

50

Not sure I understand the comment

[friss]

Thanks for taking the time to go though this! I'll respin within a couple of days. Some comments inline:

lib/DebugInfo/DWARFContext.h

134 ↗

(On Diff #17601)

Hmmm. I remember asking me the same question when I skimmed over the patch before I sent it out so I must left it intentionally... though I can;t find a good reason right now. Maybe I added the guards afterwards, dunno.

lib/DebugInfo/DWARFDebugLoc.cpp

143–146

There would be no extra element in standard cases. But yes, if parseOneLocation errors out, you'd get an incomplete location in the list. (The normal exit of the loop should always be handled by the isValidOffset() condition).

151

I agree. Only motivation is: putting the newline at the end requires a conditional, because we don't want the last line to have a newline.

lib/DebugInfo/DWARFExpression.cpp

243

This one is one purpose. If we reach that point if the code, it means the Op has a description in the table, so it really should have a name in the support routine. No user input should be able to break that.

244

I did it here and not at the other spots, because the DW_OPs might be multiple on a line. I have no strong feeling about stripping the other spots too.

[dblaikie]

lib/DebugInfo/DWARFContext.h

134 ↗

(On Diff #17601)

Fair enough - maybe just switch to an assert for now, then.

lib/DebugInfo/DWARFDebugLoc.cpp

143–146

Ah, fair - well, either way then, depending on how pedantic about bad inputs you want to be. (in some ways having the weird extra empty element might at least tell a user there's something weird, compared to silently skipping it)

151

Ah, fair enough

lib/DebugInfo/DWARFExpression.cpp

243

Makes sense.

Oh, btw - should we just put a pointer to the name in the ExpressionOps table?

[friss]

I reworked it a bit more than just addressing the review comments. Instead of just
offering a pretty-printing function, expose a real class that allows clients to
walk over the expression operations using an iterator interface. The iterator is
a bit strange because of its lazy extraction semantics and the error handling that
goes with it, but I think it looks quite usable. The pretty-printing is then
implemented over that iterator interface.

[friss]

Try to teach arcanist to leave the straightforward preparation patches out of the review...

[dblaikie]

include/llvm/DebugInfo/DWARFDebugLoc.h

80

12?

include/llvm/DebugInfo/DWARFExpression.h

109

operator overloads that can be non-members generally should be (to allow symmetric conversions on LHS and RHS) - could define it inline as a friend if that's useful.

lib/DebugInfo/DWARFDebugLoc.cpp

34

what's the boolean? ('false')

(could use a comment, maybe, or an enum, etc)

test/CodeGen/X86/2011-01-24-DbgValue-Before-Use.ll

12

Maybe CHECK-NOT: DW_{{TAG|AT}} ? I assume this was here so we didn't skip any extra attributes on this TAG.

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

50

Not sure I follow why the low_pc offset would be problematic - it'll always be zero in a single-CU file, right?

[friss]

Thanks. I'm testing an update addressing your feedback. Some comments bellow:

include/llvm/DebugInfo/DWARFExpression.h

109

Yeah, but the iterator_facade that I'm using requires a member function to deriver != from ==. I added a couple of non-members operators that forward to the member ones.

lib/DebugInfo/DWARFDebugLoc.cpp

34

It decides wether to use the standard or the EH register mapping. We never use the EH mapping for now, but I thought I'd thread it through anyway. I've changed that to a enum with a default value.

test/CodeGen/X86/2011-01-24-DbgValue-Before-Use.ll

12

I changed that to match the old test, although I'm not sure their is any value in checking the ordering of the attributes within a TAG.

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

50

This is the whole point of this test. It's a multi-cu test that verifies that the location entries are stored relatively to the low_pc of the unit. The test is that the location's base address should be 0. When it is displayed inline the offset is applied - which is a good thing - but it's not what we want to test. So I defer the test to the raw dump of the debug_lc section bellow.
The comment shouldn't read 'stored here' though, 'deployed here' would be more accurate.

[friss]

• Rebased on latest master
• Addressed review comments

[dblaikie]

Looks pretty reasonable.

Alexey - want to have a quick glance over it, since the dumping code is more your domain these days?

include/llvm/DebugInfo/DWARF/DWARFExpression.h

134 ↗

(On Diff #19340)

This would need to be defined with the "inline" keyword or it'll create ODR violations/duplicate symbol linker errors, no?

I'd just put the definition inline in the friend declaration:

friend bool op==(X, Y) {
  ...
}

include/llvm/DebugInfo/DWARFExpression.h

100

would be nice to implement ++ the usual way, returning a reference to the object, rather than void (I forget which one is pre or post increment - anyway, whichever way it's meant to work, either a copy of the unincremented value, or a reference to the incremented value)

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

130 ↗

(On Diff #19340)

Could possibly abstract over these two differences using a function template helper?

Or maybe it'd suffice to put the if (LL)/else outside the if conditios so it can be shared (& could add an else to the main if (sec.data.size()) that returns early to make that work? Dunno how that'd look)

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

31 ↗

(On Diff #19340)

Maybe we should decide whether binary data bytes should be signed or unsigned. Either change DataExtractor to deal with ArrayRef<unsigned char> or change DwarfDebugLoc::Entry::Loc to be a SmallVector<char, N> instead.

lib/DebugInfo/DWARF/DWARFExpression.cpp

32 ↗

(On Diff #19340)

This might be more succinctly to define as some kind of array literal?

128 ↗

(On Diff #19340)

Perhaps sink this switch into a separate function to avoid the Operands[Operand] repetition in every case & improve readability a little by splitting things up?

[samsonov]

include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

47 ↗

(On Diff #19340)

Just move private members decl/def to the top of the class.

62 ↗

(On Diff #19340)

Same here - DataExtractor should now the address size.

65 ↗

(On Diff #19340)

I think your DataExtractor should know AddressSize instead.

84 ↗

(On Diff #19340)

Ditto

include/llvm/DebugInfo/DWARF/DWARFExpression.h

10 ↗

(On Diff #19340)

Please fix header guard.

82 ↗

(On Diff #19340)

Do you actually use these methods anywhere?

107 ↗

(On Diff #19340)

Why do you set Op.Error in iterator, but not in Op::Extract?

include/llvm/DebugInfo/DWARFExpression.h

2

This file should be removed in favor of include/llvm/DebugInfo/DWARF/DWARFExpression.h, right?

lib/DebugInfo/DWARF/DWARFContext.cpp

129 ↗

(On Diff #19340)

This is slightly weird - what if there are no compile units, but non-empty .debug_loc_dwo?

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

119 ↗

(On Diff #19340)

extra semicolon

130 ↗

(On Diff #19340)

I actually think it's fine to leave this as is to keep the code straightforward.
We may shorten it, though

if (auto LL = DebugLoc.parseOneLocationList) {
  LL->dump(OS, U, Indent);
} else {
  OS << "error extracting location list.";
}

137 ↗

(On Diff #19340)

do you need to set indent here?

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

64 ↗

(On Diff #19340)

getAddress() ?

91 ↗

(On Diff #19340)

Consider using

E.Loc.resize(Bytes);
if (!Data.getU8(Offset, E.Loc.data(), Bytes)) {
  llvm::errs() << "...."
}

same for parsing U16 above

uint16_t Bytes;
if (!Data.getU16(Offset, &Bytes, 1)) {
  llvm::errs() << "...";
}

101 ↗

(On Diff #19340)

isValidOffsetForAddress

lib/DebugInfo/DWARF/DWARFExpression.cpp

110 ↗

(On Diff #19340)

This is a copy of method from DWARFFormValue.cpp? Probably the code should be shared, so that there's one place to fix when we support DWARF64.

[aprantl]

Fred / David: what is missing for this to land in trunk?
I'm happy to take this over and finish it up if you want to abandon it.

[friss]

Looks like I dropped the ball on this

[aprantl]

Stealing this review from Fred.

[rnk]

There are 72 remaining test failures: https://reviews.llvm.org/P8028

The printing isn't pretty enough yet, IMO, but I spent a few hours rebasing this so I figured I would post the patch for people to try it out.

[rnk]

Of course, I meant to send that to the D37123 review, which has a rebased version of this patch. It has some layering hacks, but builds for me locally. PTAL.

include/llvm/DebugInfo/DWARFDebugLoc.h

 //===-- DWARFDebugLoc.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGLOC_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGLOC_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DWARFRelocMap.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
 
 class raw_ostream;
+class DWARFUnit;
 
 class DWARFDebugLoc {
+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<unsigned char, 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.
     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, const DWARFUnit* Unit, unsigned Indent = 12) const;
   };
 
+private:
   typedef SmallVector<LocationList, 4> LocationLists;
 
   /// A list of all the variables in the debug_loc section, each one describing
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
   /// A map used to resolve binary relocations.
   const RelocAddrMap &RelocMap;
 
 public:
   DWARFDebugLoc(const RelocAddrMap &LocRelocMap) : RelocMap(LocRelocMap) {}
   /// Print the location lists found within the debug_loc section.
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS, const DWARFUnit *Unit) const;
   /// Parse the debug_loc section accessible via the 'data' parameter using the
   /// specified address size to interpret the address ranges.
   void parse(DataExtractor data, unsigned AddressSize);
+
+  Optional<LocationList>
+  parseOneLocationList(DataExtractor Data, unsigned AddressSize, uint32_t *Offset);
 };
 
 class DWARFDebugLocDWO {
+public:
   struct Entry {
     uint64_t Start;
     uint32_t Length;
     SmallVector<unsigned char, 4> Loc;
   };
 
   struct LocationList {
     unsigned Offset;
     SmallVector<Entry, 2> Entries;
+    void dump(raw_ostream &OS, const DWARFUnit *Unit,
+              unsigned Indent = 12) const;
   };
 
+private:
   typedef SmallVector<LocationList, 4> LocationLists;
-
   LocationLists Locations;
 
 public:
   void parse(DataExtractor data);
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS, const DWARFUnit *Unit) const;
+
+  static Optional<LocationList> parseOneLocationList(DataExtractor Data,
+                                                     uint32_t *Offset);
 };
 }
 
 #endif

include/llvm/DebugInfo/DWARFExpression.h

+//===--- DWARFExpression.h - DWARF Expression handling ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_DWARFEXPRESSION_H
+#define LLVM_DEBUGINFO_DWARFEXPRESSION_H
+
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+class DWARFUnit;
+class raw_ostream;
+
+class DWARFExpression {
+public:
+  class iterator;
+
+  class Op {
+  public:
+    /// \brief Size and signedness of expression operations' operands.
+    enum Encoding : uint8_t {
+      Size1 = 0,
+      Size2 = 1,
+      Size4 = 2,
+      Size8 = 3,
+      SizeLEB = 4,
+      SizeAddr = 5,
+      SizeRefAddr = 6,
+      SizeBlock = 7, ///< Preceding operand contains block size
+      SignBit = 0x8,
+      SignedSize1 = SignBit | Size1,
+      SignedSize2 = SignBit | Size2,
+      SignedSize4 = SignBit | Size4,
+      SignedSize8 = SignBit | Size8,
+      SignedSizeLEB = SignBit | SizeLEB,
+      SizeNA = 0xFF ///< Unused operands get this encoding.
+    };
+
+    enum DwarfVersion : uint8_t {
+      DwarfNA, ///< Serves as a marker for unused entries
+      Dwarf2 = 2,
+      Dwarf3,
+      Dwarf4
+    };
+
+    /// \brief Description of the encoding of one expression Op.
+    struct Description {
+      DwarfVersion Version; ///< Dwarf version where the Op was introduced.
+      Encoding Op[2]; ///< Encoding for Op operands, or SizeNA.
+
+      Description(DwarfVersion Version = DwarfNA, Encoding Op1 = SizeNA,
+                  Encoding Op2 = SizeNA)
+          : Version(Version) {
+        Op[0] = Op1;
+        Op[1] = Op2;
+      }
+    };
+
+  private:
+    friend class DWARFExpression::iterator;
+    uint8_t Opcode;
+    Description Desc;
+    bool Error;
+    uint32_t EndOffset;
+    uint64_t Operands[2];
+
+  public:
+    Description &getDescription() { return Desc; }
+    uint8_t getCode() { return Opcode; }
+    uint64_t getRawOperand(unsigned Idx) { return Operands[Idx]; }
+    uint32_t getEndOffset() { return EndOffset; }
+    bool Extract(DataExtractor Data, const DWARFUnit *U, uint32_t Offset);
+    bool isError() { return Error; }
+    bool Print(raw_ostream &OS, const DWARFExpression *U, bool isEH);
+  };
+
+  /// \brief An iterator to go through the expression operations.
+  class iterator
+      : public iterator_facade_base<iterator, std::forward_iterator_tag, Op> {
+    friend class DWARFExpression;
+    DWARFExpression *Expression;
+    uint32_t Offset;
+    Op Op;
+    iterator(DWARFExpression *Expression, uint32_t Offset)
+        : Expression(Expression), Offset(Offset) {
+      Op.Error = Offset >= Expression->Data.getData().size() ||
+        !Op.Extract(Expression->Data, Expression->Unit, Offset);
+    }
+
+  public:
+    void operator++() {
+      Offset = Op.isError() ? Expression->Data.getData().size() : Op.EndOffset;
+      Op.Error = Offset >= Expression->Data.getData().size() ||
+        !Op.Extract(Expression->Data, Expression->Unit, Offset);
+    }
+
+    class Op &operator*() {
+      return Op;
+    }
+
+    bool operator==(const iterator &I) const {
+      return Expression == I.Expression && Offset == I.Offset;
+    }
+  };
+
+  DWARFExpression(DataExtractor Data, const DWARFUnit *Unit)
+      : Data(Data), Unit(Unit) {}
+
+  iterator begin() { return iterator(this, 0); }
+  iterator end() { return iterator(this, Data.getData().size()); }
+  iterator_range<iterator> operations() { return make_range(begin(), end()); }
+
+  void Print(raw_ostream &OS, bool isEH);
+
+private:
+  DataExtractor Data;
+  const DWARFUnit *Unit;
+};
+}
+#endif

lib/DebugInfo/CMakeLists.txt

 add_llvm_library(LLVMDebugInfo
   DIContext.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFAcceleratorTable.cpp
   DWARFCompileUnit.cpp
   DWARFContext.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugAranges.cpp
   DWARFDebugFrame.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugLoc.cpp
   DWARFDebugRangeList.cpp
+  DWARFExpression.cpp
   DWARFFormValue.cpp
   DWARFTypeUnit.cpp
   DWARFUnit.cpp
   SyntaxHighlighting.cpp
   )

lib/DebugInfo/DWARFContext.cpp

if ((DumpType == DIDT_All || DumpType == DIDT_TypesDwo) &&
     OS << "\n.debug_types.dwo contents:\n";
     for (const auto &DWOTUS : dwo_type_unit_sections())
       for (const auto &DWOTU : DWOTUS)
         DWOTU->dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Loc) {
     OS << "\n.debug_loc contents:\n";
-    getDebugLoc()->dump(OS);
+    // The compile unit is wrong, but the same dirty trick is used in
+    // getDebugLoc().
+    if (getNumCompileUnits())
+      getDebugLoc()->dump(OS, getCompileUnitAtIndex(0));
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) {
     OS << "\n.debug_loc.dwo contents:\n";
-    getDebugLocDWO()->dump(OS);
+    // The compile unit is wrong, but the same dirty trick is used in
+    // getDebugLoc().
+    if (getNumCompileUnits())
+      getDebugLocDWO()->dump(OS, getCompileUnitAtIndex(0));
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
   }
 
   uint32_t offset = 0;

lib/DebugInfo/DWARFDebugInfoEntry.cpp

 //===-- DWARFDebugInfoEntry.cpp -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SyntaxHighlighting.h"
 #include "llvm/DebugInfo/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARFContext.h"
 #include "llvm/DebugInfo/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;
for (const auto &Range: Ranges) {
     OS << '\n';
     OS.indent(Indent);
     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
                  AddressSize*2, Range.first,
                  AddressSize*2, Range.second);
   }
 }
 
+static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
+                         DWARFUnit *U, unsigned Indent) {
+  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()),
+                       U->getContext().isLittleEndian(), 0);
+    DWARFExpression(Data, U).Print(OS, false);;
+    return;
+  }
+
+  FormValue.dump(OS, U);
+  if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
+    const DWARFSection &LocSection = U->getContext().getLocSection();
+    const DWARFSection &LocDWOSection = U->getContext().getLocDWOSection();
+    uint32_t Offset = *FormValue.getAsSectionOffset();
+
+    if (LocSection.Data.size()) {
+      DWARFDebugLoc DebugLoc(LocSection.Relocs);
+      DataExtractor Data(LocSection.Data, U->getContext().isLittleEndian(), 0);
+      auto LL = DebugLoc.parseOneLocationList(Data, U->getAddressByteSize(),
+                                              &Offset);
+      if (LL)
+        LL->dump(OS, U, Indent);
+      else
+        OS << "error extracting location list.";
+    } else if (LocDWOSection.Data.size()) {
+      DataExtractor Data(LocDWOSection.Data, U->getContext().isLittleEndian(), 0);
+      auto LL = DWARFDebugLocDWO::parseOneLocationList(Data, &Offset);
+      if (LL)
+        LL->dump(OS, U, Indent);
+      else
+        OS << "error extracting location list.";
+    }
+  }
+}
+
 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
                                                DWARFUnit *u,
                                                uint32_t *offset_ptr,
                                                uint16_t attr, uint16_t form,
                                                unsigned indent) const {
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
   OS.indent(indent+2);
if (const auto *LT = u->getContext().getLineTableForUnit(u))
       }
   } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
     Name = AttributeValueString(attr, *Val);
 
   if (Name)
     WithColor(OS, Color) << Name;
   else if (attr == DW_AT_decl_line || attr == DW_AT_call_line)
     OS << *formValue.getAsUnsignedConstant();
+  else if (attr == DW_AT_location || attr == DW_AT_frame_base ||
+             attr == DW_AT_data_member_location)
+    dumpLocation(OS, formValue, u, sizeof(BaseIndent)+indent+4);
   else
     formValue.dump(OS, u);
 
   // We have dumped the attribute raw value. For some attributes
   // having both the raw value and the pretty-printed value is
   // interesting. These attributes are handled below.
   if ((attr == DW_AT_specification || attr == DW_AT_abstract_origin) &&
       // The signature references aren't handled.

lib/DebugInfo/DWARFDebugLoc.cpp

 //===-- DWARFDebugLoc.cpp -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARFExpression.h"
+#include "llvm/DebugInfo/DWARFUnit.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Dwarf.h"
+#include <algorithm>
 
 using namespace llvm;
 
-void DWARFDebugLoc::dump(raw_ostream &OS) const {
-  for (const LocationList &L : Locations) {
-    OS << format("0x%8.8x: ", L.Offset);
-    const unsigned Indent = 12;
-    for (const Entry &E : L.Entries) {
-      if (&E != L.Entries.begin())
-        OS.indent(Indent);
-      OS << "Beginning address offset: " << format("0x%016" PRIx64, E.Begin)
-         << '\n';
-      OS.indent(Indent) << "   Ending address offset: "
-                        << format("0x%016" PRIx64, E.End) << '\n';
-      OS.indent(Indent) << "    Location description: ";
-      for (unsigned char Loc : E.Loc) {
-        OS << format("%2.2x ", Loc);
-      }
-      OS << "\n\n";
-    }
+void DWARFDebugLoc::LocationList::dump(raw_ostream& OS, const DWARFUnit *Unit,
+                                       unsigned Indent) const
+{
+  for (const Entry &E : Entries) {
+    OS << '\n';
+    OS << format("0x%016" PRIx64, E.Begin+Unit->getBaseAddress()) << " - "
+       << format("0x%016" PRIx64, E.End+Unit->getBaseAddress()) << ": ";
+
+    DataExtractor Data(StringRef((const char*)E.Loc.data(), E.Loc.size()),
+                       Unit->getDebugInfoExtractor().isLittleEndian(),
+                       Unit->getAddressByteSize());
+    DWARFExpression(Data, Unit).Print(OS, false);
+
+void DWARFDebugLoc::dump(raw_ostream &OS, const DWARFUnit *Unit) const {
+  for (const LocationList &L : Locations) {
+    OS << format("0x%8.8x: ", L.Offset);
+    L.dump(OS, Unit);
+    OS << "\n\n";
   }
 }
 
-void DWARFDebugLoc::parse(DataExtractor data, unsigned AddressSize) {
-  uint32_t Offset = 0;
-  while (data.isValidOffset(Offset+AddressSize-1)) {
-    Locations.resize(Locations.size() + 1);
-    LocationList &Loc = Locations.back();
-    Loc.Offset = Offset;
-    // 2.6.2 Location Lists
-    // A location list entry consists of:
-    while (true) {
-      Entry E;
-      RelocAddrMap::const_iterator AI = RelocMap.find(Offset);
-      // 1. A beginning address offset. ...
-      E.Begin = data.getUnsigned(&Offset, AddressSize);
-      if (AI != RelocMap.end())
-        E.Begin += AI->second.second;
+Optional<DWARFDebugLoc::LocationList>
+DWARFDebugLoc::parseOneLocationList(DataExtractor Data, unsigned AddressSize,
+                                    unsigned *Offset) {
+  LocationList LL;
+  LL.Offset = *Offset;
+
+    RelocAddrMap::const_iterator AI = RelocMap.find(*Offset);
+
+    if (!Data.isValidOffsetForDataOfSize(*Offset, 2 * AddressSize)) {
+      llvm::errs() << "Location list overflows the debug_loc section.\n";
+      return None;
+    }
+
+    E.Begin = Data.getUnsigned(Offset, AddressSize);
 
-      AI = RelocMap.find(Offset);
-      // 2. An ending address offset. ...
-      E.End = data.getUnsigned(&Offset, AddressSize);
-      if (AI != RelocMap.end())
-        E.End += AI->second.second;
+    AI = RelocMap.find(*Offset);
+    E.End = Data.getUnsigned(Offset, AddressSize);
 
-      // The end of any given location list is marked by an end of list entry,
-      // which consists of a 0 for the beginning address offset and a 0 for the
-      // ending address offset.
-      if (E.Begin == 0 && E.End == 0)
-        break;
+      return LL;
 
-      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.reserve(str.size());
-      std::copy(str.begin(), str.end(), std::back_inserter(E.Loc));
-      Loc.Entries.push_back(std::move(E));
-    }
-  }
+    if (!Data.isValidOffsetForDataOfSize(*Offset, 2)) {
+      llvm::errs() << "Location list overflows the debug_loc section.\n";
+      return None;
+    }
+
+    unsigned Bytes = Data.getU16(Offset);
+    if (!Data.isValidOffsetForDataOfSize(*Offset, Bytes)) {
+      llvm::errs() << "Location list overflows the debug_loc section.\n";
+      return None;
+    }
+    StringRef str = Data.getData().substr(*Offset, Bytes);
+    *Offset += Bytes;
+    LL.Entries.push_back(std::move(E));
+
+void DWARFDebugLoc::parse(DataExtractor data, unsigned AddressSize) {
+  uint32_t Offset = 0;
+  while (data.isValidOffset(Offset+AddressSize-1)) {
+    if (auto LL = parseOneLocationList(data, AddressSize, &Offset))
+      Locations.push_back(std::move(*LL));
+    else
+      break;
+  }
   if (data.isValidOffset(Offset))
     llvm::errs() << "error: failed to consume entire .debug_loc section\n";
 }
 
-void DWARFDebugLocDWO::parse(DataExtractor data) {
-  uint32_t Offset = 0;
-  while (data.isValidOffset(Offset)) {
-    Locations.resize(Locations.size() + 1);
-    LocationList &Loc = Locations.back();
-    Loc.Offset = Offset;
-    dwarf::LocationListEntry Kind;
-    while ((Kind = static_cast<dwarf::LocationListEntry>(
-                data.getU8(&Offset))) != dwarf::DW_LLE_end_of_list_entry) {
+Optional<DWARFDebugLocDWO::LocationList>
+DWARFDebugLocDWO::parseOneLocationList(DataExtractor Data, unsigned *Offset) {
+  LocationList LL;
+  LL.Offset = *Offset;
 
-      if (Kind != dwarf::DW_LLE_start_length_entry) {
-        llvm::errs() << "error: dumping support for LLE of kind " << (int)Kind
-                     << " not implemented\n";
-        return;
-      }
+  // 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))) {
+      return None;
 
-      Entry E;
+    E.Start = Data.getULEB128(Offset);
+    E.Length = Data.getU32(Offset);
 
-      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());
+    unsigned Bytes = Data.getU16(Offset);
+    StringRef str = Data.getData().substr(*Offset, Bytes);
+    *Offset += Bytes;
 
-      Loc.Entries.push_back(std::move(E));
-    }
+    LL.Entries.push_back(std::move(E));
+  return LL;
+}
+
+void DWARFDebugLocDWO::parse(DataExtractor data) {
+  uint32_t Offset = 0;
+  while (data.isValidOffset(Offset)) {
+    if (auto LL = parseOneLocationList(data, &Offset))
+      Locations.push_back(std::move(*LL));
+    else
+      return;
+  }
+}
+
+void DWARFDebugLocDWO::LocationList::dump(raw_ostream &OS, const DWARFUnit *Unit,
+                                          unsigned Indent) const {
+  for (const Entry &E : Entries) {
+    OS << '\n';
+    OS.indent(Indent);
+    OS << "Addr idx " << E.Start << " (w/ length " << E.Length << "): ";
+    DataExtractor Data(StringRef((const char*)E.Loc.data(), E.Loc.size()),
+                       Unit->getDebugInfoExtractor().isLittleEndian(),
+                       Unit->getAddressByteSize());
+    DWARFExpression(Data, Unit).Print(OS, false);
   }
 }
 
-void DWARFDebugLocDWO::dump(raw_ostream &OS) const {
+void DWARFDebugLocDWO::dump(raw_ostream &OS, const DWARFUnit *Unit) const {
   for (const LocationList &L : Locations) {
     OS << format("0x%8.8x: ", L.Offset);
-    const unsigned Indent = 12;
-    for (const Entry &E : L.Entries) {
-      if (&E != L.Entries.begin())
-        OS.indent(Indent);
-      OS << "Beginning address index: " << E.Start << '\n';
-      OS.indent(Indent) << "                 Length: " << E.Length << '\n';
-      OS.indent(Indent) << "   Location description: ";
-      for (unsigned char Loc : E.Loc)
-        OS << format("%2.2x ", Loc);
-      OS << "\n\n";
-    }
-  }
-}
+    L.dump(OS, Unit);
 

lib/DebugInfo/DWARFExpression.cpp

+//===-- DWARFExpression.cpp -----------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Format.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFContext.h"
+#include "llvm/DebugInfo/DWARFExpression.h"
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+using namespace llvm;
+using namespace dwarf;
+
+namespace llvm {
+
+typedef std::vector<DWARFExpression::Op::Description> DescVector;
+
+static DescVector &getDescriptions() {
+  static DescVector Descriptions;
+  typedef DWARFExpression::Op Op;
+  typedef Op::Description Desc;
+
+  Descriptions.resize(0xff);
+  Descriptions[DW_OP_addr] = Desc(Op::Dwarf2, Op::SizeAddr);
+  Descriptions[DW_OP_deref] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_const1u] = Desc(Op::Dwarf2, Op::Size1);
+  Descriptions[DW_OP_const1s] = Desc(Op::Dwarf2, Op::SignedSize1);
+  Descriptions[DW_OP_const2u] = Desc(Op::Dwarf2, Op::Size2);
+  Descriptions[DW_OP_const2s] = Desc(Op::Dwarf2, Op::SignedSize2);
+  Descriptions[DW_OP_const4u] = Desc(Op::Dwarf2, Op::Size4);
+  Descriptions[DW_OP_const4s] = Desc(Op::Dwarf2, Op::SignedSize4);
+  Descriptions[DW_OP_const8u] = Desc(Op::Dwarf2, Op::Size8);
+  Descriptions[DW_OP_const8s] = Desc(Op::Dwarf2, Op::SignedSize8);
+  Descriptions[DW_OP_constu] = Desc(Op::Dwarf2, Op::SizeLEB);
+  Descriptions[DW_OP_consts] = Desc(Op::Dwarf2, Op::SignedSizeLEB);
+  Descriptions[DW_OP_dup] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_drop] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_over] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_pick] = Desc(Op::Dwarf2, Op::Size1);
+  Descriptions[DW_OP_swap] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_rot] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_xderef] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_abs] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_and] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_div] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_minus] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_mod] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_mul] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_neg] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_not] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_or] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_plus] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_plus_uconst] = Desc(Op::Dwarf2, Op::SizeLEB);
+  Descriptions[DW_OP_shl] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_shr] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_shra] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_xor] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_skip] = Desc(Op::Dwarf2, Op::SignedSize2);
+  Descriptions[DW_OP_bra] = Desc(Op::Dwarf2, Op::SignedSize2);
+  Descriptions[DW_OP_eq] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_ge] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_gt] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_le] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_lt] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_ne] = Desc(Op::Dwarf2);
+  for (uint16_t LA = DW_OP_lit0; LA <= DW_OP_lit31; ++LA)
+    Descriptions[LA] = Desc(Op::Dwarf2);
+  for (uint16_t LA = DW_OP_reg0; LA <= DW_OP_reg31; ++LA)
+    Descriptions[LA] = Desc(Op::Dwarf2);
+  for (uint16_t LA = DW_OP_breg0; LA <= DW_OP_breg31; ++LA)
+    Descriptions[LA] = Desc(Op::Dwarf2, Op::SignedSizeLEB);
+  Descriptions[DW_OP_regx] = Desc(Op::Dwarf2, Op::SizeLEB);
+  Descriptions[DW_OP_fbreg] = Desc(Op::Dwarf2, Op::SignedSizeLEB);
+  Descriptions[DW_OP_bregx] = Desc(Op::Dwarf2, Op::SizeLEB, Op::SignedSizeLEB);
+  Descriptions[DW_OP_piece] = Desc(Op::Dwarf2, Op::SizeLEB);
+  Descriptions[DW_OP_deref_size] = Desc(Op::Dwarf2, Op::Size1);
+  Descriptions[DW_OP_xderef_size] = Desc(Op::Dwarf2, Op::Size1);
+  Descriptions[DW_OP_nop] = Desc(Op::Dwarf2);
+  Descriptions[DW_OP_push_object_address] = Desc(Op::Dwarf3);
+  Descriptions[DW_OP_call2] = Desc(Op::Dwarf3, Op::Size2);
+  Descriptions[DW_OP_call4] = Desc(Op::Dwarf3, Op::Size4);
+  Descriptions[DW_OP_call_ref] = Desc(Op::Dwarf3, Op::SizeRefAddr);
+  Descriptions[DW_OP_form_tls_address] = Desc(Op::Dwarf3);
+  Descriptions[DW_OP_call_frame_cfa] = Desc(Op::Dwarf3);
+  Descriptions[DW_OP_bit_piece] = Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeLEB);
+  Descriptions[DW_OP_implicit_value] =
+      Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeBlock);
+  Descriptions[DW_OP_stack_value] = Desc(Op::Dwarf3);
+  Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
+  Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
+  Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
+  return Descriptions;
+}
+
+static DWARFExpression::Op::Description getOpDesc(unsigned OpCode) {
+  static DescVector &Descriptions = getDescriptions();
+  assert(OpCode < Descriptions.size());
+  return Descriptions[OpCode];
+}
+
+static uint8_t getRefAddrSize(uint8_t AddrSize, uint16_t Version) {
+  return (Version == 2) ? AddrSize : 4;
+}
+
+bool DWARFExpression::Op::Extract(DataExtractor Data, const DWARFUnit *U,
+                                  uint32_t Offset) {
+  Opcode = Data.getU8(&Offset);
+
+  Desc = getOpDesc(Opcode);
+  if (Desc.Version == Op::DwarfNA)
+    return false;
+
+  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+    unsigned Size = Desc.Op[Operand];
+    unsigned Signed = Size & Op::SignBit;
+
+    if (Size == Op::SizeNA)
+      break;
+
+    switch (Size & ~Op::SignBit) {
+    case Op::Size1:
+      Operands[Operand] = Data.getU8(&Offset);
+      if (Signed)
+        Operands[Operand] = (int8_t)Operands[Operand];
+      break;
+    case Op::Size2:
+      Operands[Operand] = Data.getU16(&Offset);
+      if (Signed)
+        Operands[Operand] = (int16_t)Operands[Operand];
+      break;
+    case Op::Size4:
+      Operands[Operand] = Data.getU32(&Offset);
+      if (Signed)
+        Operands[Operand] = (int32_t)Operands[Operand];
+      break;
+    case Op::Size8:
+      Operands[Operand] = Data.getU64(&Offset);
+      break;
+    case Op::SizeAddr:
+      if (U->getAddressByteSize() == 8) {
+        Operands[Operand] = Data.getU64(&Offset);
+      } else {
+        assert(U->getAddressByteSize() == 4);
+        Operands[Operand] = Data.getU32(&Offset);
+      }
+      break;
+    case Op::SizeRefAddr:
+      if (getRefAddrSize(U->getAddressByteSize(), U->getVersion()) == 8) {
+        Operands[Operand] = Data.getU64(&Offset);
+      } else {
+        assert(getRefAddrSize(U->getAddressByteSize(), U->getVersion()) == 4);
+        Operands[Operand] = Data.getU32(&Offset);
+      }
+      break;
+    case Op::SizeLEB:
+      if (Signed)
+        Operands[Operand] = Data.getSLEB128(&Offset);
+      else
+        Operands[Operand] = Data.getULEB128(&Offset);
+      break;
+    case Op::SizeBlock:
+      // We need a size, so this cannot be the first operand
+      if (Operand == 0)
+        return false;
+      // Store the offset of the block as the value.
+      Operands[Operand] = Offset;
+      Offset += Operands[Operand - 1];
+      break;
+    default:
+      llvm_unreachable("Unknown DWARFExpression Op size");
+    }
+  }
+
+  EndOffset = Offset;
+  return true;
+}
+
+static bool prettyPrintRegisterOp(raw_ostream &OS, uint8_t Opcode,
+                                  uint64_t Operands[2],
+                                  const MCRegisterInfo *MRI, bool isEH) {
+  uint64_t DwarfRegNum;
+  unsigned OpNum = 0;
+
+  if (Opcode == DW_OP_bregx || Opcode == DW_OP_regx)
+    DwarfRegNum = Operands[OpNum++];
+  else if (Opcode >= DW_OP_breg0 && Opcode < DW_OP_bregx)
+    DwarfRegNum = Opcode - DW_OP_breg0;
+  else
+    DwarfRegNum = Opcode - DW_OP_reg0;
+
+  int LLVMRegNum = MRI->tryGetLLVMRegNum(DwarfRegNum, isEH);
+  if (LLVMRegNum >= 0)
+    if (const char *RegName = MRI->getName(LLVMRegNum)) {
+      if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
+          Opcode == DW_OP_bregx)
+        OS << format(" %s%+" PRId64, RegName, Operands[OpNum]);
+      else
+        OS << ' ' << RegName;
+      return true;
+    }
+
+  return false;
+}
+
+bool DWARFExpression::Op::Print(raw_ostream &OS, const DWARFExpression *Expr,
+                                bool isEH) {
+  if (Error) {
+    OS << "decoding error.";
+    return false;
+  }
+
+  const char *Name = OperationEncodingString(Opcode);
+  assert(Name && "DW_OP has no name!");
+  OS << Name + 3;
+
+  if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
+      (Opcode >= DW_OP_reg0 && Opcode <= DW_OP_reg31) ||
+      Opcode == DW_OP_bregx || Opcode == DW_OP_regx)
+    if (const MCRegisterInfo *MRI =
+            Expr->Unit->getContext().getTargetRegisterInfo())
+      if (prettyPrintRegisterOp(OS, Opcode, Operands, MRI, isEH))
+        return true;
+
+  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+    unsigned Size = Desc.Op[Operand];
+    unsigned Signed = Size & Op::SignBit;
+
+    if (Size == Op::SizeNA)
+      break;
+
+    if (Size == Op::SizeBlock) {
+      uint32_t Offset = Operands[Operand];
+      for (unsigned i = 0; i < Operands[Operand - 1]; ++i)
+        OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
+    } else {
+      if (Signed)
+        OS << format(" %+" PRId64, (int64_t)Operands[Operand]);
+      else
+        OS << format(" 0x%" PRIx64, Operands[Operand]);
+    }
+  }
+  return true;
+}
+
+void DWARFExpression::Print(raw_ostream &OS, bool isEH) {
+  for (auto &Op : operations()) {
+    if (!Op.Print(OS, this, isEH)) {
+      uint32_t FailOffset = Op.getEndOffset();
+      while (FailOffset < Data.getData().size())
+        OS << format(" %02x", Data.getU8(&FailOffset));
+      return;
+    }
+    if (Op.getEndOffset() < Data.getData().size())
+      OS << ", ";
+  }
+}
+
+} // namespace llvm

test/CodeGen/ARM/2011-01-19-MergedGlobalDbg.ll

 ; 0x10 DW_OP_constu
 ; 0x.. offset
 ; 0x22 DW_OP_plus
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x1"
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x8> 03 [[ADDR:.. .. .. ..]] 10 00 22  )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (OP_addr [[ADDR:0x[0-9a-f]*]], OP_constu 0x0, OP_plus)
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x2"
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x8> 03 [[ADDR]] 10 01 22  )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (OP_addr [[ADDR]], OP_constu 0x1, OP_plus)
 
 define zeroext i8 @get1(i8 zeroext %a) nounwind optsize {
 entry:
   tail call void @llvm.dbg.value(metadata i8 %a, i64 0, metadata !10, metadata !{!"0x102"}), !dbg !30
   %0 = load i8* @x1, align 4, !dbg !30
   tail call void @llvm.dbg.value(metadata i8 %0, i64 0, metadata !11, metadata !{!"0x102"}), !dbg !30
   store i8 %a, i8* @x1, align 4, !dbg !30
   ret i8 %0, !dbg !31

test/CodeGen/ARM/2011-08-02-MergedGlobalDbg.ll

 ; RUN: llc -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; Check debug info output for merged global.
 ; DW_AT_location
 ; 0x03 DW_OP_addr
 ; 0x.. .long __MergedGlobals
 ; 0x10 DW_OP_constu
 ; 0x.. offset
 ; 0x22 DW_OP_plus
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x1"
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x8> 03 [[ADDR:.. .. .. ..]] 10 00 22  )
+; (OP_reg0 R0)
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (OP_addr [[ADDR:0x[0-9a-f]*]], OP_constu 0x0, OP_plus)
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x2"
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x8> 03 [[ADDR]] 10 04 22  )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (OP_addr [[ADDR]], OP_constu 0x4, OP_plus)
 
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32"
 target triple = "thumbv7-apple-macosx10.7.0"
 
 @x1 = internal unnamed_addr global i32 1, align 4
 @x2 = internal unnamed_addr global i32 2, align 4
 @x3 = internal unnamed_addr global i32 3, align 4
 @x4 = internal unnamed_addr global i32 4, align 4

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

 ; RUN: llc < %s - -filetype=obj | llvm-dwarfdump -debug-dump=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.
-;
-; 0x90   DW_OP_regx of super-register
 
-; CHECK: 0x00000000: Beginning address offset:
-; CHECK-NEXT:           Ending address offset:
-; CHECK-NEXT:            Location description: 90 {{.. .. .. .. $}}
+; CHECK: 0x00000000:
+; CHECK-NEXT:        0x{{[0-9]*[a-f]*}} - 0x{{[0-9]*[a-f]*}}: OP_regx D8
+
 
 define void @_Z3foov() optsize ssp {
 entry:
   %call = tail call float @_Z3barv() optsize, !dbg !11
   tail call void @llvm.dbg.value(metadata float %call, i64 0, metadata !5, metadata !{!"0x102"}), !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

test/CodeGen/X86/2011-01-24-DbgValue-Before-Use.ll

 ; RUN: llc < %s -filetype=obj | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; RUN: llc < %s -filetype=obj -regalloc=basic | llvm-dwarfdump -debug-dump=info -  | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin10.0.0"
 
 ; Check debug info for variable z_s
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location
-; CHECK-NEXT:   DW_AT_name {{.*}} "z_s"
+; CHECK-NOT: DW_TAG
+; CHECK:   DW_AT_name {{.*}} "z_s"
 ; CHECK-NEXT:   DW_AT_decl_file
 ; CHECK-NEXT:   DW_AT_decl_line
 ; CHECK-NEXT:   DW_AT_type{{.*}}{[[TYPE:.*]]}
 ; CHECK: [[TYPE]]:
 ; CHECK-NEXT: DW_AT_name {{.*}} "int"
 
 
 @.str1 = private unnamed_addr constant [14 x i8] c"m=%u, z_s=%d\0A\00"

test/DebugInfo/AArch64/coalescing.ll

 entry:
   %size = alloca i32, align 4
   %0 = bitcast i32* %size to i8*, !dbg !15
   %call = call i8* @_Z3fooPv(i8* %0) #3, !dbg !15
   call void @llvm.dbg.value(metadata i32* %size, i64 0, metadata !10, metadata !16), !dbg !17
   ; CHECK: .debug_info contents:
   ; CHECK: DW_TAG_variable
   ; CHECK-NEXT: DW_AT_location
+  ; CHECK-NEXT:  OP_breg0 W0+0)
   ; CHECK-NEXT: DW_AT_name {{.*}}"size"
-  ; CHECK: .debug_loc contents:
-  ; CHECK: Location description: 70 00
   ret void, !dbg !18
 }
 
 ; Function Attrs: optsize
 declare i8* @_Z3fooPv(i8*) #1
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2

test/DebugInfo/ARM/s-super-register.ll

 ; RUN: llc < %s - -filetype=obj | llvm-dwarfdump -debug-dump=loc - | FileCheck %s
 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"
 
 ; The S registers on ARM are expressed as pieces of their super-registers in DWARF.
 ;
 ; 0x90   DW_OP_regx of super-register
 ; 0x93   DW_OP_piece
 ; 0x9d   DW_OP_bit_piece
-; CHECK:            Location description: 90 {{.. .. ((93 ..)|(9d .. ..)) $}}
+; CHECK:            OP_regx D8, OP{{_bit_|_}}piece 
 
 define void @_Z3foov() optsize ssp {
 entry:
   %call = tail call float @_Z3barv() optsize, !dbg !11
   tail call void @llvm.dbg.value(metadata float %call, i64 0, metadata !5, metadata !{!"0x102"}), !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

test/DebugInfo/SystemZ/variable-loc.ll

 ; RUN: llc -mtriple=s390x-linux-gnu -disable-fp-elim < %s | FileCheck %s
 ; RUN: llc -mtriple=s390x-linux-gnu -disable-fp-elim -filetype=obj < %s \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=DEBUG %s
 ;
 ; This is a regression test making sure the location of variables is correct in
 ; debugging information, even if they're addressed via the frame pointer.
 ; Originally a copy of the AArch64 test, commandeered for SystemZ.
 ;
 ; First make sure main_arr is where we expect it: %r11 + 164
 ;
 ; CHECK: main:
 ; CHECK: aghi    %r15, -568
 ; CHECK: la      %r2, 164(%r11)
 ; CHECK: brasl   %r14, populate_array@PLT
 
 ; DEBUG: DW_TAG_variable
-; Rather hard-coded, but 0x91 => DW_OP_fbreg and 0xa401 is SLEB128 encoded 164.
 ; DEBUG-NOT: DW_TAG
-; DEBUG: DW_AT_location {{.*}}(<0x3> 91 a4 01 )
+; DEBUG: DW_AT_location {{.*}}(OP_fbreg +164)
 ; DEBUG-NOT: DW_TAG
 ; DEBUG: DW_AT_name {{.*}} "main_arr"
 
 
 @.str = private unnamed_addr constant [13 x i8] c"Total is %d\0A\00", align 2
 
 declare void @populate_array(i32*, i32) nounwind
 

test/DebugInfo/X86/DW_AT_location-reference.ll

 ;   x = 2;
 ;   while (x & 2) { x *= a; }
 ;   a = g(0, x);
 ; }
 
 ; // The 'x' variable and its symbol reference location
 ; CHECK: .debug_info contents:
 ; CHECK:      DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (0x00000000)
+; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (0x00000000
+; Check that the location contains only 4 ranges - this verifies that the 4th
+; and 5th ranges were successfully merged into a single range.
+; CHECK-NEXT:   0x{{[0-9a-f]*}} - 0x{{[0-9a-f]*}}:
+; CHECK-NEXT:   0x{{[0-9a-f]*}} - 0x{{[0-9a-f]*}}:
+; CHECK-NEXT:   0x{{[0-9a-f]*}} - 0x{{[0-9a-f]*}}:
+; CHECK-NEXT:   0x{{[0-9a-f]*}} - 0x{{[0-9a-f]*}}: {{.*}})
 ; CHECK-NEXT:   DW_AT_name {{.*}} "x"
 ; CHECK-NEXT:   DW_AT_decl_file
 ; CHECK-NEXT:   DW_AT_decl_line
 ; CHECK-NEXT:   DW_AT_type
 
-; Check that the location contains only 4 ranges - this verifies that the 4th
-; and 5th ranges were successfully merged into a single range.
-; CHECK: .debug_loc contents:
-; CHECK: 0x00000000:
-; CHECK: Beginning address offset:
-; CHECK: Beginning address offset:
-; CHECK: Beginning address offset:
-; CHECK: Beginning address offset:
-; CHECK-NOT: Beginning address offset:
-
 ; Check that we have no relocations in Darwin's output.
 ; DARWIN-NOT: X86_64_RELOC{{.*}} __debug_loc
 
 ; Check we have a relocation for the debug_loc entry in Linux output.
 ; LINUX: RELOCATION RECORDS FOR [.rela.debug_info]
 ; LINUX-NOT: RELOCATION RECORDS
 ; LINUX: R_X86_64{{.*}} .debug_loc+0
 

test/DebugInfo/X86/block-capture.ll

 ; RUN: llc %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
 ; Checks that we emit debug info for the block variable declare.
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_variable
-;                                              fbreg +8, deref, +32
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x05> 91 08 06 23 20 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (OP_fbreg +8, OP_deref, OP_plus_uconst 0x20)
 ; CHECK-NEXT: DW_AT_name {{.*}} "block"
 
 ; Extracted from the clang output for:
 ; void foo() {
 ;  void (^block)() = ^{ block(); };
 ; }
 
 ; ModuleID = 'foo.m'

test/DebugInfo/X86/data_member_location.ll

 ; CHECK: DW_AT_data_member_location {{.*}} (0x00)
 
 ; CHECK: DW_AT_name {{.*}} "i"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_data_member_location {{.*}} (0x04)
 
 ; DWARF2: DW_AT_name {{.*}} "c"
 ; DWARF2-NOT: DW_TAG
-; DWARF2: DW_AT_data_member_location {{.*}} (<0x02> 23 00 )
+; DWARF2: DW_AT_data_member_location {{.*}} (OP_plus_uconst 0x0)
 
 ; DWARF2: DW_AT_name {{.*}} "i"
 ; DWARF2-NOT: DW_TAG
-; DWARF2: DW_AT_data_member_location {{.*}} (<0x02> 23 04 )
+; DWARF2: DW_AT_data_member_location {{.*}} (OP_plus_uconst 0x4)
 
 %struct.foo = type { i8, i32 }
 
 @f = global %struct.foo zeroinitializer, align 4
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!13, !15}
 !llvm.ident = !{!14}

test/DebugInfo/X86/dbg-merge-loc-entry.ll

 ; RUN: llc < %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 ; RUN: llc < %s -o %t -filetype=obj -regalloc=basic
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin8"
 
-;CHECK: DW_AT_location{{.*}}(<0x1> 55 )
+;CHECK: DW_AT_location{{.*}}(OP_reg5 RDI)
 
 %0 = type { i64, i1 }
 
 @__clz_tab = external constant [256 x i8]
 
 define hidden i128 @__divti3(i128 %u, i128 %v) nounwind readnone {
 entry:
   tail call void @llvm.dbg.value(metadata i128 %u, i64 0, metadata !14, metadata !{!"0x102"}), !dbg !15

test/DebugInfo/X86/dbg-value-const-byref.ll

 ; Test that we generate valid debug info for optimized code,
 ; particularly variables that are described as constants and passed
 ; by reference.
 ; rdar://problem/14874886
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_location [DW_FORM_data4] ([[LOC:.*]])
+; CHECK:     DW_AT_location [DW_FORM_data4] (
+; CHECK-NEXT:   0x{{[0-9a-f]*}} - 0x[[C1:[0-9a-f]*]]: OP_consts +3
+; CHECK-NEXT:   0x[[C1]] - 0x[[C2:[0-9a-f]*]]: OP_consts +7
+; CHECK-NEXT:   0x[[C2]] - 0x[[R1:[0-9a-f]*]]: OP_reg0 RAX, OP_piece 0x4
+; CHECK-NEXT:   0x[[R1]] - 0x{{[0-9a-f]*}}: OP_breg5 RDI+0)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}"i"
-; CHECK: .debug_loc contents:
-; CHECK: [[LOC]]:
-;        consts 0x00000003
-; CHECK: Beginning address offset: 0x0000000000000{{.*}}
-; CHECK:    Ending address offset: [[C1:.*]]
-; CHECK:     Location description: 11 03
-;        consts 0x00000007
-; CHECK: Beginning address offset: [[C1]]
-; CHECK:    Ending address offset: [[C2:.*]]
-; CHECK:     Location description: 11 07
-;        rax, piece 0x00000004
-; CHECK: Beginning address offset: [[C2]]
-; CHECK:    Ending address offset: [[R1:.*]]
-; CHECK:     Location description: 50 93 04
-;         rdi+0
-; CHECK: Beginning address offset: [[R1]]
-; CHECK:    Ending address offset: [[R2:.*]]
-; CHECK:     Location description: 75 00
-;
+
 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() #0 {
 entry:
   %i = alloca i32, align 4
   call void @llvm.dbg.value(metadata i32 3, i64 0, metadata !10, metadata !{!"0x102"}), !dbg !15

test/DebugInfo/X86/debug-info-blocks.ll

 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_location
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}.block_descriptor
 
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; 0x06 = DW_OP_deref
-; 0x23 = DW_OP_uconst
-; 0x91 = DW_OP_fbreg
-; CHECK: DW_AT_location{{.*}}91 {{[0-9]+}} 06 23 {{[0-9]+}} )
+; CHECK: DW_AT_location{{.*}}(OP_fbreg -24, OP_deref, OP_plus_uconst 0x20)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}"self"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_type{{.*}}{[[APTR:.*]]}
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_artificial
 
 ; CHECK: [[APTR]]:   DW_TAG_pointer_type

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

 ; CHECK: DW_AT_high_pc
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_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]   (0x00000000)
+; CHECK: DW_AT_location [DW_FORM_sec_offset]   (0x00000000
+; do not check the location stored here, as it will be offseted by the
+; compile unit's low_pc. The real check is below in the debug_loc section.
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name [DW_FORM_strp]{{.*}}"a"
 
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_location [DW_FORM_exprloc]
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: .debug_loc contents:
-; CHECK: 0x00000000: Beginning address offset: 0x0000000000000000
-; CHECK:                Ending address offset: 0x000000000000001a
+; CHECK: 0x00000000:
+; CHECK-NEXT:   0x0000000000000000 - 0x000000000000001a
 
 %struct.A = type { i32 (...)**, i32 }
 
 ; Function Attrs: nounwind
 define i32 @_Z3bari(i32 %b) #0 {
 entry:
   %b.addr = alloca i32, align 4
   store i32 %b, i32* %b.addr, align 4

test/DebugInfo/X86/fission-cu.ll

 ; CHECK-NOT: DW_AT_comp_dir
 ; CHECK: DW_AT_GNU_dwo_id [DW_FORM_data8]  (0x1f1f859683d49324)
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_name [DW_FORM_GNU_str_index]     ( indexed (00000002) string = "a")
 ; CHECK: DW_AT_type [DW_FORM_ref4]       (cu + 0x{{[0-9a-f]*}} => {[[TYPE:0x[0-9a-f]*]]})
 ; CHECK: DW_AT_external [DW_FORM_flag_present]   (true)
 ; CHECK: DW_AT_decl_file [DW_FORM_data1] (0x01)
 ; CHECK: DW_AT_decl_line [DW_FORM_data1] (1)
-; CHECK: DW_AT_location [DW_FORM_exprloc] (<0x2> fb 00 )
+; CHECK: DW_AT_location [DW_FORM_exprloc] (OP_GNU_addr_index 0x0)
 ; CHECK: [[TYPE]]: DW_TAG_base_type
 ; CHECK: DW_AT_name [DW_FORM_GNU_str_index]     ( indexed (00000003) string = "int")
 
 ; CHECK: .debug_str contents:
 ; CHECK: 0x00000000: "baz.dwo"
 ; CHECK: 0x00000008: "/usr/local/google/home/echristo/tmp"
 
 ; CHECK: .debug_str.dwo contents:

test/DebugInfo/X86/fission-ranges.ll

 ; RUN: llc -split-dwarf=Enable -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 ; RUN: llvm-objdump -h %t | FileCheck --check-prefix=HDR %s
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NEXT: DW_AT_stmt_list
 ; CHECK-NEXT: DW_AT_GNU_dwo_name
 ; CHECK-NEXT: DW_AT_comp_dir
 ; CHECK-NEXT: DW_AT_GNU_dwo_id
 ; CHECK-NEXT: DW_AT_GNU_addr_base [DW_FORM_sec_offset]                   (0x00000000)
 
-
+; Don't assume these locations are entirely correct - feel free to update them
+; if they've changed due to a bugfix, change in register allocation, etc.
 ; CHECK: .debug_info.dwo contents:
-; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[A:0x[0-9a-z]*]])
-; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[E:0x[0-9a-z]*]])
-; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[B:0x[0-9a-z]*]])
-; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[D:0x[0-9a-z]*]])
+; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[A:0x[0-9a-z]*]]
+; CHECK-NEXT:        Addr idx 2 (w/ length 190): OP_consts +0, OP_stack_value
+; CHECK-NEXT:        Addr idx 3 (w/ length 23): OP_reg0 RAX, OP_piece 0x4)
+; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[E:0x[0-9a-z]*]]
+; CHECK-NEXT:        Addr idx 4 (w/ length 21): OP_reg0 RAX, OP_piece 0x4)
+; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[B:0x[0-9a-z]*]]
+; CHECK-NEXT:        Addr idx 5 (w/ length 19): OP_reg0 RAX, OP_piece 0x4)
+; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[D:0x[0-9a-z]*]]
+; CHECK-NEXT:        Addr idx 6 (w/ length 23): OP_reg0 RAX, OP_piece 0x4)
 ; CHECK: DW_AT_ranges [DW_FORM_sec_offset]   (0x00000000
 ; CHECK: .debug_loc contents:
 ; CHECK-NOT: Beginning address offset
 ; CHECK: .debug_loc.dwo contents:
 
-; Don't assume these locations are entirely correct - feel free to update them
-; if they've changed due to a bugfix, change in register allocation, etc.
-
-; CHECK: [[A]]: Beginning address index: 2
-; CHECK-NEXT:                    Length: 190
-; CHECK-NEXT:      Location description: 11 00
-; CHECK-NEXT: {{^$}}
-; CHECK-NEXT:   Beginning address index: 3
-; CHECK-NEXT:                    Length: 23
-; CHECK-NEXT:      Location description: 50 93 04
-; CHECK: [[E]]: Beginning address index: 4
-; CHECK-NEXT:                    Length: 21
-; CHECK-NEXT:      Location description: 50 93 04
-; CHECK: [[B]]: Beginning address index: 5
-; CHECK-NEXT:                    Length: 19
-; CHECK-NEXT:      Location description: 50 93 04
-; CHECK: [[D]]: Beginning address index: 6
-; CHECK-NEXT:                    Length: 23
-; CHECK-NEXT:      Location description: 50 93 04
-
 ; Make sure we don't produce any relocations in any .dwo section (though in particular, debug_info.dwo)
 ; HDR-NOT: .rela.{{.*}}.dwo
 
 ; Make sure we have enough stuff in the debug_addr to cover the address indexes
 ; (6 is the last index in debug_loc.dwo, making 7 entries of 8 bytes each, 7 * 8
 ; == 56 base 10 == 38 base 16)
 
 ; HDR: .debug_addr 00000038

test/DebugInfo/X86/op_deref.ll

 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF4
 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj -dwarf-version=3 \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF3
 
 ; FIXME: The location here needs to be fixed, but llvm-dwarfdump doesn't handle
 ; DW_AT_location lists yet.
-; DWARF4: DW_AT_location [DW_FORM_sec_offset]                      (0x00000000)
+; DWARF4: DW_AT_location [DW_FORM_sec_offset]                      (0x00000000
 
 ; FIXME: The location here needs to be fixed, but llvm-dwarfdump doesn't handle
 ; DW_AT_location lists yet.
-; DWARF3: DW_AT_location [DW_FORM_data4]                      (0x00000000)
+; DWARF3: DW_AT_location [DW_FORM_data4]                      (0x00000000
 
+; CHECK-NEXT:   OP_breg2 RCX+0
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name [DW_FORM_strp]  ( .debug_str[0x00000067] = "vla")
 
-; Unfortunately llvm-dwarfdump can't unparse a list of DW_AT_locations
-; right now, so we check the asm output:
-; RUN: llc -O0 -mtriple=x86_64-apple-darwin %s -o - -filetype=asm | FileCheck %s -check-prefix=ASM-CHECK
-; vla should have a register-indirect address at one point.
-; ASM-CHECK: DEBUG_VALUE: vla <- RCX
-; ASM-CHECK: DW_OP_breg2
-
 ; RUN: llvm-as %s -o - | llvm-dis - | FileCheck %s --check-prefix=PRETTY-PRINT
 ; PRETTY-PRINT: [ DW_TAG_expression ] [DW_OP_deref]
 
 define void @testVLAwithSize(i32 %s) nounwind uwtable ssp {
 entry:
   %s.addr = alloca i32, align 4
   %saved_stack = alloca i8*
   %i = alloca i32, align 4

test/DebugInfo/X86/parameters.ll

 ;
 ; void func2(bool b, foo g) {
 ;   if (b)
 ;     sink(&g); // reference 'f' for now because otherwise we hit another bug
 ; }
 ; }
 
 ; CHECK: debug_info contents
-; 0x74 is DW_OP_breg4, showing that the parameter is accessed indirectly
+; DW_OP_breg4 shows that the parameter is accessed indirectly
 ; (with a zero offset) from the register parameter
-; CHECK: DW_AT_location{{.*}}(<0x0{{.}}> 74 00
+; CHECK: DW_AT_location{{.*}}(OP_breg4 RSI+0)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "f"
 
-; CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9]*]])
+; CHECK: DW_AT_location{{.*}}(0x00000000
+; CHECK-NEXT:  OP_breg4 RSI+0
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "g"
-; CHECK: debug_loc contents
-; CHECK-NEXT: [[G_LOC]]: Beginning
-; CHECK-NEXT:               Ending
-; CHECK-NEXT: Location description: 74 00
 
 %"struct.pr14763::foo" = type { i8 }
 
 ; Function Attrs: uwtable
 define void @_ZN7pr147634funcENS_3fooE(%"struct.pr14763::foo"* noalias sret %agg.result, %"struct.pr14763::foo"* %f) #0 {
 entry:
   call void @llvm.dbg.declare(metadata %"struct.pr14763::foo"* %f, metadata !22, metadata !{!"0x102\006"}), !dbg !24
   call void @_ZN7pr147633fooC1ERKS0_(%"struct.pr14763::foo"* %agg.result, %"struct.pr14763::foo"* %f), !dbg !25

test/DebugInfo/X86/pieces-1.ll

 ;    int foo(S s) {
 ;            return s.b;
 ;    }
 ;
 ;
 ; CHECK: .debug_loc contents:
 ;
 
-; 0x0000000000000000 - 0x0000000000000006: rdi, piece 0x00000008, rsi, piece 0x00000004
-; CHECK:            Beginning address offset: 0x0000000000000000
-; CHECK:               Ending address offset: [[LTMP3:.*]]
-; CHECK:                Location description: 55 93 08 54 93 04
-; 0x0000000000000006 - 0x0000000000000008: rbp-8, piece 0x00000008, rax, piece 0x00000004 )
-; CHECK:            Beginning address offset: [[LTMP3]]
-; CHECK:               Ending address offset: [[END:.*]]
-; CHECK:                Location description: 76 78 93 08 54 93 04
+; CHECK: 0x0000000000000000 - [[LTMP3:.*]]: OP_reg5 RDI, OP_piece 0x8, OP_reg4 RSI, OP_piece 0x4
+; 0x0000000000000006 - 0x0000000000000008: rbp-8, piece 0x8, rax, piece 0x4 )
+; CHECK: [[LTMP3]] - {{.*}}: OP_breg6 RBP-8, OP_piece 0x8, OP_reg4 RSI, OP_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 {
 entry:
   call void @llvm.dbg.value(metadata i64 %s.coerce0, i64 0, metadata !20, metadata !24), !dbg !21

test/DebugInfo/X86/pieces-2.ll

 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 ;
 ; CHECK: DW_TAG_variable [4]
-;                                                  rax, piece 0x00000004
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1]{{.*}}50 93 04
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1]{{.*}} (OP_reg0 RAX, OP_piece 0x4
 ; CHECK-NEXT:  DW_AT_name {{.*}}"i1"
 ;
 ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-1.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %struct.Outer = type { [2 x %struct.Inner] }
 %struct.Inner = type { i32, i64 }

test/DebugInfo/X86/pieces-3.ll

 ;    } Outer;
 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 ; CHECK: DW_TAG_formal_parameter [3]
-; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        ([[LOC:.*]])
+; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        (
+; CHECK-NEXT:         0x0000000000000000 - 0x0000000000000004: OP_reg5 RDI, OP_piece 0x8, OP_piece 0x4, OP_reg4 RSI, OP_piece 0x4
+; CHECK-NEXT:         0x0000000000000004 - 0x0000000000000008: OP_reg5 RDI, OP_piece 0x8, OP_piece 0x4, OP_reg4 RSI, OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"outer"
 ; CHECK: DW_TAG_variable
-;                                                 rsi, piece 0x00000004
-; CHECK-NEXT:   DW_AT_location [DW_FORM_block1]       {{.*}} 54 93 04
+; CHECK-NEXT:   DW_AT_location [DW_FORM_block1]{{.*}}(OP_reg4 RSI, OP_piece 0x4
 ; CHECK-NEXT:   "i1"
 ;
-; CHECK: .debug_loc
-; CHECK: [[LOC]]:
-; CHECK: Beginning address offset: 0x0000000000000000
-; CHECK:    Ending address offset: 0x0000000000000004
-; rdi, piece 0x00000008, piece 0x00000004, rsi, piece 0x00000004
-; CHECK: Location description: 55 93 08 93 04 54 93 04 
-;
 ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-2.ll'
 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 %outer.coerce0, i64 %outer.coerce1) #0 {
   call void @llvm.dbg.value(metadata i64 %outer.coerce0, i64 0, metadata !24, metadata !25), !dbg !26
   call void @llvm.dbg.declare(metadata !{null}, metadata !27, metadata !28), !dbg !26

test/DebugInfo/X86/subregisters.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o %t.o -filetype=obj -O0
 ; RUN: llvm-dwarfdump %t.o | FileCheck %s
 ;
 ; Test that on x86_64, the 32-bit subregister esi is emitted as
 ; DW_OP_piece 32 of the 64-bit rsi.
 ;
 ; rdar://problem/16015314
 ;
-; CHECK:  DW_AT_location [DW_FORM_block1]       (<0x03> 54 93 04 )
+; CHECK:  DW_AT_location [DW_FORM_block1]       (OP_reg4 RSI, OP_piece 0x4)
 ; CHECK:  DW_AT_name [DW_FORM_strp]{{.*}} "a"
 ;
 ; struct bar {
 ;   int a;
 ;   int b;
 ; };
 ;
 ; void doSomething() __attribute__ ((noinline));

test/DebugInfo/X86/template.ll

 ; CHECK-NEXT: DW_AT_const_value [DW_FORM_sdata]{{.*}}(3)
 
 ; CHECK: DW_TAG_template_value_parameter
 ; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INTPTR:0x[0-9a-f]*]]}
 
 ; The address of the global 'glbl', followed by DW_OP_stack_value (9f), to use
 ; the value immediately, rather than indirecting through the address.
 
-; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]{{ *}}(<0xa> 03 00 00 00 00 00 00 00 00 9f )
+; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]{{ *}}(OP_addr 0x0, OP_stack_value)
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_GNU_template_template_param
 ; CHECK-NEXT: DW_AT_name{{.*}}= "y"
 ; CHECK-NEXT: DW_AT_GNU_template_name{{.*}}= "y_impl"
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_template_value_parameter

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

 RUN: llvm-dwarfdump %p/Inputs/dwarfdump-test-loc-list-32bit.elf.o | FileCheck %s
 Note: the input file was generated from Inputs/dwarfdump-test-loc-list-32bit.elf.cpp
 
 CHECK: .debug_info
 CHECK: DW_AT_name{{.*}}"f"
-CHECK: DW_AT_location{{.*}}([[F_LOC:0x[0-9a-f]*]])
+CHECK: DW_AT_location{{.*}}([[F_LOC:0x[0-9a-f]*]]
+CHECK-NEXT:    0x0000000000000000 - 0x0000000000000023: OP_reg1 ECX
+CHECK-NEXT:    0x0000000000000023 - 0x000000000000005d: OP_breg5 EBP-16)
 CHECK: DW_AT_name{{.*}}"g"
-CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9a-f]*]])
+CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9a-f]*]]
+CHECK-NEXT:    0x0000000000000000 - 0x0000000000000020: OP_reg0 EAX
+CHECK-NEXT:    0x0000000000000020 - 0x000000000000005d: OP_breg5 EBP-12)
+
 CHECK: .debug_loc contents:
-CHECK-NEXT: [[F_LOC]]: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:               Ending address offset: 0x0000000000000023
+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:                Location description: 51
-CHECK-NEXT: {{^$}}
-CHECK-NEXT:            Beginning address offset: 0x0000000000000023
-CHECK-NEXT:               Ending address offset: 0x000000000000005d
-CHECK-NEXT:                Location description: 75 70
-CHECK-NEXT: {{^$}}
-CHECK-NEXT: [[G_LOC]]: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:               Ending address offset: 0x0000000000000020
-CHECK-NEXT:               Location description: 50
-CHECK-NEXT: {{^$}}
-CHECK-NEXT:            Beginning address offset: 0x0000000000000020
-CHECK-NEXT:               Ending address offset: 0x000000000000005d
-CHECK-NEXT:                Location description: 75 74
+CHECK-NEXT:             0x0000000000000000 - 0x0000000000000023: OP_reg1 ECX
+CHECK-NEXT:             0x0000000000000023 - 0x000000000000005d: OP_breg5 EBP-16
+CHECK: [[G_LOC]]:
+CHECK-NEXT:             0x0000000000000000 - 0x0000000000000020: OP_reg0 EAX
+CHECK-NEXT:             0x0000000000000020 - 0x000000000000005d: OP_breg5 EBP-12

test/DebugInfo/incorrect-variable-debugloc1.ll

 ; 
 ; int main()
 ; {
 ;   volatile int c = 13;
 ;   c = func();
 ;   return c;
 ; }
 
-; DWARF23: Location description: 10 0d {{$}}
-; DWARF4: Location description: 10 0d 9f
+; CHECK: DW_TAG_variable
+; CHECK: DW_AT_location
+; CHECK-NOT: DW_AT
+; DWARF23: OP_constu 0xd{{$}}
+; DWARF4: OP_constu 0xd, OP_stack_value{{$}}
 
 ; Function Attrs: uwtable
 define i32 @main() #0 {
 entry:
   %c = alloca i32, align 4
   tail call void @llvm.dbg.value(metadata i32 13, i64 0, metadata !10, metadata !16), !dbg !17
   store volatile i32 13, i32* %c, align 4, !dbg !18
   %call = tail call i32 @_Z4funcv(), !dbg !19