[llvm-dwarfdump] Print type names in DW_AT_type DIEs

[JDevlieghere]

Summary

This patch adds printing for DW_AT_type DIEs like it is already the case for DW_AT_specification DIEs.

0x00000063:     DW_TAG_variable [4]
                  DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 50 )
                  DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000007b] = "ptr")
                  DW_AT_decl_file [DW_FORM_data1]       ("/private/tmp/verify_type_names.cpp")
                  DW_AT_decl_line [DW_FORM_data1]       (7)
                  DW_AT_type [DW_FORM_ref4]     (cu + 0x00c7 => {0x000000c7} "int*[]")

[probinson]

We like to have the original source available for tests like this, ideally with commands to regenerate it. That practice helps people to understand the test and makes it easier to accommodate any syntactic changes that might come along (although that's more the case with IR tests than assembler tests).

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

6 ↗

(On Diff #112096)

The DW_AT_type is on the member, not the class type.

10 ↗

(On Diff #112096)

Seems like it would be simpler to have one subprogram with a return type and a formal parameter, rather than two subprograms.
I'd also like to see what happens with a type more exciting than "int".

[JDevlieghere]

Thank you for the feedback Paul! I have simplified the test and included the source code.

[probinson]

LGTM

[JDevlieghere]

• Use a more intelligent approach to dumping type names
• Update tests

[friss]

It looks like you didn't add any actual testing of what you are dumping. It doesnt' need to be exhaustive, but there needs to be some.

[aprantl]

lib/DebugInfo/DWARF/DWARFDie.cpp

88 ↗

(On Diff #112480)

remove extra braces

98 ↗

(On Diff #112480)

In other places we condense this to:

if (const char *Name = D.getName(DINameKind::LinkageName))
  return OS << Name;

This is mostly up to personal taste though.

114 ↗

(On Diff #112480)

. at the end. LLVM prefers full sentences in comments.

195 ↗

(On Diff #112480)

maybe OS <<'"'; is more legible?

[probinson]

lib/DebugInfo/DWARF/DWARFDie.cpp

84 ↗

(On Diff #112480)

This function name isn't descriptive enough; I had to read the code to understand what it was doing. Maybe dumpTypeTagName or something like that.

130 ↗

(On Diff #112480)

Missing rvalue_reference_type.

[JDevlieghere]

Thanks for the feedback everyone, it is very much appreciated!

I forgot to add my test case again after adding the type dumper. I've included a more elaborate example that covers references, pointers and arrays.

[probinson]

I'm happy, but Adrian should have a chance to comment too.

[aprantl]

Looks fine to me, too. Thanks!

[dblaikie]

Where's the 'const' being printed from (couldn't spot it from a quick glance at the code) for the test cases like "const Struct"?

test/DebugInfo/Generic/tu-composite.ll

35 ↗

(On Diff #112611)

probably easier/fine to just drop the ')' from all these cases, the } and other features are probably an adequate match rather than adding the "{{.*}}") at the end

[JDevlieghere]

In D36993#854984, @dblaikie wrote:

Where's the 'const' being printed from (couldn't spot it from a quick glance at the code) for the test cases like "const Struct"?

The function dumpTypeTagName extracts the 'type name' from a tag. For the example the function dumps DW_TAG_const_type as const.

[JDevlieghere]

• Feedback David

[dblaikie]

In D36993#855144, @JDevlieghere wrote:

In D36993#854984, @dblaikie wrote:

Where's the 'const' being printed from (couldn't spot it from a quick glance at the code) for the test cases like "const Struct"?

The function dumpTypeTagName extracts the 'type name' from a tag. For the example the function dumps DW_TAG_const_type as const.

That seems a bit subtle - does that codepath trigger/do things for other tag types, or just const? Especially if it's just const, I'd probably handle const where reference, array, pointer, etc, are handled. Seems clearer.

[JDevlieghere]

In D36993#855777, @dblaikie wrote:

In D36993#855144, @JDevlieghere wrote:

In D36993#854984, @dblaikie wrote:

Where's the 'const' being printed from (couldn't spot it from a quick glance at the code) for the test cases like "const Struct"?

The function dumpTypeTagName extracts the 'type name' from a tag. For the example the function dumps DW_TAG_const_type as const.

That seems a bit subtle - does that codepath trigger/do things for other tag types, or just const? Especially if it's just const, I'd probably handle const where reference, array, pointer, etc, are handled. Seems clearer.

It works for all tag types, but some (such as pointers and references) are handled explicitly in the switch because we don't want to print their "type name" but rather a * or &. I totally agree that it's a little subtle. However originally every tag had a corresponding switch case but this was really verbose and not very maintainable. Personally I feel it's worth the trade-off, but I'd definitely be open to a different alternative!

[JDevlieghere]

David: Do you want to discuss this further or is this okay to land as is?

[JDevlieghere]

David, apologies for missing your e-mail. I really hate that it doesn't automatically show up in Phabricator! 🙁

If the tag doesn't have a name attribute, everything will go through this function except: DW_TAG_pointer_type, DW_TAG_ptr_to_member_type, DW_TAG_reference_type, DW_TAG_rvalue_reference_type. The first part explains why class and struct don't show up. I prefer this approach because it's guaranteed to be robust. Every DW_TAG_*_type encountered without a name will have something meaningful printed.

IIRC, the original switch had between 20 and 25 cases.

[dblaikie]

In D36993#858093, @JDevlieghere wrote:

David, apologies for missing your e-mail. I really hate that it doesn't automatically show up in Phabricator! 🙁

If the tag doesn't have a name attribute, everything will go through this function except: DW_TAG_pointer_type, DW_TAG_ptr_to_member_type, DW_TAG_reference_type, DW_TAG_rvalue_reference_type. The first part explains why class and struct don't show up. I prefer this approach because it's guaranteed to be robust. Every DW_TAG_*_type encountered without a name will have something meaningful printed.

IIRC, the original switch had between 20 and 25 cases.

I'm curious what those 20-25 cases were - do you have a copy/roughly describe their contents? Because while 'const' does print nicely, (& volatile would be similar) I'm not sure what the other 10 or so cases might be and whether that's a reasonable way to print them.

[JDevlieghere]

In D36993#858121, @dblaikie wrote:

In D36993#858093, @JDevlieghere wrote:

David, apologies for missing your e-mail. I really hate that it doesn't automatically show up in Phabricator! 🙁

If the tag doesn't have a name attribute, everything will go through this function except: DW_TAG_pointer_type, DW_TAG_ptr_to_member_type, DW_TAG_reference_type, DW_TAG_rvalue_reference_type. The first part explains why class and struct don't show up. I prefer this approach because it's guaranteed to be robust. Every DW_TAG_*_type encountered without a name will have something meaningful printed.

IIRC, the original switch had between 20 and 25 cases.

I'm curious what those 20-25 cases were - do you have a copy/roughly describe their contents? Because while 'const' does print nicely, (& volatile would be similar) I'm not sure what the other 10 or so cases might be and whether that's a reasonable way to print them.

Here's the list of cases I had originally:

case DW_TAG_array_type:
case DW_TAG_base_type:
case DW_TAG_class_type:
case DW_TAG_const_type:
case DW_TAG_enumeration_type:
case DW_TAG_file_type:
case DW_TAG_interface_type:
case DW_TAG_packed_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
case DW_TAG_reference_type:
case DW_TAG_restrict_type:
case DW_TAG_set_type:
case DW_TAG_shared_type:
case DW_TAG_string_type
case DW_TAG_structure_type:
case DW_TAG_subrange_type:
case DW_TAG_subroutine_type:
case DW_TAG_thrown_type:
case DW_TAG_union_type:
case DW_TAG_unspecified_type:
case DW_TAG_volatile_type:

[dblaikie]

In D36993#858768, @JDevlieghere wrote:

In D36993#858121, @dblaikie wrote:

In D36993#858093, @JDevlieghere wrote:

David, apologies for missing your e-mail. I really hate that it doesn't automatically show up in Phabricator! 🙁

If the tag doesn't have a name attribute, everything will go through this function except: DW_TAG_pointer_type, DW_TAG_ptr_to_member_type, DW_TAG_reference_type, DW_TAG_rvalue_reference_type. The first part explains why class and struct don't show up. I prefer this approach because it's guaranteed to be robust. Every DW_TAG_*_type encountered without a name will have something meaningful printed.

IIRC, the original switch had between 20 and 25 cases.

I'm curious what those 20-25 cases were - do you have a copy/roughly describe their contents? Because while 'const' does print nicely, (& volatile would be similar) I'm not sure what the other 10 or so cases might be and whether that's a reasonable way to print them.

Here's the list of cases I had originally:

case DW_TAG_array_type:
case DW_TAG_base_type:
case DW_TAG_class_type:
case DW_TAG_const_type:
case DW_TAG_enumeration_type:
case DW_TAG_file_type:
case DW_TAG_interface_type:
case DW_TAG_packed_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
case DW_TAG_reference_type:
case DW_TAG_restrict_type:
case DW_TAG_set_type:
case DW_TAG_shared_type:
case DW_TAG_string_type
case DW_TAG_structure_type:
case DW_TAG_subrange_type:
case DW_TAG_subroutine_type:
case DW_TAG_thrown_type:
case DW_TAG_union_type:
case DW_TAG_unspecified_type:
case DW_TAG_volatile_type:

Ah, thanks!

I feel like maybe this should be examined more closely (an example of how each of these would be printed would be ideal, though that might be a bit much) - for example I don't think it makes sense to print out subroutine types like "int subroutine" (rather than "int(float, double)", say) which I /think/ is how they might look based on the current code)

lib/DebugInfo/DWARF/DWARFDie.cpp

91–95 ↗

(On Diff #113040)

This might be the wrong approach for, for example, DW_AT_thrown_type - that's an attribute that refers to a type, but isn't itself a DW_AT_type (it should probably still print the type name)

Should this logic maybe work based on the type of the DIE being referenced, rather than the attribute type used to reference it? (or maybe some of both? Not sure - maybe there's only a couple of tags that can refer to types so a short list might suffice, I'm not sure)

[aprantl]

In D36993#859034, @dblaikie wrote:

In D36993#858768, @JDevlieghere wrote:

In D36993#858121, @dblaikie wrote:

In D36993#858093, @JDevlieghere wrote:

David, apologies for missing your e-mail. I really hate that it doesn't automatically show up in Phabricator! 🙁

If the tag doesn't have a name attribute, everything will go through this function except: DW_TAG_pointer_type, DW_TAG_ptr_to_member_type, DW_TAG_reference_type, DW_TAG_rvalue_reference_type. The first part explains why class and struct don't show up. I prefer this approach because it's guaranteed to be robust. Every DW_TAG_*_type encountered without a name will have something meaningful printed.

IIRC, the original switch had between 20 and 25 cases.

I'm curious what those 20-25 cases were - do you have a copy/roughly describe their contents? Because while 'const' does print nicely, (& volatile would be similar) I'm not sure what the other 10 or so cases might be and whether that's a reasonable way to print them.

Here's the list of cases I had originally:

case DW_TAG_array_type:
case DW_TAG_base_type:
case DW_TAG_class_type:
case DW_TAG_const_type:
case DW_TAG_enumeration_type:
case DW_TAG_file_type:
case DW_TAG_interface_type:
case DW_TAG_packed_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
case DW_TAG_reference_type:
case DW_TAG_restrict_type:
case DW_TAG_set_type:
case DW_TAG_shared_type:
case DW_TAG_string_type
case DW_TAG_structure_type:
case DW_TAG_subrange_type:
case DW_TAG_subroutine_type:
case DW_TAG_thrown_type:
case DW_TAG_union_type:
case DW_TAG_unspecified_type:
case DW_TAG_volatile_type:

Ah, thanks!

I feel like maybe this should be examined more closely (an example of how each of these would be printed would be ideal, though that might be a bit much) - for example I don't think it makes sense to print out subroutine types like "int subroutine" (rather than "int(float, double)", say) which I /think/ is how they might look based on the current code)

Generally agreed, but I think it might make sense to improve this in separate follow-on patches on a case-by-case basis. Getting the pretty-printing entirely right would mean that we would have to implement different pretty-printers for each DW_LANG_foo, since e.g., a C function type would have to be rendered very differently from the same DWARF type-representation in an. e.g., Swift or Fortran context. And even if we choose to always render types as C types it is unclear what to do with types such as DW_TAG_set_type.

[aprantl]

I played around with how we could generate testcases for this.

• I'm absolutely certain that yaml2obj (the standalone tool) is too low-level to do this. Having to manually update the object file header (or Mach-O load commands) every time a section changes in size is not doable unless you are starting from an existing object file and only modifying a couple bytes to inject, e.g., an error.
• Using just the yaml2obj DWARF emitter like in the DWARFDebugInfoTest.cpp unittest is slightly better, but you still have to manually update the size of the CU header and compute all offsets by hand. Plus IMHO the use of yaml in a string constant is kind of weird., but I can get used to it.
• Using assembler allows using labels, which gets rid off all the error-prone offset calculation, but on the other hand is much more verbose and low-level than some aspects of yaml2obj.
• Using LLVM IR is much more compact than all of the above, but it has the drawback that we can only represent DWARF that LLVM can generate,
• Source code is the most compact representation, but difficult to integrate into the LLVM testsuite because of the frontend dependency. It also restricts what DWARF we can generate even more.

What I would want is a format where I can specify DWARF at the same level of abstraction that dwarfdump is presenting. The easiest way to achieve this is probably to generate the DWARF programmatically in a unit test using the same API that yaml2obj is using internally. This way I can at least write code to calculate all the offsets. It would be kind of cute to write a tool that takes dwarfdump-like output as input and emits a yaml2obj-like yaml file, but I feel that that would be overkill since it isn't going to be very useful outside of this patch.

I will think some more about this.

[JDevlieghere]

• Rebase on master
• Add FIXME regarding pretty printers

It seems like this got stuck while thinking about how we could test the individual types efficiently.

Does anyone object to landing the patch in the current state as a first general step? The goal as I see it would then be to refine our approach with separate patches that have different pretty printers per language, which can be thoroughly tested for the types that actually make sense for that particular language.

[dblaikie]

I still feel like the implementation that handles 'const' by truncating the name of the DWARF TAG itself isn't sufficiently general to be a great way to go, but it's not exactly destructive to other things, etc, so carry on.

[dblaikie]

FWIW, I ended up adding test coverage for some of this in r348954 while improving the printing of arrays to include array dimensions - hand written assembly, so yeah, it's a bit less than ideal to maintain (mostly having to edit both the abbreviation and the definition - a solution to that would be handy (& having to lookup the numeric values of the enums (DW_AT/DW_TAGs))) but I think it's worth having.

[probinson]

In D36993#1328536, @dblaikie wrote:

FWIW, I ended up adding test coverage for some of this in r348954 while improving the printing of arrays to include array dimensions - hand written assembly, so yeah, it's a bit less than ideal to maintain (mostly having to edit both the abbreviation and the definition - a solution to that would be handy (& having to lookup the numeric values of the enums (DW_AT/DW_TAGs))) but I think it's worth having.

I can imagine some scheme involving a tool that generates assembler-source constants by pulling in Dwarf.def, but it's harder to imagine getting that hooked into the test infrastructure somehow.

[dblaikie]

In D36993#1328613, @probinson wrote:

In D36993#1328536, @dblaikie wrote:

FWIW, I ended up adding test coverage for some of this in r348954 while improving the printing of arrays to include array dimensions - hand written assembly, so yeah, it's a bit less than ideal to maintain (mostly having to edit both the abbreviation and the definition - a solution to that would be handy (& having to lookup the numeric values of the enums (DW_AT/DW_TAGs))) but I think it's worth having.

I can imagine some scheme involving a tool that generates assembler-source constants by pulling in Dwarf.def, but it's harder to imagine getting that hooked into the test infrastructure somehow.

Something like yaml2obj probably already uses LLVM's object libraries, so having access to the DWARF constants there wouldn't be too hard - I think they're down at a pretty low level near there.

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

if (!LocSection.Data.empty()) {
       if (LL)
         LL->dump(OS, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, Indent);
       else
         OS << "error extracting location list.";
     }
   }
 }
 
+/// Dump the name encoded in the type tag.
+static void dumpTypeTagName(raw_ostream &OS, dwarf::Tag T) {
+  StringRef TagStr = TagString(T);
+  if (!TagStr.startswith("DW_TAG_") || !TagStr.endswith("_type"))
+    return;
+  OS << TagStr.substr(7, TagStr.size() - 12) << " ";
+}
+
+/// Recursively dump the DIE type name when applicable.
+static void dumpTypeName(raw_ostream &OS, const DWARFDie &Die) {
+  DWARFDie D = Die.getAttributeValueAsReferencedDie(DW_AT_type);
+
+  if (!D.isValid())
+    return;
+
+  if (const char *Name = D.getName(DINameKind::LinkageName)) {
+    OS << Name;
+    return;
+  }
+
+  // FIXME: We should have pretty printers per language. Currently we print
+  // everything as if it was C++ and fall back to the TAG type name.
+  const dwarf::Tag T = D.getTag();
+  switch (T) {
+  case DW_TAG_array_type:
+  case DW_TAG_pointer_type:
+  case DW_TAG_ptr_to_member_type:
+  case DW_TAG_reference_type:
+  case DW_TAG_rvalue_reference_type:
+    break;
+  default:
+    dumpTypeTagName(OS, T);
+  }
+
+  // Follow the DW_AT_type if possible.
+  dumpTypeName(OS, D);
+
+  switch (T) {
+  case DW_TAG_array_type:
+    OS << "[]";
+    break;
+  case DW_TAG_pointer_type:
+    OS << '*';
+    break;
+  case DW_TAG_ptr_to_member_type:
+    OS << '*';
+    break;
+  case DW_TAG_reference_type:
+    OS << '&';
+    break;
+  case DW_TAG_rvalue_reference_type:
+    OS << "&&";
+    break;
+  default:
+    break;
+  }
+}
+
 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;
static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
 
   // 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))
       OS << " \"" << Name << '\"';
+  } else if (Attr == DW_AT_type) {
+    OS << " \"";
+    dumpTypeName(OS, Die);
+    OS << '"';
   } else if (Attr == DW_AT_APPLE_property_attribute) {
     if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
       dumpApplePropertyAttribute(OS, *OptVal);
   } else if (Attr == DW_AT_ranges) {
     const DWARFObject &Obj = Die.getDwarfUnit()->getContext().getDWARFObj();
     dumpRanges(Obj, OS, Die.getAddressRanges(), U->getAddressByteSize(),
                sizeof(BaseIndent) + Indent + 4, DumpOpts);
   }

llvm/trunk/test/DebugInfo/AMDGPU/pointer-address-space.ll

 ;   local int *FuncVar2 = 0;
 ;   private int *FuncVar3 = 0;
 ;   int *FuncVar4 = 0;
 ; }
 
 ; CHECK:      DW_AT_name {{.*}}"FuncVar0"
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE:[a-f0-9]+]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE:[a-f0-9]+]]}
 
 ; CHECK:      DW_AT_name {{.*}}"FuncVar1"
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE]]}
 
 ; CHECK:      DW_AT_name {{.*}}"FuncVar2"
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT:      DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[LOCAL:[a-f0-9]+]]})
+; CHECK-NEXT:      DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[LOCAL:[a-f0-9]+]]}
 
 ; CHECK:      DW_AT_name {{.*}}"FuncVar3"
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[PRIVATE:[a-f0-9]+]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[PRIVATE:[a-f0-9]+]]}
 
 ; CHECK:      DW_AT_name {{.*}}"FuncVar4"
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{[a-f0-9]+}} => {0x[[NONE]]}
 
 ; CHECK:      0x[[NONE]]: DW_TAG_pointer_type
 ; CHECK-NEXT:               DW_AT_type
 ; CHECK-NOT:                DW_AT_address_class
 
 ; CHECK:      0x[[LOCAL]]: DW_TAG_pointer_type
 ; CHECK-NEXT:                DW_AT_type
 ; CHECK-NEXT:                DW_AT_address_class [DW_FORM_data4] (0x00000002)

