[dwarfdump] Pretty print location expressions and location lists

[rnk]

Summary

Based on Fred's patch here: https://reviews.llvm.org/D6771

I can't seem to commandeer the old review, so I'm creating a new one.

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 without ranges are printed inline:

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.

[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.

[aprantl]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

91 ↗

(On Diff #112622)

We use autobrief in our Doxygen configuration.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

106 ↗

(On Diff #112622)

Does this assert on invalid DWARF? Or is this an internal consistency check?

[aprantl]

Thanks a lot for picking this up!

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

86 ↗

(On Diff #112622)

extract

88 ↗

(On Diff #112622)

print

116 ↗

(On Diff #112622)

are provided

llvm/include/llvm/DebugInfo/DWARFExpression.h

80 ↗

(On Diff #112622)

extract

82 ↗

(On Diff #112622)

print

[probinson]

There are two copies of DWARFExpression.h?

Aesthetically the parens around the output location list look weird. But if that's one at some higher level I guess we can live with it.

[rnk]

llvm/include/llvm/DebugInfo/DWARFExpression.h

80 ↗

(On Diff #112622)

Hm, this appears to be a duplicate file from the rebase. I've removed it.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

25 ↗

(On Diff #112622)

Maybe this could be an ArrayRef.

106 ↗

(On Diff #112622)

Descriptions actually has 256 entries, and the opcodes are one byte, so this can't fail as written.

[rnk]

• updated, 25 test failures remaining

[dblaikie]

(Adrian: Reckon it's worth dropping the "OP_" prefix too, to simplify? (or bump it up to "DW_OP_" and then maybe have the brief version drop "DW_X_" prefixes across the board (since they're unambiguous?)

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

72 ↗

(On Diff #112744)

Worth switching this from 'unsigned char' to 'char' to avoid the conversions back and forth on reading/writing? (more compatible with DataExtractor, etc)

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

125 ↗

(On Diff #112744)

What's the point of this function? Since the DWARFExpression is already a range it seems strange to have a range accessor on top of that. It's used in one place where "operations()" could be replaced with "*this" I think?

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870–871 ↗

(On Diff #112744)

Worth fixing sooner rather than later? (ie: before this is committed) - maybe a callback for warnings here?

(in addition to racing, it's not re-usable - multiple uses of libDebugInfo in a single process would see this only once which seems unfortunate)

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

32–33 ↗

(On Diff #112744)

Formatting (I guess there should be spaces around the '+')

32–33 ↗

(On Diff #112744)

This handling of the base address could probably be a separate patch & would justify plumbing through the DWARFUnit, etc, simplifying this patch that needs it for the expression dumping as well.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

104 ↗

(On Diff #112744)

Prefer !empty over size, I think. (similarly below)

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

32–33 ↗

(On Diff #112744)

This reinitializes (possibly racing) the vector contents every time it's called? Maybe use {} init instead?

(I see it's static and only called once, but still a bit weird - I'd probably just drop this function and use {} init in the function below that needs it)

[rnk]

• fix all remaining tests

[rnk]

I think the remaining concerns are:

1. Should we split the location list base address change into another patch
2. Should we try to avoid one-time dynamic initialization for the DW_OP description table
3. Should we remove the "OP_" prefix

In general, I'd like to defer anything that people feel can wait, so that I can minimize the amount of time that I'm carrying this patch locally. It has a high risk for conflicts vs. people adding new dwarf tests, and I've already put in a lot of work updating the test suite.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

125 ↗

(On Diff #112744)

Good question, removed.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870–871 ↗

(On Diff #112744)

I made this an optional method that the creator can call to enable register name dumping. It returns an error. All clients that don't call it will just get dumps like "OP_reg5" instead of "OP_reg5 RDI", which isn't a big deal.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

32–33 ↗

(On Diff #112744)

The problem with braced initialization is that not all 256 entries are filled, so it requires duplicating not just the order of the expression opcode entries, but also the values. I didn't like that. We could make the Descriptions vector not be static, and make the caller take the vector by value so it owns it.

I was able to rewrite this to return a constexpr array inside a struct wrapper, but MSVC didn't like it.

[rnk]

• Address David's comments

[aprantl]

In D37123#854201, @rnk wrote:

I think the remaining concerns are:

1. Should we split the location list base address change into another patch

Typically the answer to the question whether we should split up a patch is always yes, but I'm fine either way.

2. Should we try to avoid one-time dynamic initialization for the DW_OP description table

Would it perhaps make sense to initialize the table from the macros in Dwarf.def?

3. Should we remove the "OP_" prefix

I think we should implement two behaviors: When DumpOptions::Brief is set, we should print expressions with DW_OP_ stripped and registers in human-readable form, e.g.: rdi+42, deref, stack-value, otherwise it should print the full expression, e.g.: DW_OP_breg1, DW_OP_constu 42, DW_OP_deref, DW_OP_stack_value.

(And at some point soon, I'll upload a patch to make brief the default instead of verbose).

In general, I'd like to defer anything that people feel can wait, so that I can minimize the amount of time that I'm carrying this patch locally. It has a high risk for conflicts vs. people adding new dwarf tests, and I've already put in a lot of work updating the test suite.

Makes sense!

[rnk]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

248–251 ↗

(On Diff #112911)

When I tried factoring out the base address patch, I ran into this comment. How would we do this correctly? What scenario would cause us to pick the wrong compile unit? Picking the wrong compile unit would add the wrong base address to the .debug_loc entries.

[rnk]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

248–251 ↗

(On Diff #112911)

I've convinced myself that this code is wrong and we actually have a test in tree for this. It doesn't test the two-CU location list case, though, so it wasn't obvious to me that this was wrong.

I'll revert this change. Most of the value is in the expression printing, not the base address change.

[rnk]

• Revert CU base address adjustment from location list dumps
• Remove all DWARFUnit threading

[dblaikie]

2. Should we try to avoid one-time dynamic initialization for the DW_OP description table

Would it perhaps make sense to initialize the table from the macros in Dwarf.def?

+1, worth considering.

3. Should we remove the "OP_" prefix

I think we should implement two behaviors: When DumpOptions::Brief is set, we should print expressions with DW_OP_ stripped and registers in human-readable form, e.g.: rdi+42, deref, stack-value, otherwise it should print the full expression, e.g.: DW_OP_breg1, DW_OP_constu 42, DW_OP_deref, DW_OP_stack_value.

Sounds good & consistent to me!

(And at some point soon, I'll upload a patch to make brief the default instead of verbose).

Excellent

With all that in mind - Signing off on this contingent on removing teh drop(3) (so printing DW_OP_* rather than OP_*). Considering all the other stuff for consideration before or shortly after this is committed, as you see fit, Reid.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

100 ↗

(On Diff #112973)

Naming the variable the same as the type is a bit awkward (given the need to then qualify the class name later ("class Op")) - maybe 'O' would do? The scope's short enough the name shouldn't be too confusing.

Or naming the type "Operation" might be helpful.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

106 ↗

(On Diff #112622)

Then shouldn't the parameter be a one byte sized type & that ought to follow through to the source of the data?

228 ↗

(On Diff #112973)

Reckon it's worth dropping 6? (OP_ is pretty redundant)

Though as-is, or with that suggestion, it's a bit inconsistent with our other DWARF enum printing (that keeps the DW_ prefix).

Maybe we should just drop the DW_ suffix everywhere? (I wonder about dropping DW_*_ everywhere - but maybe that'll only be done in 'brief' mode)

[dblaikie]

Helps if I actually 'accept'...

[aprantl]

Awesome, I can't wait for this to land!

[rnk]

In D37123#854976, @dblaikie wrote:

2. Should we try to avoid one-time dynamic initialization for the DW_OP description table

Would it perhaps make sense to initialize the table from the macros in Dwarf.def?

+1, worth considering.

3. Should we remove the "OP_" prefix

I think we should implement two behaviors: When DumpOptions::Brief is set, we should print expressions with DW_OP_ stripped and registers in human-readable form, e.g.: rdi+42, deref, stack-value, otherwise it should print the full expression, e.g.: DW_OP_breg1, DW_OP_constu 42, DW_OP_deref, DW_OP_stack_value.

Sounds good & consistent to me!

(And at some point soon, I'll upload a patch to make brief the default instead of verbose).

Excellent

With all that in mind - Signing off on this contingent on removing teh drop(3) (so printing DW_OP_* rather than OP_*). Considering all the other stuff for consideration before or shortly after this is committed, as you see fit, Reid.

Got it. It's easy to go from OP_ to DW_OP_, but a lot harder to go from no prefix to DW_OP_ prefix...

[rnk]

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

228 ↗

(On Diff #112973)

To be clear, my plan is to emit DW_OP_ for now. We can shorten it by default or with a flag in a follow up.

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

 #include <cstdint>
 #include <deque>
 #include <map>
 #include <memory>
 
 namespace llvm {
 
 class DataExtractor;
+class MCRegisterInfo;
 class MemoryBuffer;
 class raw_ostream;
 
 /// Used as a return value for a error callback passed to DWARF context.
 /// Callback should return Halt if client application wants to stop
 /// object parsing, or should return Continue otherwise.
 enum class ErrorPolicy { Halt, Continue };
 
struct DWOFile {
     object::OwningBinary<object::ObjectFile> File;
     std::unique_ptr<DWARFContext> Context;
   };
   StringMap<std::weak_ptr<DWOFile>> DWOFiles;
   std::weak_ptr<DWOFile> DWP;
   bool CheckedForDWP = false;
   std::string DWPName;
 
+  std::unique_ptr<MCRegisterInfo> RegInfo;
+
   /// Read compile units from the debug_info section (if necessary)
   /// and store them in CUs.
   void parseCompileUnits();
 
   /// Read type units from the debug_types sections (if necessary)
   /// and store them in TUs.
   void parseTypeUnits();
 
   /// Read compile units from the debug_info.dwo section (if necessary)
   /// and store them in DWOCUs.
   void parseDWOCompileUnits();
 
   /// Read type units from the debug_types.dwo section (if necessary)
   /// and store them in DWOTUs.
   void parseDWOTypeUnits();
 
 protected:
   std::unique_ptr<const DWARFObject> DObj;
 
 public:
   DWARFContext(std::unique_ptr<const DWARFObject> DObj,
-               std::string DWPName = "")
-      : DIContext(CK_DWARF), DWPName(std::move(DWPName)),
-        DObj(std::move(DObj)) {}
+               std::string DWPName = "");
+  ~DWARFContext();
+
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
 
   const DWARFObject &getDWARFObj() const { return *DObj; }
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
public:
 
   bool isLittleEndian() const { return DObj->isLittleEndian(); }
   static bool isSupportedVersion(unsigned version) {
     return version == 2 || version == 3 || version == 4 || version == 5;
   }
 
   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
 
+  const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
+
   /// Function used to handle default error reporting policy. Prints a error
   /// message and returns Continue, so DWARF context ignores the error.
   static ErrorPolicy defaultErrorHandler(Error E);
   static std::unique_ptr<DWARFContext>
   create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
          function_ref<ErrorPolicy(Error)> HandleError = defaultErrorHandler,
          std::string DWPName = "");
 
   static std::unique_ptr<DWARFContext>
   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost);
 
+  /// Loads register info for the architecture of the provided object file.
+  /// Improves readability of dumped DWARF expressions. Requires the caller to
+  /// have initialized the relevant target descriptions.
+  Error loadRegisterInfo(const object::ObjectFile &Obj);
+
 private:
   /// Return the compile unit that includes an offset (relative to .debug_info).
   DWARFCompileUnit *getCompileUnitForOffset(uint32_t Offset);
 
   /// Return the compile unit which contains instruction with provided
   /// address.
   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

llvm/trunk/include/llvm/DebugInfo/DWARF/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_DEBUGINFO_DWARF_DWARFDEBUGLOC_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include <cstdint>
 
 namespace llvm {
-
+class DWARFUnit;
+class MCRegisterInfo;
 class raw_ostream;
 
 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;
+    SmallVector<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, bool IsLittleEndian, unsigned AddressSize,
+              const MCRegisterInfo *MRI, unsigned Indent) const;
   };
 
+private:
   using LocationLists = SmallVector<LocationList, 4>;
 
   /// A list of all the variables in the debug_loc section, each one describing
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
+  unsigned AddressSize;
+
+  bool IsLittleEndian;
+
 public:
   /// Print the location lists found within the debug_loc section.
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) 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);
+
+  Optional<LocationList> parseOneLocationList(DWARFDataExtractor Data,
+                                              uint32_t *Offset);
 };
 
 class DWARFDebugLocDWO {
+public:
   struct Entry {
     uint64_t Start;
     uint32_t Length;
-    SmallVector<unsigned char, 4> Loc;
+    SmallVector<char, 4> Loc;
   };
 
   struct LocationList {
     unsigned Offset;
     SmallVector<Entry, 2> Entries;
+    void dump(raw_ostream &OS, bool IsLittleEndian, unsigned AddressSize,
+              const MCRegisterInfo *RegInfo, unsigned Indent) const;
   };
 
+private:
   using LocationLists = SmallVector<LocationList, 4>;
 
   LocationLists Locations;
 
+  unsigned AddressSize;
+
+  bool IsLittleEndian;
+
 public:
   void parse(DataExtractor data);
-  void dump(raw_ostream &OS) const;
+  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo) const;
+
+  static Optional<LocationList> parseOneLocationList(DataExtractor Data,
+                                                     uint32_t *Offset);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

llvm/trunk/include/llvm/DebugInfo/DWARF/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/ArrayRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+class DWARFUnit;
+class MCRegisterInfo;
+class raw_ostream;
+
+class DWARFExpression {
+public:
+  class iterator;
+
+  /// This class represents an Operation in the Expression. Each operation can
+  /// have up to 2 oprerands.
+  ///
+  /// An Operation can be in Error state (check with isError()). This
+  /// means that it couldn't be decoded successfully and if it is the
+  /// case, all others fields contain undefined values.
+  class Operation {
+  public:
+    /// 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
+    };
+
+    /// 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; ///< The Op Opcode, DW_OP_<something>.
+    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, uint16_t Version, uint8_t AddressSize,
+                 uint32_t Offset);
+    bool isError() { return Error; }
+    bool print(raw_ostream &OS, const DWARFExpression *U,
+               const MCRegisterInfo *RegInfo, bool isEH);
+  };
+
+  /// An iterator to go through the expression operations.
+  class iterator
+      : public iterator_facade_base<iterator, std::forward_iterator_tag, Operation> {
+    friend class DWARFExpression;
+    DWARFExpression *Expr;
+    uint32_t Offset;
+    Operation Op;
+    iterator(DWARFExpression *Expr, uint32_t Offset)
+        : Expr(Expr), Offset(Offset) {
+      Op.Error =
+          Offset >= Expr->Data.getData().size() ||
+          !Op.extract(Expr->Data, Expr->Version, Expr->AddressSize, Offset);
+    }
+
+  public:
+    class Operation &operator++() {
+      Offset = Op.isError() ? Expr->Data.getData().size() : Op.EndOffset;
+      Op.Error =
+          Offset >= Expr->Data.getData().size() ||
+          !Op.extract(Expr->Data, Expr->Version, Expr->AddressSize, Offset);
+      return Op;
+    }
+
+    class Operation &operator*() {
+      return Op;
+    }
+
+    // Comparison operators are provided out of line.
+    friend bool operator==(const iterator &, const iterator &);
+  };
+
+  DWARFExpression(DataExtractor Data, uint16_t Version, uint8_t AddressSize)
+      : Data(Data), Version(Version), AddressSize(AddressSize) {
+    assert(AddressSize == 8 || AddressSize == 4);
+  }
+
+  iterator begin() { return iterator(this, 0); }
+  iterator end() { return iterator(this, Data.getData().size()); }
+
+  void print(raw_ostream &OS, const MCRegisterInfo *RegInfo);
+
+private:
+  DataExtractor Data;
+  uint16_t Version;
+  uint8_t AddressSize;
+};
+
+inline bool operator==(const DWARFExpression::iterator &LHS,
+                       const DWARFExpression::iterator &RHS) {
+  return LHS.Expr == RHS.Expr && LHS.Offset == RHS.Offset;
+}
+
+inline bool operator!=(const DWARFExpression::iterator &LHS,
+                       const DWARFExpression::iterator &RHS) {
+  return !(LHS == RHS);
+}
+}
+#endif

llvm/trunk/lib/DebugInfo/DWARF/CMakeLists.txt

add_llvm_library(LLVMDebugInfoDWARF
   DWARFDebugFrame.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugLoc.cpp
   DWARFDebugMacro.cpp
   DWARFDebugPubTable.cpp
   DWARFDebugRangeList.cpp
   DWARFDie.cpp
+  DWARFExpression.cpp
   DWARFFormValue.cpp
   DWARFGdbIndex.cpp
   DWARFTypeUnit.cpp
   DWARFUnitIndex.cpp
   DWARFUnit.cpp
   DWARFVerifier.cpp
   SyntaxHighlighting.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
   )

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

 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Object/Decompressor.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocVisitor.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
 
 #define DEBUG_TYPE "dwarf"
 
 using DWARFLineTable = DWARFDebugLine::LineTable;
 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind;
 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
 
+DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj,
+                           std::string DWPName)
+    : DIContext(CK_DWARF), DWPName(std::move(DWPName)), DObj(std::move(DObj)) {}
+
+DWARFContext::~DWARFContext() = default;
+
 static void dumpAccelSection(raw_ostream &OS, StringRef Name,
                              const DWARFObject &Obj,
                              const DWARFSection &Section,
                              StringRef StringSection, bool LittleEndian) {
   DWARFDataExtractor AccelSection(Obj, Section, LittleEndian, 0);
   DataExtractor StrData(StringSection, LittleEndian, 0);
   OS << "\n." << Name << " contents:\n";
   DWARFAcceleratorTable Accel(AccelSection, StrData);
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, SummarizeTypes);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Loc) {
     OS << "\n.debug_loc contents:\n";
-    getDebugLoc()->dump(OS);
+    getDebugLoc()->dump(OS, getRegisterInfo());
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) {
     OS << "\n.debug_loc.dwo contents:\n";
-    getDebugLocDWO()->dump(OS);
+    getDebugLocDWO()->dump(OS, getRegisterInfo());
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
     if (DumpEH) {
       OS << "\n.eh_frame contents:\n";
       getEHFrame()->dump(OS);

 
 std::unique_ptr<DWARFContext>
 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
                      uint8_t AddrSize, bool isLittleEndian) {
   auto DObj =
       llvm::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
   return llvm::make_unique<DWARFContext>(std::move(DObj), "");
 }
+
+Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
+  // Detect the architecture from the object file. We usually don't need OS
+  // info to lookup a target and create register info.
+  Triple TT;
+  TT.setArch(Triple::ArchType(Obj.getArch()));
+  TT.setVendor(Triple::UnknownVendor);
+  TT.setOS(Triple::UnknownOS);
+  std::string TargetLookupError;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
+  if (!TargetLookupError.empty())
+    return make_error<StringError>(TargetLookupError, inconvertibleErrorCode());
+  RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
+  return Error::success();
+}

llvm/trunk/lib/DebugInfo/DWARF/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/DWARF/DWARFDebugLoc.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstdint>
 
 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";
-    }
+// When directly dumping the .debug_loc without a compile unit, we have to guess
+// at the DWARF version. This only affects DW_OP_call_ref, which is a rare
+// expression that LLVM doesn't produce. Guessing the wrong version means we
+// won't be able to pretty print expressions in DWARF2 binaries produced by
+// non-LLVM tools.
+static void dumpExpression(raw_ostream &OS, ArrayRef<char> Data,
+                           bool IsLittleEndian, unsigned AddressSize,
+                           const MCRegisterInfo *MRI) {
+  DWARFDataExtractor Extractor(StringRef(Data.data(), Data.size()),
+                               IsLittleEndian, AddressSize);
+  DWARFExpression(Extractor, AddressSize, dwarf::DWARF_VERSION).print(OS, MRI);
+}
+
+void DWARFDebugLoc::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
+                                       unsigned AddressSize,
+                                       const MCRegisterInfo *MRI,
+                                       unsigned Indent) const {
+  for (const Entry &E : Entries) {
+    OS << '\n';
+    OS << format("0x%016" PRIx64, E.Begin) << " - "
+       << format("0x%016" PRIx64, E.End) << ": ";
+
+    dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
+
+void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI) const {
+  for (const LocationList &L : Locations) {
+    OS << format("0x%8.8x: ", L.Offset);
+    L.dump(OS, IsLittleEndian, AddressSize, MRI, 12);
+    OS << "\n\n";
   }
 }
 
-void DWARFDebugLoc::parse(const DWARFDataExtractor &data) {
-  uint32_t Offset = 0;
-  while (data.isValidOffset(Offset+data.getAddressSize()-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) {
-      // A beginning and ending address offsets.
-      Entry E;
-      E.Begin = data.getRelocatedAddress(&Offset);
-      E.End = data.getRelocatedAddress(&Offset);
+Optional<DWARFDebugLoc::LocationList>
+DWARFDebugLoc::parseOneLocationList(DWARFDataExtractor Data, unsigned *Offset) {
+  LocationList LL;
+  LL.Offset = *Offset;
+
+    if (!Data.isValidOffsetForDataOfSize(*Offset, 2 * Data.getAddressSize())) {
+      llvm::errs() << "Location list overflows the debug_loc section.\n";
+      return None;
+    }
+
+    // 1. A beginning address offset. ...
+    E.Begin = Data.getRelocatedAddress(Offset);
+
+    // 2. An ending address offset. ...
+    E.End = Data.getRelocatedAddress(Offset);
 
-      // 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;
+
+    if (!Data.isValidOffsetForDataOfSize(*Offset, 2)) {
+      llvm::errs() << "Location list overflows the debug_loc section.\n";
+      return None;
+    }
 
-      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.append(str.begin(), str.end());
-      Loc.Entries.push_back(std::move(E));
-    }
-  }
+    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;
+    E.Loc.reserve(str.size());
+    std::copy(str.begin(), str.end(), std::back_inserter(E.Loc));
+    LL.Entries.push_back(std::move(E));
+
+void DWARFDebugLoc::parse(const DWARFDataExtractor &data) {
+  IsLittleEndian = data.isLittleEndian();
+  AddressSize = data.getAddressSize();
+
+  uint32_t Offset = 0;
+  while (data.isValidOffset(Offset + data.getAddressSize() - 1)) {
+    if (auto LL = parseOneLocationList(data, &Offset))
+      Locations.push_back(std::move(*LL));
+    else
+      break;
+  }
   if (data.isValidOffset(Offset))
     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) {
-
-      if (Kind != dwarf::DW_LLE_startx_length) {
-        errs() << "error: dumping support for LLE of kind " << (int)Kind
+Optional<DWARFDebugLocDWO::LocationList>
+DWARFDebugLocDWO::parseOneLocationList(DataExtractor Data, unsigned *Offset) {
+  LocationList LL;
+  LL.Offset = *Offset;
+
+  // dwarf::DW_LLE_end_of_list_entry is 0 and indicates the end of the list.
+  while (auto Kind =
+             static_cast<dwarf::LocationListEntry>(Data.getU8(Offset))) {
+      llvm::errs() << "error: dumping support for LLE of kind " << (int)Kind
                    << " not implemented\n";
-        return;
-      }
+      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) {
+  IsLittleEndian = data.isLittleEndian();
+  AddressSize = data.getAddressSize();
+
+  uint32_t Offset = 0;
+  while (data.isValidOffset(Offset)) {
+    if (auto LL = parseOneLocationList(data, &Offset))
+      Locations.push_back(std::move(*LL));
+    else
+      return;
+
+void DWARFDebugLocDWO::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
+                                          unsigned AddressSize,
+                                          const MCRegisterInfo *MRI,
+                                          unsigned Indent) const {
+  for (const Entry &E : Entries) {
+    OS << '\n';
+    OS.indent(Indent);
+    OS << "Addr idx " << E.Start << " (w/ length " << E.Length << "): ";
+    dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
+  }
 }
 
-void DWARFDebugLocDWO::dump(raw_ostream &OS) const {
+void DWARFDebugLocDWO::dump(raw_ostream &OS, const MCRegisterInfo *MRI) 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, IsLittleEndian, AddressSize, MRI, /*Indent=*/12);

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

 #include "SyntaxHighlighting.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
for (size_t I = 0; I < Ranges.size(); ++I) {
     OS << " \"" << Name << '\"';
 
     // Print section index if name is not unique.
     if (!SectionNames[R.SectionIndex].IsNameUnique)
       OS << format(" [%" PRIu64 "]", R.SectionIndex);
   }
 }
 
+static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
+                         DWARFUnit *U, unsigned Indent) {
+  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);
+    return;
+  }
+
+  FormValue.dump(OS);
+  if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
+    const DWARFSection &LocSection = Obj.getLocSection();
+    const DWARFSection &LocDWOSection = Obj.getLocDWOSection();
+    uint32_t Offset = *FormValue.getAsSectionOffset();
+
+    if (!LocSection.Data.empty()) {
+      DWARFDebugLoc DebugLoc;
+      DWARFDataExtractor Data(Obj, LocSection, Ctx.isLittleEndian(),
+                              Obj.getAddressSize());
+      auto LL = DebugLoc.parseOneLocationList(Data, &Offset);
+      if (LL)
+        LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
+      else
+        OS << "error extracting location list.";
+    } else if (!LocDWOSection.Data.empty()) {
+      DataExtractor Data(LocDWOSection.Data, Ctx.isLittleEndian(), 0);
+      auto LL = DWARFDebugLocDWO::parseOneLocationList(Data, &Offset);
+      if (LL)
+        LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
+      else
+        OS << "error extracting location list.";
+    }
+  }
+}
+
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           uint32_t *OffsetPtr, dwarf::Attribute Attr,
                           dwarf::Form Form, unsigned Indent,
                           DIDumpOptions DumpOpts) {
   if (!Die.isValid())
     return;
   const char BaseIndent[] = "            ";
   OS << BaseIndent;
if (const auto *LT = U->getContext().getLineTableForUnit(U))
       }
   } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
     Name = AttributeValueString(Attr, *Val);
 
   if (!Name.empty())
     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, DumpOpts);
 
   // 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) {
     if (const char *Name = Die.getAttributeValueAsReferencedDie(Attr).getName(DINameKind::LinkageName))

llvm/trunk/lib/DebugInfo/DWARF/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/DebugInfo/DWARF/DWARFExpression.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/Support/Format.h"
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+using namespace llvm;
+using namespace dwarf;
+
+namespace llvm {
+
+typedef std::vector<DWARFExpression::Operation::Description> DescVector;
+
+static DescVector getDescriptions() {
+  DescVector Descriptions;
+  typedef DWARFExpression::Operation 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::Operation::Description getOpDesc(unsigned OpCode) {
+  // FIXME: Make this constexpr once all compilers are smart enough to do it.
+  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::Operation::extract(DataExtractor Data, uint16_t Version,
+                                         uint8_t AddressSize, uint32_t Offset) {
+  Opcode = Data.getU8(&Offset);
+
+  Desc = getOpDesc(Opcode);
+  if (Desc.Version == Operation::DwarfNA)
+    return false;
+
+  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+    unsigned Size = Desc.Op[Operand];
+    unsigned Signed = Size & Operation::SignBit;
+
+    if (Size == Operation::SizeNA)
+      break;
+
+    switch (Size & ~Operation::SignBit) {
+    case Operation::Size1:
+      Operands[Operand] = Data.getU8(&Offset);
+      if (Signed)
+        Operands[Operand] = (int8_t)Operands[Operand];
+      break;
+    case Operation::Size2:
+      Operands[Operand] = Data.getU16(&Offset);
+      if (Signed)
+        Operands[Operand] = (int16_t)Operands[Operand];
+      break;
+    case Operation::Size4:
+      Operands[Operand] = Data.getU32(&Offset);
+      if (Signed)
+        Operands[Operand] = (int32_t)Operands[Operand];
+      break;
+    case Operation::Size8:
+      Operands[Operand] = Data.getU64(&Offset);
+      break;
+    case Operation::SizeAddr:
+      if (AddressSize == 8) {
+        Operands[Operand] = Data.getU64(&Offset);
+      } else {
+        assert(AddressSize == 4);
+        Operands[Operand] = Data.getU32(&Offset);
+      }
+      break;
+    case Operation::SizeRefAddr:
+      if (getRefAddrSize(AddressSize, Version) == 8) {
+        Operands[Operand] = Data.getU64(&Offset);
+      } else {
+        assert(getRefAddrSize(AddressSize, Version) == 4);
+        Operands[Operand] = Data.getU32(&Offset);
+      }
+      break;
+    case Operation::SizeLEB:
+      if (Signed)
+        Operands[Operand] = Data.getSLEB128(&Offset);
+      else
+        Operands[Operand] = Data.getULEB128(&Offset);
+      break;
+    case Operation::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) {
+  if (!MRI)
+    return false;
+
+  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->getLLVMRegNum(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::Operation::print(raw_ostream &OS,
+                                       const DWARFExpression *Expr,
+                                       const MCRegisterInfo *RegInfo,
+                                       bool isEH) {
+  if (Error) {
+    OS << "decoding error.";
+    return false;
+  }
+
+  StringRef Name = OperationEncodingString(Opcode);
+  assert(!Name.empty() && "DW_OP has no name!");
+  OS << Name;
+
+  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 (prettyPrintRegisterOp(OS, Opcode, Operands, RegInfo, isEH))
+      return true;
+
+  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+    unsigned Size = Desc.Op[Operand];
+    unsigned Signed = Size & Operation::SignBit;
+
+    if (Size == Operation::SizeNA)
+      break;
+
+    if (Size == Operation::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, const MCRegisterInfo *RegInfo) {
+  for (auto &Op : *this) {
+    if (!Op.print(OS, this, RegInfo, /* isEH */ false)) {
+      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

llvm/trunk/lib/DebugInfo/DWARF/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = DebugInfoDWARF
 parent = DebugInfo
-required_libraries = BinaryFormat Object Support
+required_libraries = BinaryFormat Object MC Support

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

 ; RUN: llc -arm-global-merge -global-merge-group-by-use=false -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 source_filename = "test/CodeGen/ARM/2011-01-19-MergedGlobalDbg.ll"
 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-darwin10"
 
 @x1 = internal global i8 1, align 1, !dbg !0
 @x2 = internal global i8 1, align 1, !dbg !4
 @x3 = internal global i8 1, align 1, !dbg !6
 @x4 = internal global i8 1, align 1, !dbg !8
 @x5 = global i8 1, align 1, !dbg !10
-; 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]        (<0x5> 03 [[ADDR:.. .. .. ..]]   )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr [[ADDR:0x[0-9a-fA-F]+]])
 ; 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]        (<0x7> 03 [[ADDR]] 23 01  )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr [[ADDR]], DW_OP_plus_uconst 0x1)
 
 ; Function Attrs: nounwind optsize
 define zeroext i8 @get1(i8 zeroext %a) #0 !dbg !16 {
 entry:
   tail call void @llvm.dbg.value(metadata i8 %a, metadata !20, metadata !23), !dbg !24
   %0 = load i8, i8* @x1, align 4, !dbg !24
   tail call void @llvm.dbg.value(metadata i8 %0, metadata !21, metadata !23), !dbg !24
   store i8 %a, i8* @x1, align 4, !dbg !24

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

 ; RUN: llc -arm-global-merge -global-merge-group-by-use=false -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]        (<0x5> 03 [[ADDR:.. .. .. ..]]   )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr [[ADDR:0x[0-9a-fA-F]+]])
 ; 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]        (<0x7> 03 [[ADDR]] 23 04  )
+; CHECK:    DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr [[ADDR]], DW_OP_plus_uconst 0x4)
 
 source_filename = "test/CodeGen/ARM/2011-08-02-MergedGlobalDbg.ll"
 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, !dbg !0
 @x2 = internal unnamed_addr global i32 2, align 4, !dbg !6
 @x3 = internal unnamed_addr global i32 3, align 4

llvm/trunk/test/CodeGen/ARM/debug-info-blocks.ll

 ; RUN: llc -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s
 
 ; debug_info content
 ; CHECK: DW_AT_name {{.*}} "foobar_func_block_invoke_0"
 ; CHECK-NOT: DW_TAG_subprogram
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] ([[MYDATA_LOC:0x[0-9a-f]*]])
+; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
+; CHECK-NEXT:    0x{{.*}} - 0x{{.*}}: {{.*}} DW_OP_plus_uconst 0x4, DW_OP_deref, DW_OP_plus_uconst 0x18
+; CHECK-NEXT:    0x{{.*}} - 0x{{.*}}: {{.*}} DW_OP_plus_uconst 0x4, DW_OP_deref, DW_OP_plus_uconst 0x18
 ; CHECK-NEXT: DW_AT_name {{.*}} "mydata"
 
-; debug_loc content
-; CHECK: .debug_loc contents:
-; CHECK: [[MYDATA_LOC]]: Beginning address offset: {{.*}}
-; CHECK-NOT: {{0x[0-9a-f]*}}: Beginning address offset
-; CHECK: Location description: {{.*}} 23 04 06 23 18
-; CHECK-NOT: {{0x[0-9a-f]*}}: Beginning address offset
-; CHECK: Location description: {{.*}} 23 04 06 23 18
-
 ; Radar 9331779
 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-ios"
 
 %0 = type opaque
 %1 = type { [4 x i32] }
 %2 = type <{ i8*, i32, i32, i8*, %struct.Re*, i8*, %3*, %struct.my_struct* }>
 %3 = type opaque

llvm/trunk/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]*}}: 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/trunk/test/CodeGen/X86/2010-01-18-DbgValue.ll

 ; RUN: llc -mtriple=i686-- -O0 < %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK-LABEL: .debug_info contents:
 
 ; CHECK-LABEL: DW_TAG_subprogram
 ; CHECK:   DW_AT_name [DW_FORM_strp]       ( {{.*}}"foo")
 ; CHECK:   DW_TAG_formal_parameter
-; CHECK-NEXT:     DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 {{..}} )
-;                                                             DW_OP_fbreg ??
+; CHECK-NEXT:     DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg {{[^ ]*}})
 ; CHECK-NEXT:     DW_AT_name [DW_FORM_strp]     ( {{.*}}"my_r0")
 
 %struct.Pt = type { double, double }
 %struct.Rect = type { %struct.Pt, %struct.Pt }
 
 define double @foo(%struct.Rect* byval %my_r0) nounwind ssp !dbg !1 {
 entry:
   %retval = alloca double                         ; <double*> [#uses=2]

llvm/trunk/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|AT}}
+; 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"

llvm/trunk/test/CodeGen/X86/dbg-baseptr.ll

 define i32 @f0(%struct.s* byval align 8 %input) !dbg !8 {
   call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !4, metadata !17), !dbg !18
   ret i32 42, !dbg !18
 }
 
 ; DWARF-LABEL: .debug_info contents:
 
 ; DWARF-LABEL: DW_TAG_subprogram
-; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (<0x1> 57 )
-;                                                       0x57 -> RSP
+; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (DW_OP_reg7 RSP)
 ; DWARF:   DW_AT_name [DW_FORM_strp]       ( {{.*}}"f0")
 ; DWARF:   DW_TAG_formal_parameter
-; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 08 )
-;                                                        DW_OP_fbreg (0x91) 0x08
+; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +8)
 ; DWARF-NEXT:     DW_AT_name [DW_FORM_strp]     ( {{.*}}"input")
 
 
 ; Dynamic alloca forces the use of RBP as the base pointer
 
 ; CHECK-LABEL: f1:
 ; CHECK: pushq %rbp
 ; CHECK: movl $42, %eax
 ; CHECK: popq %rbp
 ; CHECK: retq
 define i32 @f1(%struct.s* byval align 8 %input) !dbg !19 {
   %val = load i64, i64* @glob
   ; this alloca should force FP usage.
   %stackspace = alloca i32, i64 %val, align 1
   store i32* %stackspace, i32** @ptr
   call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !20, metadata !17), !dbg !21
   ret i32 42, !dbg !21
 }
 
 ; DWARF-LABEL: DW_TAG_subprogram
-; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (<0x1> 56 )
-;                                                       0x56 -> RBP
+; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (DW_OP_reg6 RBP)
 ; DWARF:   DW_AT_name [DW_FORM_strp]       ( {{.*}}"f1")
 ; DWARF:   DW_TAG_formal_parameter
-; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 10 )
-;                                                        DW_OP_fbreg (0x91) 0x10
+; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +16)
 ; DWARF-NEXT:     DW_AT_name [DW_FORM_strp]     ( {{.*}}"input")
 
 ; CHECK-LABEL: f2:
 ; Just check that we are indeed aligning the stack and setting up a base pointer
 ; in RBX.
 ; CHECK: pushq %rbp
 ; CHECK: movq %rsp, %rbp
 ; CHECK: pushq %rbx
 ; CHECK: andq $-64, %rsp
 ; CHECK: subq $64, %rsp
 ; CHECK: movq %rsp, %rbx
 define i32 @f2(%struct.s* byval align 8 %input) !dbg !22 {
   %val = load i64, i64* @glob
   %stackspace = alloca i32, i64 %val, align 64
   store i32* %stackspace, i32** @ptr
   call void @llvm.dbg.declare(metadata %struct.s* %input, metadata !23, metadata !17), !dbg !24
   ret i32 42, !dbg !24
 }
 
 ; "input" should still be referred to through RBP.
 ; DWARF-LABEL: DW_TAG_subprogram
-; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (<0x1> 56 )
-;                                                       0x56 -> RBP
+; DWARF:   DW_AT_frame_base [DW_FORM_exprloc]      (DW_OP_reg6 RBP)
 ; DWARF:   DW_AT_name [DW_FORM_strp]       ( {{.*}}"f2")
 ; DWARF:   DW_TAG_formal_parameter
-; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 10 )
-;                                                        DW_OP_fbreg (0x91) 0x10
+; DWARF-NEXT:     DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +16)
 ; DWARF-NEXT:     DW_AT_name [DW_FORM_strp]     ( {{.*}}"input")
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!0, !1}
 
 !0 = !{i32 2, !"Dwarf Version", i32 4}

llvm/trunk/test/DebugInfo/AArch64/asan-stack-vars.ll

 ;   @end
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT:   DW_AT_low_pc [DW_FORM_addr]     (0x0000000000000000)
 ; CHECK-NEXT:   DW_AT_high_pc [DW_FORM_addr]    ([[FN_END:.*]])
 ; CHECK: "_cmd"
 ; CHECK: DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location {{.*}} ([[OFS:.*]])
+; CHECK-NEXT: DW_AT_location
+; CHECK-NEXT:   0x{{0*}} - 0x{{.*}}:
+; CHECK-NOT:    DW_AT_
+; CHECK:        0x{{.*}} - [[FN_END]]:
 ; CHECK-NEXT: DW_AT_name {{.*}}"imageSize"
-;
-; CHECK: .debug_loc contents:
-; CHECK: [[OFS]]: Beginning address offset: 0x0000000000000000
-; CHECK_NOT: 0x{{.*}}: Beginning
-; CHECK:          Ending address offset: [[FN_END]]
 
 ; ModuleID = 'm.m'
 source_filename = "m.m"
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 target triple = "arm64-apple-ios"
 
 %0 = type opaque
 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }

llvm/trunk/test/DebugInfo/AArch64/bitfields.ll

 ; the storage unit to the high end of the bit field.
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"a"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x02)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x00)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 00
+; CHECK-NEXT: DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"b"
 ; CHECK-NOT: DW_TAG_member
-; CHECK:      DW_AT_data_member_location {{.*}} 04
+; CHECK:      DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x4)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"c"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x00)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 08
+; CHECK:      DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"d"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x1c)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x01)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 08
+; CHECK-NEXT: DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; ModuleID = 'bitfields.c'
 source_filename = "test/DebugInfo/AArch64/bitfields.ll"
 target datalayout = "E-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64_be--linux-gnu"
 
 %struct.bitfield = type <{ i8, [3 x i8], i64 }>
 

