[DebugInfo] Unify dumping of address ranges

[JDevlieghere]

Summary

This patch unifies the printing of address ranges as [0x0, 0x1).

rdar://34822059

[dblaikie]

Looks good to me

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

110–111 ↗

(On Diff #129821)

Looks like there's an opportunity to print these ranges similarly.

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

struct Header {
     uint8_t SegSize;
   };
 
   struct Descriptor {
     uint64_t Address;
     uint64_t Length;
 
     uint64_t getEndAddress() const { return Address + Length; }
+    void dump(raw_ostream &OS, uint32_t AddressSize) const;
   };
 
 private:
   using DescriptorColl = std::vector<Descriptor>;
   using desc_iterator_range = iterator_range<DescriptorColl::const_iterator>;
 
   uint32_t Offset;
   Header HeaderData;

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

struct DWARFAddressRange {
   }
 
   /// Returns true if [LowPC, HighPC) fully contains [RHS.LowPC, RHS.HighPC).
   bool contains(const DWARFAddressRange &RHS) const {
     if (LowPC <= RHS.LowPC && RHS.LowPC <= HighPC)
       return LowPC <= RHS.HighPC && RHS.HighPC <= HighPC;
     return false;
   }
+
+  void dump(raw_ostream &OS, uint32_t AddressSize) const;
 };
 
 static inline bool operator<(const DWARFAddressRange &LHS,
                              const DWARFAddressRange &RHS) {
   return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC, RHS.HighPC);
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const DWARFAddressRange &R);

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

 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <cstring>
 
 using namespace llvm;
 
+void DWARFDebugArangeSet::Descriptor::dump(raw_ostream &OS,
+                                           uint32_t AddressSize) const {
+  OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, Address)
+     << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2,
+               getEndAddress());
+}
+
 void DWARFDebugArangeSet::clear() {
   Offset = -1U;
   std::memset(&HeaderData, 0, sizeof(Header));
   ArangeDescriptors.clear();
 }
 
 bool
 DWARFDebugArangeSet::extract(DataExtractor data, uint32_t *offset_ptr) {

 }
 
 void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
   OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
                HeaderData.Length, HeaderData.Version)
      << format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
                HeaderData.CuOffset, HeaderData.AddrSize, HeaderData.SegSize);
 
-  const uint32_t hex_width = HeaderData.AddrSize * 2;
   for (const auto &Desc : ArangeDescriptors) {
-    OS << format("[0x%*.*" PRIx64 " -", hex_width, hex_width, Desc.Address)
-       << format(" 0x%*.*" PRIx64 ")\n",
-                 hex_width, hex_width, Desc.getEndAddress());
+    Desc.dump(OS, HeaderData.AddrSize);
+    OS << '\n';
   }
 }

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

 
 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.indent(Indent);
-    OS << format("0x%016" PRIx64, E.Begin) << " - "
-       << format("0x%016" PRIx64, E.End) << ": ";
+    OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2,
+                 E.Begin)
+       << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, E.End);
+    OS << ": ";
 
     dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI);
   }
 }
 
 DWARFDebugLoc::LocationList const *
 DWARFDebugLoc::getLocationListAtOffset(uint64_t Offset) const {
   auto It = std::lower_bound(

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

 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 #include <utility>
 
 using namespace llvm;
 
+void DWARFAddressRange::dump(raw_ostream &OS, uint32_t AddressSize) const {
+
+  OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
+     << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, HighPC);
+}
+
 raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {
-  return OS << format("[0x%16.16" PRIx64 ", 0x%16.16" PRIx64 ")", R.LowPC,
-                      R.HighPC);
+  R.dump(OS, /* AddressSize */ 8);
+  return OS;
 }
 
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;
   Entries.clear();
 }
 

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

 static void dumpRanges(const DWARFObject &Obj, raw_ostream &OS,
                        const DWARFAddressRangesVector &Ranges,
                        unsigned AddressSize, unsigned Indent,
                        const DIDumpOptions &DumpOpts) {
   ArrayRef<SectionName> SectionNames;
   if (DumpOpts.Verbose)
     SectionNames = Obj.getSectionNames();
 
-  for (size_t I = 0; I < Ranges.size(); ++I) {
-    const DWARFAddressRange &R = Ranges[I];
+  for (const DWARFAddressRange &R : Ranges) {
 
     OS << '\n';
     OS.indent(Indent);
-    OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")", AddressSize * 2,
-                 R.LowPC, AddressSize * 2, R.HighPC);
+    R.dump(OS, AddressSize);
 
     if (SectionNames.empty() || R.SectionIndex == -1ULL)
       continue;
 
     StringRef Name = SectionNames[R.SectionIndex].Name;
     OS << " \"" << Name << '\"';
 
     // Print section index if name is not unique.

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

 ; RUN: llc -filetype=obj -O0 < %s | llvm-dwarfdump -v - | 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]
-; 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:    [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"
 
 ; 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] }

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

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

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

 ; RUN: llc -O0 -fast-isel -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; Derived from (clang -O0 -g -fsanitize=address -fobjc-arc)
 ;   @protocol NSObject
 ;   @end
 ;   @interface NSObject<NSObject>{}
 ;   + (instancetype)alloc;
 ;   @end
 ;   struct CGSize {
 ;     double width;
 ;     double height;
 ;   };
 ;   typedef struct CGSize CGSize;
 ;   @interface Object : NSObject
 ;   - (instancetype)initWithSize:(CGSize)size;
 ;   - (id)aMessage;
-;   @end            
+;   @end
 ;   @implementation MyObject
 ;   + (id)doWithSize:(CGSize)imageSize andObject:(id)object {
 ;     return [object aMessage];
 ;   }
 ;   @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
-; CHECK-NEXT:   0x{{0*}} - 0x{{.*}}:
+; CHECK-NEXT:   [0x{{0*}}, 0x{{.*}}):
 ; CHECK-NOT:    DW_AT_
-; CHECK:        0x{{.*}} - [[FN_END]]:
+; CHECK:        [0x{{.*}}, [[FN_END]]):
 ; CHECK-NEXT: DW_AT_name {{.*}}"imageSize"
 
 ; 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

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

 ; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump -v -debug-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: 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)
+; CHECK:      [0x00000004, 0x00000004): DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x8
+; CHECK:      [0x00000004, 0x00000014): 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;
 ; };
-; 
+;
 ; void *memset(void *, int, size_t);
 ; void foo(void);
-; 
+;
 ; static void
 ; bar(int value)
 ; {
 ;   struct timeval lifetime;
-; 
+;
 ;   memset(&lifetime, 0, sizeof(struct timeval));
 ;   lifetime.tv_sec = value;
-; 
+;
 ;   foo();
 ; }
-; 
+;
 ; int
 ; parse_config_file(void)
 ; {
 ;   int value;
-; 
+;
 ;   bar(value);
 ;   return (0);
 ; }
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv4t--freebsd11.0-gnueabi"
 
 %struct.timeval = type { i64, i32 }

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

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump -v - | 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] ({{.*}}
-; 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
+; 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
 

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
-# CHECK-NEXT:   0x0000000000000000 - 0x0000000000000014: DW_OP_reg1 W1
-# CHECK-NEXT:   0x0000000000000014 - 0x0000000000000038: DW_OP_breg31 WSP+8
+# CHECK-NEXT:   [0x0000000000000000, 0x0000000000000014): DW_OP_reg1 W1
+# CHECK-NEXT:   [0x0000000000000014, 0x0000000000000038): DW_OP_breg31 WSP+8
 # CHECK-NEXT: DW_AT_name {{.*}}"y"
 
 --- |
   ; 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) {
   ;     g(s);
   ;     if (y)
   ;       h(&x);
   ;     return 0;
   ;   }
   source_filename = "/tmp/clobber.c"
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   target triple = "arm64-apple-ios"
-  
   %struct.Rect = type { double, double, double, double }