llvm/trunk/test/DebugInfo/Generic/cross-cu-inlining.ll

 ; }
 
 ; Ensure that func inlined into main is described and references the abstract
 ; definition in b.cpp's CU.
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_AT_name {{.*}} "a.cpp"
 ; CHECK:   DW_TAG_subprogram
-; CHECK:     DW_AT_type [DW_FORM_ref_addr] (0x00000000[[INT:.*]])
+; CHECK:     DW_AT_type [DW_FORM_ref_addr] (0x00000000[[INT:[a-f0-9]+]]
 ; CHECK:     0x[[INLINED:[0-9a-f]*]]:{{.*}}DW_TAG_inlined_subroutine
 ; CHECK:       DW_AT_abstract_origin {{.*}}[[ABS_FUNC:........]] "_Z4funci"
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_abstract_origin {{.*}}[[ABS_VAR:........]] "x"
 
 ; Check the abstract definition is in the 'b.cpp' CU and doesn't contain any
 ; concrete information (address range or variable location)
 ; CHECK: DW_TAG_compile_unit

llvm/trunk/test/DebugInfo/Generic/enum-types.ll

 ; REQUIRES: object-emission
 ;
 ; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Make sure we can handle enums with the same identifier but in enum types of
 ; different compile units.
 ; rdar://17628609
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: 0x[[ENUM:.*]]: DW_TAG_enumeration_type
 ; CHECK-NEXT:   DW_AT_name {{.*}} "EA"
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_MIPS_linkage_name {{.*}} "_Z4topA2EA"
 ; CHECK: DW_TAG_formal_parameter
-; CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[ENUM]]})
+; CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[ENUM]]}
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_Z4topB2EA"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[ENUM]]
 
 ; Function Attrs: nounwind ssp uwtable