llvm/trunk/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, metadata !10, metadata !16), !dbg !17
   ; CHECK: .debug_info contents:
   ; CHECK: DW_TAG_variable
   ; CHECK-NEXT: DW_AT_location
+  ; CHECK-NEXT: DW_OP_breg31 WSP+12, DW_OP_deref
   ; CHECK-NEXT: DW_AT_name {{.*}}"size"
-  ; CHECK: .debug_loc contents:
-  ; Expecting the encoding for sp+12: DW_OP_breg31 0c
-  ; CHECK: Location description: 8f 0c
   ret void, !dbg !18
 }
 
 ; Function Attrs: optsize
 declare i8* @_Z3fooPv(i8*) #1
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) #2

llvm/trunk/test/DebugInfo/AArch64/frameindices.ll

 ; RUN: llc -disable-fp-elim -O0 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s
 ; Test that a variable with multiple entries in the MMI table makes it into the
 ; debug info.
 ;
 ; CHECK: DW_TAG_inlined_subroutine
 ; CHECK:    "_Z3f111A"
 ; CHECK: DW_TAG_formal_parameter
-; CHECK: DW_AT_location [DW_FORM_block1]    (<0x0c> 93 01 91 51 93 0f 93 01 91 4a 93 07 )
-;  -- piece 0x00000001, fbreg -47, piece 0x0000000f, piece 0x00000001, fbreg -54, piece 0x00000007 ------^
+; CHECK: DW_AT_location [DW_FORM_block1]    (DW_OP_piece 0x1, DW_OP_fbreg -47, DW_OP_piece 0xf, DW_OP_piece 0x1, DW_OP_fbreg -54, DW_OP_piece 0x7)
 ; CHECK: DW_AT_abstract_origin {{.*}} "p1"
 ;
 ; long a;
 ; struct A {
 ;   bool x4;
 ;   void *x5;
 ;   bool x6;
 ; };

