[clang][CGDebugInfo] emit DW_LANG_C_plus_plus_{20|17} DW_LANG_C17

[nickdesaulniers]

Summary

Looks like these DW_AT_language tags made it into the DWARFv5 spec.
Let's emit them when -std=c++{20|17} or -std=c17.

Link: https://dwarfstd.org/Languages.php

[dblaikie]

This was discussed in D138597 & we decided not to implement these due to the risk of breaking existing v5 clients that might not know about the post-v5-release codes. Implementing the v6 codes as an extension might be an option, or emitting the post-v5-release codes as an extension/under non-strict mode?

But is there any particular value you're looking for by implementing these?

[nickdesaulniers]

In D142675#4084279, @dblaikie wrote:

This was discussed in D138597 & we decided not to implement these due to the risk of breaking existing v5 clients that might not know about the post-v5-release codes. Implementing the v6 codes as an extension might be an option, or emitting the post-v5-release codes as an extension/under non-strict mode?

But is there any particular value you're looking for by implementing these?

Ah, sorry I was lacking that context. No value in particular, just looked like a bug when reading through this code.

[nickdesaulniers]

Also noting that GCC 12.2.0 does not produce these newer DW_AT_language values when using -std={c17|c++17|c++20}`.

clang/lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::CreateCompileUnit() {
 
   llvm::dwarf::SourceLanguage LangTag;
   const LangOptions &LO = CGM.getLangOpts();
   if (LO.CPlusPlus) {
     if (LO.ObjC)
       LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
     else if (CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)
       LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
+    else if (LO.CPlusPlus20)
+      LangTag = llvm::dwarf::DW_LANG_C_plus_plus_20;
+    else if (LO.CPlusPlus17)
+      LangTag = llvm::dwarf::DW_LANG_C_plus_plus_17;
     else if (LO.CPlusPlus14)
       LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
     else if (LO.CPlusPlus11)
       LangTag = llvm::dwarf::DW_LANG_C_plus_plus_11;
+    // CPlusPlus03 is emitted as llvm::dwarf::DW_LANG_C_plus_plus, not
+    // llvm::dwarf::DW_LANG_C_plus_plus_03.
     else
       LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
   } else if (LO.ObjC) {
     LangTag = llvm::dwarf::DW_LANG_ObjC;
   } else if (LO.OpenCL && (!CGM.getCodeGenOpts().DebugStrictDwarf ||
                            CGM.getCodeGenOpts().DwarfVersion >= 5)) {
     LangTag = llvm::dwarf::DW_LANG_OpenCL;
   } else if (LO.RenderScript) {
     LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
+  } else if (LO.C17 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {
+    LangTag = llvm::dwarf::DW_LANG_C17;
   } else if (LO.C11 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {
       LangTag = llvm::dwarf::DW_LANG_C11;
   } else if (LO.C99) {
     LangTag = llvm::dwarf::DW_LANG_C99;
   } else {
     LangTag = llvm::dwarf::DW_LANG_C89;
   }
 

clang/test/CodeGen/debug-info-programming-language.c

 // RUN: %clang_cc1 -dwarf-version=3 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -x c -std=c11 -O0 -disable-llvm-passes -debug-info-kind=limited \
 // RUN:   | FileCheck --check-prefix=CHECK-C11 %s
 // RUN: %clang_cc1 -dwarf-version=3 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -x c -std=c17 -O0 -disable-llvm-passes -debug-info-kind=limited \
 // RUN:   | FileCheck --check-prefix=CHECK-C17 %s
 // RUN: %clang_cc1 -dwarf-version=3 -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -x c -std=c2x -O0 -disable-llvm-passes -debug-info-kind=limited \
+// RUN:   | FileCheck --check-prefix=CHECK-C2X %s
+// RUN: %clang_cc1 -dwarf-version=3 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -x c -std=c11 -O0 -disable-llvm-passes -debug-info-kind=limited \
 // RUN:   -gstrict-dwarf | FileCheck --check-prefix=CHECK-STRICT %s
 // RUN: %clang_cc1 -dwarf-version=5 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -x c -std=c11 -O0 -disable-llvm-passes -debug-info-kind=limited \
 // RUN:   -gstrict-dwarf | FileCheck --check-prefix=CHECK-C11 %s
 
 // CHECK-STRICT: !DICompileUnit(language: DW_LANG_C99
 // CHECK-C11: !DICompileUnit(language: DW_LANG_C11
-// Update this check once support for DW_LANG_C17 is broadly supported/known in
-// consumers. Maybe we'll skip this and go to the DWARFv6 language+version
-// encoding that avoids the risk of regression when describing a language
-// version newer than what the consumer is aware of.
-// CHECK-C17: !DICompileUnit(language: DW_LANG_C11
+// CHECK-C17: !DICompileUnit(language: DW_LANG_C17
+
+// Update this check once support for whichever DW_LANG_ tag gets added to
+// https://dwarfstd.org/Languages.php for c2x in DWARFv6.
+// CHECK-C2X: !DICompileUnit(language: DW_LANG_C17
 
 void f1(void) { }

clang/test/CodeGenCXX/debug-info-artificial-arg.cpp

private:
   B<A> m_client_A;
 };
 
 int main(int argc, char **argv) {
   A reallyA (500);
 }
 
 // CHECK: ![[CLASSTYPE:.*]] = distinct !DICompositeType(tag: DW_TAG_class_type, name: "A",
-// CHECK-SAME:                                 identifier: "_ZTS1A"
 // CHECK: ![[ARTARG:.*]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: ![[CLASSTYPE]],{{.*}} DIFlagArtificial
 // CHECK: !DISubprogram(name: "A", scope: ![[CLASSTYPE]]
 // CHECK-SAME:          line: 12
 // CHECK-SAME:          DIFlagPublic
 // CHECK: !DISubroutineType(types: [[FUNCTYPE:![0-9]*]])
 // CHECK: [[FUNCTYPE]] = !{null, ![[ARTARG]], !{{.*}}, !{{.*}}}

clang/test/CodeGenCXX/debug-info-auto-return.cpp

 //  Test for debug info for C++11 auto return member functions
 // RUN: %clang_cc1 -dwarf-version=5  -emit-llvm -triple x86_64-linux-gnu %s -o - \
 // RUN:   -O0 -disable-llvm-passes \
 // RUN:   -debug-info-kind=standalone \
 // RUN: | FileCheck --implicit-check-not="\"auto\"" --implicit-check-not=DISubprogram %s
 
 // CHECK: !DISubprogram(name: "findMax",{{.*}}, type: [[FUN_TYPE:![0-9]+]], {{.*}}spFlags: DISPFlagDefinition, {{.*}} declaration: [[DECL:![0-9]+]]
 
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "myClass",
-// CHECK-SAME: elements: [[MEMBERS:![0-9]+]],
+// CHECK-SAME: elements: [[MEMBERS:![0-9]+]])
 
 // CHECK: [[MEMBERS]] = !{}
 
 // CHECK: [[FUN_TYPE]] = !DISubroutineType(types: [[TYPE_NODE:![0-9]+]])
 // CHECK-NEXT: [[TYPE_NODE]] = !{[[DOUBLE_TYPE:![0-9]+]],
 // CHECK-NEXT: [[DOUBLE_TYPE]] = !DIBasicType(name: "double",
 // CHECK: [[DECL]] = !DISubprogram(name: "findMax",{{.*}}, type: [[FUN_TYPE]],
 
 struct myClass {
   auto findMax();
 };
 
 auto myClass::findMax() {
   return 0.0;
 }

clang/test/CodeGenCXX/debug-info-enum.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -gcodeview -debug-info-kind=limited %s -o - | FileCheck --check-prefix MSVC %s
 
 // CHECK: !DICompileUnit(
 // CHECK-SAME:           enums: [[ENUMS:![0-9]*]]
 // CHECK: [[ENUMS]] = !{[[E1:![0-9]*]], [[E2:![0-9]*]], [[E3:![0-9]*]]}
 
 // In MSVC check that used enum values are emitted as globals.
 // MSVC: !DICompileUnit(
 // MSVC-SAME:           globals: [[GLOBALS:![0-9]*]]
 // MSVC: [[GLOBALS]] = !{[[G1:![0-9]*]], [[G2:![0-9]*]]}
 
 namespace test1 {
 // CHECK: [[E1]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"
 // CHECK-SAME:                      scope: [[TEST1:![0-9]*]]
 // CHECK-SAME:                      elements: [[TEST1_ENUMS:![0-9]*]]
-// CHECK-SAME:                      identifier: "_ZTSN5test11eE"
 // CHECK: [[TEST1]] = !DINamespace(name: "test1"
 // CHECK: [[TEST1_ENUMS]] = !{[[TEST1_E:![0-9]*]]}
 // CHECK: [[TEST1_E]] = !DIEnumerator(name: "E", value: 0, isUnsigned: true)
 
 // MSVC: [[G1]] = !DIGlobalVariableExpression(var: [[VAR1:![0-9]*]],
 // MSVC-SAME:                                 expr: !DIExpression(DW_OP_constu, 0
 // MSVC: [[VAR1]] = distinct !DIGlobalVariable(name: "E"
 enum e { E };
 void foo() {
   int v = E;
 }
 }
 
 namespace test2 {
 // rdar://8195980
 // CHECK: [[E2]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"
 // CHECK-SAME:                      scope: [[TEST2:![0-9]+]]
 // CHECK-SAME:                      elements: [[TEST1_ENUMS]]
-// CHECK-SAME:                      identifier: "_ZTSN5test21eE"
 // CHECK: [[TEST2]] = !DINamespace(name: "test2"
 
 // MSVC: [[G2]] = !DIGlobalVariableExpression(var: [[VAR2:![0-9]*]],
 // MSVC-SAME:                                 expr: !DIExpression(DW_OP_constu, 0
 // MSVC: [[VAR2]] = distinct !DIGlobalVariable(name: "E"
 enum e { E };
 bool func(int i) {
   return i == E;
 }
 }
 
 namespace test3 {
 // CHECK: [[E3]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"
 // CHECK-SAME:                      scope: [[TEST3:![0-9]*]]
 // CHECK-SAME:                      elements: [[TEST3_ENUMS:![0-9]*]]
-// CHECK-SAME:                      identifier: "_ZTSN5test31eE"
 // CHECK: [[TEST3]] = !DINamespace(name: "test3"
 // CHECK: [[TEST3_ENUMS]] = !{[[TEST3_E:![0-9]*]]}
 // CHECK: [[TEST3_E]] = !DIEnumerator(name: "E", value: -1)
 enum e { E = -1 };
 void func() {
   e x;
 }
 }

clang/test/CodeGenCXX/debug-info-indirect-field-decl.cpp

 // RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s
 //
 // Test that indirect field decls are handled gracefully.
 // rdar://problem/16348575
 //
 template <class T, int T::*ptr> class Foo {  };
 
 struct Bar {
   int i1;
   // CHECK: ![[INT:[0-9]+]] = !DIBasicType(name: "int"
   // CHECK: !DIDerivedType(tag: DW_TAG_member, scope:
   // CHECK-SAME:           line: [[@LINE+4]]
   // CHECK-SAME:           baseType: ![[UNION:[0-9]+]]
   // CHECK-SAME:           size: 32, offset: 32
-  // CHECK: ![[UNION]] = distinct !DICompositeType(tag: DW_TAG_union_type,{{.*}} identifier: "_ZTSN3BarUt_E")
+  // CHECK: ![[UNION]] = distinct !DICompositeType(tag: DW_TAG_union_type,
   union {
     // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "i2",
     // CHECK-SAME:           line: [[@LINE+5]]
     // CHECK-SAME:           baseType: ![[INT]]
     // CHECK-SAME:           size: 32
     // CHECK-NOT:            offset:
     // CHECK-SAME:           ){{$}}
     int i2;
   };
 };
 
 Foo<Bar, &Bar::i2> the_foo;

clang/test/CodeGenCXX/debug-info-ms-abi.cpp

 // RUN: %clang_cc1 %s -triple=i686-pc-windows-msvc -debug-info-kind=limited -gcodeview -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 %s -triple=i686-pc-windows-msvc -debug-info-kind=limited -gcodeview -gcodeview-ghash -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,GHASH
 
 // Tests that certain miscellaneous features work in the MS ABI.
 
 struct Foo {
   virtual void f();
   virtual void g();
   virtual void h();
   static void i(int, int);
   struct Nested {};
 };
 Foo f;
 Foo::Nested n;
 
 // CHECK: ![[Nested:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Nested",
-// CHECK-SAME: identifier: ".?AUNested@Foo@@"
 
 // CHECK: ![[Foo:[^ ]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo",
 // CHECK-SAME: elements: ![[elements:[0-9]+]]
-// CHECK-SAME: identifier: ".?AUFoo@@"
 
 // CHECK: ![[elements]] = !{![[vshape:[0-9]+]], ![[vptr:[0-9]+]], ![[Nested]], ![[f:[0-9]+]], ![[g:[0-9]+]], ![[h:[0-9]+]], ![[i:[0-9]+]]}
 
 // CHECK: ![[vshape]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "__vtbl_ptr_type", baseType: null, size: 96)
 
 // CHECK: ![[vptr]] = !DIDerivedType(tag: DW_TAG_member, name: "_vptr$Foo",
 // CHECK-SAME: baseType: ![[vptr_ty:[0-9]+]],
 

clang/test/CodeGenCXX/debug-info-programming-language.cpp

 // RUN: %clang_cc1 -dwarf-version=5 -gstrict-dwarf -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -x c++ -std=c++14 -O0 -disable-llvm-passes -debug-info-kind=limited \
 // RUN:   | FileCheck --check-prefix=CHECK-CPP14 %s
 
 int main() {
   return 0;
 }
 
-// Update these tests once support for DW_LANG_C_plus_plus_17/20 is added - it's
-// a complicated tradeoff. The language codes are already published/blessed by
-// the DWARF committee, but haven't been released in a published standard yet,
-// so consumers might not be ready for these codes & could regress functionality
-// (because they wouldn't be able to identify that the language was C++). The
-// DWARFv6 language encoding, separating language from language version, would
-// remove this problem/not require new codes for new language versions and make
-// it possible to identify the base language irrespective of the version.
+// The DWARFv6 language encoding, separating language from language version,
+// would remove this problem/not require new codes for new language versions
+// and make it possible to identify the base language irrespective of the
+// version.
 // CHECK-CPP14: distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14,
-// CHECK-CPP17: distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14,
-// CHECK-CPP20: distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14,
+// CHECK-CPP17: distinct !DICompileUnit(language: DW_LANG_C_plus_plus_17,
+// CHECK-CPP20: distinct !DICompileUnit(language: DW_LANG_C_plus_plus_20,
 // CHECK: distinct !DICompileUnit(language: DW_LANG_C_plus_plus,

clang/test/CodeGenCXX/debug-info-template-limit.cpp

 // RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple %itanium_abi_triple %s -o - | FileCheck %s
 
 // Check that this pointer type is TC<int>
-// CHECK: ![[LINE:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_class_type, name: "TC<int>"{{.*}}, identifier: "_ZTS2TCIiE")
+// CHECK: ![[LINE:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_class_type, name: "TC<int>"
 // CHECK: !DIDerivedType(tag: DW_TAG_pointer_type, baseType: ![[LINE]]
 
 template<typename T>
 class TC {
 public:
   TC(const TC &) {}
   TC() {}
 };
 
 TC<int> tci;

clang/test/CodeGenCXX/debug-info-template-member.cpp

 // CHECK-SAME: name: "var"
 // CHECK-SAME: templateParams: {{![0-9]+}}
 // CHECK: !DITemplateTypeParameter(name: "T", type: {{![0-9]+}})
 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
 // CHECK-SAME: name: "varray"
 // CHECK-SAME: templateParams: {{![0-9]+}}
 // CHECK: !DITemplateValueParameter(name: "N", type: [[TY]], value: i32 1)
 
-// CHECK: ![[OUTER_FOO_INNER_ID:[0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "inner"{{.*}}, identifier:
+// CHECK: ![[OUTER_FOO_INNER_ID:[0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "inner"{{.*}},
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
 // CHECK-SAME:             elements: [[FOO_MEM:![0-9]*]]
-// CHECK-SAME:             identifier: "_ZTS3foo"
 // CHECK: [[FOO_MEM]] = !{[[FOO_FUNC:![0-9]*]]}
 // CHECK: [[FOO_FUNC]] = !DISubprogram(name: "func", linkageName: "_ZN3foo4funcEN5outerIS_E5innerE",
 // CHECK-SAME:                         type: [[FOO_FUNC_TYPE:![0-9]*]]
 // CHECK: [[FOO_FUNC_TYPE]] = !DISubroutineType(types: [[FOO_FUNC_PARAMS:![0-9]*]])
 // CHECK: [[FOO_FUNC_PARAMS]] = !{null, !{{[0-9]*}}, ![[OUTER_FOO_INNER_ID]]}
 
 // CHECK: [[C:![0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "MyClass"
 // CHECK-SAME:                             elements: [[C_MEM:![0-9]*]]
 // CHECK-SAME:                             vtableHolder: [[C]]
-// CHECK-SAME:                             identifier: "_ZTS7MyClass")
 // CHECK: [[C_MEM]] = !{[[C_VPTR:![0-9]*]], [[C_FUNC:![0-9]*]]}
 // CHECK: [[C_VPTR]] = !DIDerivedType(tag: DW_TAG_member, name: "_vptr$MyClass"
 
 // CHECK: [[C_FUNC]] = !DISubprogram(name: "func",{{.*}} line: 9,
 
 // CHECK: !DISubprogram(name: "add<2>"
 // CHECK-SAME:          scope: [[C]]
 //
 // CHECK: [[VIRT_TEMP:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "virt<elem>"
 // CHECK-SAME:             elements: [[VIRT_MEM:![0-9]*]]
 // CHECK-SAME:             vtableHolder: [[VIRT_TEMP]]
 // CHECK-SAME:             templateParams: [[VIRT_TEMP_PARAM:![0-9]*]]
-// CHECK-SAME:             identifier: "_ZTS4virtI4elemE"
 
 // CHECK: [[ELEM:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "elem"
 // CHECK-SAME:                                elements: [[ELEM_MEM:![0-9]*]]
-// CHECK-SAME:                                identifier: "_ZTS4elem"
 // CHECK: [[ELEM_MEM]] = !{[[ELEM_X:![0-9]*]]}
 // CHECK: [[ELEM_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: [[ELEM]]
 // CHECK-SAME:                        baseType: [[VIRT_TEMP:![0-9]+]]
 
 // CHECK: [[VIRT_TEMP_PARAM]] = !{[[VIRT_T:![0-9]*]]}
 // CHECK: [[VIRT_T]] = !DITemplateTypeParameter(name: "T", type: [[ELEM]])
 
 template<typename T>

clang/test/CodeGenCXX/debug-info-template-partial-specialization.cpp

 // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone %std_cxx98-14 | FileCheck %s --check-prefixes=CHECK,PRE17
 // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -debug-info-kind=standalone %std_cxx17- | FileCheck %s --check-prefixes=CHECK,CXX17
 namespace __pointer_type_imp
 {
   template <class _Tp, class _Dp, bool > struct __pointer_type1 {};
 
   // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "__pointer_type1<C, default_delete<C>, false>",
   // CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]]
-  // CHECK-SAME:             identifier: "_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"
   template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false>
   {
     typedef _Tp* type;
   };
 }
 template <class _Tp, class _Dp>
 struct __pointer_type2
 {

clang/test/CodeGenCXX/debug-info-template.cpp

 // CHECK: [[INT]] = !DIBasicType(name: "int"
   &glb,
 // CHECK: [[TCARG4]] = !DITemplateValueParameter(name: "a", type: [[MEMINTPTR:![0-9]*]], value: i64 8)
 // CHECK: [[MEMINTPTR]] = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, {{.*}}baseType: [[INT]], {{.*}}extraData: ![[FOO:[0-9]+]])
 //
 // We could just emit a declaration of 'foo' here, rather than the entire
 // definition (same goes for any time we emit a member (function or data)
 // pointer type)
-// CHECK: [[FOO]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "foo", {{.*}}identifier: "_ZTS3foo")
+// CHECK: [[FOO]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "foo", {{.*}})
 // CHECK: !DISubprogram(name: "f", linkageName: "_ZN3foo1fEv", {{.*}}type: [[FTYPE:![0-9]*]]
 //
 // Currently Clang emits the pointer-to-member-function value, but LLVM doesn't
 // use it (GCC doesn't emit a value for pointers to member functions either - so
 // it's not clear what, if any, format would be acceptable to GDB)
 //
 // CHECK: [[FTYPE:![0-9]*]] = !DISubroutineType(types: [[FARGS:![0-9]*]])
 // CHECK: [[FARGS]] = !{null, [[FARG1:![0-9]*]]}

 };
 
 // CHECK: [[NN]] = !DIGlobalVariableExpression(var: [[NNV:.*]], expr: !DIExpression())
 // CHECK: [[NNV]] = distinct !DIGlobalVariable(name: "nn"
 // CHECK-SAME:                                 type: ![[NNT:[0-9]+]]
 
 // CHECK: ![[NNT]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "NN<tmpl_impl, glb>",
 // CHECK-SAME:             templateParams: [[NNARGS:![0-9]*]]
-// CHECK-SAME:             identifier:
 // CHECK: [[NNARGS]] = !{[[NNARG1:![0-9]*]], [[NNARG2:![0-9]*]]}
 // CHECK: [[NNARG1]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_template_param, name: "tmpl", value: !"tmpl_impl")
 // CHECK: [[NNARG2]] = !DITemplateValueParameter(name: "lvr", type: [[INTLVR:![0-9]*]], value: ptr @glb)
 // CHECK: [[INTLVR]] = !DIDerivedType(tag: DW_TAG_reference_type, baseType: [[INT]]
 NN<tmpl_impl, glb> nn;
 
 // CHECK: ![[PADDINGATEND:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "PaddingAtEnd",
 struct PaddingAtEnd {

 struct ClassTemplateArg {
   int a;
   float f;
 };
 template<ClassTemplateArg A> struct ClassTemplateArgTemplate {
   static constexpr const ClassTemplateArg &Arg = A;
 };
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgTemplate<ClassTemplateArg{1, 2.000000e+00}>", {{.*}}, templateParams: ![[CLASS_TEMP_ARGS:[0-9]*]],
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgTemplate<ClassTemplateArg{1, 2.000000e+00}>", {{.*}}, templateParams: ![[CLASS_TEMP_ARGS:[0-9]*]])
 // CHECK: ![[CLASS_TEMP_ARG_CONST_REF_TYPE:[0-9]*]] = !DIDerivedType(tag: DW_TAG_reference_type, baseType: ![[CLASS_TEMP_ARG_CONST_TYPE:[0-9]*]],
 // CHECK: ![[CLASS_TEMP_ARG_CONST_TYPE]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[CLASS_TEMP_ARG_TYPE:[0-9]*]])
 // CHECK: ![[CLASS_TEMP_ARG_TYPE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArg",
 // CHECK: ![[CLASS_TEMP_ARGS]] = !{![[CLASS_TEMP_ARG:[0-9]*]]}
 // CHECK: ![[CLASS_TEMP_ARG]] = !DITemplateValueParameter(name: "A", type: ![[CLASS_TEMP_ARG_TYPE]], value: %{{[^ *]+}} { i32 1, float 2.000000e+00 })
 ClassTemplateArgTemplate<ClassTemplateArg{1, 2.0f}> ClassTemplateArgObj;
 
 template<const ClassTemplateArg&> struct ClassTemplateArgRefTemplate {};
 ClassTemplateArgRefTemplate<ClassTemplateArgObj.Arg> ClassTemplateArgRefObj;
 
-// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgRefTemplate<<template param ClassTemplateArg{1, 2.000000e+00}> >", {{.*}}, templateParams: ![[CLASS_TEMP_REF_ARGS:[0-9]*]],
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgRefTemplate<<template param ClassTemplateArg{1, 2.000000e+00}> >", {{.*}}, templateParams: ![[CLASS_TEMP_REF_ARGS:[0-9]*]])
 // CHECK: ![[CLASS_TEMP_REF_ARGS]] = !{![[CLASS_TEMP_REF_ARG:[0-9]*]]}
 // CHECK: ![[CLASS_TEMP_REF_ARG]] = !DITemplateValueParameter(type: ![[CLASS_TEMP_ARG_CONST_REF_TYPE]], value: ptr @_ZTAXtl16ClassTemplateArgLi1ELf40000000EEE)
 
 inline namespace inl {
   struct t1 { };
 }
 template<typename T> struct ClassTemplateInlineNamespaceArg {
 };

clang/test/CodeGenCXX/debug-info-union-template.cpp

 // RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-linux-gnu  %s -o - | FileCheck %s
 
 // Make sure that the union type has template parameters.
 
 namespace PR15637 {
   template <typename T> union Value { int a; };
   void g(float value) {
     Value<float> tempValue;
   }
   Value<float> f;
 }
 
 // CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "Value<float>",
-// CHECK-SAME:             templateParams: [[TTPARAM:![0-9]+]]
-// CHECK-SAME:             identifier: "_ZTSN7PR156375ValueIfEE"
+// CHECK-SAME: templateParams: [[TTPARAM:![0-9]+]]
 // CHECK: [[TTPARAM]] = !{[[PARAMS:.*]]}
 // CHECK: [[PARAMS]] = !DITemplateTypeParameter(name: "T"

clang/test/CodeGenCXX/debug-info.cpp

 // CHECK-SAME:                                      type: {{![0-9]+}}
 // CHECK-SAME:                                      DISPFlagDefinition
 
 // CHECK: [[PR14763:![0-9]+]] = !DINamespace(name: "pr14763"
 namespace pr14763 {
 struct foo {
 // CHECK: ![[FOO:[0-9]+]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "foo"
 // CHECK-SAME:             scope: [[PR14763]]
-// CHECK-SAME:             identifier:
   foo(const foo&);
 };
 
 // For some reason function arguments ended up down here
 // CHECK: ![[F]] = !DILocalVariable(name: "f", arg: 1, scope: ![[FUNC]]
 // CHECK-SAME:                      type: ![[FOO]]
 foo func(foo f) {
   return f; // reference 'f' for now because otherwise we hit another bug

 namespace pr9608 { // also pr9600
 struct incomplete;
 incomplete (*x)[3];
 }
 
 namespace pr16214 {
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "a"
 // CHECK-SAME:             elements: [[A_MEM:![0-9]+]]
-// CHECK-SAME:             identifier: "_ZTSN7pr162141aE"
 // CHECK: [[A_MEM]] = !{[[A_I:![0-9]*]]}
 struct a {
 // CHECK: [[A_I]] = !DIDerivedType(tag: DW_TAG_member, name: "i"
   int i;
 };
 
 typedef a at;