llvm/trunk/test/DebugInfo/Generic/member-pointers.ll

 ; REQUIRES: object-emission
 ; XFAIL: hexagon
 
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_ptr_to_member_type
 ; CHECK: DW_TAG_ptr_to_member_type
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]}
 ; CHECK: [[TYPE]]:   DW_TAG_subroutine_type
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_type
 ; CHECK-NEXT: DW_AT_artificial [DW_FORM_flag
 ; IR generated from clang -g with the following source:
 ; struct S {
 ; };
 ;

llvm/trunk/test/DebugInfo/Generic/tu-composite.ll

 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "Nested")
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "Nested2")
 ; CHECK-NEXT: DW_AT_declaration [DW_FORM_flag]      (0x01)
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "virt<bar>")
 ; Make sure we correctly handle type of a template_type being a type identifier.
 ; CHECK: DW_TAG_template_type_parameter
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "T")
 ; Make sure we correctly handle derived-from of a typedef being a type identifier.
 ; CHECK: DW_TAG_typedef
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
 ; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "baz2")
 ; Make sure we correctly handle derived-from of a pointer type being a type identifier.
 ; CHECK: DW_TAG_pointer_type
-; CHECK: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE]]})
+; CHECK: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE]]}
 ; CHECK: DW_TAG_typedef
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
 ; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "baz")
 ; Make sure we correctly handle derived-from of an array type being a type identifier.
 ; CHECK: DW_TAG_array_type
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
 ; IR generated from clang -g with the following source:
 ; struct C {
 ;   virtual void foo();
 ; };
 ; void C::foo() {
 ; }
 ;
 ; struct bar { };