llvm/trunk/test/DebugInfo/AMDGPU/variable-locations.ll

 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 ; CHECK: {{.*}}DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name {{.*}}"GlobA"
 ; CHECK-NEXT: DW_AT_type
 ; CHECK-NEXT: DW_AT_external
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x09> 03 00 00 00 00 00 00 00 00 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
 @GlobA = common addrspace(1) global i32 0, align 4, !dbg !0
 
 ; CHECK: {{.*}}DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name {{.*}}"GlobB"
 ; CHECK-NEXT: DW_AT_type
 ; CHECK-NEXT: DW_AT_external
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x09> 03 00 00 00 00 00 00 00 00 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
 @GlobB = common addrspace(1) global i32 0, align 4, !dbg !6
 
 define amdgpu_kernel void @kernel1(
 ; CHECK: {{.*}}DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x06> 91 04 10 01 16 18 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +4, DW_OP_constu 0x1, DW_OP_swap, DW_OP_xderef)
 ; CHECK-NEXT: DW_AT_name {{.*}}"ArgN"
     i32 %ArgN,
 ; CHECK: {{.*}}DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x06> 91 08 10 01 16 18 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +8, DW_OP_constu 0x1, DW_OP_swap, DW_OP_xderef)
 ; CHECK-NEXT: DW_AT_name {{.*}}"ArgA"
     i32 addrspace(1)* %ArgA,
 ; CHECK: {{.*}}DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (<0x06> 91 10 10 01 16 18 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +16, DW_OP_constu 0x1, DW_OP_swap, DW_OP_xderef)
 ; CHECK-NEXT: DW_AT_name {{.*}}"ArgB"
     i32 addrspace(1)* %ArgB) !dbg !13 {
 entry:
   %ArgN.addr = alloca i32, align 4
   %ArgA.addr = alloca i32 addrspace(1)*, align 4
   %ArgB.addr = alloca i32 addrspace(1)*, align 4
   store i32 %ArgN, i32* %ArgN.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %ArgN.addr, metadata !22, metadata !23), !dbg !24

llvm/trunk/test/DebugInfo/ARM/PR16736.ll

 ; RUN: llc -filetype=asm < %s | FileCheck %s
 ; RUN: llc -filetype=obj < %s \
-; RUN:   | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=DWARF
 ;
 ; CHECK: @DEBUG_VALUE: h:x <- [DW_OP_plus_uconst {{.*}}] [%R{{.*}}+0]
-; DWARF: Location description: {{7[0-9] [0-9]+ $}}
-;                              DW_OP_breg. +..
+; DWARF: DW_TAG_formal_parameter
+; DWARF:       DW_AT_location
+; DWARF-NEXT:    DW_OP_reg0 R0
+; DWARF: DW_TAG_formal_parameter
+; DWARF:       DW_AT_location
+; DWARF-NEXT:    DW_OP_reg1 R1
+; DWARF: DW_TAG_formal_parameter
+; DWARF:       DW_AT_location
+; DWARF-NEXT:    DW_OP_reg2 R2
+; DWARF: DW_TAG_formal_parameter
+; DWARF:       DW_AT_location
+; DWARF-NEXT:    DW_OP_reg3 R3
+; DWARF: DW_TAG_formal_parameter
+; DWARF: DW_AT_location
+; DWARF-NEXT: DW_OP_breg7 R7+8
 ; generated from:
 ; clang -cc1 -triple  thumbv7 -S -O1 arm.cpp  -g
 ;
 ; int f();
 ; void g(float);
 ; void h(int, int, int, int, float x) {
 ;    g(x = f());
 ; }

llvm/trunk/test/DebugInfo/ARM/PR26163.ll

-; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ;
 ; Checks that we're creating two ranges, one that terminates immediately
 ; and one that spans the rest of the function. This isn't necessarily the
 ; best thing to do here (and also not necessarily correct, since the first
 ; one has a bit_piece), but it is what is currently being emitted, any
 ; change here needs to be intentional, so the test is very specific.
 ;
-; CHECK: .debug_loc contents:
-; CHECK: 0x00000000: Beginning address offset: 0x0000000000000004
-; CHECK:                Ending address offset: 0x0000000000000004
-; CHECK:                 Location description: 10 00 9f
-; CHECK:             Beginning address offset: 0x0000000000000004
-; CHECK:                Ending address offset: 0x0000000000000014
-; CHECK:                 Location description: 10 00 9f
+; CHECK: DW_TAG_inlined_subroutine
+; CHECK: DW_TAG_variable
+; CHECK:   DW_AT_location [DW_FORM_sec_offset] ({{.*}}
+; CHECK:      0x0000000000000004 - 0x0000000000000004: DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x8
+; CHECK:      0x0000000000000004 - 0x0000000000000014: DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
 
 ; Created form the following test case (PR26163) with
 ; clang -cc1 -triple armv4t--freebsd11.0-gnueabi -emit-obj -debug-info-kind=standalone -O2 -x c test.c
 ;
 ; typedef unsigned int  size_t;
 ; struct timeval {
 ;   long long tv_sec;
 ;   int tv_usec;

llvm/trunk/test/DebugInfo/ARM/bitfield.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t.o %s
 ; RUN: llvm-dwarfdump -debug-dump=info %t.o | FileCheck %s
 ; REQUIRES: object-emission
 ;
 ; Generated from:
 ; struct {
 ;   char c;
 ;   int : 4;
 ;   int reserved : 28;
 ; } a;
 ;
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "reserved"
 ; CHECK:          DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK:          DW_AT_bit_size   {{.*}} (0x1c)
 ; CHECK:          DW_AT_bit_offset {{.*}} (0xfffffffffffffff8)
-; CHECK:          DW_AT_data_member_location {{.*}}00
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 source_filename = "test/DebugInfo/ARM/bitfield.ll"
 target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
 target triple = "thumbv7-apple-ios"
 
 %struct.anon = type { i8, [5 x i8] }
 
 @a = common global %struct.anon zeroinitializer, align 1, !dbg !0
 

llvm/trunk/test/DebugInfo/ARM/partial-subreg.ll

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 ; This tests a fragment that partially covers subregister compositions.
 ;
 ; Our fragment is 96 bits long and lies in a 128-bit register, which
 ; in turn has to be composed out of its two 64-bit subregisters.
 
 ; CHECK: .debug_info
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}}"subscript.get"
 ; CHECK:  DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] (0x00000000)
-; CHECK: .debug_loc
-; CHECK: 0x00000000: Beginning address offset
-; CHECK-NEXT:           Ending address offset
-; CHECK-NEXT:            Location description: 90 90 02 93 08 90 91 02 93 04
-;                        d16, piece 0x00000008, d17, piece 0x00000004
+; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
+; CHECK-NEXT:  0x{{.*}} - 0x{{.*}}: DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4, DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4
+
 source_filename = "simd.ll"
 target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
 target triple = "armv7-apple-ios7.0"
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 
 define <3 x float> @_TFV4simd8float2x3g9subscriptFSiVS_6float3(i32, <3 x float>, <3 x float>) !dbg !5 {

llvm/trunk/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
-; CHECK:            Location description: 90
+; CHECK: DW_OP_regx
 
 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/trunk/test/DebugInfo/ARM/split-complex.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t.o %s
 ; RUN: llvm-dwarfdump -debug-dump=info %t.o | FileCheck %s
 ; REQUIRES: object-emission
 target datalayout = "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7-apple-unknown-macho"
 
 ; generated from (-triple thumbv7-apple-unknown-macho -Os):
 ;   void f(_Complex double c) { c = 0; }
 
 ; Function Attrs: nounwind readnone
 define arm_aapcscc void @f([2 x i64] %c.coerce) #0 !dbg !4 {
 entry:
   tail call void @llvm.dbg.declare(metadata { double, double }* undef, metadata !14, metadata !15), !dbg !16
   ; The target has no native double type.
   ; SROA split the complex value into two i64 values.
   ; CHECK: DW_TAG_formal_parameter
-  ; CHECK-NEXT:  DW_AT_location [DW_FORM_block1]  (<0x04> 10 00 93 08 )
-  ;              DW_AT_location       ( constu 0x00000000, piece 0x00000008 )
+  ; CHECK-NEXT:  DW_AT_location [DW_FORM_block1]  (DW_OP_constu 0x0, DW_OP_piece 0x8)
   ; CHECK-NEXT:  DW_AT_name {{.*}} "c"
   tail call void @llvm.dbg.value(metadata i64 0, metadata !14, metadata !17), !dbg !16
   ; Manually removed to disable location list emission:
   ; tail call void @llvm.dbg.value(metadata i64 0, metadata !14, metadata !18), !dbg !16
   ret void, !dbg !19
 }
 
 ; Function Attrs: nounwind readnone

llvm/trunk/test/DebugInfo/Generic/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: DW_OP_constu 0xd{{$}}
+; DWARF4: DW_OP_constu 0xd, DW_OP_stack_value{{$}}
 
 ; Function Attrs: uwtable
 define i32 @main() #0 !dbg !4 {
 entry:
   %c = alloca i32, align 4
   tail call void @llvm.dbg.value(metadata i32 13, metadata !10, metadata !16), !dbg !17
   store volatile i32 13, i32* %c, align 4, !dbg !18
   %call = tail call i32 @_Z4funcv(), !dbg !19

llvm/trunk/test/DebugInfo/MIR/AArch64/clobber-sp.mir

 # RUN: llc -start-after=livedebugvalues -filetype=obj -o - %s \
 # RUN:   | llvm-dwarfdump - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_formal_parameter
 # CHECK: DW_TAG_formal_parameter
