[clang][DebugInfo] Support DW_AT_LLVM_preferred_name attribute

[Michael137]

Summary

With this patch, we now emit a DW_AT_LLVM_preferred_name for
the [[clang::preferred_name]] attribute attached to a class template.

This is useful for consumers in case they want to display the
name in terms of the preferred name, e.g., LLDB's type-summaries.

For now this is behind an LLDB tuning.

E.g., for following code:

template<typename T> struct Foo;

typedef Foo<int> BarInt;
typedef Foo<double> BarDouble;

template<typename T>
struct [[clang::preferred_name(BarInt),
         clang::preferred_name(BarDouble)]] Foo {};

...the generated DWARF with this patch looks as follows:

0x0000006b:   DW_TAG_structure_type
                DW_AT_LLVM_preferred_name       (0x00000082)
                DW_AT_name      ("Foo<int>")

0x00000082:   DW_TAG_typedef
               DW_AT_type      (0x0000006b "Foo<int>")
               DW_AT_name      ("BarInt")

0x0000008d:   DW_TAG_structure_type
                DW_AT_LLVM_preferred_name       (0x000000ab)
                DW_AT_name      ("Foo<double>")

0x000000ab:   DW_TAG_typedef
                DW_AT_type      (0x0000008d "Foo<double>")
                DW_AT_name      ("BarDouble")

[Michael137]

• Remove redundant TODO

[Michael137]

• clang-format

[Michael137]

Since the new attribute only gets attached to a structure definition, and the preferred_name attribute is currently only really used in a handful of places in libcxx, this practically doesn't affect debug-info size

[aprantl]

I originally was hoping we wouldn't have to introduce a new attribute for this, but it looks like there are legitimate concerns about the alternatives, so in that sense this looks good!

[Michael137]

• Add test case for multiple alias templates

[Michael137]

• Update test

[dblaikie]

In D145077#4162110, @aprantl wrote:

I originally was hoping we wouldn't have to introduce a new attribute for this, but it looks like there are legitimate concerns about the alternatives, so in that sense this looks good!

Out of curiosity, what were the other existing attributes that were considered? (would be curious to have them written down here to explain/add strength to the motivation to add a new extension attribute)

[dblaikie]

In D145077#4168209, @dblaikie wrote:

In D145077#4162110, @aprantl wrote:

I originally was hoping we wouldn't have to introduce a new attribute for this, but it looks like there are legitimate concerns about the alternatives, so in that sense this looks good!

Out of curiosity, what were the other existing attributes that were considered? (would be curious to have them written down here to explain/add strength to the motivation to add a new extension attribute)

Oh, I guess this discussion might go better in the llvm side that actually introduces the attribute D145076

[Michael137]

Making use of this in LLDB (see https://reviews.llvm.org/D145078) was a bit too finicky for my taste, so I prepared an alternative which doesn't require adding a new attribute (see https://reviews.llvm.org/D145803) and no LLDB changes. I *think* this is what @aprantl and @dblaikie had in mind couple of weeks back

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/WebAssemblyReferenceTypes.def"
 
   /// A helper function to collect debug info for C++ base
   /// classes. This is used while creating debug info entry for a
   /// Record.
   void CollectCXXBases(const CXXRecordDecl *Decl, llvm::DIFile *F,
                        SmallVectorImpl<llvm::Metadata *> &EltTys,
                        llvm::DIType *RecordTy);
 
+  /// Helper class that retrieves returns llvm::DIType the that
+  /// PreferredNameAttr attribute on \ref RD refers to. If no such
+  /// attribute exists, returns nullptr.
+  llvm::DIType *GetPreferredNameType(const CXXRecordDecl *RD,
+                                     llvm::DIFile *Unit);
+
   /// Helper function for CollectCXXBases.
   /// Adds debug info entries for types in Bases that are not in SeenTypes.
   void CollectCXXBasesAux(
       const CXXRecordDecl *RD, llvm::DIFile *Unit,
       SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
       const CXXRecordDecl::base_class_const_range &Bases,
       llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes,
       llvm::DINode::DIFlags StartingFlags);

clang/lib/CodeGen/CGDebugInfo.cpp

if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
     if (!T)
       T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
     return T;
   }
 
   return CreateTypeDefinition(Ty);
 }
 