llvm/trunk/test/DebugInfo/Generic/tu-member-pointer.ll

 ; REQUIRES: object-emission
 
 ; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: DW_TAG_ptr_to_member_type
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE:0x[0-9a-f]+]]}
 ; CHECK: [[TYPE]]:   DW_TAG_base_type
 ; IR generated from clang -g with the following source:
 ; struct Foo {
 ;   int e;
 ; };
 ; int Foo:*x = 0;
 
 source_filename = "test/DebugInfo/Generic/tu-member-pointer.ll"

llvm/trunk/test/DebugInfo/X86/default-subrange-array.ll

 
 %class.A = type { [42 x i32] }
 
 @a = global %class.A zeroinitializer, align 4, !dbg !0
 
 ; CHECK:       DW_TAG_class_type
 ; CHECK:         DW_TAG_member
 ; CHECK-NEXT:      DW_AT_name {{.*}} "x"
-; CHECK-NEXT:      DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ARRAY:0x[0-9a-f]+]]})
+; CHECK-NEXT:      DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ARRAY:0x[0-9a-f]+]]}
 
 ; CHECK: [[ARRAY]]: DW_TAG_array_type
 ; CHECK-NEXT:         DW_AT_type
 ; CHECK:            DW_TAG_subrange_type
 ; CHECK-NEXT:         DW_AT_type
 ; DWARF4-NEXT:        DW_AT_lower_bound [DW_FORM_data1] (0x00)
 ; CHECK-NEXT:         DW_AT_count [DW_FORM_data1]       (0x2a)
 ; DWARF5-NOT:         DW_AT_lower_bound