-  
   ; Function Attrs: nounwind optsize ssp
   define i32 @f(i32 %x, i32 %y, [4 x double] %s.coerce) local_unnamed_addr #0 !dbg !7 {
   entry:
     %x.addr = alloca i32, align 4
     tail call void @llvm.dbg.value(metadata i32 %x, i64 0, metadata !19, metadata !22), !dbg !23
     store i32 %x, i32* %x.addr, align 4, !tbaa !24
     tail call void @llvm.dbg.value(metadata i32 %y, i64 0, metadata !20, metadata !22), !dbg !28
     tail call void @llvm.dbg.declare(metadata %struct.Rect* undef, metadata !21, metadata !22), !dbg !29
     tail call void @g([4 x double] %s.coerce) #4, !dbg !30
     %tobool = icmp eq i32 %y, 0, !dbg !31
     br i1 %tobool, label %if.end, label %if.then, !dbg !33
-  
   if.then:                                          ; preds = %entry
     tail call void @llvm.dbg.value(metadata i32* %x.addr, i64 0, metadata !19, metadata !22), !dbg !23
     call void @h(i32* nonnull %x.addr) #4, !dbg !34
     br label %if.end, !dbg !34
-  
   if.end:                                           ; preds = %if.then, %entry
     ret i32 0, !dbg !35
   }
-  
   declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
   declare void @g([4 x double]) local_unnamed_addr #2
   declare void @h(i32*) local_unnamed_addr #2
   declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
   declare void @llvm.stackprotector(i8*, i8**) #3
-  
   attributes #0 = { nounwind optsize ssp }
   attributes #1 = { nounwind readnone speculatable }
   attributes #2 = { optsize }
   attributes #3 = { nounwind }
   attributes #4 = { nounwind optsize }
-  
   !llvm.dbg.cu = !{!0}
   !llvm.module.flags = !{!3, !4, !5}
   !llvm.ident = !{!6}
-  
   !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 5.0.0 (trunk 302682) (llvm/trunk 302683)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
   !1 = !DIFile(filename: "/tmp/clobber.c", directory: "/Volumes/Data/apple-internal/swift")
   !2 = !{}
   !3 = !{i32 2, !"Dwarf Version", i32 2}
   !4 = !{i32 2, !"Debug Info Version", i32 3}
   !5 = !{i32 1, !"PIC Level", i32 2}
   !6 = !{!"clang version 5.0.0 (trunk 302682) (llvm/trunk 302683)"}
   !7 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 7, type: !8, isLocal: false, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !18)

 ---
 name:            f
 alignment:       2
 exposesReturnsTwice: false
 legalized:       false
 regBankSelected: false
 selected:        false
 tracksRegLiveness: true
-liveins:         
+liveins:
   - { reg: '%w0' }
   - { reg: '%w1' }
   - { reg: '%d0' }
   - { reg: '%d1' }
   - { reg: '%d2' }
   - { reg: '%d3' }
-frameInfo:       
+frameInfo:
   isFrameAddressTaken: false
   isReturnAddressTaken: false
   hasStackMap:     false
   hasPatchPoint:   false
   stackSize:       32
   offsetAdjustment: 0
   maxAlignment:    8
   adjustsStack:    true
   hasCalls:        true
   maxCallFrameSize: 0
   hasOpaqueSPAdjustment: false
   hasVAStart:      false
   hasMustTailInVarArgFunc: false
-stack:           
+stack:
   - { id: 0, name: x.addr, offset: -20, size: 4, alignment: 4, local-offset: -4 }
   - { id: 1, type: spill-slot, offset: -24, size: 4, alignment: 4 }
   - { id: 2, type: spill-slot, offset: -8, size: 8, alignment: 8, callee-saved-register: '%lr' }
   - { id: 3, type: spill-slot, offset: -16, size: 8, alignment: 8, callee-saved-register: '%fp' }
 body:             |
   bb.0.entry:
     successors: %bb.2.if.end(0x40000000), %bb.1.if.then(0x40000000)
     liveins: %w0, %w1, %d0, %d1, %d2, %d3, %lr
-  
     %sp = frame-setup SUBXri %sp, 32, 0
     frame-setup STPXi killed %fp, killed %lr, %sp, 2 :: (store 8 into %stack.3), (store 8 into %stack.2)
     %fp = frame-setup ADDXri %sp, 16, 0
     DBG_VALUE debug-use %w0, debug-use _, !19, !22, debug-location !23
     STURWi killed %w0, %fp, -4 :: (store 4 into %stack.0.x.addr)
     DBG_VALUE debug-use %w1, debug-use _, !20, !22, debug-location !28
     STRWui killed %w1, %sp, 2, debug-location !30 :: (store 4 into %stack.1)
     DBG_VALUE %sp, 0, !20, !36, debug-location !28
     BL @g, csr_aarch64_aapcs, implicit-def dead %lr, implicit %sp, implicit killed %d0, implicit killed %d1, implicit killed %d2, implicit killed %d3, implicit-def %sp, debug-location !30
     %w0 = LDRWui %sp, 2, debug-location !33 :: (load 4 from %stack.1)
     CBZW killed %w0, %bb.2.if.end, debug-location !33
-  
   bb.1.if.then:
     successors: %bb.2.if.end(0x80000000)
-  
     DBG_VALUE debug-use %sp, 0, !20, !36, debug-location !28
     %x0 = SUBXri %fp, 4, 0
     DBG_VALUE debug-use %x0, debug-use _, !19, !22, debug-location !23
     BL @h, csr_aarch64_aapcs, implicit-def dead %lr, implicit %sp, implicit killed %x0, debug-location !34
-  
   bb.2.if.end:
     DBG_VALUE debug-use %sp, 0, !20, !36, debug-location !28
     %w8 = MOVZWi 0, 0
     %x0 = ORRXrs %xzr, undef %x8, 0, implicit killed %w8, debug-location !35
     %fp, %lr = LDPXi %sp, 2, debug-location !35 :: (load 8 from %stack.3), (load 8 from %stack.2)
     %sp = ADDXri %sp, 32, 0, debug-location !35
     RET undef %lr, implicit killed %w0, debug-location !35
 
 ...

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

 # RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s | \
 # RUN:     llvm-dwarfdump -debug-info - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_variable
 # 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: [0x00000010, 0x00000018): 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"
 
 --- |
   ; 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];
   ; }
 
   target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
   target triple = "thumbv7s-apple-ios5.0.0"
-  
   define float @f() local_unnamed_addr #0 !dbg !9 {
   entry:
     %call = tail call <4 x float> bitcast (<4 x float> (...)* @v to <4 x float> ()*)() #0, !dbg !19
     tail call void @llvm.dbg.value(metadata <4 x float> %call, i64 0, metadata !14, metadata !20), !dbg !21
     %vecext = extractelement <4 x float> %call, i32 0, !dbg !22
     %vecext1 = extractelement <4 x float> %call, i32 1, !dbg !23
     %add = fadd float %vecext, %vecext1, !dbg !24
     ret float %add, !dbg !25
   }
