[clang][DebugInfo] Emit DW_AT_type of preferred name if available

[Michael137]

Summary

With this patch, whenever we emit a DW_AT_type for some declaration
and the type is a template class with a clang::PreferredNameAttr, we
will emit the typedef that the attribute refers to instead. I.e.,

0x123 DW_TAG_variable
DW_AT_name "var"
DW_AT_type (0x123 "basic_string<char>")

0x124 DW_TAG_structure_type
DW_AT_name "basic_string<char>"

...becomes

0x123 DW_TAG_variable
DW_AT_name "var"
DW_AT_type (0x124 "std::string")

0x124 DW_TAG_structure_type
DW_AT_name "basic_string<char>"

0x125 DW_TAG_typedef
DW_AT_name "std::string"
DW_AT_type (0x124 "basic_string<char>")

We do this by returning the preferred name typedef DIType when
we create a structure definition. In some cases, e.g., with -gmodules,
we don't complete the structure definition immediately but do so later
via completeClassData, which overwrites the TypeCache. In such cases
we don't actually want to rewrite the cache with the preferred name. We
handle this by returning both the definition and the preferred typedef
from CreateTypeDefinition and let the callee decide what to do with
it.

Essentially we set up the types as:

TypeCache[Record] => DICompositeType
ReplaceMap[Record] => DIDerivedType(baseType: DICompositeType)

For now we keep this behind LLDB tuning.

Testing

• Added clang unit-test
• check-llvm, check-clang pass
• Confirmed that this change correctly repoints

basic_string references in some of my test programs.

• Will add follow-up LLDB API tests

[Michael137]

Yet another alternative for emitting preferred_names.

Makes the attribute introduced in https://reviews.llvm.org/D145077 redundant. Also doesn't require any changes to LLDB (making https://reviews.llvm.org/D145078 redundant, which got a bit hairy)

[aprantl]

This seems to be a much simpler implementation that just automatically works. I think I'd prefer that over adding new DWARF attributes.

[Michael137]

• Add test

[Michael137]

• Update commit message

[dblaikie]

Yeah, can't say this had occurred to me - but totally makes sense/reckon it's OK. Any reason to limit this to lldb? I'd expect it'd probably "Just Work(tm)" on any DWARF consumer?

it doesn't hit any recursion issues? (I guess maybe skirts it due to the existing recursion handling in the decl/def structure type stuff - so it creates a declaration for the type, then creates the typedef, which can find that existing declaration, then return the typedef from the create type query?)

I guess it means that references to the type even for like, the type of the "this" parameter - would refer to the typedef? That's /probably/ OK if a bit surprising to some people/consumers sometimes?

[Michael137]

In D145803#4186805, @dblaikie wrote:

Yeah, can't say this had occurred to me - but totally makes sense/reckon it's OK. Any reason to limit this to lldb? I'd expect it'd probably "Just Work(tm)" on any DWARF consumer?

No particular reason other than being on the safe side and get field experience before enabling it for all consumers. But I agree, I don't see why this couldn't be enabled always.

it doesn't hit any recursion issues? (I guess maybe skirts it due to the existing recursion handling in the decl/def structure type stuff - so it creates a declaration for the type, then creates the typedef, which can find that existing declaration, then return the typedef from the create type query?)

Yup that's the intention

I guess it means that references to the type even for like, the type of the "this" parameter - would refer to the typedef? That's /probably/ OK if a bit surprising to some people/consumers sometimes?

Good point, it does also repoint the this pointer to the typedef. LLDB seems to handle this fine. Can add some test cases for this (in Clang and LLDB)

[Michael137]

Apparently some Objective-C/gmodules LLDB tests aren't happy with this change
Investigating...

[Michael137]

• Fix cycle in DIDerivedType when we deal with forward declarations and complete explicitly via completeClassData (e.g., with -gmodules)
• Add tests for -gmodules

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

2640

I'm curious if this works if we encounter a forward declaration, early exit here, then encounter a use of the type, and then the definition, since completeClass effectively also ignores the preferred name?

[Michael137]

clang/lib/CodeGen/CGDebugInfo.cpp

2640