llvm/trunk/test/DebugInfo/X86/empty-array.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -O0 -filetype=obj -o %t < %s
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; <rdar://problem/12566646>
 
 source_filename = "test/DebugInfo/X86/empty-array.ll"
 
 %class.A = type { [0 x i32] }
 
 @a = global %class.A zeroinitializer, align 4, !dbg !0
 ; CHECK: DW_TAG_class_type
 ; CHECK:      DW_TAG_member
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp]  ( .debug_str[0x{{[0-9a-f]*}}] = "x")
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[ARRAY:0x[0-9a-f]*]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[ARRAY:0x[0-9a-f]*]]}
 
 ; CHECK:      [[ARRAY]]: DW_TAG_array_type [{{.*}}] *
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]    (cu + 0x{{[0-9a-f]*}} => {[[BASETYPE:0x[0-9a-f]*]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]    (cu + 0x{{[0-9a-f]*}} => {[[BASETYPE:0x[0-9a-f]*]]}
 
 ; CHECK:      DW_TAG_subrange_type
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[BASE2:0x[0-9a-f]*]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[BASE2:0x[0-9a-f]*]]}
 ; CHECK-NOT:  DW_AT_upper_bound
 
 ; CHECK: [[BASETYPE]]: DW_TAG_base_type
 ; CHECK: [[BASE2]]: DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name
 ; CHECK-NEXT: DW_AT_byte_size [DW_FORM_data1]  (0x08)
 ; CHECK-NEXT: DW_AT_encoding [DW_FORM_data1]   (DW_ATE_unsigned)
 

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

 ; CHECK: DW_AT_language [DW_FORM_data2]        (DW_LANG_C99)
 ; CHECK: DW_AT_name [DW_FORM_GNU_str_index]    ( indexed (00000002) string = "baz.c")
 ; CHECK-NOT: DW_AT_low_pc
 ; CHECK-NOT: DW_AT_stmt_list
 ; 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_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] (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:

llvm/trunk/test/DebugInfo/X86/nondefault-subrange-array.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin -O0 -filetype=obj -o %t < %s
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 source_filename = "test/DebugInfo/X86/nondefault-subrange-array.ll"
 
 %class.A = type { [42 x i32] }
 
 @a = global %class.A zeroinitializer, align 4, !dbg !0
 ; Check that we can handle non-default array bounds. In this case, the array
 ; goes from [-3, 38].
 
 ; CHECK: DW_TAG_class_type
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT:                   DW_AT_name [DW_FORM_strp]       ( .debug_str[0x{{[0-9a-f]*}}] = "x")
-; CHECK-NEXT:                   DW_AT_type [DW_FORM_ref4]       (cu + 0x{{[0-9a-f]*}} => {[[ARRAY:0x[0-9a-f]*]]})
+; CHECK-NEXT:                   DW_AT_type [DW_FORM_ref4]       (cu + 0x{{[0-9a-f]*}} => {[[ARRAY:0x[0-9a-f]*]]}
 
 ; CHECK: [[ARRAY]]: DW_TAG_array_type [{{.*}}] *
-; CHECK-NEXT:                 DW_AT_type [DW_FORM_ref4]    (cu + 0x{{[0-9a-f]*}} => {[[BASE:0x[0-9a-f]*]]})
+; CHECK-NEXT:                 DW_AT_type [DW_FORM_ref4]    (cu + 0x{{[0-9a-f]*}} => {[[BASE:0x[0-9a-f]*]]}
 
 ; CHECK: DW_TAG_subrange_type
-; CHECK-NEXT:                   DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[BASE2:0x[0-9a-f]*]]})
+; CHECK-NEXT:                   DW_AT_type [DW_FORM_ref4]  (cu + 0x{{[0-9a-f]*}} => {[[BASE2:0x[0-9a-f]*]]}
 ; CHECK-NEXT:                   DW_AT_lower_bound [DW_FORM_data8]       (0xfffffffffffffffd)
 ; CHECK-NEXT:                   DW_AT_count [DW_FORM_data1]       (0x2a)
 
 ; CHECK: [[BASE]]: DW_TAG_base_type
 ; CHECK: [[BASE2]]: DW_TAG_base_type
 ; CHECK-NEXT:                 DW_AT_name [DW_FORM_strp]       ( .debug_str[0x{{[0-9a-f]*}}] = "sizetype")
 ; CHECK-NEXT:                 DW_AT_byte_size [DW_FORM_data1] (0x08)
 ; CHECK-NEXT:                 DW_AT_encoding [DW_FORM_data1]  (DW_ATE_unsigned)

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

 ; DARWIN-ASM4: .long [[TYPE]] ## DW_AT_type
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: .section
 
 ; CHECK-DWARF: DW_TAG_compile_unit
 ; CHECK-DWARF: 0x[[ADDR:.*]]: DW_TAG_structure_type
 ; CHECK-DWARF: DW_TAG_compile_unit
 ; CHECK-DWARF: DW_TAG_variable
-; CHECK-DWARF: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[ADDR]])
+; CHECK-DWARF: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[ADDR]]
 
 ; CHECK-DWARF2: DW_TAG_compile_unit
 ; CHECK-DWARF2: DW_TAG_variable
-; CHECK-DWARF2: DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ADDR:.*]]})
+; CHECK-DWARF2: DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ADDR:.*]]}
 ; CHECK-DWARF2: [[ADDR]]: DW_TAG_structure_type
 
 source_filename = "test/DebugInfo/X86/ref_addr_relocation.ll"
 
 %struct.foo = type { i8 }
 
 @f = global %struct.foo zeroinitializer, align 1, !dbg !0
 @g = global %struct.foo zeroinitializer, align 1, !dbg !6