-  
   declare arm_aapcs_vfpcc <4 x float> @v(...) local_unnamed_addr #0
-  
   declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #0
-  
   attributes #0 = { nounwind readnone }
-  
   !llvm.dbg.cu = !{!0}
   !llvm.module.flags = !{!3, !4, !5, !6, !7}
   !llvm.ident = !{!8}
-  
   !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 4.0.0 (trunk 286322) (llvm/trunk 286305)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
   !1 = !DIFile(filename: "v.c", directory: "/")
   !2 = !{}
   !3 = !{i32 2, !"Dwarf Version", i32 2}
   !4 = !{i32 2, !"Debug Info Version", i32 3}
   !5 = !{i32 1, !"wchar_size", i32 4}
   !6 = !{i32 1, !"min_enum_size", i32 4}
   !7 = !{i32 1, !"PIC Level", i32 2}

 ---
 name:            f
 alignment:       1
 exposesReturnsTwice: false
 legalized:       false
 regBankSelected: false
 selected:        false
 tracksRegLiveness: true
-calleeSavedRegisters: [ '%lr', '%d8', '%d9', '%d10', '%d11', '%d12', '%d13', 
-                        '%d14', '%d15', '%q4', '%q5', '%q6', '%q7', '%r4', 
-                        '%r5', '%r6', '%r7', '%r8', '%r10', '%r11', '%s16', 
-                        '%s17', '%s18', '%s19', '%s20', '%s21', '%s22', 
-                        '%s23', '%s24', '%s25', '%s26', '%s27', '%s28', 
-                        '%s29', '%s30', '%s31', '%d8_d10', '%d9_d11', '%d10_d12', 
-                        '%d11_d13', '%d12_d14', '%d13_d15', '%q4_q5', '%q5_q6', 
-                        '%q6_q7', '%q4_q5_q6_q7', '%r4_r5', '%r6_r7', '%r10_r11', 
-                        '%d8_d9_d10', '%d9_d10_d11', '%d10_d11_d12', '%d11_d12_d13', 
-                        '%d12_d13_d14', '%d13_d14_d15', '%d8_d10_d12', 
-                        '%d9_d11_d13', '%d10_d12_d14', '%d11_d13_d15', 
-                        '%d8_d10_d12_d14', '%d9_d11_d13_d15', '%d9_d10', 
+calleeSavedRegisters: [ '%lr', '%d8', '%d9', '%d10', '%d11', '%d12', '%d13',
+                        '%d14', '%d15', '%q4', '%q5', '%q6', '%q7', '%r4',
+                        '%r5', '%r6', '%r7', '%r8', '%r10', '%r11', '%s16',
+                        '%s17', '%s18', '%s19', '%s20', '%s21', '%s22',
+                        '%s23', '%s24', '%s25', '%s26', '%s27', '%s28',
+                        '%s29', '%s30', '%s31', '%d8_d10', '%d9_d11', '%d10_d12',
+                        '%d11_d13', '%d12_d14', '%d13_d15', '%q4_q5', '%q5_q6',
+                        '%q6_q7', '%q4_q5_q6_q7', '%r4_r5', '%r6_r7', '%r10_r11',
+                        '%d8_d9_d10', '%d9_d10_d11', '%d10_d11_d12', '%d11_d12_d13',
+                        '%d12_d13_d14', '%d13_d14_d15', '%d8_d10_d12',
+                        '%d9_d11_d13', '%d10_d12_d14', '%d11_d13_d15',
+                        '%d8_d10_d12_d14', '%d9_d11_d13_d15', '%d9_d10',
                         '%d11_d12', '%d13_d14', '%d9_d10_d11_d12', '%d11_d12_d13_d14' ]
-frameInfo:       
+frameInfo:
   isFrameAddressTaken: false
   isReturnAddressTaken: false
   hasStackMap:     false
   hasPatchPoint:   false
   stackSize:       4
   offsetAdjustment: 0
   maxAlignment:    4
   adjustsStack:    true
   hasCalls:        true
   maxCallFrameSize: 0
   hasOpaqueSPAdjustment: false
   hasVAStart:      false
   hasMustTailInVarArgFunc: false
-stack:           
+stack:
   - { id: 0, type: spill-slot, offset: -4, size: 4, alignment: 4, callee-saved-register: '%lr' }
 body:             |
   bb.0.entry:
     liveins: %lr
-  
     early-clobber %sp = frame-setup t2STR_PRE killed undef %lr, %sp, -4, 14, _
     frame-setup CFI_INSTRUCTION def_cfa_offset 4
     frame-setup CFI_INSTRUCTION offset %lr, -4
     tBL 14, _, @v, csr_ios, implicit-def dead %lr, implicit %sp, implicit-def %sp, implicit-def %r0, implicit-def %r1, implicit-def %r2, implicit-def %r3, debug-location !19
     %d1 = VMOVDRR killed %r2, killed %r3, 14, _, implicit-def %q0, debug-location !19
     %d0 = VMOVDRR killed %r0, killed %r1, 14, _, implicit killed %q0, implicit-def %q0, debug-location !19
     DBG_VALUE debug-use %q0, debug-use _, !14, !20, debug-location !21
     %s4 = VMOVS %s1, 14, _, implicit-def %d2, debug-location !24
     %d0 = VADDfd %d0, killed %d2, 14, _, implicit killed %q0, debug-location !24
     %r0 = VMOVRS %s0, 14, _, implicit killed %d0, debug-location !25
     %lr, %sp = t2LDR_POST %sp, 4, 14, _, debug-location !25
     tBX_RET 14, _, implicit %r0, debug-location !25
 
 ...

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
-# CHECK-NEXT: 0x0000000000000010 - 0x0000000000000018: DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8)
+# CHECK-NEXT: [0x00000010, 0x00000018): DW_OP_regx D0, DW_OP_piece 0x8, DW_OP_regx D1, DW_OP_piece 0x8)
 # CHECK-NEXT: DW_AT_name {{.*}}"vec"
 
 --- |
   ; Generated from:
   ; typedef float vec2 __attribute__((vector_size(16)));
   ; vec2 v();
   ; float f() {
   ;   vec2 vec = v();
   ;   return vec[0] + vec[1];
   ; }
 
   target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
   target triple = "thumbv7s-apple-ios5.0.0"
-  
   define float @f() local_unnamed_addr #0 !dbg !9 {
   entry:
     %call = tail call <4 x float> bitcast (<4 x float> (...)* @v to <4 x float> ()*)() #0, !dbg !19
     tail call void @llvm.dbg.value(metadata <4 x float> %call, i64 0, metadata !14, metadata !20), !dbg !21
     %vecext = extractelement <4 x float> %call, i32 0, !dbg !22
     %vecext1 = extractelement <4 x float> %call, i32 1, !dbg !23
     %add = fadd float %vecext, %vecext1, !dbg !24
     ret float %add, !dbg !25
   }
-  
   declare arm_aapcs_vfpcc <4 x float> @v(...) local_unnamed_addr #0
-  
   declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #0
-  
   attributes #0 = { nounwind readnone }
-  
   !llvm.dbg.cu = !{!0}
   !llvm.module.flags = !{!3, !4, !5, !6, !7}
   !llvm.ident = !{!8}