-# CHECK-NEXT: DW_AT_location [DW_FORM_data4]  ([[LOC:.*]])
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT:   0x0000000000000000 - 0x0000000000000014: DW_OP_reg1 W1
+# CHECK-NEXT:   0x0000000000000014 - 0x0000000000000038: DW_OP_breg31 WSP+8
 # CHECK-NEXT: DW_AT_name {{.*}}"y"
-# CHECK: .debug_loc contents:
-# CHECK: [[LOC]]:
-# CHECK-SAME:        Beginning address offset: 0x0000000000000000
-# CHECK-NEXT:   Ending address offset: 0x0000000000000014
-# CHECK-NEXT:    Location description: 51
-#                                              reg1
-#
-# The range of y's [SP+8] location must not be interrupted by the call to h.
-# CHECK:       Beginning address offset: 0x0000000000000014
-# CHECK-NEXT:   Ending address offset: 0x0000000000000038
-# CHECK-NEXT:      Location description: 8f 08
-#                                              breg31 +8
+
 --- |
   ; Generated at -Os from:
   ;   struct Rect {
   ;     double x, y, w, h;
   ;   };
   ;   void g(struct Rect);
   ;   void h(int *);
   ;   int f(int x, int y, struct Rect s) {

llvm/trunk/test/DebugInfo/MIR/ARM/split-superreg-piece.mir

 # RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s | \
-# RUN:     llvm-dwarfdump - | FileCheck %s
+# RUN:     llvm-dwarfdump -debug-dump=info - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_variable
-# CHECK-NEXT: DW_AT_location [DW_FORM_data4]  ([[OFS:.*]])
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT: 0x0000000000000010 - 0x0000000000000018: DW_OP_piece 0x10, DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8)
 # CHECK-NEXT: DW_AT_name {{.*}}"vec"
-# CHECK: .debug_loc contents:
-# CHECK: [[OFS]]: Beginning address offset: 0x0000000000000010
-# CHECK:             Ending address offset: 0x0000000000000018
-# CHECK:              Location description: 93 10 90 80 02 93 08 90 81 02 93 08 
-#                  piece 0x00000010, d0, piece 0x00000008, d1, piece 0x00000008
+
 --- |
   ; Generate from (and then manually modified to incorporate a DW_OP_LLVM_fragment):
   ; typedef float vec2 __attribute__((vector_size(16)));
   ; vec2 v();
   ; float f() {
   ;   vec2 vec = v();
   ;   return vec[0] + vec[1];
   ; }

llvm/trunk/test/DebugInfo/MIR/ARM/split-superreg.mir

 # RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s | \
 # RUN:     llvm-dwarfdump - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_variable
-# CHECK-NEXT: DW_AT_location [DW_FORM_data4]  ([[OFS:.*]])
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT: 0x0000000000000010 - 0x0000000000000018: DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8)
 # CHECK-NEXT: DW_AT_name {{.*}}"vec"
-# CHECK: .debug_loc contents:
-# CHECK: [[OFS]]: Beginning address offset: 0x0000000000000010
-# CHECK:             Ending address offset: 0x0000000000000018
-# CHECK:              Location description: 90 80 02 93 08 90 81 02 93 08 
-#                                           d0, piece 0x00000008, d1, piece 0x00000008
+
 --- |
   ; Generated from:
   ; typedef float vec2 __attribute__((vector_size(16)));
   ; vec2 v();
   ; float f() {
   ;   vec2 vec = v();
   ;   return vec[0] + vec[1];
   ; }

llvm/trunk/test/DebugInfo/MIR/X86/bit-piece-dh.mir

 # RUN: llc -filetype=obj -o - %s | llvm-dwarfdump --debug-dump=info - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_variable
-#                                           rdx, bit-piece 8 8
-# CHECK-NEXT: DW_AT_location {{.*}}         51 9d 08 08
+# CHECK-NEXT: DW_AT_location {{.*}}         (DW_OP_reg1 RDX, DW_OP_bit_piece 0x8 0x8)
 # CHECK-NEXT: DW_AT_name {{.*}}"dh"
 --- |
   ; Manually created after:
   ; char f(int i) {
   ;   char dh = i>>8;
   ;   return dh;
   ; }
 

llvm/trunk/test/DebugInfo/Mips/dsr-fixed-objects.ll

 ; RUN: llc -march=mips -mcpu=mips32r2 -O1 -filetype=obj -relocation-model=pic <%s | \
-; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s -check-prefix=F0
-; RUN: llc -march=mips -mcpu=mips32r2 -O1 -filetype=obj -relocation-model=pic <%s | \
-; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s -check-prefix=F1
+; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s
 
 ; void foo(int *);
 ;
 ; int f0(int a, int b, int c, int d, int e) {
 ;   int x = a + b + c + d + e;
 ;   foo(&x);
 ;   return x;
 ; }
 ;
 ; int f1(int a, int b, int c, int d, int e) {
 ;   int x __attribute__((aligned(16))) = a + b + c + d + e;
 ;   foo(&x);
 ;   return x;
 ; }
 
 declare void @llvm.lifetime.start(i64, i8* nocapture)
 declare void @llvm.lifetime.end(i64, i8* nocapture)
 
 declare void @foo(i32*)
 
-; F0: DW_AT_name {{.*}}"e"
-; F0: DW_TAG_variable
-; F0-NEXT: DW_AT_location [DW_FORM_sec_offset]   ([[LOC:.*]])
-; F0-NEXT: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000006b] = "x")
-;
-; x -> DW_OP_reg1(51)
-; F0: [[LOC]]: Beginning address offset: 0x0000000000000028
-; F0:             Ending address offset: 0x000000000000002c
-; F0:              Location description: 51
+; CHECK: DW_AT_name {{.*}}"e"
+; CHECK: DW_TAG_variable
+; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] (
+; CHECK-NEXT:   0x0000000000000028 - 0x000000000000002c: DW_OP_reg1 AT_64
+; CHECK-NEXT:   0x000000000000002c - 0x0000000000000048: DW_OP_breg29 SP_64+16, DW_OP_deref)
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000006b] = "x")
 
 define i32 @f0(i32 signext %a, i32 signext %b, i32 signext %c, i32 signext %d, i32 signext %e) !dbg !4 {
 entry:
   %x = alloca i32, align 4
   tail call void @llvm.dbg.value(metadata i32 %a, metadata !9,  metadata !DIExpression()), !dbg !27
   tail call void @llvm.dbg.value(metadata i32 %b, metadata !10, metadata !DIExpression()), !dbg !28
   tail call void @llvm.dbg.value(metadata i32 %c, metadata !11, metadata !DIExpression()), !dbg !29
   tail call void @llvm.dbg.value(metadata i32 %d, metadata !12, metadata !DIExpression()), !dbg !30
entry:
   call void @foo(i32* nonnull %x) #4, !dbg !42
   call void @llvm.dbg.value(metadata i32* %x, metadata !14, metadata !26), !dbg !37
   %1 = load i32, i32* %x, align 4, !dbg !43, !tbaa !38
   call void @llvm.lifetime.end(i64 4, i8* %0) #4, !dbg !44
   ret i32 %1, !dbg !45
 }
 
 
-; F1: DW_AT_name {{.*}}"x"
-; F1: DW_AT_name {{.*}}"e"
-; F1: DW_TAG_variable
-; F1-NEXT: DW_AT_location [DW_FORM_sec_offset]   ([[LOC:.*]])
-; F1-NEXT: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000006b] = "x")
-
-; x -> DW_OP_reg1(51)
-; F1: [[LOC]]: Beginning address offset: 0x0000000000000080
-; F1:             Ending address offset: 0x0000000000000084
-; F1:              Location description: 51
+; CHECK: DW_TAG_variable
+; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]  (
+; CHECK-NEXT:   0x0000000000000080 - 0x0000000000000084: DW_OP_reg1 AT_64
+; CHECK-NEXT:   0x0000000000000084 - 0x0000000000000098: DW_OP_breg29 SP_64+16, DW_OP_deref)
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000006b] = "x")
 
 define i32 @f1(i32 signext %a, i32 signext %b, i32 signext %c, i32 signext %d, i32 signext %e) !dbg !15 {
 entry:
   %x = alloca i32, align 16
   tail call void @llvm.dbg.value(metadata i32 %a, metadata !17, metadata !DIExpression()), !dbg !46
   tail call void @llvm.dbg.value(metadata i32 %b, metadata !18, metadata !DIExpression()), !dbg !47
   tail call void @llvm.dbg.value(metadata i32 %c, metadata !19, metadata !DIExpression()), !dbg !48
   tail call void @llvm.dbg.value(metadata i32 %d, metadata !20, metadata !DIExpression()), !dbg !49

llvm/trunk/test/DebugInfo/Mips/dsr-non-fixed-objects.ll

 ; RUN: llc -march=mips -mcpu=mips32r2 -O0 -filetype=obj -fast-isel=0 <%s | \
-; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s -check-prefix=F2
-; RUN: llc -march=mips -mcpu=mips32r2 -O0 -filetype=obj -fast-isel=0 <%s | \
-; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s -check-prefix=F3
+; RUN:    llvm-dwarfdump -debug-dump=all - | FileCheck %s
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 declare void @foo(i32*)
 
 ; void foo(int *);
 ;
 ; int f2(int a, int b) {
 ;   int c __attribute__((aligned(16))) = a + b;
 ;   foo(&c);
 ;   return c;
 ; }
 ;
 ; int *f3(int a, int b) {
 ;   int c __attribute__((aligned(16))) = a + b;
 ;   int *w = alloca(c);
 ;   foo(&c);
 ;   return w;
 ; }
 
-; c -> DW_OP_breg29(r29): 16
-; F2: DW_AT_location [DW_FORM_exprloc]      (<0x2> 8d 10 )
-; F2: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000065] = "c")
+; CHECK: DW_TAG_subprogram
+; CHECK: DW_AT_location [DW_FORM_exprloc]      (DW_OP_breg29 SP_64+36)
+; CHECK: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000065] = "c")
 
 ; Function Attrs: nounwind
 define i32 @f2(i32 signext %a, i32 signext %b) !dbg !4 {
 entry:
   %a.addr = alloca i32, align 4
   %b.addr = alloca i32, align 4
   %c = alloca i32, align 16
   store i32 %a, i32* %a.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !15, metadata !16), !dbg !17
   store i32 %b, i32* %b.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %b.addr, metadata !18, metadata !16), !dbg !19
   call void @llvm.dbg.declare(metadata i32* %c, metadata !20, metadata !16), !dbg !21
   %0 = load i32, i32* %a.addr, align 4, !dbg !22
   %1 = load i32, i32* %b.addr, align 4, !dbg !23
   %add = add nsw i32 %0, %1, !dbg !24
   store i32 %add, i32* %c, align 16, !dbg !21
   call void @foo(i32* %c), !dbg !25
   %2 = load i32, i32* %c, align 16, !dbg !26
   ret i32 %2, !dbg !27
 }
 
-; c -> DW_OP_breg23(r23): 16
-; F3: DW_AT_location [DW_FORM_exprloc]      (<0x2> 87 10 )
-; F3: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000065] = "c")
+; CHECK: DW_TAG_subprogram
+; CHECK: DW_AT_location [DW_FORM_exprloc]      (DW_OP_breg23 S7_64+32)
+; CHECK: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000065] = "c")
 
 define i32* @f3(i32 signext %a, i32 signext %b) !dbg !8 {
 entry:
   %a.addr = alloca i32, align 4
   %b.addr = alloca i32, align 4
   %c = alloca i32, align 16
   %w = alloca i32*, align 4
   store i32 %a, i32* %a.addr, align 4

llvm/trunk/test/DebugInfo/Sparc/subreg.ll

-; RUN: llc -filetype=obj -O0 < %s -mtriple sparc64-unknown-linux-gnu | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -filetype=obj -O0 < %s -mtriple sparc64-unknown-linux-gnu | llvm-dwarfdump - -debug-dump=loc | FileCheck %s
 ; The undescribable 128-bit register should be split into two 64-bit registers.
-; CHECK: Location description: 90 48 93 08 90 49 93 08
-;                              DW_OP_reg74 DW_OP_piece 8 DW_OP_reg75 DW_OP_piece 8 ...
+; 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/trunk/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 {{.*}}(DW_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
 

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

llvm/trunk/test/DebugInfo/X86/FrameIndexExprs.ll

 ; PR31381: An assertion in the DWARF backend when fragments in MMI slots are
 ; sorted by largest offset first.
 ; RUN: llc -mtriple=x86_64-apple-darwin -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]  (<0xa> 91 78 93 03 93 06 91 7d 93 03 )
-;           fbreg -8, piece 0x00000003, piece 0x00000006, fbreg -3, piece 0x00000003 
+; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc] (DW_OP_fbreg -8, DW_OP_piece 0x3, DW_OP_piece 0x6, DW_OP_fbreg -3, DW_OP_piece 0x3)
 ; CHECK-NEXT: DW_AT_abstract_origin {{.*}}"p"
 source_filename = "bugpoint-reduced-simplified.ll"
 target triple = "x86_64-apple-darwin"
 
 @f = common local_unnamed_addr global i32 0, align 4, !dbg !0
 @h = common local_unnamed_addr global i32 0, align 4, !dbg !6
 
 ; Function Attrs: nounwind readnone

llvm/trunk/test/DebugInfo/X86/PR26148.ll

-; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump - -debug-dump=loc | FileCheck %s
 ;
 ; Created using clang -g -O3 from:
 ; struct S0 {
 ;  short f0;
 ;  int f3;
 ; } a;
 ; void fn1(short p1) {
 ;  struct S0 b, c = {3};
 ;  b.f3 = p1;
 ;  a = b = c;
 ; }
 ; 
 ; 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 expect two ranges (as opposed to one), the first one being zero sized
 ;
 ;
-; CHECK:             Beginning address offset: 0x0000000000000004
-; CHECK:                Ending address offset: 0x0000000000000004
-; CHECK:                 Location description: 10 03 93 04 55 93 02
-; constu 0x00000003, piece 0x00000004, rdi, piece 0x00000002
-; CHECK:             Beginning address offset: 0x0000000000000004
-; CHECK:                Ending address offset: 0x0000000000000014
-; CHECK:                 Location description: 10 03 93 04 10 00
-; constu 0x00000003, piece 0x00000004, constu 0x00000000, piece 0x00000004
+; CHECK: 0x0000000000000004 - 0x0000000000000004: DW_OP_constu 0x3, DW_OP_piece 0x4, DW_OP_reg5 RDI, DW_OP_piece 0x2
+; CHECK: 0x0000000000000004 - 0x0000000000000014: DW_OP_constu 0x3, DW_OP_piece 0x4, DW_OP_constu 0x0, 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/trunk/test/DebugInfo/X86/array.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - --debug-dump=info | FileCheck %s --check-prefix=DWARF
 
 ; CHECK-LABEL: _main:
 ; CHECK: movaps {{.*}}, (%rsp)
 ; CHECK: movq    %rsp, %rdi
 ; CHECK: callq _f
 
 ; DWARF: DW_TAG_variable
-;   "<0x2> 91 00" means fbreg 0, i.e. offset RSP+0.
-; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 00 )
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +0)
 ; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "array")
 
 ; ModuleID = '/tmp/array.c'
 source_filename = "/tmp/array.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 @main.array = private unnamed_addr constant [4 x i32] [i32 0, i32 1, i32 2, i32 3], align 16

llvm/trunk/test/DebugInfo/X86/bitfields.ll

 ; the storage unit to the high end of the bit field.
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"a"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x02)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x1e)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 00
+; CHECK-NEXT: DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"b"
 ; CHECK-NOT: DW_TAG_member
-; CHECK:      DW_AT_data_member_location {{.*}} 04
+; CHECK:      DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x4)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"c"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x1f)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 08
+; CHECK:      DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"d"
 ; CHECK-NOT: DW_TAG_member
 ; CHECK:      DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK-NEXT: DW_AT_bit_size   {{.*}} (0x1c)
 ; CHECK-NEXT: DW_AT_bit_offset {{.*}} (0x03)
-; CHECK-NEXT: DW_AT_data_member_location {{.*}} 08
+; CHECK-NEXT: DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; ModuleID = 'bitfields.c'
 source_filename = "test/DebugInfo/X86/bitfields.ll"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 %struct.bitfield = type <{ i8, [3 x i8], i64 }>
 

llvm/trunk/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] (DW_OP_fbreg +8, DW_OP_deref, DW_OP_plus_uconst 0x20)
 ; CHECK-NEXT: DW_AT_name {{.*}} "block"
 
 ; Extracted from the clang output for:
 ; void foo() {
 ;  void (^block)() = ^{ block(); };
 ; }
 
 ; ModuleID = 'foo.m'

llvm/trunk/test/DebugInfo/X86/constant-loclist.ll

-; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; A hand-written testcase to check 64-bit constant handling in location lists.
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (0x[[D:.*]])
+; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
+; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x4000000000000000)
 ; CHECK-NEXT: DW_AT_name {{.*}}"d"
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (0x[[I:.*]])
+; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
+; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_consts +0
+; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_consts +4611686018427387904)
 ; CHECK-NEXT: DW_AT_name {{.*}}"i"
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (0x[[U:.*]])
+; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
+; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x0
+; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x4000000000000000)
 ; CHECK-NEXT: DW_AT_name {{.*}}"u"