Good point. If we ever take this branch we won't end up emitting the preferred name. For my -gmodules test cases this works out fine because the modules that contain the instantiations would see the preferred name. But I can indeed construct a non-modules test case where we end up using a forward declared structure where the preferred name gets ignored here. Not sure we can do much here for such cases.

The alternative I considered where we create some sort of PreferredNameCache[TagType*] => DIDerivedType and use it when replacing forward declarations in finalize() doesn't work for the normal case because we don't have any forward declarations to replace

[probinson]

This is pretty different from the "always desugar to the canonical type" habit that has always been in place. Sony has done some downstream things to try to work around that in the past. @wolfgangp will remember it better than I do, but I think we make some effort to preserve the type-as-written. This goes in completely the other direction.

clang/test/CodeGen/preferred_name.cpp

49

This doesn't become Foo<BarInt> ?

[wolfgangp]

In D145803#4219894, @probinson wrote:

This is pretty different from the "always desugar to the canonical type" habit that has always been in place. Sony has done some downstream things to try to work around that in the past. @wolfgangp will remember it better than I do, but I think we make some effort to preserve the type-as-written. This goes in completely the other direction.

The Sony solution does not rely on a user-specified attribute, but uniformly preserves all typedefs, though only in template argument types. Similar to this solution, it adds a second type to keep track of the preferred type, though it does so in the TemplateArgument structure as a separate QualType. A client can then either print the preferred type or the canonical type, depending on a printing policy, which is controlled by an option. This leads to a similar result in the resulting DWARF, i.e. the DW_AT_type node gets the preferred type string. The preferred type can also be used for diagnostic messages.

clang/lib/CodeGen/CGDebugInfo.h

289

This comment seems a bit garbled. Also, this is just a helper function, no?

[Michael137]

clang/test/CodeGen/preferred_name.cpp

49

The name stays as Foo<Foo<int>> but the type of the template parameter becomes BarInt. So the dwarf would look like:

DW_TAG_structure_type
  DW_AT_name      ("Foo<Foo<int> >")

  DW_TAG_template_type_parameter
    DW_AT_type    (0x00000095 "BarInt")
    DW_AT_name    ("T")

Will add the parameter metadata to the test

[Michael137]

• Refine tests:
  • Check for type of template parameter
  • Add test for chained typedefs.

[Michael137]

• Fix function docstring

[dblaikie]

clang/test/CodeGen/preferred_name.cpp

49

Hmm, that seems buggy - why doesn't Foo<Foo<int> > become Foo<BarInt>? (is the preferred name ever used in the DW_AT_name? I'd have thought it should be unless it's explicitly avoided to ensure type compatibility/collapsing with debug info built without this feature enabled?)

[Michael137]

clang/test/CodeGen/preferred_name.cpp

49

I suspect it's because the name is constructed using the clang TypePrinter. And we turn off PrintingPolicy::UsePreferredNames by default to avoid divergence from GCC.

Will double check though

[dblaikie]

clang/test/CodeGen/preferred_name.cpp

49

Yeah, that sounds right/OK to me. Sorry for the diversion.

[Michael137]

In D145803#4220124, @wolfgangp wrote:

In D145803#4219894, @probinson wrote:

This is pretty different from the "always desugar to the canonical type" habit that has always been in place. Sony has done some downstream things to try to work around that in the past. @wolfgangp will remember it better than I do, but I think we make some effort to preserve the type-as-written. This goes in completely the other direction.

The Sony solution does not rely on a user-specified attribute, but uniformly preserves all typedefs, though only in template argument types. Similar to this solution, it adds a second type to keep track of the preferred type, though it does so in the TemplateArgument structure as a separate QualType. A client can then either print the preferred type or the canonical type, depending on a printing policy, which is controlled by an option. This leads to a similar result in the resulting DWARF, i.e. the DW_AT_type node gets the preferred type string. The preferred type can also be used for diagnostic messages.

Neat, thanks for outlining your approach.

@probinson Sounds like Sony's solution also changes the DW_AT_type to a non-canonical form. Do you still have concerns with the direction of this patch? Would it cause any problems for you downstream?

[Michael137]

ping

[wolfgangp]