llvm/trunk/test/DebugInfo/X86/subrange-type.ll

 ; RUN: llc -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Make sure that the base type from the subrange type has a name.
 ; CHECK: DW_TAG_subrange_type
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]     (cu + 0x{{[0-9a-f]+}} => {[[SUBTYPE:0x[0-9a-f]*]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]     (cu + 0x{{[0-9a-f]+}} => {[[SUBTYPE:0x[0-9a-f]*]]}
 ; CHECK: [[SUBTYPE]]: DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name
 
 define i32 @main() nounwind uwtable !dbg !5 {
 entry:
   %retval = alloca i32, align 4
   %i = alloca [2 x i32], align 4
   store i32 0, i32* %retval

llvm/trunk/test/DebugInfo/dwarfdump-type-units.test

 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-type-units.elf-x86-64 | FileCheck -check-prefix=CHECK -check-prefix=LONG %s
 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-type-units.elf-x86-64 -summarize-types | FileCheck -check-prefix=CHECK -check-prefix=SHORT %s
 RUN: llvm-dwarfdump -v -debug-types %p/Inputs/dwarfdump-type-units.elf-x86-64 | FileCheck -check-prefix=TYPES %s
 
 CHECK: debug_info contents:
 
 CHECK: DW_TAG_variable
 CHECK-NEXT: DW_AT_name {{.*}}"f"
-CHECK: DW_AT_type [DW_FORM_ref_sig8] ([[FOO_SIG:0x[0-9a-f]*]])
+CHECK: DW_AT_type [DW_FORM_ref_sig8] ([[FOO_SIG:0x[0-9a-f]*]]
 
 CHECK: DW_TAG_variable
 CHECK-NEXT: DW_AT_name {{.*}}"b"
-CHECK: DW_AT_type [DW_FORM_ref_sig8] ([[BAR_SIG:0x[0-9a-f]*]])
+CHECK: DW_AT_type [DW_FORM_ref_sig8] ([[BAR_SIG:0x[0-9a-f]*]]
 
 
 CHECK: debug_types contents:
 
 LONG: 0x00000000: Type Unit: {{.*}} name =
 SHORT-NOT: Type Unit
 SHORT: name =
 CHECK-SAME: 'bar' type_signature = [[BAR_SIG]]

llvm/trunk/test/Linker/Inputs/type-unique-simple2-a.ll

 ; Make sure the backend generates a single DIE and uses ref_addr.
 ; CHECK: 0x[[BASE:.*]]: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name {{.*}} = "Base"
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: 0x[[INT:.*]]: DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name {{.*}} = "int"
 ; CHECK-NOT: DW_TAG_base_type
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_formal_parameter
-; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]])
+; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]]
 ; CHECK: DW_TAG_variable
-; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]])
+; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]]
 
 ; Make sure llvm-link only generates a single copy of the struct.
 ; LINK: DW_TAG_structure_type
 ; LINK-NOT: DW_TAG_structure_type
 
 ; Content of header files:
 ; struct Base {
 ;   int a;

llvm/trunk/test/Linker/type-unique-simple-a.ll

 ; CHECK-NEXT: DW_AT_name {{.*}} = "Base"
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: 0x[[INT:.*]]: DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name {{.*}} = "int"
 ; CHECK-NOT: DW_TAG_base_type
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_formal_parameter
-; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]])
+; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]]
 ; CHECK: DW_TAG_variable
-; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]])
+; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]]
 
 ; Make sure llvm-link only generates a single copy of the struct.
 ; LINK: DW_TAG_structure_type
 ; LINK-NOT: DW_TAG_structure_type
 ; Content of header files:
 ; struct Base {
 ;   int a;
 ; };

llvm/trunk/test/Linker/type-unique-type-array-a.ll

 ;
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_class_type
 ; CHECK-NEXT:   DW_AT_name {{.*}} "A"
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_name {{.*}} "testA"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_TAG_formal_parameter
-; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[STRUCT:.*]]})
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[STRUCT:.*]]}
 ; CHECK: 0x[[STRUCT]]: DW_TAG_structure_type
 ; CHECK-NEXT:   DW_AT_name {{.*}} "SA"
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_class_type
 ; CHECK-NEXT:   DW_AT_name {{.*}} "B"
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "testB"

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

 CHECK:    DW_AT_stmt_list (0x00000000)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:    DW_AT_low_pc (0x0000000100000ea0)
 CHECK:    DW_TAG_subprogram
 CHECK:    DW_AT_name ("main")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_decl_line (23)
 CHECK:      DW_AT_prototyped (0x01)