-; CHECK: .debug_loc contents:
-; CHECK: [[D]]:
-; CHECK: Location description: 10 80 80 80 80 80 80 80 80 40
-; CHECK: [[I]]:
-; CHECK: Location description: 11 80 80 80 80 80 80 80 80 c0 00
-; CHECK: [[U]]:
-; CHECK: Location description: 10 80 80 80 80 80 80 80 80 40 
 
 source_filename = "test.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @main() #0 !dbg !7 {
   %1 = alloca double, align 8

llvm/trunk/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 {{.*}} (DW_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 {{.*}} (DW_OP_plus_uconst 0x4)
 
 source_filename = "test/DebugInfo/X86/data_member_location.ll"
 
 %struct.foo = type { i8, i32 }
 
 @f = global %struct.foo zeroinitializer, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!9}

llvm/trunk/test/DebugInfo/X86/dbg-declare-alloca.ll

 ; RUN: llc < %s | FileCheck %s
 ; RUN: llc < %s -filetype=obj | llvm-dwarfdump - -debug-dump=info | FileCheck %s --check-prefix=DWARF
 
 ; This should use the frame index side table for allocas, not DBG_VALUE
 ; instructions. For SDAG ISel, this test would see an SDNode materializing the
 ; argument to escape_foo and we'd get DBG_VALUE MachineInstr.
 
 ; CHECK-LABEL: use_dbg_declare:
 ; CHECK-NOT: #DEBUG_VALUE
 
-;   "<0x2> 91 00" means "fbreg uleb(0)", i.e. RSP+0.
 ; DWARF: DW_TAG_variable
-; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 00 )
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +0)
 ; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "o")
 
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 

llvm/trunk/test/DebugInfo/X86/dbg-declare-arg.ll

 ; RUN: llc -O0 -fast-isel=true  -filetype=obj -o - %s | llvm-dwarfdump - | 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-macosx10.6.7"
 ; rdar://problem/9321650
 ;
 ; CHECK: DW_AT_name {{.*}}"j"
 ; CHECK: DW_TAG_variable  
-; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (0x00000000)
+; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (
+; CHECK-NEXT:     0x{{.*}} - 0x{{.*}}: DW_OP_breg7 RSP+8)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"my_a"
-; CHECK: .debug_loc contents:
-; CHECK: 0x00000000: Beginning address offset:
-; CHECK-NEXT:           Ending address offset:
-; CHECK-NEXT:            Location description: 77 08
-;                                              rsp+8
 
 %class.A = type { i32, i32, i32, i32 }
 
 define void @_Z3fooi(%class.A* sret %agg.result, i32 %i) ssp !dbg !19 {
 entry:
   %i.addr = alloca i32, align 4
   %j = alloca i32, align 4
   %nrvo = alloca i1

llvm/trunk/test/DebugInfo/X86/dbg-declare.ll

 ; RUN: llc < %s -O0 -mtriple x86_64-apple-darwin | FileCheck %s
 ; RUN: llc < %s -O0 -mtriple x86_64-apple-darwin -filetype=obj \
 ; RUN:     | llvm-dwarfdump - -debug-dump=info | FileCheck %s --check-prefix=DWARF
 ; <rdar://problem/11134152>
 
 ; CHECK-LABEL: _foo:
 ; CHECK-NOT: #DEBUG_VALUE
 
 ; "[DW_FORM_exprloc] <0x2> 91 XX" means fbreg uleb(XX)
 ; DWARF-LABEL: DW_TAG_formal_parameter
-; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 70 )
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg -16)
 ; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "x")
 
 ; FIXME: There is no debug info to describe "a".
 
 define i32 @foo(i32* %x) nounwind uwtable ssp !dbg !5 {
 entry:
   %x.addr = alloca i32*, align 8
   %saved_stack = alloca i8*

llvm/trunk/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"
 
 ; Test that consecutive, identical DBG_VALUEs are merged.
-;CHECK: DW_AT_location{{.*}}(<0x1> 55 )
+; CHECK: DW_AT_location{{.*}}(DW_OP_reg5 RDI)
 
 %0 = type { i64, i1 }
 
 @__clz_tab = external constant [256 x i8]
 
 define hidden i128 @__divti3(i128 %u, i128 %v) nounwind readnone !dbg !9 {
 entry:
   tail call void @llvm.dbg.value(metadata i128 %u, metadata !14, metadata !DIExpression()), !dbg !15

llvm/trunk/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 {{.*}}({{.*}}
+; CHECK-NEXT:  0x{{0*.*}} - [[C1:0x.*]]: DW_OP_consts +3
+; CHECK-NEXT:      [[C1]] - [[C2:0x.*]]: DW_OP_consts +7
+; CHECK-NEXT:      [[C2]] - [[R1:0x.*]]: DW_OP_reg0 RAX
+; CHECK-NEXT:      [[R1]] - [[R2:0x.*]]: DW_OP_breg7 RSP+4, DW_OP_deref)
 ; 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
-; CHECK: Beginning address offset: [[C2]]
-; CHECK:    Ending address offset: [[R1:.*]]
-; CHECK:     Location description: 50
-;         rdi+0
-; CHECK: Beginning address offset: [[R1]]
-; CHECK:    Ending address offset: [[R2:.*]]
-; CHECK:     Location description: 77 04
-;         rsp+4
-;
+
 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 !dbg !4 {
 entry:
   %i = alloca i32, align 4
   call void @llvm.dbg.value(metadata i32 3, metadata !10, metadata !DIExpression()), !dbg !15

llvm/trunk/test/DebugInfo/X86/dbg-value-frame-index.ll

while.body:
   br i1 0, label %while.end, label %while.cond
 
 while.end:
   ret i1 true
 }
 
 ; CHECK-LABEL: test
 ; CHECK:       #DEBUG_VALUE: test:w <- [DW_OP_plus_uconst 8] [%RSP+0]
-; DWARF:       Location description: 77 08
-;                                    DW_OP_breg7 +8
+; DWARF:  DW_AT_location [DW_FORM_sec_offset] (
+; DWARF-NEXT:   {{.*}} - {{.*}}: DW_OP_breg7 RSP+8)
 
 declare i1 @fn(i64*, i64*, i64*, i8*, i64, i64*, i32*, i8*)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2,!3}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 4.0.0", emissionKind: FullDebug)

llvm/trunk/test/DebugInfo/X86/dbg-value-regmask-clobber.ll

 ; ASM-NEXT: .quad   .Lfunc_begin0-.Lfunc_begin0
 ; ASM-NEXT: .quad   [[argc_range_end]]-.Lfunc_begin0
 ; ASM-NEXT: .short  1                       # Loc expr size
 ; ASM-NEXT: .byte   82                      # super-register DW_OP_reg2
 
 ; argc is the first formal parameter.
 ; DWARF: .debug_info contents:
 ; DWARF:  DW_TAG_formal_parameter
-; DWARF-NEXT:    DW_AT_location [DW_FORM_sec_offset]   ([[argc_loc_offset:0x.*]])
+; DWARF-NEXT:    DW_AT_location [DW_FORM_sec_offset]   ({{0x.*}}
+; DWARF-NEXT:      0x0000000000000000 - 0x0000000000000013: DW_OP_reg2 RCX)
 ; DWARF-NEXT:    DW_AT_name [DW_FORM_strp]     {{.*}} "argc"
 
-; DWARF: .debug_loc contents:
-; DWARF: [[argc_loc_offset]]: Beginning address offset: 0x0000000000000000
-; DWARF-NEXT:                    Ending address offset: 0x0000000000000013
-; DWARF-NEXT:                     Location description: 52
-
 ; ModuleID = 't.cpp'
 source_filename = "test/DebugInfo/X86/dbg-value-regmask-clobber.ll"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"
 
 @x = common global i32 0, align 4, !dbg !0
 
 ; Function Attrs: nounwind uwtable

llvm/trunk/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{{.*}}(DW_OP_fbreg -24, DW_OP_deref, DW_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

llvm/trunk/test/DebugInfo/X86/debug-info-packed-struct.ll

 %struct.size8 = type { i64 }
 %struct.layout1 = type <{ i8, %struct.size8_anon, i8, [2 x i8] }>
 %struct.size8_anon = type { i64 }
 ; CHECK:  DW_TAG_structure_type
 ; CHECK:      DW_AT_name {{.*}} "layout0"
 ; CHECK:      DW_AT_byte_size {{.*}} (0x18)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l0_ofs0"
-; CHECK:          DW_AT_data_member_location {{.*}}00
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l0_ofs8"
-; CHECK:          DW_AT_data_member_location {{.*}}08
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l0_ofs16"
 ; CHECK:          DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK:          DW_AT_bit_offset {{.*}} (0x1f)
-; CHECK:          DW_AT_data_member_location {{.*}}10
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x10)
 
 ; // ---------------------------------------------------------------------
 ; // Implicitly packed.
 ; // ---------------------------------------------------------------------
 ; struct size8_anon {
 ;   int : 4;
 ;   long long : 60;
 ; };
 ; struct layout1 {
 ;   char l1_ofs0;
 ;   struct size8_anon l1_ofs1;
 ;   int l1_ofs9 : 1;
 ; } l1;
 
 %struct.layout2 = type <{ i8, %struct.size8_pack1, i8 }>
 %struct.size8_pack1 = type { i64 }
 %struct.layout3 = type <{ i8, [3 x i8], %struct.size8_pack4, i8, [3 x i8] }>
 %struct.size8_pack4 = type { i64 }
 
 ; CHECK:  DW_TAG_structure_type
 ; CHECK:      DW_AT_name {{.*}} "layout1"
 ; CHECK:      DW_AT_byte_size {{.*}} (0x0c)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l1_ofs0"
-; CHECK:          DW_AT_data_member_location {{.*}}00
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l1_ofs1"
-; CHECK:          DW_AT_data_member_location {{.*}}01
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x1)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l1_ofs9"
 ; CHECK:          DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK:          DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK:          DW_AT_bit_offset {{.*}} (0x17)
-; CHECK:          DW_AT_data_member_location {{.*}}08
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; // ---------------------------------------------------------------------
 ; // Explicitly packed.
 ; // ---------------------------------------------------------------------
 ; #pragma pack(1)
 ; struct size8_pack1 {
 ;   int i : 4;
 ;   long long l : 60;
 ; };
 ; struct layout2 {
 ;   char l2_ofs0;
 ;   struct size8_pack1 l2_ofs1;
 ;   int l2_ofs9 : 1;
 ; } l2;
 ; #pragma pack()
 
 @l0 = common global %struct.layout0 zeroinitializer, align 8, !dbg !0
 @l1 = common global %struct.layout1 zeroinitializer, align 4, !dbg !6
 ; CHECK:  DW_TAG_structure_type
 ; CHECK:      DW_AT_name {{.*}} "layout2"
 ; CHECK:      DW_AT_byte_size {{.*}} (0x0a)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l2_ofs0"
-; CHECK:          DW_AT_data_member_location {{.*}}00
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l2_ofs1"
-; CHECK:          DW_AT_data_member_location {{.*}}01
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x1)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l2_ofs9"
 ; CHECK:          DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK:          DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK:          DW_AT_bit_offset {{.*}} (0x17)
-; CHECK:          DW_AT_data_member_location {{.*}}08
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x8)
 
 ; // ---------------------------------------------------------------------
 ; // Explicitly packed with different alignment.
 ; // ---------------------------------------------------------------------
 ; #pragma pack(4)
 ; struct size8_pack4 {
 ;   int i : 4;
 ;   long long l : 60;
 ; };
 ; struct layout3 {
 ;   char l3_ofs0;
 ;   struct size8_pack4 l3_ofs4;
 ;   int l3_ofs12 : 1;
 ; } l 3;
 ; #pragma pack()
 
 @l2 = common global %struct.layout2 zeroinitializer, align 1, !dbg !17
 @l3 = common global %struct.layout3 zeroinitializer, align 4, !dbg !29
 ; CHECK:  DW_TAG_structure_type
 ; CHECK:      DW_AT_name {{.*}} "layout3"
 ; CHECK:      DW_AT_byte_size {{.*}} (0x10)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l3_ofs0"
-; CHECK:          DW_AT_data_member_location {{.*}}00
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x0)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l3_ofs4"
-; CHECK:          DW_AT_data_member_location {{.*}}04
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0x4)
 ; CHECK:      DW_TAG_member
 ; CHECK:          DW_AT_name {{.*}} "l3_ofs12"
 ; CHECK:          DW_AT_byte_size  {{.*}} (0x04)
 ; CHECK:          DW_AT_bit_size   {{.*}} (0x01)
 ; CHECK:          DW_AT_bit_offset {{.*}} (0x1f)
-; CHECK:          DW_AT_data_member_location {{.*}}0c
+; CHECK:          DW_AT_data_member_location {{.*}} (DW_OP_plus_uconst 0xc)
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!49, !50}
 !llvm.ident = !{!51}
 
 !0 = !DIGlobalVariableExpression(var: !1)
 !1 = !DIGlobalVariable(name: "l0", scope: !2, file: !8, line: 88, type: !40, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 3.7.0 (trunk 240791) (llvm/trunk 240790)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !5, imports: !4)

llvm/trunk/test/DebugInfo/X86/debug-loc-asan.ll

 ; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: llc  -O0 -mtriple=x86_64-unknown-linux-gnu -filetype=obj < %s \
-; RUN:   | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s --check-prefix=DWARF
 
 ; Verify that we have correct debug info for local variables in code
 ; instrumented with AddressSanitizer.
 
 ; Generated from the source file test.cc:
 ; int bar(int y) {
 ;   return y + 2;
 ; }

 
 ; CHECK: .Ldebug_loc{{[0-9]+}}:
 ; We expect two location ranges for the variable.
 
 ; First, its address is stored in %rdi:
 ; CHECK:      .quad .Lfunc_begin0-.Lfunc_begin0
 ; CHECK-NEXT: .quad [[START_LABEL]]-.Lfunc_begin0
 ; CHECK: DW_OP_breg5
-; DWARF: Location description: 75 00 06
-;                              DW_OP_breg5+0 DW_OP_deref
+; DWARF:       DW_TAG_formal_parameter
+; DWARF:         DW_AT_location
+; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_breg5 RDI+0, DW_OP_deref
 
 ; Then it's addressed via %rsp:
 ; CHECK:      .quad [[START_LABEL]]-.Lfunc_begin0
 ; CHECK-NEXT: .quad [[END_LABEL]]-.Lfunc_begin0
 ; CHECK: DW_OP_breg7
 ; CHECK-NEXT: [[OFFSET]]
 ; CHECK: DW_OP_deref
-; DWARF: Location description: {{77 .. 06 06}}
-;                              DW_OP_breg7+OFFSET DW_OP_deref DW_OP_deref
+; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_deref, DW_OP_deref)
 
 ; ModuleID = 'test.cc'
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 1, void ()* @asan.module_ctor }]
 @__asan_option_detect_stack_use_after_return = external global i32
 @__asan_gen_ = private unnamed_addr constant [16 x i8] c"1 32 4 6 y.addr\00", align 1

llvm/trunk/test/DebugInfo/X86/debug-loc-frame.ll

 ;   foo(2, &data);
 ;   return zero;
 ; }
 ;
 ; CHECK:      .debug_info contents
 ; CHECK:      DW_TAG_subprogram
 ; CHECK-NOT:  NULL
 ; CHECK:      DW_TAG_variable
-; CHECK:      DW_AT_location [DW_FORM_sec_offset] ([[DEBUGLOCOFFSET:0x[0-9a-f]+]]){{[[:space:]].*}}"val"
-
-; See that 'val' has at least one location entry with a DW_op_breg? operand.
-; The DWARF DW_op_breg* ops are encoded from 0x70 to 0x8f, but checking for an
-; op in the range from 0x70 to 0x7f should suffice because that range covers
-; all integer GPRs.
-;
-; CHECK: .debug_loc contents:
-; CHECK-NOT: .debug{{.*}} contents
-; CHECK: [[DEBUGLOCOFFSET]]: Beginning
-; CHECK-NOT: {{0x[0-9a-f]+}}: Beginning
-; CHECK: Location description: 7{{[0-9a-f] .*}}
+; CHECK:      DW_AT_location [DW_FORM_sec_offset] ({{.*}}
+; CHECK-NEXT:   {{0x.*}} - {{0x.*}}: DW_OP_reg0 RAX
+; CHECK-NEXT:   {{0x.*}} - {{0x.*}}: DW_OP_breg7 RSP+4, DW_OP_deref)
+; CHECK-NEXT: DW_AT_name {{.*}}"val"
 
 ; ModuleID = 'frame.c'
 source_filename = "frame.c"
 
 @data = global i32 17, align 4, !dbg !0
 @sum = local_unnamed_addr global i32 0, align 4, !dbg !6
 @zero = local_unnamed_addr global i32 0, align 4, !dbg !9
 @ptr = common local_unnamed_addr global i32* null, align 8, !dbg !11

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

 ;   int z = 2;
 ;   if (a.var > 2)
 ;     z++;
 ;   if (a.foo() == 'a')
 ;     z++;
 ; }
 
 ; Compiled separately for i386-pc-linux-gnu and linked together.