-  
   !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 4.0.0 (trunk 286322) (llvm/trunk 286305)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
   !1 = !DIFile(filename: "v.c", directory: "/")
   !2 = !{}
   !3 = !{i32 2, !"Dwarf Version", i32 2}
   !4 = !{i32 2, !"Debug Info Version", i32 3}
   !5 = !{i32 1, !"wchar_size", i32 4}
   !6 = !{i32 1, !"min_enum_size", i32 4}
   !7 = !{i32 1, !"PIC Level", i32 2}

 ---
 name:            f
 alignment:       1
 exposesReturnsTwice: false
 legalized:       false
 regBankSelected: false
 selected:        false
 tracksRegLiveness: true
-calleeSavedRegisters: [ '%lr', '%d8', '%d9', '%d10', '%d11', '%d12', '%d13', 
-                        '%d14', '%d15', '%q4', '%q5', '%q6', '%q7', '%r4', 
-                        '%r5', '%r6', '%r7', '%r8', '%r10', '%r11', '%s16', 
-                        '%s17', '%s18', '%s19', '%s20', '%s21', '%s22', 
-                        '%s23', '%s24', '%s25', '%s26', '%s27', '%s28', 
-                        '%s29', '%s30', '%s31', '%d8_d10', '%d9_d11', '%d10_d12', 
-                        '%d11_d13', '%d12_d14', '%d13_d15', '%q4_q5', '%q5_q6', 
-                        '%q6_q7', '%q4_q5_q6_q7', '%r4_r5', '%r6_r7', '%r10_r11', 
-                        '%d8_d9_d10', '%d9_d10_d11', '%d10_d11_d12', '%d11_d12_d13', 
-                        '%d12_d13_d14', '%d13_d14_d15', '%d8_d10_d12', 
-                        '%d9_d11_d13', '%d10_d12_d14', '%d11_d13_d15', 
-                        '%d8_d10_d12_d14', '%d9_d11_d13_d15', '%d9_d10', 
+calleeSavedRegisters: [ '%lr', '%d8', '%d9', '%d10', '%d11', '%d12', '%d13',
+                        '%d14', '%d15', '%q4', '%q5', '%q6', '%q7', '%r4',
+                        '%r5', '%r6', '%r7', '%r8', '%r10', '%r11', '%s16',
+                        '%s17', '%s18', '%s19', '%s20', '%s21', '%s22',
+                        '%s23', '%s24', '%s25', '%s26', '%s27', '%s28',
+                        '%s29', '%s30', '%s31', '%d8_d10', '%d9_d11', '%d10_d12',
+                        '%d11_d13', '%d12_d14', '%d13_d15', '%q4_q5', '%q5_q6',
+                        '%q6_q7', '%q4_q5_q6_q7', '%r4_r5', '%r6_r7', '%r10_r11',
+                        '%d8_d9_d10', '%d9_d10_d11', '%d10_d11_d12', '%d11_d12_d13',
+                        '%d12_d13_d14', '%d13_d14_d15', '%d8_d10_d12',
+                        '%d9_d11_d13', '%d10_d12_d14', '%d11_d13_d15',
+                        '%d8_d10_d12_d14', '%d9_d11_d13_d15', '%d9_d10',
                         '%d11_d12', '%d13_d14', '%d9_d10_d11_d12', '%d11_d12_d13_d14' ]
-frameInfo:       
+frameInfo:
   isFrameAddressTaken: false
   isReturnAddressTaken: false
   hasStackMap:     false
   hasPatchPoint:   false
   stackSize:       4
   offsetAdjustment: 0
   maxAlignment:    4
   adjustsStack:    true
   hasCalls:        true
   maxCallFrameSize: 0
   hasOpaqueSPAdjustment: false
   hasVAStart:      false
   hasMustTailInVarArgFunc: false
-stack:           
+stack:
   - { id: 0, type: spill-slot, offset: -4, size: 4, alignment: 4, callee-saved-register: '%lr' }
 body:             |
   bb.0.entry:
     liveins: %lr
-  
     early-clobber %sp = frame-setup t2STR_PRE killed undef %lr, %sp, -4, 14, _
     frame-setup CFI_INSTRUCTION def_cfa_offset 4
     frame-setup CFI_INSTRUCTION offset %lr, -4
     tBL 14, _, @v, csr_ios, implicit-def dead %lr, implicit %sp, implicit-def %sp, implicit-def %r0, implicit-def %r1, implicit-def %r2, implicit-def %r3, debug-location !19
     %d1 = VMOVDRR killed %r2, killed %r3, 14, _, implicit-def %q0, debug-location !19
     %d0 = VMOVDRR killed %r0, killed %r1, 14, _, implicit killed %q0, implicit-def %q0, debug-location !19
     DBG_VALUE debug-use %q0, debug-use _, !14, !20, debug-location !21
     %s4 = VMOVS %s1, 14, _, implicit-def %d2, debug-location !24
     %d0 = VADDfd %d0, killed %d2, 14, _, implicit killed %q0, debug-location !24
     %r0 = VMOVRS %s0, 14, _, implicit killed %d0, debug-location !25
     %lr, %sp = t2LDR_POST %sp, 4, 14, _, debug-location !25
     tBX_RET 14, _, implicit %r0, debug-location !25
 
 ...

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

 declare void @llvm.lifetime.start(i64, i8* nocapture)
 declare void @llvm.lifetime.end(i64, i8* nocapture)
 
 declare void @foo(i32*)
 
 ; 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:   [0x00000028, 0x0000002c): DW_OP_reg1 AT_64
+; CHECK-NEXT:   [0x0000002c, 0x00000048): 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
entry:
   %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
 }
 
 
 ; 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:   [0x00000080, 0x00000084): DW_OP_reg1 AT_64
+; CHECK-NEXT:   [0x00000084, 0x00000098): 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

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

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

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

 ; We don't actually care where 'x' lives, or what exact optimizations get
 ; used, as long as 'x' moves around we're fine.
 
 ; // The variable 'x' lives in different locations, so it needs an entry in
 ; // the .debug_loc table section, referenced by DW_AT_location.
 ; // This ref is not relocatable on Darwin, and is relocatable elsewhere.
 ; extern int g(int, int);
 ; extern int a;
