[dwarfdump] Print the name for referenced specification of abstract_origin DIEs.

[dblaikie]

Looks fairly reasonable - not sure whether the test cases (if they pass without modifications) need updating. I'm undecided about if/how this feature will improve testing (in the existing cases, as you've kept, they really end up testing that the offsets actually refer to the desired DIE - I think that's valuable, rather than just testing the name (& at that point I'm not sure how much value we gain by testing the name as well)). What are your thoughts?

test/DebugInfo/inline-scopes.ll

27 ↗

(On Diff #13992)

Why so many changes here? I assume this test would've passed unmodified even with your improvements (but I guess that's true of most of these test cases?)

[friss]

In D5466#4, @dblaikie wrote:

Looks fairly reasonable - not sure whether the test cases (if they pass without modifications) need updating. I'm undecided about if/how this feature will improve testing (in the existing cases, as you've kept, they really end up testing that the offsets actually refer to the desired DIE - I think that's valuable, rather than just testing the name (& at that point I'm not sure how much value we gain by testing the name as well)). What are your thoughts?

I think that the feature is very valuable as a llvm-dwarfdump user. In a real dump, being able to identify directly inlined subroutines is really neat. For testing, I'm quite sure some tests can benefit from it. In the one you point out in the review for example, I test that the FileCheck patterns are actually checking the right function without having to match the offsets. There is little room for doubt in the test, but I think it is a nice and easy addition, if only as some sort of self-documentation of the test. Testing both the name and the offset - like it's done in many of the updated tests - doesn't bring any value except for testing the dumping feature in itself.

I think only 1 or 2 tests needed real updates to pass. All the others I modified just add coverage for the introduced feature. I looked for tests that handle abstract_origins and specifications and just choose some of them (being sure to include exotic stuff like cross-cu references).

test/DebugInfo/inline-scopes.ll

27 ↗