@probinson Sounds like Sony's solution also changes the DW_AT_type to a non-canonical form. Do you still have concerns with the direction of this patch? Would it cause any problems for you downstream?

Sorry for the late reply. Looking at the patch I don't think it will cause us any trouble. The 2 solutions should be able to live happily side by side.

[Michael137]

I'll submit later today then if nobody has any other objections

Will add a release note

[chapuni]

clang/test/Modules/gmodules-preferred-name-alias.cpp

7

I guess it made difficult to find out the actual error since it hid stderr.
In fact, I had to reproduce failures locally.

In addition, mixing stdout and stderr sometimes confuse line order due to buffering.

btw, did it really require stderr?

[aaron.ballman]

The changes in this patch seem to have caused https://lab.llvm.org/buildbot/#/builders/clang-ppc64-aix to go down for the past 4 days -- can you revert and investigate?

[Michael137]

Looks like gmodules isn't fully supported on AIX (based on other tests that use -dwarf-ext-refs. So I'll just disable the new tests

Thanks for notifying @aaron.ballman , email notifications got lost in the inbox

[Michael137]

Oh looks like @Jake-Egan already did

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/WebAssemblyReferenceTypes.def"
   llvm::DIType *CreateType(const TemplateSpecializationType *Ty,
                            llvm::DIFile *Fg);
   llvm::DIType *CreateType(const ObjCObjectPointerType *Ty, llvm::DIFile *F);
   llvm::DIType *CreateType(const PointerType *Ty, llvm::DIFile *F);
   llvm::DIType *CreateType(const BlockPointerType *Ty, llvm::DIFile *F);
   llvm::DIType *CreateType(const FunctionType *Ty, llvm::DIFile *F);
   /// Get structure or union type.
   llvm::DIType *CreateType(const RecordType *Tyg);
-  llvm::DIType *CreateTypeDefinition(const RecordType *Ty);
+
+  /// Create definition for the specified 'Ty'.
+  ///
+  /// \returns A pair of 'llvm::DIType's. The first is the definition
+  /// of the 'Ty'. The second is the type specified by the preferred_name
+  /// attribute on 'Ty', which can be a nullptr if no such attribute
+  /// exists.
+  std::pair<llvm::DIType *, llvm::DIType *>
+  CreateTypeDefinition(const RecordType *Ty);
   llvm::DICompositeType *CreateLimitedType(const RecordType *Ty);
   void CollectContainingType(const CXXRecordDecl *RD,
                              llvm::DICompositeType *CT);
   /// Get Objective-C interface type.
   llvm::DIType *CreateType(const ObjCInterfaceType *Ty, llvm::DIFile *F);
   llvm::DIType *CreateTypeDefinition(const ObjCInterfaceType *Ty,
                                      llvm::DIFile *F);
   /// Get Objective-C object type.
#include "clang/Basic/WebAssemblyReferenceTypes.def"
   /// 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);
 
+  /// 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);
+
   struct TemplateArgs {
     const TemplateParameterList *TList;
     llvm::ArrayRef<TemplateArgument> Args;
   };
   /// A helper function to collect template parameters.
   llvm::DINodeArray CollectTemplateParams(std::optional<TemplateArgs> Args,
                                           llvm::DIFile *Unit);
   /// A helper function to collect debug info for function template

clang/lib/CodeGen/CGDebugInfo.cpp

 void CGDebugInfo::completeClass(const RecordDecl *RD) {
   if (DebugKind <= codegenoptions::DebugLineTablesOnly)
     return;
   QualType Ty = CGM.getContext().getRecordType(RD);
   void *TyPtr = Ty.getAsOpaquePtr();
   auto I = TypeCache.find(TyPtr);
   if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
     return;
-  llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
+
+  // We want the canonical definition of the structure to not
+  // be the typedef. Since that would lead to circular typedef
+  // metadata.
+  auto [Res, PrefRes] = CreateTypeDefinition(Ty->castAs<RecordType>());
   assert(!Res->isForwardDecl());
   TypeCache[TyPtr].reset(Res);
 }
 
 static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I,
                                         CXXRecordDecl::method_iterator End) {
   for (CXXMethodDecl *MD : llvm::make_range(I, End))
     if (FunctionDecl *Tmpl = MD->getInstantiatedFromMemberFunction())
llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
   llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
   if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
                                 CGM.getLangOpts())) {
     if (!T)
       T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
     return T;
   }
 