-; This ensures that we have multiple compile units so that we can verify that
+; This ensures that we have multiple compile units and multiple location lists
+; so that we can verify that
 ; debug_loc entries are relative to the low_pc of the CU. The loc entry for
 ; the byval argument in foo.cpp is in the second CU and so should have
 ; an offset relative to that CU rather than from the beginning of the text
 ; section.
 
 ; Checking that we have two compile units with two sets of high/lo_pc.
 ; CHECK: .debug_info contents
 ; CHECK: DW_TAG_compile_unit
-; CHECK: DW_AT_low_pc
+; CHECK: DW_AT_low_pc {{.*}} (0x0000000000000020)
 ; CHECK: DW_AT_high_pc
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_linkage_name [DW_FORM_strp]{{.*}}"_Z3baz1A"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_location [DW_FORM_sec_offset]   (0x00000000)
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name [DW_FORM_strp]{{.*}}"a"
+; CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
+; CHECK-NEXT:    0x0000000000000000 - 0x0000000000000017: DW_OP_breg0 EAX+0, DW_OP_deref
+; CHECK-NEXT:    0x0000000000000017 - 0x0000000000000043: DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
+; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"a"
 
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_location [DW_FORM_exprloc]
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK: DW_AT_low_pc
+; CHECK: DW_AT_low_pc {{.*}} (0x0000000000000000)
 ; CHECK: DW_AT_high_pc
 
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_linkage_name [DW_FORM_strp]{{.*}}"_Z3bari"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK: DW_TAG_formal_parameter
+; CHECK-NOT: DW_TAG
+; CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
+; CHECK-NEXT:    0x0000000000000000 - 0x000000000000000a: DW_OP_consts +0, DW_OP_stack_value
+; CHECK-NEXT:    0x000000000000000a - 0x0000000000000017: DW_OP_consts +1, DW_OP_stack_value)
+; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"b"
+
 ; CHECK: .debug_loc contents:
-; CHECK: 0x00000000: Beginning address offset: 0x0000000000000000
-; CHECK:                Ending address offset: 0x0000000000000017
+; CHECK:       0x00000000:
+; CHECK-NEXT:    0x0000000000000000 - 0x000000000000000a: DW_OP_consts +0, DW_OP_stack_value
+; CHECK-NEXT:    0x000000000000000a - 0x0000000000000017: DW_OP_consts +1, DW_OP_stack_value
+; CHECK:       0x00000022:
+; CHECK-NEXT:    0x0000000000000000 - 0x0000000000000017: DW_OP_breg0 EAX+0, DW_OP_deref
+; CHECK-NEXT:    0x0000000000000017 - 0x0000000000000043: DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 
 %struct.A = type { i32 (...)**, i32 }
 
 ; Function Attrs: nounwind
 define i32 @_Z3bari(i32 %b) #0 !dbg !4 {
 entry:
   %b.addr = alloca i32, align 4
   store i32 %b, i32* %b.addr, align 4
-  call void @llvm.dbg.declare(metadata i32* %b.addr, metadata !21, metadata !DIExpression()), !dbg !22
+  call void @llvm.dbg.value(metadata i32 0, metadata !21, metadata !DIExpression()), !dbg !22
   %0 = load i32, i32* %b.addr, align 4, !dbg !23
+  call void @llvm.dbg.value(metadata i32 1, metadata !21, metadata !DIExpression()), !dbg !22
   %add = add nsw i32 %0, 4, !dbg !23
   ret i32 %add, !dbg !23
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
 define void @_Z3baz1A(%struct.A* %a) #2 !dbg !14 {
 entry:
   %z = alloca i32, align 4
   call void @llvm.dbg.declare(metadata %struct.A* %a, metadata !24, metadata !DIExpression(DW_OP_deref)), !dbg !25
   call void @llvm.dbg.declare(metadata i32* %z, metadata !26, metadata !DIExpression()), !dbg !27
   store i32 2, i32* %z, align 4, !dbg !27
   %var = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 1, !dbg !28
   %0 = load i32, i32* %var, align 4, !dbg !28

llvm/trunk/test/DebugInfo/X86/dw_op_minus_direct.ll

 ; Test dwarf codegen of DW_OP_minus.
 ; RUN: llc -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s
 ; RUN: llc -dwarf-version=2 -filetype=obj < %s | llvm-dwarfdump - \
 ; RUN:   | FileCheck %s --check-prefix=DWARF2
 ; RUN: llc -dwarf-version=3 -filetype=obj < %s | llvm-dwarfdump - \
 ; RUN:   | FileCheck %s --check-prefix=DWARF2
 
 ; This was derived manually from:
 ; int inc(int i) {
 ;  return i+1;
 ; }
 
 ; DWARF2: .debug_info
 ; DWARF2: DW_TAG_formal_parameter
 ; DWARF2-NEXT: DW_AT_name {{.*}}"i"
-; DWARF2-NOT:  DW_AT_location
+; DWARF2-NOT:      DW_AT_location
 
-; CHECK: Beginning address offset: 0x0000000000000000
-; CHECK:    Ending address offset: 0x0000000000000004
-; CHECK:     Location description: 70 00 10 ff ff ff ff 0f 1a 10 01 1c 9f
+; CHECK: .debug_loc contents:
+; CHECK: 0x00000000:
+; CHECK-NEXT:   0x0000000000000000 - 0x0000000000000004: DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_constu 0x1, 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:
   %add = add nsw i32 %i, 1, !dbg !15
   tail call void @llvm.dbg.value(metadata i32 %add, metadata !12, metadata !13), !dbg !14

llvm/trunk/test/DebugInfo/X86/fi-expr.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -o - %s -filetype=obj \
 ; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; A hand-crafted FrameIndex location with a DW_OP_deref.
 ; CHECK: DW_TAG_formal_parameter
 ;                                          fbreg -8, deref
-; CHECK-NEXT: DW_AT_location {{.*}} (<0x3> 91 78 06 )
+; CHECK-NEXT: DW_AT_location {{.*}} (DW_OP_fbreg -8, DW_OP_deref)
 ; CHECK-NEXT: DW_AT_name {{.*}} "foo"
+
 define void @f(i8* %bar) !dbg !6 {
 entry:
   %foo.addr = alloca i8*
   store i8* %bar, i8** %foo.addr
   call void @llvm.dbg.declare(metadata i8** %foo.addr, metadata !12, metadata !13), !dbg !14
   ret void, !dbg !15
 }
 

llvm/trunk/test/DebugInfo/X86/fi-piece.ll

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 ; Test that multi-DW_OP_piece expressions are emitted for FI variables.
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_abstract_origin
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location [DW_FORM_exprloc]  (<0x8> 91 7c 93 02 91 78 93 02 )
-;                       fbreg -8, piece 0x00000002, fbreg -4, piece 0x00000002
+; CHECK-NEXT:   DW_AT_location [DW_FORM_exprloc]  (DW_OP_fbreg -4, DW_OP_piece 0x2, DW_OP_fbreg -8, DW_OP_piece 0x2)
 ; CHECK-NEXT:   DW_AT_abstract_origin {{.*}}"a"
 ; Inlined variable, not to be merged.
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_variable
 ; CHECK-NEXT:     DW_AT_location
 ; CHECK-NEXT:   DW_AT_abstract_origin {{.*}}"a"

llvm/trunk/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 (00000003) 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] (DW_OP_GNU_addr_index 0x0)
 ; CHECK: [[TYPE]]: DW_TAG_base_type
 ; CHECK: DW_AT_name [DW_FORM_GNU_str_index]     ( indexed (00000004) string = "int")
 
 ; CHECK: .debug_str contents:
 ; CHECK: 0x00000000: "baz.dwo"
 ; CHECK: 0x00000008: "/usr/local/google/home/echristo/tmp"
 
 ; CHECK: .debug_str.dwo contents:

llvm/trunk/test/DebugInfo/X86/fission-ranges.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -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)
 
 
 ; 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: 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_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: 169
-; CHECK-NEXT:      Location description: 11 00
-; CHECK-NEXT: {{^$}}
-; CHECK-NEXT:   Beginning address index: 3
-; CHECK-NEXT:                    Length: 25
-; CHECK-NEXT:      Location description: 50
-; CHECK: [[E]]: Beginning address index: 4
-; CHECK-NEXT:                    Length: 19
-; CHECK-NEXT:      Location description: 50
-; CHECK: [[B]]: Beginning address index: 5
-; CHECK-NEXT:                    Length: 17
-; CHECK-NEXT:      Location description: 50
-; CHECK: [[D]]: Beginning address index: 6
-; CHECK-NEXT:                    Length: 17
-; CHECK-NEXT:      Location description: 50
+; CHECK:      [[A]]:
+; CHECK-NEXT:   Addr idx 2 (w/ length 169): DW_OP_consts +0, DW_OP_stack_value
+; CHECK-NEXT:   Addr idx 3 (w/ length 25): DW_OP_reg0 RAX
+; CHECK:      [[E]]:
+; CHECK-NEXT:   Addr idx 4 (w/ length 19): DW_OP_reg0 RAX
+; CHECK:      [[B]]:
+; CHECK-NEXT:   Addr idx 5 (w/ length 17): DW_OP_reg0 RAX
+; CHECK:      [[D]]:
+; CHECK-NEXT:   Addr idx 6 (w/ length 17): DW_OP_reg0 RAX
+
 
 ; 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)
 

llvm/trunk/test/DebugInfo/X86/float_const_loclist.ll

 ;
 ; SANITY: CALL{{.*}} @barrier
 ; SANITY: DBG_VALUE x86_fp80 0xK4000C8F5C28F5C28F800
 ; SANITY: DBG_VALUE float 0x40091EB860000000
 ; SANITY: TAILJMP{{.*}} @barrier
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:  DW_AT_location {{.*}} (0x[[LD:.*]])
+; CHECK-NEXT:  DW_AT_location {{.*}} (
+; CHECK-NEXT:    [[START:0x.*]] - [[END:0x.*]]: DW_OP_constu 0xc8f5c28f5c28f800, DW_OP_piece 0x8, DW_OP_constu 0x4000, DW_OP_bit_piece 0x10 0x40)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"ld"
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:  DW_AT_location {{.*}} (0x[[F:.*]])
+; CHECK-NEXT:  DW_AT_location {{.*}} (
+; CHECK-NEXT:    [[START]] - [[END]]: DW_OP_constu 0x4048f5c3)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"f"
-;
-; CHECK: .debug_loc contents:
-; CHECK: [[LD]]: Beginning address offset: [[START:.*]]
-; CHECK:            Ending address offset: [[END:.*]]
-; CHECK: Location description: 10 80 f0 a3 e1 f5 d1 f0 fa c8 01 93 08 10 80 80 01 9d 10 40
-;                   constu 0xc8f5c28f5c28f800, piece 8, constu 0x00004000, bit-piece 16 64
-; CHECK: [[F]]: Beginning address offset: [[START]]
-; CHECK:           Ending address offset: [[END]]
-; CHECK:            Location description: 10 c3 eb a3 82 04
-;                                         constu ...
+
 source_filename = "test.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @foo() #0 !dbg !4 {
 entry:
   tail call void (...) @barrier() #3, !dbg !16

llvm/trunk/test/DebugInfo/X86/frame-register.ll

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump --debug-dump=info - | FileCheck %s
 ; CHECK: DW_TAG_variable
-;                                                      DW_OP_fbreg
-; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 00 )
+; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +0)
 ; CHECK-NEXT: DW_AT_name {{.*}}"i"
 
 target datalayout = "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 ; Function Attrs: nounwind uwtable
 declare i32 @foo(i32 %i) #0
 

llvm/trunk/test/DebugInfo/X86/inlined-formal-parameter.ll

 ; CHECK:       DW_TAG_inlined_subroutine
 ; CHECK-NEXT:    DW_AT_abstract_origin {{.*}} "bar"
 ; CHECK:         DW_TAG_formal_parameter
 ; CHECK-NEXT:      DW_AT_const_value
 ; CHECK-NEXT:      DW_AT_abstract_origin {{.*}} "a"
 ; CHECK:       DW_TAG_inlined_subroutine
 ; CHECK-NEXT:    DW_AT_abstract_origin {{.*}} "bar"
 ; CHECK:         DW_TAG_formal_parameter
-; CHECK-NEXT:      DW_AT_location [DW_FORM_data4] (0x00000000)
+; CHECK-NEXT:      DW_AT_location [DW_FORM_data4] (
+; CHECK-NEXT:        {{.*}} - {{.*}}: DW_OP_consts +0)
 ; CHECK-NEXT:      DW_AT_abstract_origin {{.*}} "a"
-;
-; CHECK: .debug_loc
-; CHECK: Location description: 11 00
+
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @foo() #0 !dbg !4 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 0, metadata !12, metadata !17) #3, !dbg !18
   tail call void @sink() #3, !dbg !20

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

 ; 
 ; int foo(int a, int b, int c, int d, int e) {
 ;   return F(a,b,c,d,e) +
 ;          F(a,b,c,d,e) +
 ;          F(a,b,c,d,e) +
 ;          F(a,b,c,d,e);
 ; }
 
-; CHECK: Beginning address offset
-; CHECK-NOT: Beginning address offset
+; CHECK:      .debug_loc contents:
+; CHECK-NEXT: 0x00000000:
+; CHECK-NEXT:              0x000000000000001f - 0x000000000000003c: DW_OP_reg3 RBX
+;   We should only have one entry
+; 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
   %call.i = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !43
   %call.i21 = tail call i32 @foobar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #3, !dbg !50

llvm/trunk/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)
-
-; 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)
+; DWARF4: DW_AT_location [DW_FORM_sec_offset]                      (0x00000000
+; DWARF4-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
+
+; DWARF3: DW_AT_location [DW_FORM_data4]                      (0x00000000
+; DWARF3-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
 
 ; 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:
+; Check the DEBUG_VALUE comments for good measure.
 ; 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 <- [DW_OP_deref] [%RCX+0]
 ; ASM-CHECK: DW_OP_breg2
 
 ; RUN: llvm-as %s -o - | llvm-dis - | FileCheck %s --check-prefix=PRETTY-PRINT
 ; PRETTY-PRINT: DIExpression(DW_OP_deref)
 

llvm/trunk/test/DebugInfo/X86/parameters.ll

 ; REQUIRES: object-emission
 ;
 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -O0 -filetype=obj < %s > %t
-; RUN: llvm-dwarfdump %t | FileCheck %s
+; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
 ; Test case derived from compiling the following source with clang -g:
 ;
 ; namespace pr14763 {
 ; struct foo {
 ;   foo(const foo&);
 ; };
 ;
 ; foo func(foo f) {
 ;   return f; // reference 'f' for now because otherwise we hit another bug
 ; }
 ;
 ; void sink(void*);
 ;
 ; 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
-; (with a zero offset) from the register parameter.
-; CHECK: DW_AT_location {{.*}} 74 00 06
-
+; The parameter is accessed indirectly (with a zero offset) from the second
+; register parameter. RDI is consumed by 'sret'.
+; CHECK: DW_TAG_subprogram
+; CHECK: DW_AT_name{{.*}} = "func"
+; CHECK: DW_TAG_formal_parameter
+; CHECK: DW_AT_location {{.*}} (DW_OP_breg4 RSI+0, DW_OP_deref)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "f"
-;
-; CHECK: DW_AT_location{{.*}}([[G_LOC:0x[0-9]*]])
+
+; CHECK: DW_TAG_subprogram
+; CHECK: DW_AT_name{{.*}} = "func2"
+; CHECK: DW_TAG_formal_parameter
+; CHECK: DW_AT_location{{.*}}(DW_OP_fbreg +23)
+; CHECK: DW_TAG_formal_parameter
+; CHECK: DW_AT_location{{.*}}(
+; CHECK-NEXT: {{.*}}: DW_OP_breg4 RSI+0, DW_OP_deref
+; CHECK-NEXT: {{.*}}: DW_OP_breg7 RSP+8, DW_OP_deref, DW_OP_deref)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}} = "g"
-;
-; CHECK: debug_loc contents
-; CHECK:         [[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 !dbg !4 {
 entry:
   call void @llvm.dbg.declare(metadata %"struct.pr14763::foo"* %f, metadata !22, metadata !DIExpression(DW_OP_deref)), !dbg !24
   call void @_ZN7pr147633fooC1ERKS0_(%"struct.pr14763::foo"* %agg.result, %"struct.pr14763::foo"* %f), !dbg !25

llvm/trunk/test/DebugInfo/X86/partial-constant.ll

 ;   f();
 ;   result = true;
 ; exit:
 ;   return result;
 ; }
 ;
 ; The constant should NOT be available for the entire function.
 ; CHECK-NOT: DW_AT_const_value
-; CHECK: .debug_loc
-; CHECK: Location description: 10 01 9f
-;                              constu 0x00000001, stack-value
+; CHECK: .debug_loc contents:
+; CHECK-NEXT: 0x00000000:
+; CHECK-NEXT:   {{.*}}: DW_OP_constu 0x1, DW_OP_stack_value
+
 source_filename = "test.ii"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 ; Function Attrs: noimplicitfloat noredzone nounwind optsize
 define zeroext i1 @_Z5startv() local_unnamed_addr #0 !dbg !7 {
 entry:
   %call = tail call zeroext i1 @_Z1cv() #3, !dbg !13

llvm/trunk/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:.*]]: 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 )
+; CHECK: [[LTMP3]] - {{.*}}: DW_OP_breg6 RBP-8, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_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 !dbg !4 {
 entry:
   call void @llvm.dbg.value(metadata i64 %s.coerce0, metadata !20, metadata !24), !dbg !21

llvm/trunk/test/DebugInfo/X86/pieces-2.ll

 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 ;
 ; CHECK: DW_TAG_variable [4]
-; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        ([[LOC:.*]])
+; CHECK-NEXT:   DW_AT_location [DW_FORM_data4] (
+; CHECK-NEXT:     0x0000000000000004 - 0x0000000000000005: DW_OP_reg0 RAX, DW_OP_piece 0x4)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"i1"
-;
-; CHECK: .debug_loc
-; CHECK: [[LOC]]: Beginning address offset: 0x0000000000000004
-; CHECK-NEXT:        Ending address offset: 0x0000000000000005
-;                                           rax, piece 0x00000004
-; CHECK-NEXT:         Location description: 50 93 04
-;
+
 ; 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 }
 
 ; Function Attrs: nounwind ssp uwtable