(On Diff #13992)

I just added checks that we are FileChecking the right inlined_subroutine tree. yes, this test would have passed without modifications.

[samsonov]

Overall, I think that printing the name of referenced function makes sense and improves usability. I don't have strong opinion about the test cases (we should of course modify some of them to test the new behavior).

lib/DebugInfo/DWARFDebugInfoEntry.cpp

129 ↗

(On Diff #13992)

instead of manually checking for DW_FORM_ref_sig8, can you check it like

formValue.getAsReference(u).hasValue()

?

[friss]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

129 ↗

(On Diff #13992)

I'm not exactly sure what you're suggesting, but the issue is not that there might be no value, but that the value returned for DW_FORM_ref_sig8 attributes is non-sensical in this context (For ref_sig8 attributes, the returned value is a hash of the referenced DIE tree).
I've in fact been through a few iterations about this, because I don't find this check very elegant. In one of these, I created a new FormClass - FC_Signature - and thus I had the sig8 attributes return None for getAsReference(). This made the code above a bit nicer, but I didn't like that something that's explicitly named a reference (*ref*_sig8) would not be in the FC_Reference FormClass.

[samsonov]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

129 ↗

(On Diff #13992)

Yes, supporting DW_FORM_ref_sig8 is tricky, and we have a FIXME in getAsReference(). Can valid subprogram DIE actually have DW_FORM_ref_sig8 in its DW_AT_specification/DW_AT_abstract_origin? I thought that ref_sig8 is now used only for type units.

It makes sense to have DW_FORM_ref_sig8 be FC_Reference to be consistent with what's written in DWARF standard. But we can improve out getAsReference() method - instead of just returning uint64_t it may return a pair: <Unit containing a referenced DIE, Offset of referenced DIE in a corresponding section>.

Anyway, all this is about future improvement. I think the patch is fine to go in as is, once you agree with David about the amount of changes to the test cases.

[dblaikie]

In D5466#5, @friss wrote:

In D5466#4, @dblaikie wrote:

Looks fairly reasonable - not sure whether the test cases (if they pass without modifications) need updating. I'm undecided about if/how this feature will improve testing (in the existing cases, as you've kept, they really end up testing that the offsets actually refer to the desired DIE - I think that's valuable, rather than just testing the name (& at that point I'm not sure how much value we gain by testing the name as well)). What are your thoughts?

I think that the feature is very valuable as a llvm-dwarfdump user.

Agreed, no contest.

In a real dump, being able to identify directly inlined subroutines is really neat. For testing, I'm quite sure some tests can benefit from it. In the one you point out in the review for example, I test that the FileCheck patterns are actually checking the right function without having to match the offsets. There is little room for doubt in the test, but I think it is a nice and easy addition, if only as some sort of self-documentation of the test. Testing both the name and the offset - like it's done in many of the updated tests - doesn't bring any value except for testing the dumping feature in itself.

I'm not entirely sure here - but I don't /disagree/ as such. If that's the case, then could we remove the extra offset checking from those test cases?

I think only 1 or 2 tests needed real updates to pass. All the others I modified just add coverage for the introduced feature.

This kind of incidental coverage is somewhat problematic. If someone comes back tomorrow and says "oh, I can make these tests simpler by dropping the offset checking and just check the names - it still tests what it was intended to test that way" and we lose coverage on this feature. I think it might be best to head that off, simplify the tests as we think they should be written (probably dropping the offset checking entirely - as we do for checking strings, for example) and add explicit test coverage to the feature in a separate file with a clear name, comments, etc.

I looked for tests that handle abstract_origins and specifications and just choose some of them (being sure to include exotic stuff like cross-cu references).

[friss]

In D5466#11, @dblaikie wrote:

In a real dump, being able to identify directly inlined subroutines is really neat. For testing, I'm quite sure some tests can benefit from it. In the one you point out in the review for example, I test that the FileCheck patterns are actually checking the right function without having to match the offsets. There is little room for doubt in the test, but I think it is a nice and easy addition, if only as some sort of self-documentation of the test. Testing both the name and the offset - like it's done in many of the updated tests - doesn't bring any value except for testing the dumping feature in itself.

I'm not entirely sure here - but I don't /disagree/ as such. If that's the case, then could we remove the extra offset checking from those test cases?

I think we could. There is one small pitfall that I can see though: static symbols (or symbols in anonymous namespaces) could end up with the same name even though they represent different symbols. I don't think this would be an issue for any of the tests.

I think only 1 or 2 tests needed real updates to pass. All the others I modified just add coverage for the introduced feature.

This kind of incidental coverage is somewhat problematic. If someone comes back tomorrow and says "oh, I can make these tests simpler by dropping the offset checking and just check the names - it still tests what it was intended to test that way" and we lose coverage on this feature. I think it might be best to head that off, simplify the tests as we think they should be written (probably dropping the offset checking entirely - as we do for checking strings, for example) and add explicit test coverage to the feature in a separate file with a clear name, comments, etc.

I'm a bit confused. If someone simplifies the test by removing the offsets, then we still cover the introduced feature. Or maybe by 'the feature' you mean the actual printing of the offsets? I agree that simplifying the tests is probably better, but are you actually suggesting that we should then add a test that explicitly checks the offsets?

[dblaikie]

In D5466#12, @friss wrote:

In D5466#11, @dblaikie wrote:

In a real dump, being able to identify directly inlined subroutines is really neat. For testing, I'm quite sure some tests can benefit from it. In the one you point out in the review for example, I test that the FileCheck patterns are actually checking the right function without having to match the offsets. There is little room for doubt in the test, but I think it is a nice and easy addition, if only as some sort of self-documentation of the test. Testing both the name and the offset - like it's done in many of the updated tests - doesn't bring any value except for testing the dumping feature in itself.

I'm not entirely sure here - but I don't /disagree/ as such. If that's the case, then could we remove the extra offset checking from those test cases?

I think we could. There is one small pitfall that I can see though: static symbols (or symbols in anonymous namespaces) could end up with the same name even though they represent different symbols. I don't think this would be an issue for any of the tests.

Right - if we have a test for which that's an issue, use the extra offset testing (& probably drop the names) & include a comment explaining why that's interesting. But as you say, I doubt we have any tests for which that's an issue.

I think only 1 or 2 tests needed real updates to pass. All the others I modified just add coverage for the introduced feature.

This kind of incidental coverage is somewhat problematic. If someone comes back tomorrow and says "oh, I can make these tests simpler by dropping the offset checking and just check the names - it still tests what it was intended to test that way" and we lose coverage on this feature. I think it might be best to head that off, simplify the tests as we think they should be written (probably dropping the offset checking entirely - as we do for checking strings, for example) and add explicit test coverage to the feature in a separate file with a clear name, comments, etc.

I'm a bit confused. If someone simplifies the test by removing the offsets, then we still cover the introduced feature. Or maybe by 'the feature' you mean the actual printing of the offsets? I agree that simplifying the tests is probably better, but are you actually suggesting that we should then add a test that explicitly checks the offsets?

Fair point, that the tests will still cover your new functionality - though I'm still a little on the fence about testing dumper functionality in LLVM feature tests rather than in separate dumper tests. It's not a big deal though - I've gone back & forth on it myself (in some cases checking in binaries and adding specific llvm-dwarfdump tests, then adding separate tests for the LLVM functionality I wanted to test, and in some cases cutting corners and just introducing the dumper functionality and testing LLVM immediately without a dumper test)

Long story short: If you want to update test cases, please update them to their "ideal" form, how you think they should be written if the feature had been available - rather than a little of the old and a little of the new, that would just be confusing to future readers ("wait, why is it testing this thing and this other thing? Am I missing some details that make that important/relevant?"). If you want to be extra diligent, add an explicit dumper test for the functionality you're adding.

[friss]

Modify all tests matching the target of DW_AT_abstract_origin or
DW_AT_specification attributes to use the introduced name resolving feature
of llvm-dwarfdump. The offset checking was left in 3 tests that are equally
interested in the layout of the Dwarf and in the correctness of the references.

A followup patch will generalize the feature to also resolve variable refs. The
current implementation only resolves subroutines.

[dblaikie]

Looks good - just some optional bits/questions/ideas.

test/DebugInfo/Inputs/gmlt.ll

46 ↗

(On Diff #14414)

Not sure - might even be worth dropping these abstract subprograms entirely when they're not checking anything interesting (just the name is being checked by the abstract_definition check you modified below). *shrug* dunno.

test/DebugInfo/X86/inline-member-function.ll

24 ↗

(On Diff #14414)

Could write this as {{NULL|TAG}} (& update the other one nearby to do that for consistency). If you like.

test/DebugInfo/X86/inline-seldag-test.ll

14 ↗

(On Diff #14414)

I see you dropped the abs def checking in this case - why this case & not others?

test/DebugInfo/inline-scopes.ll

29 ↗

(On Diff #13992)

{{NULL|DW_TAG}} ?

[friss]

test/DebugInfo/Inputs/gmlt.ll

46 ↗

(On Diff #14414)

Unfortunately, in some test cases they have to stay because they 'consume' a part of the file. If I had removed this one, then the next TAG_subprogram would match the abstract DIE and the test would fail. This is one of the biggest shortcomings of testing the Dwarf contents with FileCheck IMHO.

test/DebugInfo/X86/inline-member-function.ll

24 ↗

(On Diff #14414)

Will do

test/DebugInfo/X86/inline-seldag-test.ll

14 ↗

(On Diff #14414)

Because in this case, noone else tries to match a TAG_subprogram, the test bellow is for an inline_subroutine.

[friss]

Closed by commit rL219099 (authored by @friss).

llvm/trunk/lib/DebugInfo/DWARFDebugInfoEntry.cpp

void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
   if (Name) {
     OS << Name;
   } else if (attr == DW_AT_decl_line || attr == DW_AT_call_line) {
     OS << *formValue.getAsUnsignedConstant();
   } else {
     formValue.dump(OS, u);
   }
 
+  // We have dumped the attribute raw value. For some attributes
+  // having both the raw value and the pretty-printed value is
+  // interesting. These attributes are handled below.
+  if ((attr == DW_AT_specification || attr == DW_AT_abstract_origin) &&
+      // The signature references aren't handled.
+      formValue.getForm() != DW_FORM_ref_sig8) {
+    uint32_t Ref = formValue.getAsReference(u).getValue();
+    DWARFDebugInfoEntryMinimal DIE;
+    if (const DWARFUnit *RefU = findUnitAndExtractFast(DIE, u, &Ref))
+      if (const char *Ref = DIE.getSubroutineName(RefU,
+                                                  FunctionNameKind::LinkageName))
+        OS << " \"" << Ref << '\"';
+  }
+
   OS << ")\n";
 }
 
 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U,
                                              uint32_t *OffsetPtr) {
   Offset = *OffsetPtr;
   DataExtractor DebugInfoData = U->getDebugInfoExtractor();
   uint32_t UEndOffset = U->getNextUnitOffset();

llvm/trunk/test/DebugInfo/Inputs/gmlt.ll

 
 
 ; FIXME: Emitting separate abstract definitions is inefficient when we could
 ; just attach the DW_AT_name to the inlined_subroutine directly. Except that
 ; would produce many string relocations. Implement string indexing in the
 ; skeleton CU to address the relocation problem, then remove abstract
 ; definitions from -gmlt here.
 
-; CHECK: [[F3_ABS_DEF:.*]]:  DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT:     DW_AT_name {{.*}} "f3"
 
 ; FIXME: We don't really need DW_AT_inline, consumers can ignore this due to
 ; the absence of high_pc/low_pc/ranges and know that they just need it for
 ; retrieving the name of a concrete inlined instance
 
 ; CHECK-NOT: {{DW_TAG|DW_AT|NULL}}
 
 ; Check that we only provide the minimal attributes on a subprogram to save space.
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NEXT:     DW_AT_low_pc
 ; CHECK-NEXT:     DW_AT_high_pc
 ; CHECK-NEXT:     DW_AT_name
 ; CHECK-NOT: {{DW_TAG|DW_AT}}
 ; CHECK:     DW_TAG_inlined_subroutine
 
 ; As mentioned above - replace DW_AT_abstract_origin with DW_AT_name to save
 ; space once we have support for string indexing in non-dwo sections
 
-; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} {[[F3_ABS_DEF]]}
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} "f3"
 ; CHECK-NEXT:       DW_AT_low_pc
 ; CHECK-NEXT:       DW_AT_high_pc
 ; CHECK-NEXT:       DW_AT_call_file
 ; CHECK-NEXT:       DW_AT_call_line
 
 ; Make sure we don't have any other subprograms here (subprograms with no
 ; inlined subroutines are omitted by design to save space)
 

llvm/trunk/test/DebugInfo/PR20038.ll

 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "C"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[C_DTOR_DECL:.*]]:  DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "~C"
 
-; CHECK: [[D1_ABS:.*]]: DW_TAG_subprogram
+; CHECK:  DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_ZN1CD1Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[D1_THIS_ABS:.*]]:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "this"
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "fun4"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} {[[D1_ABS]]}
+; CHECK:     DW_AT_abstract_origin {{.*}} "_ZN1CD1Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_abstract_origin {{.*}} {[[D1_THIS_ABS]]}
 
 ; FIXME: D2 is actually inlined into D1 but doesn't show up here, possibly due
 ; to there being no work in D2 (calling another member function from the dtor
 ; causes D2 to show up, calling a free function doesn't).

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

 ; }
 ;
 ; rdar://problem/16362674
 ;
 ; Test that we do not emit a linkage name for the declaration of a destructor.
 ; Test that we do emit a linkage name for a specific instance of it.
 
 ; CHECK: DW_TAG_subprogram
-; CHECK: [[A_DTOR:.*]]:     DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_name {{.*}} "~A"
 ; CHECK-NOT: DW_AT_MIPS_linkage_name
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name {{.*}} "_ZN1AD2Ev"
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_specification {{.*}}[[A_DTOR]]
+; CHECK: DW_AT_specification {{.*}} "~A"
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %struct.A = type { i8 }
 
 ; Function Attrs: nounwind ssp uwtable

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

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
 ; test that the DW_AT_specification is a back edge in the file.
 
-; CHECK: [[BAR_DECL:0x[0-9a-f]*]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT: DW_AT_MIPS_linkage_name {{.*}} "_ZN3foo3barEv"
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_specification {{.*}} {[[BAR_DECL]]}
+; CHECK: DW_AT_specification {{.*}} "_ZN3foo3barEv"
 
 
 @_ZZN3foo3barEvE1x = constant i32 0, align 4
 
 define void @_ZN3foo3barEv()  {
 entry:
   ret void, !dbg !25
 }

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

 ; RUN: llc -mtriple=x86_64-linux < %s -filetype=obj | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 
 ; test that we add DW_AT_inline even when we only have concrete out of line
 ; instances.
 
 ; first check that we have a TAG_subprogram at a given offset and it has
 ; AT_inline.
 
 ; CHECK: DW_TAG_class_type
 ; CHECK:   DW_TAG_subprogram
-; CHECK: [[ASSIGN_DECL:0x........]]:  DW_TAG_subprogram
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_MIPS_linkage_name {{.*}} "_ZN12nsAutoRefCntaSEi"
 
 ; CHECK: DW_TAG_class_type
-; CHECK: [[RELEASE_DECL:0x........]]:  DW_TAG_subprogram
-; CHECK: [[DTOR_DECL:0x........]]:  DW_TAG_subprogram
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_MIPS_linkage_name {{.*}} "_ZN17nsAutoRefCnt7ReleaseEv"
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name {{.*}} "~nsAutoRefCnt"
 
-; CHECK: [[D2_ABS:.*]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT:     DW_AT_{{.*}}linkage_name {{.*}}D2
-; CHECK-NEXT:     DW_AT_specification {{.*}} {[[DTOR_DECL]]}
+; CHECK-NEXT:     DW_AT_specification {{.*}} "~nsAutoRefCnt"
 ; CHECK-NEXT:     DW_AT_inline
 ; CHECK-NOT:      DW_AT
 ; CHECK: DW_TAG
-; CHECK: [[D1_ABS:.*]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT:     DW_AT_{{.*}}linkage_name {{.*}}D1
-; CHECK-NEXT:     DW_AT_specification {{.*}} {[[DTOR_DECL]]}
+; CHECK-NEXT:     DW_AT_specification {{.*}} "~nsAutoRefCnt"
 ; CHECK-NEXT:     DW_AT_inline
 ; CHECK-NOT:     DW_AT
 ; CHECK: [[D1_THIS_ABS:.*]]: DW_TAG_formal_parameter
 
-; CHECK: [[RELEASE:0x........]]: DW_TAG_subprogram
-; CHECK:     DW_AT_specification {{.*}} {[[RELEASE_DECL]]}
+; CHECK: DW_TAG_subprogram
+; CHECK:     DW_AT_specification {{.*}} "_ZN17nsAutoRefCnt7ReleaseEv"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: NULL
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[ASSIGN:0x........]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "_ZN12nsAutoRefCntaSEi"
 ; CHECK-NOT: NULL
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[D1_ABS]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "_ZN17nsAutoRefCntD1Ev"
 ; CHECK-NOT: NULL
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[D2_ABS]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "_ZN17nsAutoRefCntD2Ev"
 
 ; and then that a TAG_subprogram refers to it with AT_abstract_origin.
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_abstract_origin {{.*}} {[[D1_ABS]]}
+; CHECK: DW_AT_abstract_origin {{.*}} "_ZN17nsAutoRefCntD1Ev"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_abstract_origin {{.*}} {[[D1_THIS_ABS]]}
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[D2_ABS]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "_ZN17nsAutoRefCntD2Ev"
 
 
 define i32 @_ZN17nsAutoRefCnt7ReleaseEv() {
 entry:
   store i32 1, i32* null, align 4, !dbg !50
   tail call void @_Z8moz_freePv(i8* null) nounwind, !dbg !54
   ret i32 0
 }

llvm/trunk/test/DebugInfo/X86/dbg-value-inlined-parameter.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin < %s -filetype=obj \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
 ; RUN: llc -mtriple=x86_64-linux-gnu < %s -filetype=obj \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
 ; RUN: llc -mtriple=x86_64-apple-darwin < %s -filetype=obj -regalloc=basic \
 ; RUN:     | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
 
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_abstract_origin {{.*}}{[[ABS:.*]]}
+; CHECK:   DW_AT_abstract_origin {{.*}} "foo"
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_abstract_origin {{.*}}{[[ABS_SP:.*]]}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_abstract_origin {{.*}}{[[ABS_NUMS:.*]]}
 
-; CHECK: [[ABS]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "foo"
 ; CHECK: [[ABS_SP]]:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "sp"
 ; CHECK: [[ABS_NUMS]]:  DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "nums"
 
 ;CHECK: DW_TAG_inlined_subroutine
-;CHECK-NEXT: DW_AT_abstract_origin {{.*}}{[[ABS]]}
+;CHECK-NEXT: DW_AT_abstract_origin {{.*}} "foo"
 ;CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr]
 ;CHECK-NEXT: DW_AT_high_pc [DW_FORM_data4]
 ;CHECK-NEXT: DW_AT_call_file
 ;CHECK-NEXT: DW_AT_call_line
 
 ;CHECK: DW_TAG_formal_parameter
 ;FIXME: Linux shouldn't drop this parameter either...
 ;CHECK-NOT: DW_TAG

llvm/trunk/test/DebugInfo/X86/gnu-public-names.ll

 ; CHECK-NOT: DW_AT_GNU_pubtypes [
 
 ; CHECK: [[C:0x[0-9a-f]+]]: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name {{.*}} "C"
 
 ; CHECK: [[STATIC_MEM_DECL:0x[0-9a-f]+]]: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name {{.*}} "static_member_variable"
 
-; CHECK: [[MEM_FUNC_DECL:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT: DW_AT_MIPS_linkage_name
 ; CHECK-NEXT: DW_AT_name {{.*}} "member_function"
 
-; CHECK: [[STATIC_MEM_FUNC_DECL:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NEXT: DW_AT_MIPS_linkage_name
 ; CHECK-NEXT: DW_AT_name {{.*}} "static_member_function"
 
 ; CHECK: [[INT:0x[0-9a-f]+]]: DW_TAG_base_type
 ; CHECK-NEXT: DW_AT_name {{.*}} "int"
 
 ; CHECK: [[STATIC_MEM_VAR:0x[0-9a-f]+]]: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_specification {{.*}} {[[STATIC_MEM_DECL]]}

 ; CHECK-NOT: DW_TAG
 ; CHECK-NEXT:   DW_AT_specification {{.*}} {[[ANON_INNER_B_DECL]]}
 ; CHECK: [[ANON_I:.*]]: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK-NEXT:   DW_AT_specification {{.*}} {[[ANON_I_DECL]]}
 
 ; CHECK: [[MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_specification {{.*}} {[[MEM_FUNC_DECL]]}
+; CHECK: DW_AT_specification {{.*}} "_ZN1C15member_functionEv"
 
 ; CHECK: [[STATIC_MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_specification {{.*}} {[[STATIC_MEM_FUNC_DECL]]}
+; CHECK: DW_AT_specification {{.*}} "_ZN1C22static_member_functionEv"
 
 ; CHECK: [[GLOBAL_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}} "global_function"
 
 ; CHECK-LABEL: .debug_gnu_pubnames contents:

llvm/trunk/test/DebugInfo/X86/inline-member-function.ll

 ;   return foo().func(i);
 ; }
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK:   DW_TAG_subprogram
 
 ; But make sure we emit DW_AT_object_pointer on the abstract definition.
 ; CHECK: [[ABSTRACT_ORIGIN:.*]]: DW_TAG_subprogram
-; CHECK-NOT: NULL
-; CHECK-NOT: TAG
+; CHECK-NOT: {{NULL|TAG}}
+; CHECK: DW_AT_specification {{.*}} "_ZN3foo4funcEi"
+; CHECK-NOT: {{NULL|TAG}}
 ; CHECK: DW_AT_object_pointer
 
 ; Ensure we omit DW_AT_object_pointer on inlined subroutines.
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}}{[[ABSTRACT_ORIGIN]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[ABSTRACT_ORIGIN]]} "_ZN3foo4funcEi"
 ; CHECK-NOT: NULL
 ; CHECK-NOT: DW_AT_object_pointer
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_AT_artificial
 ; CHECK: DW_TAG
 
 %struct.foo = type { i8 }
 

llvm/trunk/test/DebugInfo/X86/inline-seldag-test.ll

 ; RUN: llc -mtriple=x86_64-linux-gnu -fast-isel=false -filetype=obj < %s -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ; RUN: llc -mtriple=x86_64-linux-gnu -fast-isel=false -filetype=asm < %s -o - | FileCheck --check-prefix=ASM %s
 
 ; Generated from:
 ; clang-tot -c -S -emit-llvm -g inline-seldag-test.c
 ; inline int __attribute__((always_inline)) f(int y) {
 ;   return y ? 4 : 7;
 ; }
 ; void func() {
 ;   volatile int x;
 ;   x = f(x);
 ; }
 
-; CHECK: [[F:.*]]: DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}} "f"
-
 ; CHECK: DW_TAG_inlined_subroutine
-; CHECK-NEXT: DW_AT_abstract_origin {{.*}} {[[F]]}
+; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "f"
 
 
 ; Make sure the condition test is attributed to the inline function, not the
 ; location of the test's operands within the caller.
 
 ; ASM: # inline-seldag-test.c:2:0
 ; ASM-NOT: .loc
 ; ASM: testl

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

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -debug-dump=info %t | FileCheck %s
 
 ; test that the DW_AT_specification is a back edge in the file.
 
 ; Skip the definition of zed(foo*)
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_class_type
-; CHECK: [[BAR_DECL:0x[0-9a-f]*]]:     DW_TAG_subprogram
+; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_MIPS_linkage_name {{.*}} "_ZN3foo3barEv"
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_specification {{.*}} {[[BAR_DECL]]}
+; CHECK:   DW_AT_specification {{.*}} "_ZN3foo3barEv"
 
 %struct.foo = type { i8 }
 
 define void @_Z3zedP3foo(%struct.foo* %x) uwtable {
 entry:
   %x.addr = alloca %struct.foo*, align 8
   store %struct.foo* %x, %struct.foo** %x.addr, align 8
   call void @llvm.dbg.declare(metadata !{%struct.foo** %x.addr}, metadata !23, metadata !{metadata !"0x102"}), !dbg !24

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

 ; void fn4() { x->m_fn2(); }
 ; void fn5() { x->m_fn2(); }
 
 ; The definition of C and declaration of C::m_fn2
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_member
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK: [[M_FN2_DECL:.*]]:   DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "m_fn2"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[M_FN2_THIS_DECL:.*]]:     DW_TAG_formal_parameter
 
 ; The abstract definition of C::m_fn2
 ; CHECK: [[M_FN2_ABS_DEF:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_specification {{.*}} {[[M_FN2_DECL]]}
+; CHECK:   DW_AT_specification {{.*}} "_ZN1C5m_fn2Ev"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_inline
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[M_FN2_THIS_ABS_DEF:.*]]:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "this"
 
 ; Skip some other functions
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 
 ; The concrete definition of C::m_fn2
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_abstract_origin {{.*}} {[[M_FN2_ABS_DEF]]}
+; CHECK:   DW_AT_abstract_origin {{.*}} {[[M_FN2_ABS_DEF]]} "_ZN1C5m_fn2Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_abstract_origin {{.*}} {[[M_FN2_THIS_ABS_DEF]]}
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; Inlined fn3:
 ; CHECK:     DW_TAG_inlined_subroutine
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; Inlined fn6:
 ; CHECK:       DW_TAG_inlined_subroutine
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; Inlined C::m_fn2:
 ; CHECK:         DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
-; CHECK:           DW_AT_abstract_origin {{.*}} {[[M_FN2_ABS_DEF]]}
+; CHECK:           DW_AT_abstract_origin {{.*}} {[[M_FN2_ABS_DEF]]} "_ZN1C5m_fn2Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:           DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:              DW_AT_abstract_origin {{.*}} {[[M_FN2_THIS_ABS_DEF]]}
 
 
 
 %struct.C = type { i32 }

llvm/trunk/test/DebugInfo/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_TAG_inlined_subroutine
-; CHECK:       DW_AT_abstract_origin {{.*}}[[ABS_FUNC:........]])
+; CHECK:       DW_AT_abstract_origin {{.*}}[[ABS_FUNC:........]] "_Z4funci"
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_abstract_origin {{.*}}[[ABS_VAR:........]])
 
 ; 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
 ; CHECK:   DW_AT_name {{.*}} "b.cpp"
 ; CHECK: 0x[[ABS_FUNC]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_AT_low_pc
 ; CHECK: 0x[[ABS_VAR]]: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_AT_location
 ; CHECK: DW_AT_type [DW_FORM_ref4] {{.*}} {0x[[INT]]}
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: 0x[[INT]]: DW_TAG_base_type
 ; CHECK:   DW_AT_name {{.*}} "int"
 
 ; Check the concrete out of line definition references the abstract and
 ; provides the address range and variable location
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_low_pc
-; CHECK:   DW_AT_abstract_origin {{.*}} {0x[[ABS_FUNC]]}
+; CHECK:   DW_AT_abstract_origin {{.*}} {0x[[ABS_FUNC]]} "_Z4funci"
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK:     DW_AT_location
 ; CHECK:     DW_AT_abstract_origin {{.*}} {0x[[ABS_VAR]]}
 
 
 @i = external global i32
 
 ; Function Attrs: uwtable

llvm/trunk/test/DebugInfo/incorrect-variable-debugloc.ll

 ; }
 ; void C::m_fn3() {
 ;   A().m_fn1();
 ;   b.m_fn2();
 ; }
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name {{.*}} "C"
-; CHECK: [[FN3_DECL:.*]]: DW_TAG_subprogram
+; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}} "m_fn3"
 
-; CHECK: DW_AT_specification {{.*}} {[[FN3_DECL]]}
+; CHECK: DW_AT_specification {{.*}} "_ZN1C5m_fn3Ev"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "this"
 
 %struct.C = type { i32, %struct.B }
 %struct.B = type { i32 }
 %struct.A = type { i8 }

llvm/trunk/test/DebugInfo/missing-abstract-variable.ll

 ; void b() {
 ;   x(false);
 ; }
 ;
 ; void a(bool u) {
 ;   x(u);
 ; }
 
-; CHECK: [[ABS_X:.*]]: DW_TAG_subprogram
+; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "x"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[ABS_B:.*]]:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "b"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:       DW_TAG_lexical_block
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[ABS_S:.*]]:       DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:         DW_AT_name {{.*}} "s"
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "b"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} {[[ABS_X]]}
+; CHECK:     DW_AT_abstract_origin {{.*}} "_Z1xb"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_abstract_origin {{.*}} {[[ABS_B]]}
 ; Notice 'x's local variable 's' is missing. Not necessarily a bug here,
 ; since it's been optimized entirely away and it should be described in
 ; abstract subprogram.
 ; CHECK-NOT: DW_TAG
 ; CHECK: NULL
 ; CHECK-NOT: DW_TAG
 ; CHECK: NULL
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_name {{.*}} "a"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} {[[ABS_X]]}
+; CHECK:     DW_AT_abstract_origin {{.*}} "_Z1xb"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; FIXME: This formal parameter goes missing at least at -O2 (& on
 ; mips/powerpc), maybe before that. Perhaps SelectionDAG is to blame (and
 ; fastisel succeeds).
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_abstract_origin {{.*}} {[[ABS_B]]}
 

llvm/trunk/test/DebugInfo/namespace_inline_function_definition.ll

 ; }
 ; extern int x;
 ; int main() { return ns::func(x); }
 ; int __attribute__((always_inline)) ns::func(int i) { return i * 2; }
 
 ; CHECK: DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name {{.*}} "ns"
 ; CHECK-NOT: DW_TAG
-; CHECK: [[ABS_DEF:0x.*]]: DW_TAG_subprogram
+; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_ZN2ns4funcEi"
 ; CHECK-NOT: DW_TAG
 ; CHECK: [[ABS_PRM:0x.*]]:   DW_TAG_formal_parameter
 ; CHECK:   NULL
 ; CHECK-NOT: NULL
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} {[[ABS_DEF]]}
+; CHECK:     DW_AT_abstract_origin {{.*}} "_ZN2ns4funcEi"
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK:       DW_AT_abstract_origin {{.*}} {[[ABS_PRM]]}
 ; CHECK:     NULL
 ; CHECK:   NULL
 ; CHECK: NULL
 
 @x = external global i32

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

 ; CHECK:      DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_Z3bazv"
 ; CHECK:      DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_ZL3barv"
 
 ; getFoo and A may only appear once.
-; CHECK-NOT:  {{(getFoo)|("A")}}
+; CHECK-NOT:  AT_name{{.*(getFoo)|("A")}}
 
 
 ; ModuleID = 'type-unique-odr-a.cpp'
 
 %class.A = type { i32 }
 
 ; Function Attrs: nounwind
 define void @_Z3bazv() #0 {