-CHECK:      DW_AT_type (cu + 0x0063)
+CHECK:      DW_AT_type (cu + 0x0063
 CHECK:      DW_AT_external (0x01)
 CHECK:      DW_AT_accessibility (DW_ACCESS_public)
 CHECK:      DW_AT_low_pc (0x0000000100000ea0)
 CHECK:      DW_AT_high_pc (0x0000000100000ec4)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("argc")
 CHECK:        DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:        DW_AT_decl_line (23)
-CHECK:        DW_AT_type (cu + 0x0063)
+CHECK:        DW_AT_type (cu + 0x0063
 CHECK:        DW_AT_location (DW_OP_fbreg -8)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("argv")
 CHECK:        DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:        DW_AT_decl_line (23)
-CHECK:        DW_AT_type (cu + 0x006a)
+CHECK:        DW_AT_type (cu + 0x006a
 CHECK:        DW_AT_location (DW_OP_fbreg -16)
 CHECK:      NULL
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("int")
 CHECK:      DW_AT_encoding (DW_ATE_signed)
 CHECK:      DW_AT_byte_size (0x04)
 CHECK:    DW_TAG_pointer_type
-CHECK:      DW_AT_type (cu + 0x006f)
+CHECK:      DW_AT_type (cu + 0x006f
 CHECK:    DW_TAG_pointer_type
-CHECK:      DW_AT_type (cu + 0x0074)
+CHECK:      DW_AT_type (cu + 0x0074
 CHECK:    DW_TAG_const_type
-CHECK:      DW_AT_type (cu + 0x0079)
+CHECK:      DW_AT_type (cu + 0x0079
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("char")
 CHECK:      DW_AT_encoding (DW_ATE_signed_char)
 CHECK:      DW_AT_byte_size (0x01)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit
 CHECK:   DW_AT_producer ("Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:   DW_AT_name ("basic2.c")
 CHECK:   DW_AT_stmt_list (0x0000003f)
 CHECK:   DW_AT_comp_dir ("/Inputs")
 CHECK:   DW_AT_low_pc (0x0000000100000ed0)
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("int")
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("private_int")
-CHECK:      DW_AT_type (cu + 0x0026)
+CHECK:      DW_AT_type (cu + 0x0026
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
 BASIC:      DW_AT_location (DW_OP_addr 0x100001008)
 ARCHIVE:    DW_AT_location (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("baz")
-CHECK:      DW_AT_type (cu + 0x0026)
+CHECK:      DW_AT_type (cu + 0x0026
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("foo")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
-CHECK:      DW_AT_type (cu + 0x0026)
+CHECK:      DW_AT_type (cu + 0x0026
 CHECK:      DW_AT_low_pc (0x0000000100000ed0)
 CHECK:      DW_AT_high_pc (0x0000000100000f19)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
-CHECK:        DW_AT_type (cu + 0x0026)
+CHECK:        DW_AT_type (cu + 0x0026
 CHECK:        DW_AT_location (DW_OP_fbreg -4)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
-CHECK:      DW_AT_type (cu + 0x0026)
+CHECK:      DW_AT_type (cu + 0x0026
 CHECK:      DW_AT_low_pc (0x0000000100000f20)
 CHECK:      DW_AT_high_pc (0x0000000100000f37)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:    DW_AT_name ("basic3.c")
 CHECK:    DW_AT_stmt_list (0x00000093)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:    DW_AT_low_pc (0x0000000100000f40)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("val")
-CHECK:      DW_AT_type (cu + 0x003c)
+CHECK:      DW_AT_type (cu + 0x003c
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic3.c")
 BASIC:      DW_AT_location (DW_OP_addr 0x100001004)
 ARCHIVE:    DW_AT_location (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_volatile_type
-CHECK:      DW_AT_type (cu + 0x0041)
+CHECK:      DW_AT_type (cu + 0x0041
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("int")
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("bar")
-CHECK:      DW_AT_type (cu + 0x0041)
+CHECK:      DW_AT_type (cu + 0x0041
 CHECK:      DW_AT_low_pc (0x0000000100000f40)
 CHECK:      DW_AT_high_pc (0x0000000100000f84)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("arg")
-CHECK:        DW_AT_type (cu + 0x0041)
+CHECK:        DW_AT_type (cu + 0x0041
 CHECK:        DW_AT_location (DW_OP_fbreg -8)
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
-CHECK:      DW_AT_type (cu + 0x0041)
+CHECK:      DW_AT_type (cu + 0x0041
 CHECK:      DW_AT_low_pc (0x0000000100000f90)
 CHECK:      DW_AT_high_pc (0x0000000100000fa9)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 
 CHECK:    NULL
 
 CHECK-NOT: .debug_loc contents
 

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

 CHECK:    DW_AT_high_pc (0x0000000b)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_low_pc (0x0000000100000f40)
 CHECK:      DW_AT_high_pc (0x0000000b)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name ("main")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_prototyped (true)
-CHECK:      DW_AT_type (0x00000000000000a1)
+CHECK:      DW_AT_type (0x00000000000000a1
 CHECK:      DW_AT_external (true)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_location (DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:        DW_AT_name ("argc")
 CHECK:        DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
-CHECK:        DW_AT_type (0x00000000000000a1)
+CHECK:        DW_AT_type (0x00000000000000a1
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_location (DW_OP_reg4 RSI)
 CHECK:        DW_AT_name ("argv")
-CHECK:        DW_AT_type (cu + 0x0060)
+CHECK:        DW_AT_type (cu + 0x0060
 CHECK:      NULL
 CHECK:    DW_TAG_pointer_type
-CHECK:       DW_AT_type (cu + 0x0065)
+CHECK:       DW_AT_type (cu + 0x0065
 CHECK:    DW_TAG_pointer_type
 CHECK:    DW_TAG_const_type
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("char")
 CHECK:      DW_AT_encoding (DW_ATE_signed_char)
 CHECK:      DW_AT_byte_size (0x01)
 CHECK:    NULL
 

 CHECK:      DW_AT_name ("baz")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("private_int")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
-CHECK:      DW_AT_type (cu + 0x002a)
+CHECK:      DW_AT_type (cu + 0x002a
 CHECK:      DW_AT_inline (DW_INL_inlined)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_low_pc (0x0000000100000f50)
 CHECK:      DW_AT_high_pc (0x00000037)
 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_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:        DW_AT_name ("arg")
-CHECK:        DW_AT_type (cu + 0x002a)
+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 (0x0000000f)
 CHECK:      NULL
 CHECK:    NULL
 
 CHECK:  Compile Unit: {{.*}} version = 0x0004

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

 CHECK:    DW_AT_stmt_list (0x00000000)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:    DW_AT_low_pc (0x0000000100000f40)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("main")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_decl_line (23)
 CHECK:      DW_AT_prototyped (0x01)
-CHECK:      DW_AT_type (cu + 0x0063)
+CHECK:      DW_AT_type (cu + 0x0063
 CHECK:      DW_AT_external (0x01)
 CHECK:      DW_AT_accessibility (DW_ACCESS_public)
 CHECK:      DW_AT_low_pc (0x0000000100000f40)
 CHECK:      DW_AT_high_pc (0x0000000100000f4b)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("argc")
-CHECK:        DW_AT_type (cu + 0x0063)
+CHECK:        DW_AT_type (cu + 0x0063
 CHECK:        DW_AT_location (DW_OP_reg5 RDI, DW_OP_piece 0x4)
 CHECK:      DW_TAG_formal_parameter
 CHECK:        DW_AT_name ("argv")
-CHECK:        DW_AT_type (cu + 0x006a)
+CHECK:        DW_AT_type (cu + 0x006a
 CHECK:        DW_AT_location (DW_OP_reg4 RSI)
 CHECK:      NULL
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("int")
 CHECK:      DW_AT_encoding (DW_ATE_signed)
 CHECK:      DW_AT_byte_size (0x04)
 CHECK:    DW_TAG_pointer_type
-CHECK:      DW_AT_type (cu + 0x006f)
+CHECK:      DW_AT_type (cu + 0x006f
 CHECK:    DW_TAG_pointer_type
-CHECK:      DW_AT_type (cu + 0x0074)
+CHECK:      DW_AT_type (cu + 0x0074
 CHECK:    DW_TAG_const_type
-CHECK:      DW_AT_type (cu + 0x0079)
+CHECK:      DW_AT_type (cu + 0x0079
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("char")
 CHECK:      DW_AT_encoding (DW_ATE_signed_char)
 CHECK:      DW_AT_byte_size (0x01)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:    DW_AT_name ("basic2.c")
 CHECK:    DW_AT_stmt_list (0x0000003e)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:   DW_AT_low_pc (0x0000000100000f50)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("private_int")
-CHECK:      DW_AT_type (0x0000000000000063)
+CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001008)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("baz")
-CHECK:      DW_AT_type (0x0000000000000063)
+CHECK:      DW_AT_type (0x0000000000000063
 CHECK:      DW_AT_location (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("foo")
-CHECK:      DW_AT_type (0x0000000000000063)
+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_type (0x0000000000000063
 CHECK:        DW_AT_location (0x00000000
 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_type (0x0000000000000063
 CHECK:      DW_AT_inline (DW_INL_inlined)
 CHECK:    NULL
 
 CHECK:  Compile Unit:
 
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
 CHECK:    DW_AT_name ("basic3.c")
 CHECK:    DW_AT_stmt_list (0x0000007e)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:    DW_AT_low_pc (0x0000000100000f90)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("val")
-CHECK:      DW_AT_type (cu + 0x003c)
+CHECK:      DW_AT_type (cu + 0x003c
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic3.c")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_volatile_type
-CHECK:      DW_AT_type (0x0000000000000063)
+CHECK:      DW_AT_type (0x0000000000000063
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("bar")
-CHECK:      DW_AT_type (0x0000000000000063)
+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_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:      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:        NULL
 CHECK:      NULL
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
-CHECK:      DW_AT_type (0x0000000000000063)
+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-NOT: :
 CHECK:      0x00000025:
 CHECK-NEXT:              0x0000000000000000 - 0x000000000000000f: DW_OP_reg5 RDI, DW_OP_piece 0x4

llvm/trunk/test/tools/dsymutil/X86/modules.m

 // ---------------------------------------------------------------------
 // CHECK:               DW_TAG_compile_unit
 // CHECK-NOT:             DW_TAG
 // CHECK: 0x0[[FOO:.*]]:  DW_TAG_module
 // CHECK-NEXT:              DW_AT_name{{.*}}"Foo"
 // CHECK-NOT:               DW_TAG
 // CHECK: 0x0[[BARTD:.*]]: DW_TAG_typedef
 // CHECK-NOT:                 DW_TAG
-// CHECK:                     DW_AT_type [DW_FORM_ref_addr] (0x{{0*}}[[BAR]])
+// CHECK:                     DW_AT_type [DW_FORM_ref_addr] (0x{{0*}}[[BAR]]
 // CHECK:                   DW_TAG_structure_type
 // CHECK-NEXT:                DW_AT_name{{.*}}"S"
 // CHECK-NOT:                 DW_TAG
 // CHECK: 0x0[[INTERFACE:.*]]: DW_TAG_structure_type
 // CHECK-NEXT:                DW_AT_name{{.*}}"Foo"
 
 @import Bar;
 typedef struct Bar Bar;

 // CHECK:       DW_AT_type [DW_FORM_ref_addr] (0x{{0*}}[[BARTD]]
 // CHECK:     DW_TAG_variable
 // CHECK-NOT:   DW_TAG
 // CHECK:       DW_AT_name{{.*}}"foo"
 // CHECK-NOT:   DW_TAG
 // CHECK:       DW_AT_type {{.*}}{0x{{0*}}[[PTR:.*]]}
 //
 // CHECK: 0x{{0*}}[[PTR]]: DW_TAG_pointer_type
-// CHECK-NEXT   DW_AT_type [DW_FORM_ref_addr] {0x{{0*}}[[INTERFACE]])
+// CHECK-NEXT   DW_AT_type [DW_FORM_ref_addr] {0x{{0*}}[[INTERFACE]]
 extern int odr_violation;
 
 @import Foo;
 int main(int argc, char **argv) {
   Bar bar;
   Foo *foo = 0;
   bar.value = odr_violation;
   return bar.value;
 }
 #endif
 #endif
 #endif
 
 // CHECK: DW_TAG_compile_unit
 // CHECK:   DW_AT_name {{.*}}"odr_violation.c"
 // CHECK: DW_TAG_variable
 // CHECK:   DW_AT_name {{.*}}"odr_violation"
-// CHECK:   DW_AT_type [DW_FORM_ref4] ({{.*}}{0x{{0*}}[[BAR2:.*]]})
+// CHECK:   DW_AT_type [DW_FORM_ref4] ({{.*}}{0x{{0*}}[[BAR2:.*]]}
 // CHECK: 0x{{0*}}[[BAR2]]: DW_TAG_typedef
-// CHECK:   DW_AT_type [DW_FORM_ref4] ({{.*}}{0x{{0*}}[[BAR3:.*]]})
+// CHECK:   DW_AT_type [DW_FORM_ref4] ({{.*}}{0x{{0*}}[[BAR3:.*]]}
 // CHECK:   DW_AT_name {{.*}}"Bar"
 // CHECK: 0x{{0*}}[[BAR3]]: DW_TAG_structure_type
 // CHECK-NEXT:   DW_AT_name {{.*}}"Bar"

llvm/trunk/test/tools/dsymutil/X86/odr-member-functions.cpp

 // CHECK: 0x[[FOOI_SUB:[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 // CHECK-NEXT: DW_AT_specification{{.*}}[[FOOI]]
 // CHECK-NOT: DW_TAG_structure_type
 
 // CHECK: DW_TAG_variable
 // CHECK-NOT: DW_TAG
 // CHECK: DW_AT_name {{.*}}"s"
 // CHECK-NOT: DW_TAG
-// CHECK: DW_AT_type {{.*}}[[S]])
+// CHECK: DW_AT_type {{.*}}[[S]]
 // CHECK: DW_TAG_inlined_subroutine
 // CHECK-NEXT: DW_AT_abstract_origin{{.*}}[[FOO_SUB]]
 // CHECK-NOT: DW_TAG
 // CHECK: DW_AT_call_line{{.*}}40
 // CHECK: DW_TAG_inlined_subroutine
 // CHECK-NEXT: DW_AT_abstract_origin{{.*}}[[FOOI_SUB]]
 // CHECK-NOT: DW_TAG
 // CHECK: DW_AT_call_line{{.*}}41