llvm/trunk/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]        ([[LOC1:.*]])
+; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        (
+; CHECK-NEXT:     0x0000000000000000 - 0x0000000000000004: DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_piece 0x4, DW_OP_reg4 RSI, DW_OP_piece 0x4
+; CHECK-NEXT:     0x0000000000000004 - 0x0000000000000008: DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_piece 0x4, DW_OP_reg4 RSI, DW_OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"outer"
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location
-;                                     rsi, piece 0x00000004
-; CHECK-SAME:                         54 93 04
+; CHECK-NEXT:   DW_AT_location {{.*}}(DW_OP_reg4 RSI, DW_OP_piece 0x4)
 ; CHECK-NEXT:   "i1"
-;
-; CHECK: .debug_loc
-; CHECK: [[LOC1]]: Beginning address offset: 0x0000000000000000
-; CHECK-NEXT:         Ending address offset: 0x0000000000000004
-;             rdi, piece 0x00000008, piece 0x00000004, rsi, piece 0x00000004
-; CHECK-NEXT: Location description: 55 93 08 93 04 54 93 04
-; This location is split into two ranges with identical locations
-; because it comes from a DBG_VALUE %RSI followed by a DBG_VALUE %ESI.
-; CHECK:           Beginning address offset: 0x0000000000000004
-; CHECK-NEXT:         Ending address offset: 0x0000000000000008
-; CHECK-NEXT: 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 !dbg !4 {
   call void @llvm.dbg.value(metadata i64 %outer.coerce0, metadata !24, metadata !25), !dbg !26
   call void @llvm.dbg.declare(metadata !{null}, metadata !27, metadata !28), !dbg !26

llvm/trunk/test/DebugInfo/X86/pieces-4.ll

 ; RUN: llc < %s | FileCheck %s
-; RUN: llc -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+; RUN: llc -filetype=obj < %s | llvm-dwarfdump -debug-dump=loc - | FileCheck %s --check-prefix=DWARF
 
 ; Compile the following with -O1:
 
 ; struct IntPair { int x, y; };
 ; int g(void);
 ; int bitpiece_spill() {
 ;   struct IntPair o = {g(), 0};
 ;   // Force o.x to spill
 ;   asm volatile("" : : : "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp",
 ;                "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15");
 ;   return o.x;
 ; }
 
 ; CHECK-LABEL: bitpiece_spill:                         # @bitpiece_spill
 ; CHECK:               callq   g
 ; CHECK:               movl    %eax, [[offs:[0-9]+]](%rsp)          # 4-byte Spill
 ; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] 0
 ; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offs]], DW_OP_LLVM_fragment 0 32] [%RSP+0]
 ; CHECK:               #APP
 ; CHECK:               #NO_APP
 ; CHECK:               movl    [[offs]](%rsp), %eax          # 4-byte Reload
 ; CHECK:               retq
-; DWARF: Location description: {{77 .. 93 04 10 00 9f 93 04}}
-; DW_OP_breg7+offs DW_OP_piece 4 DW_OP_constu 0 DW_OP_stack_value DW_OP_piece 4
+
+; DWARF: .debug_loc contents:
+; DWARF-NEXT: 0x00000000:
+; DWARF-NEXT: {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24210"
 
 %struct.IntPair = type { i32, i32 }
 

llvm/trunk/test/DebugInfo/X86/reference-argument.ll

 ; RUN: llc -mtriple=x86_64-apple-macosx10.9.0 -filetype=obj -O0 < %s \
 ; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; ModuleID = 'aggregate-indirect-arg.cpp'
 ; extracted from debuginfo-tests/aggregate-indirect-arg.cpp
 
 ; v should be a pointer.
 ; CHECK:  .debug_info contents:
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_specification {{.*}} "_ZN1A3fooE4SVal"
 ; CHECK-NOT: DW_TAG_subprogram
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK:       DW_AT_name {{.*}} "this"
 ; CHECK-NOT:   DW_TAG_subprogram
 ; CHECK:     DW_TAG_formal_parameter
-; CHECK-NEXT:  DW_AT_location 
-;                                rsi+0
-; CHECK-SAME:                    74 00
+; CHECK-NEXT:  DW_AT_location {{.*}}(DW_OP_breg4 RSI+0)
 ; CHECK-NEXT:  DW_AT_name {{.*}} "v"
 
 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-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %class.SVal = type { i8*, i32 }
 %class.A = type { i8 }
 

llvm/trunk/test/DebugInfo/X86/single-dbg_value.ll

 ; RUN: %llc_dwarf -stop-after=livedebugvalues -o - %s \
 ; RUN:   | FileCheck %s --check-prefix=SANITY
 ; RUN: %llc_dwarf -march=x86-64 -o - %s -filetype=obj \
 ; RUN:   | llvm-dwarfdump -debug-dump=all - | FileCheck %s
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]
+; CHECK-NEXT:   DW_AT_location [DW_FORM_data4] (
+; CHECK-NEXT:     {{.*}}: DW_OP_reg0 RAX)
 ; CHECK-NEXT:   DW_AT_name{{.*}}"a"
-; CHECK: .debug_loc contents:
-;                               rax
-; CHECK:  Location description: 50
+
 ; SANITY: DBG_VALUE
 ; SANITY-NOT: DBG_VALUE
-; ModuleID = 'test.ll'
+
 ; Compiled with -O:
 ;   void h(int);
 ;   int g();
 ;   void f() {
 ;     h(0);
 ;     int a = g();
 ;     h(a);
 ;   }
+
+; ModuleID = 'test.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @f() #0 !dbg !4 {
 entry:
   tail call void @h(i32 0) #2, !dbg !14
   %call = tail call i32 (...) @g() #2, !dbg !15

llvm/trunk/test/DebugInfo/X86/single-fi.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -o - %s -filetype=obj \
 ; RUN:   | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; A single FI location. This used to trigger an assertion in debug libstdc++.
 ; CHECK: DW_TAG_formal_parameter
 ;                                          fbreg -8
-; CHECK-NEXT: DW_AT_location {{.*}} (<0x2> 91 78 )
+; CHECK-NEXT: DW_AT_location {{.*}} (DW_OP_fbreg -8)
 ; CHECK-NEXT: DW_AT_name {{.*}} "dipsy"
 define void @tinkywinky(i8* %dipsy) !dbg !6 {
 entry:
   %dipsy.addr = alloca i8*
   store i8* %dipsy, i8** %dipsy.addr
   call void @llvm.dbg.declare(metadata i8** %dipsy.addr, metadata !12, metadata
 !13), !dbg !14
   ret void, !dbg !15

llvm/trunk/test/DebugInfo/X86/split-global.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o - -filetype=obj | \
 ; RUN:     llvm-dwarfdump --debug-dump=info - | FileCheck %s
 ;
 ; Test emitting debug info for fragmented global values.
 ; This is a handcrafted example of an SROAed global variable.
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 %struct.anon = type { i32, i32 }
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name {{.*}}"point"
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_location [DW_FORM_exprloc] (<0x16> 03 04 00 00 00 00 00 00 00 93 04 03 00 00 00 00 00 00 00 00 93 04 )
-;     [0x0000000000000004], piece 0x00000004, [0x0000000000000000], piece 0x00000004
+; CHECK: DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x4, DW_OP_piece 0x4, DW_OP_addr 0x0, DW_OP_piece 0x4)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name {{.*}}"part_const"
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_location [DW_FORM_exprloc] (<0x10> 03 08 00 00 00 00 00 00 00 93 04 10 02 9f 93 04 )
+; CHECK: DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x8, DW_OP_piece 0x4, DW_OP_constu 0x2, DW_OP_stack_value, DW_OP_piece 0x4)
 ;     [0x0000000000000008], piece 0x00000004, constu 0x00000002, stack-value, piece 0x00000004
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name {{.*}}"full_const"
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_location [DW_FORM_exprloc] (<0xa> 10 01 9f 93 04 10 02 9f 93 04 )
-;     constu 0x00000001, stack-value, piece 0x00000004, constu 0x00000002, stack-value, piece 0x00000004
+; CHECK: DW_AT_location [DW_FORM_exprloc] (DW_OP_constu 0x1, DW_OP_stack_value, DW_OP_piece 0x4, DW_OP_constu 0x2, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NOT: DW_TAG
 @point.y = global i32 2, align 4, !dbg !13
 @point.x = global i32 1, align 4, !dbg !12
 
 @part_const.x = global i32 1, align 4, !dbg !14
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!10, !11}

llvm/trunk/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 -debug-dump=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 - | FileCheck %s
 ; RUN: llc -O0 -fast-isel=false -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 ; CHECK: _ZN1B9AInstanceEv
 ; 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-NEXT:     {{.*}} - {{.*}}: DW_OP_breg5 RDI+0
+; CHECK-NEXT:     {{.*}} - {{.*}}: DW_OP_breg6 RBP-24, DW_OP_deref)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"a"
-; CHECK: .debug_loc contents:
-; CHECK: 0x00000000: Beginning address offset:
-; CHECK-NEXT:                Ending address offset:
-; CHECK-NEXT:                 Location description: 75 00
-;                                                   rdi+0
 
 %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*)]
 @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
 @_ZTS1A = linkonce_odr constant [3 x i8] c"1A\00"
 @_ZTI1A = linkonce_odr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i64 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }

llvm/trunk/test/DebugInfo/X86/stack-value-dwarf2.ll

-; RUN: llc -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -filetype=obj -o - %s | llvm-dwarfdump -debug-dump=loc - | FileCheck %s
+
 ; Note that it would be even better to avoid emitting the empty piece.
-; CHECK:  Location description: 93 08
-;                               piece 0x00000008
+; CHECK:  {{.*}}: DW_OP_piece 0x8{{$}}
+
 source_filename = "bugpoint-reduced-simplified.ll"
 target triple = "i386-apple-ios7.0.0"
 
 %class.K = type { %class.N, %struct.F, i32 }
 %class.N = type { %struct.B }
 %struct.B = type { i8 }
 %struct.F = type { i8 }
 %struct.ConditionPlatformHelper = type { i8 }

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

 ;   F r = {f, 0};
 ;   return r;
 ; }
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "i"
 ; CHECK:   DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location {{.*}} ([[I:.*]])
+; CHECK-NEXT:   DW_AT_location {{.*}} ([[I:.*]]
+; CHECK-NEXT:     {{.*}} - {{.*}}: DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 ;
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "f"
 ; CHECK:   DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location {{.*}} ([[F:.*]])
+; CHECK-NEXT:   DW_AT_location {{.*}} ([[F:.*]]
+; CHECK-NEXT:     {{.*}} - {{.*}}: DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 ;
 ; CHECK: .debug_loc contents:
-; CHECK: [[I]]: Beginning address offset:
-; CHECK-NEXT:           Ending address offset:
-; CHECK-NEXT:            Location description: 55 93 04 10 00 9f 93 04 
-; rdi, piece 0x00000004, constu 0x00000000, stack-value, piece 0x00000004
-;
-; CHECK: [[F]]: Beginning address offset:
-; CHECK-NEXT:           Ending address offset:
-; CHECK-NEXT:            Location description: 61 93 04 10 00 9f 93 04
-; reg17, piece 0x00000004, constu 0x00000000, stack-value, piece 0x00000004
+; CHECK:      [[I]]:
+; CHECK-NEXT:   {{.*}} - {{.*}}: DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4
+; CHECK:      [[F]]:
+; CHECK-NEXT:   {{.*}} - {{.*}}: DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_constu 0x0, 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/trunk/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
 ; subregister of the 64-bit rsi.
 ;
 ; rdar://problem/16015314
 ;
 ; CHECK:  .debug_info contents:
 ; CHECK:  DW_TAG_variable
-; CHECK-NEXT:  DW_AT_location [DW_FORM_data4] (0x00000000)
+; CHECK-NEXT:  DW_AT_location [DW_FORM_data4] (
+; CHECK-NEXT:    {{.*}} - {{.*}}: DW_OP_reg4 RSI)
 ; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}} "a"
-; CHECK: .debug_loc contents:
-;                                    rsi
-; CHECK:       Location description: 54
 ;
 ; struct bar {
 ;   int a;
 ;   int b;
 ; };
 ;
 ; void doSomething() __attribute__ ((noinline));
 ;

llvm/trunk/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]{{ *}}(DW_OP_addr 0x0, DW_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

llvm/trunk/test/DebugInfo/X86/this-stack_value.ll

 ;   };
 ;    
 ;   B *getB() { return new B(); }
 ;
 ; The inlined A::this pointer has the same location as B::this, but it may not be
 ; modified by the debugger.
 ;
 ; ASM: [DW_OP_stack_value]
-; CHECK:  DW_AT_location {{.*}} 70 00 9f
-;                               rax+0, stack-value
+; CHECK:  DW_AT_location {{.*}} (DW_OP_breg0 RAX+0, DW_OP_stack_value)
+
 source_filename = "ab.cpp"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 %struct.B = type { %class.A, i32 }
 %class.A = type { i32, i32 }
 
 ; Function Attrs: ssp uwtable

llvm/trunk/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: DW_OP_reg1 ECX
+CHECK-NEXT:    0x0000000000000023 - 0x000000000000005d: DW_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: DW_OP_reg0 EAX
+CHECK-NEXT:    0x0000000000000020 - 0x000000000000005d: DW_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: DW_OP_reg1 ECX
+CHECK-NEXT:             0x0000000000000023 - 0x000000000000005d: DW_OP_breg5 EBP-16
+CHECK: [[G_LOC]]:
+CHECK-NEXT:             0x0000000000000000 - 0x0000000000000020: DW_OP_reg0 EAX
+CHECK-NEXT:             0x0000000000000020 - 0x000000000000005d: DW_OP_breg5 EBP-12

llvm/trunk/test/tools/dsymutil/ARM/scattered.c

 RUN: llvm-dsymutil -y %p/dummy-debug-map.map -oso-prepend-path %p/../Inputs/scattered-reloc/ -f -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 // See Inputs/scattered-reloc/scattered.s to see how this test
 // actually works. 
 int bar = 42;
 
 CHECK: DW_TAG_variable
 CHECK-NOT: DW_TAG