-  return CreateTypeDefinition(Ty);
+  auto [Def, Pref] = CreateTypeDefinition(Ty);
+
+  return Pref ? Pref : Def;
+}
+
+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) {
+std::pair<llvm::DIType *, 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.
   // Then (if it is a definition) we go through and get debug info for all of
   // its members.  Finally, we create a descriptor for the complete type (which
   // may refer to the forward decl if the struct is recursive) and replace all
   // uses of the forward declaration with the final definition.
   llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty);
 
   const RecordDecl *D = RD->getDefinition();
   if (!D || !D->isCompleteDefinition())
-    return FwdDecl;
+    return {FwdDecl, nullptr};
 
   if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
     CollectContainingType(CXXDecl, FwdDecl);
 
   // Push the struct on region stack.
   LexicalBlockStack.emplace_back(&*FwdDecl);
   RegionMap[Ty->getDecl()].reset(FwdDecl);
 
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));
 
   RegionMap[Ty->getDecl()].reset(FwdDecl);
-  return FwdDecl;
+
+  if (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB)
+    if (auto *PrefDI = GetPreferredNameType(CXXDecl, DefUnit))
+      return {FwdDecl, PrefDI};
+
+  return {FwdDecl, nullptr};
 }
 
 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
                                       llvm::DIFile *Unit) {
   // Ignore protocols.
   return getOrCreateType(Ty->getBaseType(), Unit);
 }
 