-; 
+;
 ; void f(void) {
 ;   int x;
 ;   a = g(0, 0);
 ;   x = 1;
 ;   while (x & 1) { x *= a; }
 ;   a = g(x, 0);
 ;   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 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:   [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 we have no relocations in Darwin's output.
 ; DARWIN-NOT: X86_64_RELOC{{.*}} __debug_loc
 

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

 ; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump - --debug-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: 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
+; 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/constant-loclist.ll

 ; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump -v -debug-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]  (
-; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x4000000000000000)
+; 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]  (
-; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_consts +0
-; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_consts +4611686018427387904)
+; 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]  (
-; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x0
-; CHECK-NEXT:   0x{{.*}} - 0x{{.*}}: DW_OP_constu 0x4000000000000000)
+; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x0
+; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x4000000000000000)
 ; CHECK-NEXT: DW_AT_name {{.*}}"u"
 
 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 {

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

 ; RUN: llc %s -o %t.s
 ; RUN: llvm-mc -triple x86_64--linux %t.s -filetype=obj -o %t.o
 ; RUN: FileCheck < %t.s %s
 ; RUN: llvm-dwarfdump %t.o | FileCheck %s --check-prefix=DWARF
 
 ; Unlike dbg.declare, dbg.addr should be lowered to DBG_VALUE instructions. It
 ; is control-dependent.
 
 ; CHECK-LABEL: use_dbg_addr:
 ; CHECK: #DEBUG_VALUE: use_dbg_addr:o <- [%rsp+0]
 
 ; FIXME: Avoid the use of a single-location location list and use
 ; DW_AT_start_offset instead.
 
 ; DWARF: DW_TAG_variable
 ; DWARF-NEXT:              DW_AT_location (0x00000000
-; DWARF-NEXT:                          0x{{.*}} - 0x{{.*}}: DW_OP_breg7 RSP+0)
+; DWARF-NEXT:                          [0x{{.*}}, 0x{{.*}}): DW_OP_breg7 RSP+0)
 ; DWARF-NEXT:              DW_AT_name ("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 -v - | 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
 
 ; C++ source:
 ; class A { public: int x; int y; int z; int o; ~A() { x = 1; }};
-; 
+;
 ; A foo(int i) {
 ;   int j = 0;
 ;   if (i == 42) {
 ;     j = i + 1;
 ;   };
 ;   A my_a;
 ;   my_a.x = j;
 ;   return my_a;
 ; }
 
 ; CHECK: DW_AT_name {{.*}}"j"
-; CHECK: DW_TAG_variable  
+; CHECK: DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_sec_offset] (
-; CHECK-NEXT:     0x{{.*}} - 0x{{.*}}: DW_OP_breg7 RSP+8, DW_OP_deref)
+; CHECK-NEXT:     [0x{{.*}}, 0x{{.*}}): DW_OP_breg7 RSP+8, DW_OP_deref)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"my_a"
 
 %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

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

 ; 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 {{.*}}({{.*}}
-; 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-NEXT:  [0x{{0*.*}}, 0x[[C1:.*]]): DW_OP_consts +3
+; CHECK-NEXT:      [0x[[C1]], 0x[[C2:.*]]): DW_OP_consts +7
+; CHECK-NEXT:      [0x[[C2]], 0x[[R1:.*]]): DW_OP_reg0 RAX
+; CHECK-NEXT:      [0x[[R1]], 0x[[R2:.*]]): DW_OP_breg7 RSP+4, DW_OP_deref)
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}"i"
 
 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 {

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

 
 while.end:
   ret i1 true
 }
 
 ; CHECK-LABEL: test
 ; CHECK:       #DEBUG_VALUE: test:w <- [DW_OP_plus_uconst 8] [%rsp+0]
 ; DWARF:  DW_AT_location [DW_FORM_sec_offset] (
-; DWARF-NEXT:   {{.*}} - {{.*}}: DW_OP_breg7 RSP+8)
+; 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   [[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]   ({{0x.*}}
-; DWARF-NEXT:      0x0000000000000000 - 0x0000000000000013: DW_OP_reg2 RCX)
+; DWARF-NEXT:      [0x0000000000000000, 0x0000000000000013): DW_OP_reg2 RCX)
 ; DWARF-NEXT:    DW_AT_name [DW_FORM_strp]     {{.*}} "argc"
 
 ; 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

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

 ; 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:       DW_TAG_formal_parameter
 ; DWARF:         DW_AT_location
-; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_breg5 RDI+0, DW_OP_deref
+; 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-NEXT:      {{.*}} - {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, 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

 ;   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] ({{.*}}
-; CHECK-NEXT:   {{0x.*}} - {{0x.*}}: DW_OP_reg0 RAX
-; CHECK-NEXT:   {{0x.*}} - {{0x.*}}: DW_OP_breg7 RSP+4, DW_OP_deref)
+; 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

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

 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_linkage_name [DW_FORM_strp]{{.*}}"_Z3baz1A"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
-; CHECK-NEXT:    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:    [0x00000000, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
+; CHECK-NEXT:    [0x00000017, 0x00000043): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 ; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"a"
 
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_location [DW_FORM_exprloc]
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_low_pc {{.*}} (0x0000000000000000)
 ; 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:    [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
+; CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value)
 ; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"b"
 
 ; CHECK: .debug_loc contents:
 ; CHECK:       0x00000000:
-; CHECK-NEXT:    0x0000000000000000 - 0x000000000000000a: DW_OP_consts +0, DW_OP_stack_value
-; CHECK-NEXT:    0x000000000000000a - 0x0000000000000017: DW_OP_consts +1, DW_OP_stack_value
+; CHECK-NEXT:    [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
+; CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value
 ; CHECK:       0x00000022:
-; CHECK-NEXT:    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:    [0x00000000, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
+; CHECK-NEXT:    [0x00000017, 0x00000043): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 
 %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

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

 
 ; DWARF2: .debug_info
 ; DWARF2: DW_TAG_formal_parameter
 ; DWARF2-NEXT: DW_AT_name {{.*}}"i"
 ; DWARF2-NOT:      DW_AT_location
 
 ; CHECK: .debug_loc contents:
 ; CHECK: 0x00000000:
-; CHECK-NEXT:   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
+; 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:

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

 RUN: llvm-dwarfdump -v %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-NEXT:    0x0000000000000000 - 0x0000000000000023: DW_OP_reg1 ECX
-CHECK-NEXT:    0x0000000000000023 - 0x000000000000005d: DW_OP_breg5 EBP-16)
+CHECK-NEXT:    [0x00000000, 0x00000023): DW_OP_reg1 ECX
+CHECK-NEXT:    [0x00000023, 0x0000005d): DW_OP_breg5 EBP-16)
 CHECK: DW_AT_name{{.*}}"g"
 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-NEXT:    [0x00000000, 0x00000020): DW_OP_reg0 EAX
+CHECK-NEXT:    [0x00000020, 0x0000005d): DW_OP_breg5 EBP-12)
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: [[F_LOC]]:
 this is actually the wrong location due to PR14763, but that doesn't matter for
 the purposes of testing dwarfdump
-CHECK-NEXT:             0x0000000000000000 - 0x0000000000000023: DW_OP_reg1 ECX
-CHECK-NEXT:             0x0000000000000023 - 0x000000000000005d: DW_OP_breg5 EBP-16
+CHECK-NEXT:             [0x00000000, 0x00000023): DW_OP_reg1 ECX
+CHECK-NEXT:             [0x00000023, 0x0000005d): DW_OP_breg5 EBP-16
 CHECK: [[G_LOC]]:
-CHECK-NEXT:             0x0000000000000000 - 0x0000000000000020: DW_OP_reg0 EAX
-CHECK-NEXT:             0x0000000000000020 - 0x000000000000005d: DW_OP_breg5 EBP-12
+CHECK-NEXT:             [0x00000000, 0x00000020): DW_OP_reg0 EAX
+CHECK-NEXT:             [0x00000020, 0x0000005d): DW_OP_breg5 EBP-12

llvm/trunk/test/DebugInfo/X86/dwarfdump-ranges-baseaddr-exe.s

 # RUN: llvm-dwarfdump -v %S/../Inputs/dwarfdump-ranges-baseaddr-exe.elf-x86-64 \
 # RUN:  | FileCheck %s
 
-## Executable binary for test produced from object built in 
+## Executable binary for test produced from object built in
 ## dwarfdump-ranges-baseaddr.s testcase.
 
 # CHECK: .debug_info contents:
 # CHECK: 0x0000000b: DW_TAG_compile_unit [1]
 # CHECK:             DW_AT_low_pc [DW_FORM_addr]       (0x0000000000400078)
 # CHECK-NEXT:        DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