+llvm::DIType *CGDebugInfo::GetPreferredNameType(const CXXRecordDecl *RD,
+                                                llvm::DIFile *Unit) {
+  if (!RD)
+    return nullptr;
+
+  auto const *PNA = RD->getAttr<PreferredNameAttr>();
+  if (!PNA)
+    return nullptr;
+
+  return getOrCreateType(PNA->getTypedefType(), Unit);
+}
+
 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
   RecordDecl *RD = Ty->getDecl();
 
   // Get overall information about the record type for the debug info.
   llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
 
   // Records and classes and unions can all be recursive.  To handle them, we
   // first generate a debug descriptor for the struct as a forward declaration.
llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
 
   llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
   DBuilder.replaceArrays(FwdDecl, Elements);
 
   if (FwdDecl->isTemporary())
     FwdDecl =
         llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
 
+  if (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB)
+    FwdDecl->replacePreferredName(GetPreferredNameType(CXXDecl, DefUnit));
+
   RegionMap[Ty->getDecl()].reset(FwdDecl);
   return FwdDecl;
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
                                       llvm::DIFile *Unit) {
   // Ignore protocols.
   return getOrCreateType(Ty->getBaseType(), Unit);

clang/test/CodeGen/attr-preferred_name-alias-template.cpp

+// RUN: %clang -target x86_64 -glldb -S -emit-llvm -o - %s | FileCheck %s --check-prefixes=LLDB,COMMON
+// RUN: %clang -target x86_64 -ggdb -S -emit-llvm -o - %s | FileCheck %s --check-prefixes=GDB,COMMON
+
+template<typename T>
+struct Foo;
+
+template<typename T>
+using Bar = Foo<T>;
+
+template<typename T>
+struct [[clang::preferred_name(Bar<int>),
+         clang::preferred_name(Bar<double>)]] Foo {};
+
+Foo<int> varInt;
+Foo<double> varDouble;
+Foo<char> varChar;
+
+// COMMON:      ![[FOO_DOUBLE:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<double>"
+// GDB-NOT:     preferredName: [[#]]
+// LLDB-SAME:   preferredName: ![[DOUBLE_PREF:[0-9]+]]
+// COMMON-SAME: )
+
+// LLDB:      ![[DOUBLE_PREF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<double>",
+// LLDB-SAME: baseType: ![[FOO_DOUBLE]]
+
+// COMMON:       !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"
+// GDB-NOT:      preferredName: [[#]]
+// LLDB-NOT:     preferredName: [[#]]
+// COMMON-SAME:  )
+
+// COMMON:      ![[FOO_INT:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<int>"
+// GDB-NOT:     preferredName: [[#]]
+// LLDB-SAME:   preferredName: ![[INT_PREF:[0-9]+]]
+// COMMON-SAME: )
+
+// LLDB:      ![[INT_PREF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<int>",
+// LLDB-SAME: baseType: ![[FOO_INT]]

clang/test/CodeGen/attr-preferred_name-typedef.cpp

+// RUN: %clang -target x86_64 -glldb -S -emit-llvm -o - %s | FileCheck %s --check-prefixes=LLDB,COMMON
+// RUN: %clang -target x86_64 -ggdb -S -emit-llvm -o - %s | FileCheck %s --check-prefixes=GDB,COMMON
+
+template<typename T>
+struct Foo;
+
+typedef Foo<int> BarInt;
+typedef Foo<double> BarDouble;
+typedef Foo<char> BarChar;
+
+template<typename T>
+struct [[clang::preferred_name(BarInt),
+         clang::preferred_name(BarDouble)]] Foo {};
+
+Foo<int> varInt;
+Foo<double> varDouble;
+Foo<char> varChar;
+
+// COMMON:    ![[FOO_DOUBLE:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<double>"
+// GDB-NOT:   preferredName: [[#]]
+// LLDB-SAME: preferredName: ![[DOUBLE_PREF:[0-9]+]])
+// COMMON:    )
+
+// LLDB:      !DIDerivedType(tag: DW_TAG_typedef, name: "BarDouble",
+// LLDB-SAME: baseType: ![[FOO_DOUBLE]])
+
+// COMMON:    !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"
+// GDB-NOT:   preferredName: [[#]]
+// LLDB-NOT:  preferredName: [[#]]
+// COMMON:    )
+
+// COMMON:    ![[FOO_INT:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<int>"
+// GDB-NOT:   preferredName: [[#]]
+// LLDB-SAME: preferredName: ![[INT_PREF:[0-9]+]])
+// COMMON:    )
+
+// LLDB:      !DIDerivedType(tag: DW_TAG_typedef, name: "BarInt",
+// LLDB-SAME: baseType: ![[FOO_INT]])