if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
     DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
                            CollectCXXTemplateParams(TSpecial, DefUnit));
   return RealDecl;
 }
 
 void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
                                         llvm::DICompositeType *RealDecl) {
   // A class's primary base or the class itself contains the vtable.
-  llvm::DICompositeType *ContainingType = nullptr;
+  llvm::DIType *ContainingType = nullptr;
   const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
   if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
     // Seek non-virtual primary base root.
     while (true) {
       const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
       const CXXRecordDecl *PBT = BRL.getPrimaryBase();
       if (PBT && !BRL.isPrimaryBaseVirtual())
         PBase = PBT;
       else
         break;
     }
-    ContainingType = cast<llvm::DICompositeType>(
-        getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
-                        getOrCreateFile(RD->getLocation())));
+    ContainingType = getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
+                                     getOrCreateFile(RD->getLocation()));
   } else if (RD->isDynamicClass())
     ContainingType = RealDecl;
 
   DBuilder.replaceVTableHolder(RealDecl, ContainingType);
 }
 
 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
                                             StringRef Name, uint64_t *Offset) {

clang/test/CodeGen/preferred_name.cpp

+// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -debug-info-kind=standalone -debugger-tuning=lldb %s | FileCheck %s --check-prefixes=COMMON,LLDB
+// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -debug-info-kind=standalone -debugger-tuning=gdb %s | FileCheck %s --check-prefixes=COMMON,GDB
+
+template <typename T>
+struct Foo;
+
+typedef Foo<int> BarInt;
+typedef Foo<double> BarDouble;
+
+template <typename T>
+using Bar = Foo<T>;
+
+template <typename T>
+struct [[clang::preferred_name(BarInt),
+         clang::preferred_name(BarDouble),
+         clang::preferred_name(Bar<short>),
+         clang::preferred_name(Bar<char>)]] Foo{
+         };
+
+int main() {
+    Foo<int> varInt;
+
+// COMMON: !DILocalVariable(name: "varInt", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_INT_TY:[0-9]+]])
+// LLDB:   ![[BAR_INT_TY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BarInt", file: ![[#]], line: [[#]], baseType: ![[BAR_INT_BASE:[0-9]+]])
+// LLDB:   ![[BAR_INT_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<int>", file: ![[#]], line: [[#]], size: [[#]]
+// GDB:    ![[BAR_INT_TY]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<int>", file: ![[#]], line: [[#]], size: [[#]]
+
+    Foo<double> varDouble;
+
+// COMMON: !DILocalVariable(name: "varDouble", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_DOUBLE_TY:[0-9]+]])
+// LLDB:   ![[BAR_DOUBLE_TY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BarDouble", file: ![[#]], line: [[#]], baseType: ![[BAR_DOUBLE_BASE:[0-9]+]])
+// LLDB:   ![[BAR_DOUBLE_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<double>"
+// GDB:    ![[BAR_DOUBLE_TY]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<double>"
+
+    Foo<short> varShort;
+
+// COMMON: !DILocalVariable(name: "varShort", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_SHORT_TY:[0-9]+]])
+// LLDB:   ![[BAR_SHORT_TY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<short>", file: ![[#]], line: [[#]], baseType: ![[BAR_SHORT_BASE:[0-9]+]])
+// LLDB:   ![[BAR_SHORT_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<short>"
+// GDB:    ![[BAR_SHORT_TY]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<short>"
+
+    Foo<char> varChar;
+
+// COMMON: !DILocalVariable(name: "varChar", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_CHAR_TY:[0-9]+]])
+// LLDB:   ![[BAR_CHAR_TY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<char>", file: ![[#]], line: [[#]], baseType: ![[BAR_CHAR_BASE:[0-9]+]])
+// LLDB:   ![[BAR_CHAR_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"
+// GDB:    ![[BAR_CHAR_TY]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"
+
+    Foo<Foo<int>> varFooInt;
+
+// COMMON: !DILocalVariable(name: "varFooInt", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_FOO_INT_TY:[0-9]+]])
+// COMMON: ![[BAR_FOO_INT_TY]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<Foo<int> >"
+
+    BarInt barInt;
+
+// LLDB:   !DILocalVariable(name: "barInt", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_INT_TY]])
+// GDB:    !DILocalVariable(name: "barInt", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_INT_TYPEDEF:[0-9]+]])
+// GDB:    ![[BAR_INT_TYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BarInt"
+
+    BarDouble barDouble;
+
+// LLDB:   !DILocalVariable(name: "barDouble", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_DOUBLE_TY]])
+// GDB:    !DILocalVariable(name: "barDouble", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_DOUBLE_TYPEDEF:[0-9]+]])
+// GDB:    ![[BAR_DOUBLE_TYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BarDouble"
+
+    Bar<short> barShort;
+
+// LLDB:   !DILocalVariable(name: "barShort", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_SHORT_TY_2:[0-9]+]])
+// GDB:    !DILocalVariable(name: "barShort", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_SHORT_TYPEDEF:[0-9]+]])
+// GDB:    ![[BAR_SHORT_TYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<short>"
+
+    Bar<char> barChar;
+
+// LLDB:   ![[BAR_SHORT_TY_2]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<short>", file: ![[#]], line: [[#]], baseType: ![[BAR_SHORT_TY]])
+
+// LLDB:   !DILocalVariable(name: "barChar", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_CHAR_TY_2:[0-9]+]])
+// GDB:    !DILocalVariable(name: "barChar", scope: ![[#]], file: ![[#]], line: [[#]], type: ![[BAR_CHAR_TYPEDEF:[0-9]+]])
+// GDB:    ![[BAR_CHAR_TYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<char>"
+
+// LLDB:   ![[BAR_CHAR_TY_2]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<char>", file: ![[#]], line: [[#]], baseType: ![[BAR_CHAR_TY]])
+
+    return 0;
+}
+
+

clang/test/Modules/Inputs/gmodules-preferred-name-alias.h

+template<typename T> struct Foo;
+
+template<typename T>
+using Bar = Foo<T>;
+
+template<typename T> struct [[clang::preferred_name(Bar<T>)]] Foo {};
+
+template <typename T> struct Baz { Foo<char> member; };

clang/test/Modules/Inputs/gmodules-preferred-name-alias.modulemap

+module PreferredNameModule {
+  header "gmodules-preferred-name-alias.h"
+  export *
+}

clang/test/Modules/Inputs/gmodules-preferred-name-typedef.h

+template<typename T> struct Foo;
+
+typedef Foo<char> Bar;
+
+template<typename T> struct [[clang::preferred_name(Bar)]] Foo {};
+
+template <typename T> struct Baz { Foo<char> member; };

clang/test/Modules/Inputs/gmodules-preferred-name-typedef.modulemap

+module PreferredNameModule {
+  header "gmodules-preferred-name-typedef.h"
+  export *
+}

clang/test/Modules/gmodules-preferred-name-alias.cpp

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -std=c++11 -dwarf-ext-refs -fmodule-format=obj \
+// RUN:     -fmodule-map-file=%S/Inputs/gmodules-preferred-name-alias.modulemap \
+// RUN:     -fmodules-cache-path=%t -debug-info-kind=standalone -debugger-tuning=lldb \
+// RUN:     -fmodules -mllvm -debug-only=pchcontainer -x c++ \
+// RUN:     -I %S/Inputs %s &> %t.ll
+// RUN: cat %t.ll | FileCheck %s
+
+#include "gmodules-preferred-name-alias.h"
+
+// CHECK: ![[#]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar<char>", scope: ![[#]], file: ![[#]], line: [[#]], baseType: ![[PREF_BASE:[0-9]+]])
+// CHECK: ![[PREF_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"

clang/test/Modules/gmodules-preferred-name-typedef.cpp

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -std=c++11 -dwarf-ext-refs -fmodule-format=obj \
+// RUN:     -fmodule-map-file=%S/Inputs/gmodules-preferred-name-typedef.modulemap \
+// RUN:     -fmodules-cache-path=%t -debug-info-kind=standalone -debugger-tuning=lldb \
+// RUN:     -fmodules -mllvm -debug-only=pchcontainer -x c++ \
+// RUN:     -I %S/Inputs %s &> %t.ll
+// RUN: cat %t.ll | FileCheck %s
+
+#include "gmodules-preferred-name-typedef.h"
+
+// CHECK: ![[#]] = !DIDerivedType(tag: DW_TAG_typedef, name: "Bar", scope: ![[#]], file: ![[#]], line: [[#]], baseType: ![[PREF_BASE:[0-9]+]])
+// CHECK: ![[PREF_BASE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo<char>"

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/shared_ptr/TestDataFormatterLibcxxSharedPtr.py

def test_shared_ptr_variables(self):
             "sp_int_ref_ref",
             type="std::shared_ptr<int> &&",
             children=[ValueCheck(name="__ptr_")],
         )
         self.assertRegex(valobj.summary, r"^10( strong=1)? weak=1$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
-            string_type = "std::basic_string<char>"
+            string_type = "std::string"
         else:
-            string_type = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
+            string_type = "std::basic_string<char, std::char_traits<char>, std::allocator<char> > "
 
         valobj = self.expect_var_path(
             "sp_str",
-            type="std::shared_ptr<" + string_type + " >",
+            type="std::shared_ptr<" + string_type + ">",
             children=[ValueCheck(name="__ptr_", summary='"hello"')],
         )
         self.assertRegex(valobj.summary, r'^"hello"( strong=1)? weak=1$')
 
         valobj = self.expect_var_path("sp_user", type="std::shared_ptr<User>")
         self.assertRegex(
             valobj.summary,
             "^std(::__[^:]*)?::shared_ptr<User>::element_type @ 0x0*[1-9a-f][0-9a-f]+( strong=1)? weak=1",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/TestDataFormatterLibcxxUniquePtr.py

def make_expected_type(self, pointee_type: str, qualifiers: str = "") -> str:
 
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             return f'std::unique_ptr<{pointee_type}>{qualifiers}'
         else:
             return f'std::unique_ptr<{pointee_type}, std::default_delete<{pointee_type}> >{qualifiers}'
 
     def make_expected_basic_string_ptr(self) -> str:
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
-            return f'std::unique_ptr<std::basic_string<char> >'
+            return f'std::unique_ptr<std::string>'
         else:
             return 'std::unique_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, ' \
                    'std::default_delete<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >'
 
     @add_test_categories(["libc++"])
     def test_unique_ptr_variables(self):
         """Test `frame variable` output for `std::unique_ptr` types."""
         self.build()