-# CHECK-NEXT:    [0x0000000000400078 - 0x0000000000400079)
-# CHECK-NEXT:    [0x000000000040007b - 0x000000000040007e)
-# CHECK-NEXT:    [0x000000000040007f - 0x0000000000400080))
+# CHECK-NEXT:    [0x0000000000400078, 0x0000000000400079)
+# CHECK-NEXT:    [0x000000000040007b, 0x000000000040007e)
+# CHECK-NEXT:    [0x000000000040007f, 0x0000000000400080))

llvm/trunk/test/DebugInfo/X86/dwarfdump-ranges-baseaddr.s

 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
 # RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 # CHECK: .debug_info contents:
 # CHECK: 0x0000000b: DW_TAG_compile_unit [1]
 # CHECK:             DW_AT_low_pc [DW_FORM_addr]       (0x0000000000000000)
 # CHECK-NEXT:        DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
-# CHECK-NEXT:    [0x0000000000000000 - 0x0000000000000001) ".text"
-# CHECK-NEXT:    [0x0000000000000003 - 0x0000000000000006) ".text"
-# CHECK-NEXT:    [0x0000000000000001 - 0x0000000000000002) ".text.foo1")
+# CHECK-NEXT:    [0x0000000000000000, 0x0000000000000001) ".text"
+# CHECK-NEXT:    [0x0000000000000003, 0x0000000000000006) ".text"
+# CHECK-NEXT:    [0x0000000000000001, 0x0000000000000002) ".text.foo1")
 
 .text
 .globl foo
 .type foo,@function
-foo: 
+foo:
 .Lfunc_begin0:
   nop
 .Ltmp0:
   nop
   nop
 .Ltmp1:
   nop
   nop
   nop
 .Ltmp2:
 
 .section .text.foo1,"ax",@progbits
 .Ltmp3:
  nop
-.Ltmp4: 
+.Ltmp4:
  nop
 .Ltmp5:
 
 .section .debug_abbrev,"",@progbits
 .byte 1                       # Abbreviation Code
 .byte 17                      # DW_TAG_compile_unit
 .byte 0                       # DW_CHILDREN_no
 .byte 37                      # DW_AT_producer

llvm/trunk/test/DebugInfo/X86/dwarfdump-ranges-unrelocated.s

 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
 # RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_compile_unit
 # CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
-# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000001) ".text.foo1"
-# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000002) ".text.foo2" [4]
-# CHECK-NEXT:  [0x0000000000000000 - 0x0000000000000003) ".text.foo2" [5])
+# CHECK-NEXT:  [0x0000000000000000, 0x0000000000000001) ".text.foo1"
+# CHECK-NEXT:  [0x0000000000000000, 0x0000000000000002) ".text.foo2" [4]
+# CHECK-NEXT:  [0x0000000000000000, 0x0000000000000003) ".text.foo2" [5])
 
 # CHECK: .debug_ranges contents:
 # CHECK:   00000000 0000000000000000 0000000000000001
 # CHECK:   00000000 0000000000000000 0000000000000002
 # CHECK:   00000000 0000000000000000 0000000000000003
 # CHECK:   00000000 <End of list>
 
 # RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=BRIEF
 # BRIEF: DW_TAG_compile_unit
 # BRIEF: DW_AT_ranges         (0x00000000
-# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000001)
-# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000002)
-# BRIEF-NEXT:  [0x0000000000000000 - 0x0000000000000003))
+# BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000001)
+# BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000002)
+# BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000003))
 
 ## Asm code for testcase is a reduced and modified output from next
 ## invocation and source:
 # clang test.cpp -S -o test.s -gmlt -ffunction-sections
 # test.cpp:
-#   void foo1() { }  
-#   void foo2() { }  
+#   void foo1() { }
+#   void foo2() { }
 
 .section .text.foo1,"ax",@progbits
 .Lfunc_begin0:
  nop
 .Lfunc_end0:
 
 .section .text.foo2,"ax",@progbits, unique, 1
 .Lfunc_begin1:

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 {{.*}} (
-; 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:    [0x[[START:.*]], 0x[[END:.*]]): 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 {{.*}} (
-; CHECK-NEXT:    [[START]] - [[END]]: DW_OP_constu 0x4048f5c3)
+; CHECK-NEXT:    [0x[[START]], 0x[[END]]): DW_OP_constu 0x4048f5c3)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"f"
 
 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 {

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

 ; 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] (
-; CHECK-NEXT:        {{.*}} - {{.*}}: DW_OP_consts +0)
+; CHECK-NEXT:        [{{.*}}, {{.*}}): DW_OP_consts +0)
 ; CHECK-NEXT:      DW_AT_abstract_origin {{.*}} "a"
 
 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:

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

 ; RUN: llc -mtriple=x86_64-linux-gnu -filetype=obj -o - %s | llvm-dwarfdump -debug-loc - | FileCheck %s
 
 ; The test inlines the function F four times, with each inlined variable for
 ; "i4" sharing the same virtual register. This means the live interval of the
 ; register spans all of the inlined callsites, extending beyond the lexical
 ; scope of each. Later during register allocation the live interval is split
 ; into multiple intervals. Check that this does not generate multiple entries
 ; within the debug location (see PR33730).
 ;
 ; Generated from:
 ;
 ; extern int foobar(int, int, int, int, int);
-; 
+;
 ; int F(int i1, int i2, int i3, int i4, int i5) {
 ;   return foobar(i1, i2, i3, i4, i5);
 ; }
-; 
+;
 ; 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:      .debug_loc contents:
 ; CHECK-NEXT: 0x00000000:
 ;   We currently emit an entry for the function prologue, too, which could be optimized away.
-; CHECK:              0x000000000000001f - 0x000000000000003c: DW_OP_reg3 RBX
+; CHECK:              [0x000000000000001f, 0x000000000000003c): DW_OP_reg3 RBX
 ;   We should only have one entry inside the function.
 ; CHECK-NOT: :
 
 declare i32 @foobar(i32, i32, i32, i32, i32)
 
 define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) !dbg !25 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 %d, i64 0, metadata !15, metadata !17) #3, !dbg !41

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

 ;    int foo(S s) {
 ;            return s.b;
 ;    }
 ;
 ;
 ; CHECK: .debug_loc contents:
 ;
 
-; CHECK: 0x0000000000000000 - [[LTMP3:.*]]: DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_OP_piece 0x4
+; CHECK: [0x0000000000000000, 0x[[LTMP3:.*]]): DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_OP_piece 0x4
 ; 0x0000000000000006 - 0x0000000000000008: rbp-8, piece 0x8, rax, piece 0x4 )