-CHECK: DW_AT_name{{.*}}"bar"
-CHECK-NOT: DW_TAG
-CHECK: DW_AT_location{{.*}}<0x05> 03 10 00 01 00 
-
+CHECK: DW_AT_name{{.*}}
+"bar" CHECK - NOT : DW_TAG
+                        CHECK : DW_AT_location{{.*}}(DW_OP_addr 0x10010)

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

 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_decl_line [DW_FORM_data1] (23)
 CHECK:      DW_AT_prototyped [DW_FORM_flag] (0x01)
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0063 => {0x00000063})
 CHECK:      DW_AT_external [DW_FORM_flag] (0x01)
 CHECK:      DW_AT_accessibility [DW_FORM_data1] (DW_ACCESS_public)
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000ea0)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000ec4)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000056] = "argc")
 CHECK:        DW_AT_decl_file [DW_FORM_data1]       ("/Inputs{{[/\\]}}basic1.c")
 CHECK:        DW_AT_decl_line [DW_FORM_data1] (23)
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x0063 => {0x00000063})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x02> 91 78 )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_fbreg -8)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000005b] = "argv")
 CHECK:        DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic1.c")
 CHECK:        DW_AT_decl_line [DW_FORM_data1] (23)
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x006a => {0x0000006a})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x02> 91 70 )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_fbreg -16)
 CHECK:      NULL
 CHECK:    DW_TAG_base_type [4]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000060] = "int")
 CHECK:      DW_AT_encoding [DW_FORM_data1]  (DW_ATE_signed)
 CHECK:      DW_AT_byte_size [DW_FORM_data1] (0x04)
 CHECK:    DW_TAG_pointer_type [5]
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x006f => {0x0000006f})
 CHECK:    DW_TAG_pointer_type [5]

 CHECK:   DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x00000049] = "/Inputs")
 CHECK:   DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000ed0)
 CHECK:    DW_TAG_base_type [4]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000060] = "int")
 CHECK:    DW_TAG_variable [7]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000072] = "private_int")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0026 => {0x000000a7})
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
-BASIC:      DW_AT_location [DW_FORM_block1] (<0x09> 03 08 10 00 00 01 00 00 00 )
-ARCHIVE:    DW_AT_location [DW_FORM_block1] (<0x09> 03 04 10 00 00 01 00 00 00 )
+BASIC:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001008)
+ARCHIVE:    DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_variable [7]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000007e] = "baz")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0026 => {0x000000a7})
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
-CHECK:      DW_AT_location [DW_FORM_block1] (<0x09> 03 00 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_subprogram [2] *
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000082] = "foo")
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0026 => {0x000000a7})
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000ed0)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000f19)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000086] = "arg")
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x0026 => {0x000000a7})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x02> 91 7c )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_fbreg -4)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram [8]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000008a] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0026 => {0x000000a7})
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f20)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000f37)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit [1] *
 CHECK:    DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000008e] = "basic3.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_data4]   (0x00000093)
 CHECK:    DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x00000049] = "/Inputs")
 CHECK:    DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f40)
 CHECK:    DW_TAG_variable [9]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000097] = "val")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x003c => {0x00000162})
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic3.c")
-BASIC:      DW_AT_location [DW_FORM_block1] (<0x09> 03 04 10 00 00 01 00 00 00 )
-ARCHIVE:    DW_AT_location [DW_FORM_block1] (<0x09> 03 08 10 00 00 01 00 00 00 )
+BASIC:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001004)
+ARCHIVE:    DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_volatile_type [10]
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0041 => {0x00000167})
 CHECK:    DW_TAG_base_type [4]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000060] = "int")
 CHECK:    DW_TAG_subprogram [2] *
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000009b] = "bar")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0041 => {0x00000167})
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f40)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000f84)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000086] = "arg")
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x0041 => {0x00000167})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x02> 91 78 )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_fbreg -8)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram [8]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000008a] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0041 => {0x00000167})
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f90)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000fa9)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 
 CHECK:    NULL
 
 CHECK: .debug_loc contents
 CHECK-NOT: Location
 
 CHECK:.debug_aranges contents:
 CHECK-NEXT:Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00

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

 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000016] = "basic1.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_sec_offset]      (0x00000000)
 CHECK:    DW_AT_comp_dir [DW_FORM_strp] ( .debug_str[0x0000001f] = "/Inputs")
 CHECK:    DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f40)
 CHECK:    DW_AT_high_pc [DW_FORM_data4]     (0x0000000b)
 CHECK:    DW_TAG_subprogram [2] *
 CHECK:      DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f40)
 CHECK:      DW_AT_high_pc [DW_FORM_data4] (0x0000000b)
-CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (<0x1> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000027] = "main")
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_prototyped [DW_FORM_flag_present] (true)
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x00000000000000a1)
 CHECK:      DW_AT_external [DW_FORM_flag_present] (true)
 CHECK:      DW_TAG_formal_parameter [3]  
-CHECK:        DW_AT_location [DW_FORM_exprloc]  (<0x3> 55 93 04 )
+CHECK:        DW_AT_location [DW_FORM_exprloc]  (DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000002c] = "argc")
 CHECK:        DW_AT_decl_file [DW_FORM_data1]       ("/Inputs{{[/\\]}}basic1.c")
 CHECK:        DW_AT_type [DW_FORM_ref_addr] (0x00000000000000a1)
 CHECK:      DW_TAG_formal_parameter [4]  
-CHECK:        DW_AT_location [DW_FORM_exprloc]  (<0x1> 54 )
+CHECK:        DW_AT_location [DW_FORM_exprloc]  (DW_OP_reg4 RSI)
 CHECK:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000031] = "argv")
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x0060 => {0x00000060})
 CHECK:      NULL
 CHECK:    DW_TAG_pointer_type [5]
 CHECK:       DW_AT_type [DW_FORM_ref4]       (cu + 0x0065 => {0x00000065})
 CHECK:    DW_TAG_pointer_type [5]  
 CHECK:    DW_TAG_const_type [6]  
 CHECK:    DW_TAG_base_type [7]  

 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000003b] = "basic2.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_sec_offset]      (0x00000044)
 CHECK:    DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f50)
 CHECK:    DW_AT_high_pc [DW_FORM_data4]     (0x00000037)
 CHECK:    DW_TAG_base_type [7]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000044] = "int")
 CHECK:    DW_TAG_variable [8]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000048] = "baz")
-CHECK:      DW_AT_location [DW_FORM_exprloc]  (<0x9> 03 00 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_variable [8]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000004c] = "private_int")
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
-CHECK:      DW_AT_location [DW_FORM_exprloc]  (<0x9> 03 08 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_subprogram [9]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000058] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref4] (cu + 0x002a => {0x000000a1})
 CHECK:      DW_AT_inline [DW_FORM_data1]  (DW_INL_inlined)
 CHECK:    DW_TAG_subprogram [10] *
 CHECK:      DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f50)
 CHECK:      DW_AT_high_pc [DW_FORM_data4] (0x00000037)
-CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (<0x1> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000005c] = "foo")
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_prototyped [DW_FORM_flag_present] (true)
 CHECK:      DW_AT_type [DW_FORM_ref4] (cu + 0x002a => {0x000000a1})
 CHECK:      DW_TAG_formal_parameter [11]
-CHECK:        DW_AT_location [DW_FORM_sec_offset]   (0x00000000)
+CHECK:        DW_AT_location [DW_FORM_sec_offset]   (0x00000000
+CHECK:          0x0000000000000000 - 0x000000000000000c: DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000060] = "arg")
 CHECK:        DW_AT_type [DW_FORM_ref4] (cu + 0x002a => {0x000000a1})
 CHECK:      DW_TAG_inlined_subroutine [12]  
 CHECK:        DW_AT_abstract_origin [DW_FORM_ref4]  (cu + 0x005b => {0x000000d2} "inc")
 CHECK:        DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f61)
 CHECK:        DW_AT_high_pc [DW_FORM_data4] (0x0000000f)
 CHECK:      NULL
 CHECK:    NULL
 
 CHECK:  Compile Unit: {{.*}} version = 0x0004
 
 CHECK:  DW_TAG_compile_unit [1] *
 CHECK:    DW_AT_producer [DW_FORM_strp] ( .debug_str[0x00000001] = "clang version 3.7.0 ")
 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000064] = "basic3.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_sec_offset]      (0x0000009a)
 CHECK:    DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f90)
 CHECK:    DW_AT_high_pc [DW_FORM_data4]     (0x00000024)
 CHECK:    DW_TAG_variable [13]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000006d] = "val")
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic3.c")
-CHECK:      DW_AT_location [DW_FORM_exprloc]  (<0x9> 03 04 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_volatile_type [14]  
 CHECK:    DW_TAG_subprogram [15]  
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000058] = "inc")
 CHECK:      DW_AT_inline [DW_FORM_data1]  (DW_INL_inlined)
 CHECK:    DW_TAG_subprogram [2] *
 CHECK:      DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f90)
 CHECK:      DW_AT_high_pc [DW_FORM_data4] (0x00000024)
-CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (<0x1> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_exprloc]  (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000071] = "bar")
 CHECK:      DW_TAG_formal_parameter [16]
-CHECK:        DW_AT_location [DW_FORM_sec_offset]   (0x00000025)
+CHECK:        DW_AT_location [DW_FORM_sec_offset]   (0x00000025
+CHECK:          0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK:          0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000060] = "arg")
 CHECK:      DW_TAG_inlined_subroutine [17]  
 CHECK:        DW_AT_abstract_origin [DW_FORM_ref4]  (cu + 0x0044 => {0x0000015f} "inc")
 CHECK:        DW_AT_ranges [DW_FORM_sec_offset]     (0x00000000
 CHECK:           [0x0000000100000f94 - 0x0000000100000f9a)
 CHECK:           [0x0000000100000f9f - 0x0000000100000fa7))
 
 CHECK:      NULL
 CHECK:    NULL
 
 
 CHECK: .debug_loc contents:
-CHECK-NEXT: 0x00000000: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:                Ending address offset: 0x000000000000000c
-CHECK-NEXT:                 Location description: 55 93 04
-CHECK-NEXT: {{^$}}
-CHECK-NEXT: 0x00000025: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:                Ending address offset: 0x000000000000000f
-CHECK-NEXT:                 Location description: 55 93 04 
-CHECK-NEXT: {{^$}}
-CHECK-NEXT:             Beginning address offset: 0x0000000000000019
-CHECK-NEXT:                Ending address offset: 0x000000000000001d
-CHECK-NEXT:                 Location description: 55 93 04 
+CHECK-NEXT: 0x00000000:
+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: .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
 CHECK-NEXT: [0x0000000100000f90 - 0x0000000100000fb4)

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

 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_decl_line [DW_FORM_data1] (23)
 CHECK:      DW_AT_prototyped [DW_FORM_flag] (0x01)
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x0063 => {0x00000063})
 CHECK:      DW_AT_external [DW_FORM_flag] (0x01)
 CHECK:      DW_AT_accessibility [DW_FORM_data1] (DW_ACCESS_public)
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f40)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]     (0x0000000100000f4b)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000056] = "argc")
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x0063 => {0x00000063})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x03> 55 93 04 )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_formal_parameter [3]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000005b] = "argv")
 CHECK:        DW_AT_type [DW_FORM_ref4]     (cu + 0x006a => {0x0000006a})
-CHECK:        DW_AT_location [DW_FORM_block1] (<0x01> 54 )
+CHECK:        DW_AT_location [DW_FORM_block1] (DW_OP_reg4 RSI)
 CHECK:      NULL
 CHECK:    DW_TAG_base_type [4]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000060] = "int")
 CHECK:      DW_AT_encoding [DW_FORM_data1]  (DW_ATE_signed)
 CHECK:      DW_AT_byte_size [DW_FORM_data1] (0x04)
 CHECK:    DW_TAG_pointer_type [5]
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x006f => {0x0000006f})
 CHECK:    DW_TAG_pointer_type [5]

 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000069] = "basic2.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_data4]   (0x0000003e)
 CHECK:    DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x00000049] = "/Inputs")
 CHECK:   DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f50)
 CHECK:    DW_TAG_variable [7]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000072] = "private_int")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic2.c")
-CHECK:      DW_AT_location [DW_FORM_block1] (<0x09> 03 08 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_variable [7]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000007e] = "baz")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
-CHECK:      DW_AT_location [DW_FORM_block1] (<0x09> 03 00 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_subprogram [8] *
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000082] = "foo")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f50)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000f89)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [9]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000086] = "arg")
 CHECK:        DW_AT_type [DW_FORM_ref_addr] (0x0000000000000063)
-CHECK:        DW_AT_location [DW_FORM_data4]        (0x00000000)
+CHECK:        DW_AT_location [DW_FORM_data4]        (0x00000000
+CHECK:          0x0000000000000000 - 0x000000000000000e: DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_inlined_subroutine [10]
 CHECK:        DW_AT_abstract_origin [DW_FORM_ref4]  (cu + 0x00a7 => {0x00000128} "inc")
 CHECK:        DW_AT_low_pc [DW_FORM_addr]   (0x0000000100000f63)
 CHECK:        DW_AT_high_pc [DW_FORM_addr]  (0x0000000100000f72)
 CHECK:        DW_AT_call_line [DW_FORM_data1] (20)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram [11]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000008a] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:      DW_AT_inline [DW_FORM_data1]  (DW_INL_inlined)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit [1] *
 CHECK:    DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:    DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000008e] = "basic3.c")
 CHECK:    DW_AT_stmt_list [DW_FORM_data4]   (0x0000007e)
 CHECK:    DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x00000049] = "/Inputs")
 CHECK:    DW_AT_low_pc [DW_FORM_addr]       (0x0000000100000f90)
 CHECK:    DW_TAG_variable [12]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000097] = "val")
 CHECK:      DW_AT_type [DW_FORM_ref4]       (cu + 0x003c => {0x00000176})
 CHECK:      DW_AT_decl_file [DW_FORM_data1] ("/Inputs{{[/\\]}}basic3.c")
-CHECK:      DW_AT_location [DW_FORM_block1] (<0x09> 03 04 10 00 00 01 00 00 00 )
+CHECK:      DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_volatile_type [13]
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:    DW_TAG_subprogram [8] *
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000009b] = "bar")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:      DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000f90)
 CHECK:      DW_AT_high_pc [DW_FORM_addr]    (0x0000000100000fb4)
-CHECK:      DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
+CHECK:      DW_AT_frame_base [DW_FORM_block1] (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter [9]
 CHECK:        DW_AT_name [DW_FORM_strp]     ( .debug_str[0x00000086] = "arg")
 CHECK:        DW_AT_type [DW_FORM_ref_addr] (0x0000000000000063)
-CHECK:        DW_AT_location [DW_FORM_data4]        (0x00000025)
+CHECK:        DW_AT_location [DW_FORM_data4]        (0x00000025
+CHECK:          0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK:          0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_lexical_block [14] *
 CHECK:        DW_AT_low_pc [DW_FORM_addr]   (0x0000000100000f94)
 CHECK:        DW_AT_high_pc [DW_FORM_addr]  (0x0000000100000fa7)
 CHECK:        DW_TAG_inlined_subroutine [15]
 CHECK:          DW_AT_abstract_origin [DW_FORM_ref4]        (cu + 0x009a => {0x000001d4} "inc")
 CHECK:          DW_AT_ranges [DW_FORM_data4]        (0x00000000
 CHECK:             [0x0000000100000f94 - 0x0000000100000f9a)
 CHECK:             [0x0000000100000f9f - 0x0000000100000fa7))
 CHECK:        NULL
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram [11]
 CHECK:      DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000008a] = "inc")
 CHECK:      DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000063)
 CHECK:    NULL
 
-CHECK:.debug_loc contents:
-CHECK-NEXT: 0x00000000: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:                Ending address offset: 0x000000000000000e
-CHECK-NEXT:                 Location description: 55 93 04 
-CHECK-NEXT: {{^$}}
-CHECK-NEXT: 0x00000025: Beginning address offset: 0x0000000000000000
-CHECK-NEXT:                Ending address offset: 0x000000000000000f
-CHECK-NEXT:                 Location description: 55 93 04 
-CHECK-NEXT: {{^$}}
-CHECK-NEXT:             Beginning address offset: 0x0000000000000019
-CHECK-NEXT:                Ending address offset: 0x000000000000001d
-CHECK-NEXT:                 Location description: 55 93 04 
+CHECK: .debug_loc contents:
+CHECK-NEXT: 0x00000000:
+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: .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/trunk/test/tools/dsymutil/X86/common-sym.test

 RUN: llvm-dsymutil -oso-prepend-path %p/.. %p/../Inputs/common.macho.x86_64 -f -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 The test was compiled from a single source:
 $ cat common.c 
 char common[16];
 int main() { return 0;}
 void bar() {}
 $ clang -g -c common.c -o common.macho.x86_64.o
 $ clang common.macho.x86_64.o -o common.macho.x86_64
 
 CHECK:   DW_TAG_variable
 CHECK:     DW_AT_name {{.*}} "common"
 CHECK-NOT: {{NULL|DW_TAG}}
-CHECK:     DW_AT_location {{.*}} (<0x09> 03 00 10 00 00 01 00 00 00 )
+CHECK:     DW_AT_location {{.*}} (DW_OP_addr 0x100001000)
 
 CHECK:   DW_TAG_subprogram
 CHECK-NEXT:     DW_AT_low_pc{{.*}}(0x0000000100000f80)
 CHECK-NOT: {{NULL|DW_TAG}}
 CHECK:     DW_AT_name {{.*}} "main"
 
 CHECK:   DW_TAG_subprogram
 CHECK-NEXT:     DW_AT_low_pc{{.*}}(0x0000000100000f90)
 CHECK-NOT: {{NULL|DW_TAG}}
 CHECK:     DW_AT_name {{.*}} "bar"

llvm/trunk/tools/llvm-dwarfdump/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
+  AllTargetsDescs
+  AllTargetsInfos
+  MC
   Object
   Support
   )
 
 add_llvm_tool(llvm-dwarfdump
   llvm-dwarfdump.cpp
   )
 
 if(LLVM_USE_SANITIZE_COVERAGE)
   add_subdirectory(fuzzer)
 endif()

llvm/trunk/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace object;

 static void error(StringRef Filename, std::error_code EC) {
   if (!EC)
     return;
   errs() << Filename << ": " << EC.message() << "\n";
   exit(1);
 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
-  std::unique_ptr<DIContext> DICtx = DWARFContext::create(Obj);
+  std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
+  logAllUnhandledErrors(DICtx->loadRegisterInfo(Obj), errs(),
+                        Filename.str() + ": ");
 
   outs() << Filename.str() << ":\tfile format " << Obj.getFileFormatName()
          << "\n\n";
 
 
   // Dump the complete DWARF structure.
   DIDumpOptions DumpOpts;
   DumpOpts.DumpType = DumpType;

 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargetMCs();
+
   cl::ParseCommandLineOptions(argc, argv, "llvm dwarf dumper\n");
 
   // Defaults to a.out if no filenames specified.
   if (InputFilenames.size() == 0)
     InputFilenames.push_back("a.out");
 
   // Expand any .dSYM bundles to the individual object files contained therein.
   std::vector<std::string> Objects;