-; CHECK: [[LTMP3]] - {{.*}}: DW_OP_breg6 RBP-8, DW_OP_piece 0x8, DW_OP_reg4 RSI, DW_OP_piece 0x4
+; CHECK: [0x[[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] (
-; CHECK-NEXT:     0x0000000000000004 - 0x0000000000000005: DW_OP_reg0 RAX, DW_OP_piece 0x4)
+; CHECK-NEXT:     [0x0000000000000004, 0x0000000000000005): DW_OP_reg0 RAX, DW_OP_piece 0x4)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"i1"
 
 ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-1.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %struct.Outer = type { [2 x %struct.Inner] }
 %struct.Inner = type { i32, i64 }

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

 ;
 ;    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]        (
-; 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:     [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 {{.*}}(DW_OP_reg4 RSI, DW_OP_piece 0x4)
 ; CHECK-NEXT:   "i1"
 
 ; 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"

llvm/trunk/test/DebugInfo/X86/spill-nospill.ll

 ; CHECK: movl    %[[CSR]], %ecx
 ; CHECK: callq   g
 ; CHECK: movl    [[X_OFFS]](%rsp), %eax          # 4-byte Reload
 ; CHECK: #DEBUG_VALUE: f:x <- %eax
 ; CHECK: addl    %[[CSR]], %eax
 
 ; DWARF:      DW_TAG_variable
 ; DWARF-NEXT:   DW_AT_location        (
-; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_breg7 RSP+36
-; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_reg0 RAX)
+; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_breg7 RSP+36
+; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_reg0 RAX)
 ; DWARF-NEXT:   DW_AT_name    ("x")
 
 ; DWARF:      DW_TAG_variable
 ; DWARF-NEXT:   DW_AT_location        (
-; DWARF-NEXT:      {{.*}} - {{.*}}: DW_OP_reg4 RSI)
+; DWARF-NEXT:      [{{.*}},  {{.*}}): DW_OP_reg4 RSI)
 ; DWARF-NEXT:   DW_AT_name    ("y")
 
 ; ModuleID = 'spill-nospill.c'
 source_filename = "spill-nospill.c"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 
 ; Function Attrs: nounwind uwtable

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 -v -all %t | FileCheck %s --check-prefix=CHECK-DWO
 
 ; Based on the debuginfo-tests/sret.cpp code.
 
 ; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
 ; CHECK-DWO: DW_AT_GNU_dwo_id [DW_FORM_data8] (0x51ac5644b1937aa1)
 
 ; RUN: llc -O0 -fast-isel=true -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; RUN: llc -O0 -fast-isel=false -mtriple=x86_64-apple-darwin -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ; CHECK: _ZN1B9AInstanceEv
-; CHECK: DW_TAG_variable  
+; CHECK: DW_TAG_variable
 ; 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_OP_breg5 RDI+0
+; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_breg6 RBP-24, DW_OP_deref)
 ; CHECK-NEXT:   DW_AT_name {{.*}}"a"
 
 %class.A = type { i32 (...)**, i32 }
 %class.B = type { i8 }
 
 @_ZTV1A = linkonce_odr unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%class.A*)* @_ZN1AD0Ev to i8*)]
 @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
 @_ZTS1A = linkonce_odr constant [3 x i8] c"1A\00"

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

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump -v - | FileCheck %s
 ; Test that DW_OP_piece is emitted for constants.
 ;
 ; // Generated from:
 ; typedef struct { int a, b; } I;
 ; I i(int i) {
 ;   I r = {i, 0};
 ;   return r;
 ; }
-;  
+;
 ; typedef struct { float a, b; } F;
 ; F f(float f) {
 ;   F r = {f, 0};
 ;   return r;
 ; }
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "i"
 ; CHECK:   DW_TAG_variable
 ; 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_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_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
+; 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]]:
-; 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_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
+; 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 -v %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] (
-; CHECK-NEXT:    {{.*}} - {{.*}}: DW_OP_reg4 RSI)
+; CHECK-NEXT:    [{{.*}}, {{.*}}): DW_OP_reg4 RSI)
 ; CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}} "a"
 ;
 ; struct bar {
 ;   int a;
 ;   int b;
 ; };
 ;
 ; void doSomething() __attribute__ ((noinline));

llvm/trunk/test/DebugInfo/dwarfdump-ranges.test

 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-test4.elf-x86-64 | FileCheck %s
 
 CHECK: .debug_info contents:
 CHECK: DW_TAG_compile_unit
 CHECK-NOT: TAG
 CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000000
-CHECK-NEXT:          [0x000000000000062c - 0x0000000000000637)
-CHECK-NEXT:          [0x0000000000000637 - 0x000000000000063d))
+CHECK-NEXT:          [0x000000000000062c, 0x0000000000000637)
+CHECK-NEXT:          [0x0000000000000637, 0x000000000000063d))
 
 CHECK: DW_TAG_compile_unit
 CHECK-NOT: TAG
 CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000030
-CHECK-NEXT:          [0x0000000000000640 - 0x000000000000064b)
-CHECK-NEXT:          [0x0000000000000637 - 0x000000000000063d))
+CHECK-NEXT:          [0x0000000000000640, 0x000000000000064b)
+CHECK-NEXT:          [0x0000000000000637, 0x000000000000063d))
 
 
 CHECK:      .debug_ranges contents:
 CHECK-NEXT: 00000000 000000000000062c 0000000000000637
 CHECK-NEXT: 00000000 0000000000000637 000000000000063d
 CHECK-NEXT: 00000000 <End of list>
 CHECK-NEXT: 00000030 0000000000000640 000000000000064b
 CHECK-NEXT: 00000030 0000000000000637 000000000000063d
 CHECK-NEXT: 00000030 <End of list>
 

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections-dwarf-2.s

 // DWARF:               DW_AT_high_pc {{.*}}(0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name {{.*}}("a")
 
 
 // DWARF: .debug_aranges contents:
 // DWARF-NEXT: Address Range Header: length = 0x00000024, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
-// DWARF-NEXT: [0x00000000 - 0x00000004)
-// DWARF-NEXT: [0x00000000 - 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0 is_stmt end_sequence
 // DWARF:      0x0000000000000000     11      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004     11      0      1   0   0 is_stmt end_sequence
 
 

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("a")
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("b")
 
 
 // DWARF: .debug_aranges contents:
 // DWARF-NEXT: Address Range Header: length = 0x00000024, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
-// DWARF-NEXT: [0x00000000 - 0x00000004)
-// DWARF-NEXT: [0x00000000 - 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF-DL: .debug_line contents:
 // DWARF-DL: version: [[DWVER]]
 // DWARF-DL-5:    address_size: 4
 // DWARF-DL-5:    include_directories[  1] = ''
 // DWARF-DL:      file_names[  1] {{.*}} <stdin>
 // DWARF-DL:      0x0000000000000000     17      0      1   0   0  is_stmt

llvm/trunk/test/MC/ARM/dwarf-asm-nonstandard-section.s

 // DWARF:               DW_AT_high_pc (0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name ("b")
 
 
 // DWARF: .debug_aranges contents:
 // DWARF-NEXT: Address Range Header: length = 0x0000001c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
-// DWARF-NEXT: [0x00000000 - 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0  is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0  is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:

llvm/trunk/test/MC/ARM/dwarf-asm-single-section.s

 // DWARF:               DW_AT_high_pc (0x0000000000000004)
 
 // DWARF: DW_TAG_label
 // DWARF-NEXT: DW_AT_name ("a")
 
 
 // DWARF: .debug_aranges contents:
 // DWARF-NEXT: Address Range Header: length = 0x0000001c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
-// DWARF-NEXT: [0x00000000 - 0x00000004)
+// DWARF-NEXT: [0x00000000, 0x00000004)
 
 // DWARF: .debug_line contents:
 // DWARF:      0x0000000000000000      7      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0 is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:
 // DWARF-NOT: .debug_pubnames contents:

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

 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 
 CHECK:    NULL
 
 CHECK-NOT: .debug_loc contents
 
 CHECK:.debug_aranges contents:
 CHECK-NEXT:Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT:[0x0000000100000ea0 - 0x0000000100000ec4)
+CHECK-NEXT:[0x0000000100000ea0, 0x0000000100000ec4)
 CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT:[0x0000000100000ed0 - 0x0000000100000f19)
-CHECK-NEXT:[0x0000000100000f20 - 0x0000000100000f37)
+CHECK-NEXT:[0x0000000100000ed0, 0x0000000100000f19)
+CHECK-NEXT:[0x0000000100000f20, 0x0000000100000f37)
 CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT:[0x0000000100000f40 - 0x0000000100000f84)
-CHECK-NEXT:[0x0000000100000f90 - 0x0000000100000fa9)
+CHECK-NEXT:[0x0000000100000f40, 0x0000000100000f84)
+CHECK-NEXT:[0x0000000100000f90, 0x0000000100000fa9)
 
 CHECK: .debug_line contents:
 CHECK:                Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
 CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000ea0     23      0      1   0             0  is_stmt

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

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

 CHECK:      DW_AT_inline (DW_INL_inlined)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_low_pc (0x0000000100000f90)
 CHECK:      DW_AT_high_pc (0x0000000100000fb4)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name ("bar")
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_location (0x00000025
-CHECK:          0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK:          0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [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 ("arg")
 CHECK:      DW_TAG_inlined_subroutine
 CHECK:        DW_AT_abstract_origin (cu + 0x0044 "inc")
 CHECK:        DW_AT_ranges (0x00000000
-CHECK:           [0x0000000100000f94 - 0x0000000100000f9a)
-CHECK:           [0x0000000100000f9f - 0x0000000100000fa7))
+CHECK:           [0x0000000100000f94, 0x0000000100000f9a)
+CHECK:           [0x0000000100000f9f, 0x0000000100000fa7))
 
 CHECK:      NULL
 CHECK:    NULL
 
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x00000000:
-CHECK-NEXT:              0x0000000000000000 - 0x000000000000000c: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000000, 0x000000000000000c): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
-CHECK-NEXT:              0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK-NEXT:              0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 
 CHECK: .debug_aranges contents:
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT: [0x0000000100000f40 - 0x0000000100000f4b)
+CHECK-NEXT: [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: [0x0000000100000f50, 0x0000000100000f87)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT: [0x0000000100000f90 - 0x0000000100000fb4)
+CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 CHECK: .debug_line contents:
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
 CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f40     26      0      1   0             0  is_stmt

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

 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_low_pc (0x0000000100000f50)
 CHECK:      DW_AT_high_pc (0x0000000100000f89)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
 CHECK:        DW_AT_type (0x0000000000000063
 CHECK:        DW_AT_location (0x00000000
-CHECK:          0x0000000000000000 - 0x000000000000000e: DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_inlined_subroutine
 CHECK:        DW_AT_abstract_origin (cu + 0x00a7 "inc")
 CHECK:        DW_AT_low_pc (0x0000000100000f63)
 CHECK:        DW_AT_high_pc (0x0000000100000f72)
 CHECK:        DW_AT_call_line (20)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")

 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_low_pc (0x0000000100000f90)
 CHECK:      DW_AT_high_pc (0x0000000100000fb4)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
 CHECK:        DW_AT_type (0x0000000000000063
 CHECK:        DW_AT_location (0x00000025
-CHECK:          0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK:          0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4)
+CHECK:          [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
 CHECK:        DW_AT_low_pc (0x0000000100000f94)
 CHECK:        DW_AT_high_pc (0x0000000100000fa7)
 CHECK:        DW_TAG_inlined_subroutine
 CHECK:          DW_AT_abstract_origin (cu + 0x009a "inc")
 CHECK:          DW_AT_ranges (0x00000000
-CHECK:             [0x0000000100000f94 - 0x0000000100000f9a)
-CHECK:             [0x0000000100000f9f - 0x0000000100000fa7))
+CHECK:             [0x0000000100000f94, 0x0000000100000f9a)
+CHECK:             [0x0000000100000f9f, 0x0000000100000fa7))
 CHECK:        NULL
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
 CHECK:      DW_AT_type (0x0000000000000063
 CHECK:    NULL
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x00000000:
-CHECK-NEXT:              0x0000000000000000 - 0x000000000000000e: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000000, 0x000000000000000e): DW_OP_reg5 RDI, DW_OP_piece 0x4
 CHECK-NOT: :
 CHECK:      0x00000025:
-CHECK-NEXT:              0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4
-CHECK-NEXT:              0x0000000000000019 - 0x000000000000001d: DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000000, 0x000000000000000f): DW_OP_reg5 RDI, DW_OP_piece 0x4
+CHECK-NEXT:              [0x0000000000000019, 0x000000000000001d): DW_OP_reg5 RDI, DW_OP_piece 0x4
 
 CHECK: .debug_aranges contents:
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT: [0x0000000100000f40 - 0x0000000100000f4b)
+CHECK-NEXT: [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: [0x0000000100000f50, 0x0000000100000f89)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
-CHECK-NEXT: [0x0000000100000f90 - 0x0000000100000fb4)
+CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 
 CHECK: .debug_line contents
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
 CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
 CHECK: 0x0000000100000f40     23      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f44     24      0      1   0             0  is_stmt prologue_end

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

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

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

 # RUN: llvm-mc %s -filetype obj -triple x86_64-linux-elf -o - \
 # RUN: | llvm-dwarfdump --debug-loc - \
 # RUN: | FileCheck %s
 
 # CHECK: .debug_loc contents:
 
 # CHECK: 0x00000000:
-# CHECK-NEXT: 0x0000000000000000 - 0x0000000000000003: DW_OP_reg5 RDI
-# CHECK-NEXT: 0x0000000000000003 - 0x0000000000000004: DW_OP_reg0 RAX
+# CHECK-NEXT: [0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
+# CHECK-NEXT: [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
 
 # CHECK: 0x00000036:
-# CHECK-NEXT: 0x0000000000000010 - 0x0000000000000013: DW_OP_reg5 RDI
-# CHECK-NEXT: 0x0000000000000013 - 0x0000000000000014: DW_OP_reg0 RAX
+# CHECK-NEXT: [0x0000000000000010, 0x0000000000000013): DW_OP_reg5 RDI
+# CHECK-NEXT: [0x0000000000000013, 0x0000000000000014): DW_OP_reg0 RAX
 
 # Source:
 #   int* foo(int* i) { return i; }
 #   int* bar(int* i) { return i; }
 # Compile with:
 #   clang -g -O3 test.c -S -o debugloc.s
 
   .text

llvm/trunk/test/tools/llvm-dwarfdump/X86/verify_die_ranges.s

Lset0 = Lsection_abbrev-Lsection_abbrev ## Offset Into Abbrev. Section
   .byte 8                       ## Address Size (in bytes)
   .byte 1                       ## Abbrev [1] 0xb:0x3f DW_TAG_compile_unit
   .long 0                       ## DW_AT_producer
   .short  12                      ## DW_AT_language
   .long 55                      ## DW_AT_name
 Lset1 = Lline_table_start0-Lsection_line ## DW_AT_stmt_list
   .long Lset1
   .long 63                      ## DW_AT_comp_dir
-  .quad 7               ## DW_AT_low_pc -- error: Invalid address range [0x00000007 - 0x00000006].
+  .quad 7               ## DW_AT_low_pc -- error: Invalid address range [0x0000000000000007, 0x0000000000000006)
   .quad 6                   ## DW_AT_high_pc
   .byte 0                       ## End Of Children Mark
 .subsections_via_symbols
   .section  __DWARF,__debug_line,regular,debug
 Lsection_line:
 Lline_table_start0: