[NativePDB] Add the ability to create clang record decls from mangled names.

[zturner]

Summary

Previously we were not able to accurately represent tag record types with clang record decls. The primary reason for this is that for type information PDB only contains fully instantiated type names. It does not contain rich information about namespaces, declaration contexts (e.g. parent classes, function scopes for local classes, etc), template parameters, or anything else. All you have is a big long string that is a fully instantiated type name. What it does give you, however, is the mangled name of this type. So we can extract all of the relevant information (minus the distinction between outer class and outer namespace) from the mangled name. This patch is the start of this effort.

It uses LLVM's demangler to demangle the name, and treat each component as one component of a namespace chain.

Obviously this is not true in the general case, as something like Foo<int>::Bar(double)::1'::LocalClass<7>::NestedClass` will get treated as if it were in a series of namespaces. However, it's a good start, and clang doesn't actually care for most uses. So we can improve on this incrementally with subsequent patches to make this more accurate.

[lemo]

nice!

lldb/source/Plugins/SymbolFile/NativePDB/MangledAST.cpp

81

what does this mean? pretend that all the members of a class are private?

[zturner]

In D54053#1286272, @lemo wrote:

nice!

AFAIU this is just the "default" access of the class. I should probably investigate why it's needed in the first place, since it can be deduced from the tag type.

[labath]

A very nice use of the structured demangler.

[zturner]

I actually found some issues with this, or at least some potential issues which I'm not sure are actual issues. But I'm adding some new functionality to LLDB to help me confirm whether these are real issues or not, and worst case scenario it will open up some new testing possibilities and help us understand the consequences of messing around with clang ASTs in various ways. So I'm not going to commit this quite yet. Stay tuned.

[zturner]

I just added a new test which dumps the clang AST and makes sure no bogus records get introduced. Since this is already LGTM'ed I'm assuming this is good to go, but since it now depends on D54072, I figure I might as well update this diff since I can't commit it yet.

[zturner]

Bleh, I think I found a problem with this approach. Since we assume everything is a namespace, it can lead to ambiguities. I think we need to actually consult the debug info while parsing components of the mangled name. For example, suppose you have this code:

namespace NS1 {
  struct Tag2 {
    class TagRecord {};
  };
}

NS1::Tag2::TagRecord ATR;
NS1::Tag2 T2;

And in LLDB you run the following commands:

(lldb) target variable ATR
(lldb) target variable T2

We demangle the first name and create an AST from it, but we don't know what Tag2 is so we assume it's a namespace and we create a NamespaceDecl. Then we get to the second one we actually know what it is because we have a precise debug info record for it so we know it's a struct so we create a CXXRecordDecl for it. So now we end up creating an invalid AST. Clang will accept it, but it's going to lead to ambiguities on name lookup and create problems down the line. So, I think what we should do instead is ask the debug info "Do you know what the type named NS1 is in the global scope?" If no, it's a namespace. Otherwise we create (or lookup) the appropriate decl. Then we can repeat this at each step along the way.

BTW, when I run those above 2 commands with the patch as it is above, here is the output I get. And you can see that there are two conflicting decls.

D:\src\llvmbuild\ninja-x64>"bin\lldb" "-f" "D:\src\llvmbuild\ninja-x64\tools\lldb\lit\SymbolFile\NativePDB\Output\ast-reconstruction.cpp.tmp.exe"
(lldb) target create "D:\\src\\llvmbuild\\ninja-x64\\tools\\lldb\\lit\\SymbolFile\\NativePDB\\Output\\ast-reconstruction.cpp.tmp.exe"
Current executable set to 'D:\src\llvmbuild\ninja-x64\tools\lldb\lit\SymbolFile\NativePDB\Output\ast-reconstruction.cpp.tmp.exe' (x86_64).
(lldb) target variable ATR
(NS1::Tag2::TagRecord) ATR = {}
(lldb) target variable T2
(NS1::Tag2) T2 = {}
(lldb) target modules dump ast
TranslationUnitDecl 0x2247dff6fd8 <<invalid sloc>> <invalid sloc>
|-NamespaceDecl 0x2247dff7898 <<invalid sloc>> <invalid sloc> NS1
| |-NamespaceDecl 0x2247dff7918 <<invalid sloc>> <invalid sloc> Tag2
| | `-CXXRecordDecl 0x2247dff7998 <<invalid sloc>> <invalid sloc> class TagRecord definition
| |   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| |   | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| |   | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| |   | |-MoveConstructor exists simple trivial needs_implicit
| |   | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
| |   | |-MoveAssignment exists simple trivial needs_implicit
| |   | `-Destructor simple irrelevant trivial needs_implicit
| |   `-MSInheritanceAttr 0x2247dff7a60 <<invalid sloc>> Implicit __single_inheritance
| `-CXXRecordDecl 0x2247dff7b08 <<invalid sloc>> <invalid sloc> struct Tag2 definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveConstructor exists simple trivial needs_implicit
|   | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   `-MSInheritanceAttr 0x2247dff7bd0 <<invalid sloc>> Implicit __single_inheritance
`-<undeserialized declarations>
Dumping clang ast for 1 modules.

[zturner]

So I tried to go down this route, but alas, I still can't come up with a good way to make color output work, because the Stream is not a StreamFile object, it is a StreamString object, even when the output is going to a terminal. We could have an argument such as --color but perhaps it should be the default and the option should be --no-color.

Edit: Commented on wrong diff

[aleksandr.urakov]

In D54053#1286653, @zturner wrote:

Bleh, I think I found a problem with this approach. Since we assume everything is a namespace, it can lead to ambiguities. I think we need to actually consult the debug info while parsing components of the mangled name.

Yes, it is what actually we have done in PDBASTParser::GetDeclContextContainingSymbol. Also I think that it is worth to remember if we already have created the class / function parent before, and do not create namespaces in this case. For example: N0::N1::CClass::PrivateFunc::__l2::InnerFuncStruct. We have here the PrivateFunc function and the InnerFuncStruct structure inside it. So we do not need to create the __l2 namespace inside the PrivateFunc function (moreover, it is not possible to create a namespace inside a class / function).

There is a similar problem with global and static variables and functions. Are the mangled names presented for them? Can we solve it in the same way?

Anyway, I think that this patch is a great start!

[zturner]

In D54053#1288415, @aleksandr.urakov wrote:

In D54053#1286653, @zturner wrote:

Bleh, I think I found a problem with this approach. Since we assume everything is a namespace, it can lead to ambiguities. I think we need to actually consult the debug info while parsing components of the mangled name.

Yes, it is what actually we have done in PDBASTParser::GetDeclContextContainingSymbol. Also I think that it is worth to remember if we already have created the class / function parent before, and do not create namespaces in this case. For example: N0::N1::CClass::PrivateFunc::__l2::InnerFuncStruct. We have here the PrivateFunc function and the InnerFuncStruct structure inside it. So we do not need to create the __l2 namespace inside the PrivateFunc function (moreover, it is not possible to create a namespace inside a class / function).

There is a similar problem with global and static variables and functions. Are the mangled names presented for them? Can we solve it in the same way?

Anyway, I think that this patch is a great start!

I actually think I have a totally different solution to this that will be more robust. It will handle the nested classes and namespaces perfectly, but not the scoped classes. But we can deal with that later. But it gives us the highest quality correctness level for this case, which I think is ultimately the most common (nested classes are pretty rare). So we can try the best methods first, and fall back to other methods as needed. I'm going to abandon this patch for now, but we'll keep it in mind for later. I'll upload a new patch with the new approach soon.

[shafik]

Is this PR still relevant or can it be closed?

lldb/lit/SymbolFile/NativePDB/Inputs/ast-reconstruction.lldbinit

+target variable ABR
+target variable ATR
+target variable BAR
+target variable BT
+target variable GlobalC
+target variable GlobalU
+target variable GlobalS
+target variable GlobalE
+
+target modules dump ast
+
+target variable ABR
+target variable ATR
+target variable BAR
+target variable BT
+target variable GlobalC
+target variable GlobalU
+target variable GlobalS
+target variable GlobalE
+
+target modules dump ast
+
+quit
 No newline at end of file

lldb/lit/SymbolFile/NativePDB/ast-reconstruction.cpp

+// clang-format off
+// REQUIRES: lld
+
+// RUN: clang-cl /Z7 /GS- /GR- /c -Xclang -fkeep-static-consts /Fo%t.obj -- %s
+// RUN: lld-link /DEBUG /nodefaultlib /entry:main /OUT:%t.exe /PDB:%t.pdb -- %t.obj
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-NS1 %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-NS2 %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-TAGRECORD %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-C %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-U %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-S %s
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
+// RUN:     %p/Inputs/ast-reconstruction.lldbinit 2>&1 | FileCheck \
+// RUN:     --check-prefix=NODUPE-E %s
+
+
+struct S {};
+class C {};
+union U {};
+enum class E {
+  A = 1
+};
+
+namespace NS1 {
+  namespace NS2 {
+    struct TagRecord { };
+  }
+
+  struct Tag2 {
+    class TagRecord {};
+  };
+}
+
+struct NS2 {
+  struct NS1 {
+    union TagRecord {};
+  };
+  enum TagRecord {};
+};
+
+S GlobalS;
+C GlobalC;
+U GlobalU;
+E GlobalE = E::A;
+
+NS1::NS2::TagRecord ABR;
+NS1::Tag2::TagRecord ATR;
+NS2::NS1::TagRecord BAR;
+NS2::TagRecord BT;
+
+// CHECK: TranslationUnitDecl
+// CHECK: |-NamespaceDecl {{.*}} NS1
+// CHECK: | |-NamespaceDecl {{.*}} NS2
+// CHECK: | | `-CXXRecordDecl {{.*}} struct TagRecord definition
+// CHECK: | |   `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: | `-NamespaceDecl {{.*}} Tag2
+// CHECK: |   `-CXXRecordDecl {{.*}} class TagRecord definition
+// CHECK: |     `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: |-NamespaceDecl {{.*}} NS2
+// CHECK: | `-NamespaceDecl {{.*}} NS1
+// CHECK: |   `-CXXRecordDecl {{.*}} union TagRecord definition
+// CHECK: |     `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: |-EnumDecl {{.*}} TagRecord
+// CHECK: |-CXXRecordDecl {{.*}} class C definition
+// CHECK: | `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: |-CXXRecordDecl {{.*}} union U definition
+// CHECK: | `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: |-CXXRecordDecl {{.*}} struct S definition
+// CHECK: | `-MSInheritanceAttr {{.*}} Implicit __single_inheritance
+// CHECK: |-EnumDecl {{.*}} E
+// CHECK: `-<undeserialized declarations>
+
+// NODUPE-NS1:     TranslationUnitDecl
+// NODUPE-NS1:     |-NamespaceDecl {{.*}} NS1
+// NODUPE-NS1-NOT: |-NamespaceDecl {{.*}} NS1
+// NODUPE-NS1:     `-<undeserialized declarations>
+
+// NODUPE-NS2:     TranslationUnitDecl
+// NODUPE-NS2:     |-NamespaceDecl {{.*}} NS1
+// NODUPE-NS2-NOT: |-NamespaceDecl {{.*}} NS1
+// NODUPE-NS2:     `-<undeserialized declarations>
+
+// NODUPE-TAGRECORD:     TranslationUnitDecl
+// NODUPE-TAGRECORD:     | | `-CXXRecordDecl {{.*}} struct TagRecord definition
+// NODUPE-TAGRECORD-NOT: | | `-CXXRecordDecl {{.*}} struct TagRecord definition
+// NODUPE-TAGRECORD:     `-<undeserialized declarations>
+
+// NODUPE-C:     TranslationUnitDecl
+// NODUPE-C:     |-CXXRecordDecl {{.*}} class C definition
+// NODUPE-C-NOT: |-CXXRecordDecl {{.*}} class C definition
+// NODUPE-C:     `-<undeserialized declarations>
+
+// NODUPE-U:     TranslationUnitDecl
+// NODUPE-U:     |-CXXRecordDecl {{.*}} union U definition
+// NODUPE-U-NOT: |-CXXRecordDecl {{.*}} union U definition
+// NODUPE-U:     `-<undeserialized declarations>
+
+// NODUPE-S:     TranslationUnitDecl
+// NODUPE-S:     |-CXXRecordDecl {{.*}} struct S definition
+// NODUPE-S-NOT: |-CXXRecordDecl {{.*}} struct S definition
+// NODUPE-S:     `-<undeserialized declarations>
+
+// NODUPE-E:     TranslationUnitDecl
+// NODUPE-E:     |-EnumDecl {{.*}} E
+// NODUPE-E-NOT: |-EnumDecl {{.*}} E
+// NODUPE-E:     `-<undeserialized declarations>
+
+int main(int argc, char **argv) {
+  return 0;
+}

lldb/lit/SymbolFile/NativePDB/function-types-classes.cpp

 // CHECK: (E (*)(const S *, const C &, const U &&)) b = {{.*}}
 auto c = &four<U, volatile E*, volatile S&, volatile C&&>;
 // CHECK: (U (*)(volatile E *, volatile S &, volatile C &&)) c = {{.*}}
 auto d = &four<C, const volatile U*, const volatile E&, const volatile S&&>;
 // CHECK: (C (*)(const volatile U *, const volatile E &, const volatile S &&)) d = {{.*}}
 
 // classes nested in namespaces and inner classes
 
-// FIXME: LLDB with native pdb plugin doesn't currently resolve nested names
-// correctly, because it requires creating clang::NamespaceDecl or
-// clang::RecordDecl for the outer namespace or classes.  PDB doesn't contain
-// sufficient information to distinguish namespace scopes from nested class
-// scopes, so the best we can hope for is a heuristic reconstruction of the
-// clang AST based on demangling the type's unique name.  However, this is
-// as-yet unimplemented in the native PDB plugin, so for now all of these will
-// all just look like `S` when LLDB prints them.
 auto e = &three<A::B::S*, B::A::S*, A::C::S&>;
-// CHECK: (S *(*)(S *, S &)) e = {{.*}}
+// CHECK: (A::B::S *(*)(B::A::S *, A::C::S &)) e = {{.*}}
 auto f = &three<A::C::S&, A::B::S*, B::A::S*>;
-// CHECK: (S &(*)(S *, S *)) f = {{.*}}
+// CHECK: (A::C::S &(*)(A::B::S *, B::A::S *)) f = {{.*}}
 auto g = &three<B::A::S*, A::C::S&, A::B::S*>;
-// CHECK: (S *(*)(S &, S *)) g = {{.*}}
+// CHECK: (B::A::S *(*)(A::C::S &, A::B::S *)) g = {{.*}}
 
 // parameter types that are themselves template instantiations.
 auto h = &four<TC<void>, TC<int>, TC<TC<int>>, TC<A::B::S>>;
 // Note the awkward space in TC<TC<int> >.  This is because this is how template
 // instantiations are emitted by the compiler, as the fully instantiated name.
 // Only via reconstruction of the AST through the mangled type name (see above
 // comment) can we hope to do better than this).
-// CHECK: (TC<void> (*)(TC<int>, TC<TC<int> >, S>)) h = {{.*}}
+// CHECK: (TC<void> (*)(TC<int>, TC<struct TC<int>>, TC<struct A::B::S>)) h = {{.*}}
 
 auto i = &nullary<A::B::S>;
-// CHECK: (S (*)()) i = {{.*}}
+// CHECK: (A::B::S (*)()) i = {{.*}}
 
 
 // Make sure we can handle types that don't have complete debug info.
 struct Incomplete;
 auto incomplete = &three<Incomplete*, Incomplete**, const Incomplete*>;
 // CHECK: (Incomplete *(*)(Incomplete **, const Incomplete *)) incomplete = {{.*}}
 
 int main(int argc, char **argv) {
   return 0;
 }

lldb/source/Plugins/SymbolFile/NativePDB/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileNativePDB PLUGIN
   CompileUnitIndex.cpp
+  MangledAST.cpp
   PdbIndex.cpp
   PdbUtil.cpp
   SymbolFileNativePDB.cpp
   UdtRecordCompleter.cpp
 
   LINK_LIBS
     clangAST
     clangLex
     lldbCore
     lldbSymbol
     lldbUtility
   LINK_COMPONENTS
     DebugInfoCodeView
     DebugInfoPDB
     Support
   )

lldb/source/Plugins/SymbolFile/NativePDB/MangledAST.h

+//===-- MangledAST.h --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SYMBOLFILE_NATIVEPDB_MANGLEDAST_H
+#define LLDB_PLUGINS_SYMBOLFILE_NATIVEPDB_MANGLEDAST_H
+
+namespace clang {
+class TagDecl;
+} // namespace clang
+
+namespace llvm {
+class StringRef;
+}
+
+namespace lldb_private {
+class ClangASTContext;
+class CompilerType;
+namespace npdb {
+CompilerType CreateClangDeclFromMangledName(ClangASTContext &clang,
+                                            llvm::StringRef mangled);
+} // namespace npdb
+} // namespace lldb_private
+
+#endif // LLDB_PLUGINS_SYMBOLFILE_NATIVEPDB_MANGLEDAST_H

lldb/source/Plugins/SymbolFile/NativePDB/MangledAST.cpp

+//===-- MangledAST.cpp ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MangledAST.h"
+
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/lldb-enumerations.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Demangle/MicrosoftDemangle.h"
+#include "llvm/Demangle/MicrosoftDemangleNodes.h"
+#include "llvm/Demangle/StringView.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::npdb;
+using namespace llvm::ms_demangle;
+
+static std::string render(const Node &node) {
+  OutputStream OS;
+  initializeOutputStream(nullptr, nullptr, OS, 1024);
+  node.output(OS, OF_Default);
+  OS << '\0';
+  return {OS.getBuffer()};
+}
+
+static clang::TagTypeKind TranslateTagKind(TagKind tk) {
+  switch (tk) {
+  case TagKind::Class:
+    return clang::TagTypeKind::TTK_Class;
+  case TagKind::Enum:
+    return clang::TagTypeKind::TTK_Enum;
+  case TagKind::Struct:
+    return clang::TagTypeKind::TTK_Struct;
+  case TagKind::Union:
+    return clang::TagTypeKind::TTK_Union;
+  }
+  llvm_unreachable("Unreachable!");
+}
+
+static clang::DeclContext *CreateDeclContext(ClangASTContext &clang,
+                                             llvm::ArrayRef<Node *> scope) {
+  clang::DeclContext *decl_context = clang.GetTranslationUnitDecl();
+  if (scope.empty())
+    return decl_context;
+
+  clang::DeclContext *top_level_decl = decl_context;
+  // For now we're just going to pretend that each component of the scope is a
+  // namespace.  This isn't actually true, as they could be functions, nested
+  // classes with template parameters, or many other things.  But it's a nice
+  // simplifying assumption that lets us make incremental progress while keeping
+  // things simple.
+  for (Node *ns : scope) {
+    std::string name = render(*ns);
+    decl_context =
+        clang.GetUniqueNamespaceDeclaration(name.c_str(), decl_context);
+  }
+  return decl_context;
+}
+
+CompilerType
+lldb_private::npdb::CreateClangDeclFromMangledName(ClangASTContext &clang,
+                                                   llvm::StringRef mangled) {
+  StringView sv(mangled.data(), mangled.size());
+  Demangler demangler;
+  TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
+  if (!ttn)
+    return CompilerType{};
+
+  NodeArrayNode &name_components = *ttn->QualifiedName->Components;
+
+  llvm::ArrayRef<Node *> components(name_components.Nodes,
+                                    name_components.Count);
+
+  lldb::AccessType access =
+      (ttn->Tag == TagKind::Class) ? lldb::eAccessPrivate : lldb::eAccessPublic;
+
+  std::string name = render(*components.back());
+
+  llvm::ArrayRef<Node *> scope = components.drop_back();
+  clang::TagTypeKind ttk = TranslateTagKind(ttn->Tag);
+  clang::DeclContext *decl_context = CreateDeclContext(clang, scope);
+  return clang.CreateRecordType(decl_context, access, name.c_str(), ttk,
+                                lldb::eLanguageTypeC_plus_plus, nullptr);
+}

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

lldb::TypeSP CreateTagType(PdbSymUid type_uid,
                              const llvm::codeview::EnumRecord &er);
   lldb::TypeSP CreateTagType(PdbSymUid type_uid,
                              const llvm::codeview::UnionRecord &ur);
   lldb::TypeSP CreateArrayType(PdbSymUid type_uid,
                                const llvm::codeview::ArrayRecord &ar);
   lldb::TypeSP CreateProcedureType(PdbSymUid type_uid,
                                    const llvm::codeview::ProcedureRecord &pr);
   lldb::TypeSP
-  CreateClassStructUnion(PdbSymUid type_uid, llvm::StringRef name, size_t size,
+  CreateClassStructUnion(PdbSymUid type_uid, llvm::StringRef name,
+                         llvm::StringRef unique_name, size_t size,
                          clang::TagTypeKind ttk,
                          clang::MSInheritanceAttr::Spelling inheritance);
 
   lldb::FunctionSP GetOrCreateFunction(PdbSymUid func_uid,
                                        const SymbolContext &sc);
   lldb::CompUnitSP GetOrCreateCompileUnit(const CompilandIndexItem &cci);
   lldb::TypeSP GetOrCreateType(PdbSymUid type_uid);
   lldb::TypeSP GetOrCreateType(llvm::codeview::TypeIndex ti);

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusNameParser.h"
 
+#include "MangledAST.h"
 #include "PdbSymUid.h"
 #include "PdbUtil.h"
 #include "UdtRecordCompleter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace npdb;
 using namespace llvm::codeview;
lldb::TypeSP SymbolFileNativePDB::CreateSimpleType(TypeIndex ti) {
   Declaration decl;
   return std::make_shared<Type>(uid.toOpaqueId(), m_clang->GetSymbolFile(),
                                 ConstString(type_name), size, nullptr,
                                 LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
                                 ct, Type::eResolveStateFull);
 }
 
 lldb::TypeSP SymbolFileNativePDB::CreateClassStructUnion(
-    PdbSymUid type_uid, llvm::StringRef name, size_t size,
-    clang::TagTypeKind ttk, clang::MSInheritanceAttr::Spelling inheritance) {
+    PdbSymUid type_uid, llvm::StringRef name, llvm::StringRef unique_name,
+    size_t size, clang::TagTypeKind ttk,
+    clang::MSInheritanceAttr::Spelling inheritance) {
 
-  // Ignore unnamed-tag UDTs.
-  name = DropNameScope(name);
-  if (name.empty())
-    return nullptr;
-
-  clang::DeclContext *decl_context = m_clang->GetTranslationUnitDecl();
-
-  lldb::AccessType access =
-      (ttk == clang::TTK_Class) ? lldb::eAccessPrivate : lldb::eAccessPublic;
-
-  ClangASTMetadata metadata;
-  metadata.SetUserID(type_uid.toOpaqueId());
-  metadata.SetIsDynamicCXXType(false);
-
-  CompilerType ct =
-      m_clang->CreateRecordType(decl_context, access, name.str().c_str(), ttk,
-                                lldb::eLanguageTypeC_plus_plus, &metadata);
-  lldbassert(ct.IsValid());
+  CompilerType ct = CreateClangDeclFromMangledName(*m_clang, unique_name);
 
   clang::CXXRecordDecl *record_decl =
       m_clang->GetAsCXXRecordDecl(ct.GetOpaqueQualType());
   lldbassert(record_decl);
 
   clang::MSInheritanceAttr *attr = clang::MSInheritanceAttr::CreateImplicit(
       *m_clang->getASTContext(), inheritance);
   record_decl->addAttr(attr);
 
   ClangASTContext::StartTagDeclarationDefinition(ct);
 
   // Even if it's possible, don't complete it at this point. Just mark it
   // forward resolved, and if/when LLDB needs the full definition, it can
   // ask us.
   ClangASTContext::SetHasExternalStorage(ct.GetOpaqueQualType(), true);
 
   // FIXME: Search IPI stream for LF_UDT_MOD_SRC_LINE.
   Declaration decl;
   return std::make_shared<Type>(type_uid.toOpaqueId(), m_clang->GetSymbolFile(),
-                                ConstString(name), size, nullptr,
+                                ct.GetTypeName(), size, nullptr,
                                 LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
                                 ct, Type::eResolveStateForward);
 }
 
 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbSymUid type_uid,
                                                 const ClassRecord &cr) {
   clang::TagTypeKind ttk = TranslateUdtKind(cr);
 
   clang::MSInheritanceAttr::Spelling inheritance =
       GetMSInheritance(m_index->tpi().typeCollection(), cr);
-  return CreateClassStructUnion(type_uid, cr.getName(), cr.getSize(), ttk,
-                                inheritance);
+  return CreateClassStructUnion(type_uid, cr.getName(), cr.getUniqueName(),
+                                cr.getSize(), ttk, inheritance);
 }
 
 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbSymUid type_uid,
                                                 const UnionRecord &ur) {
   return CreateClassStructUnion(
-      type_uid, ur.getName(), ur.getSize(), clang::TTK_Union,
+      type_uid, ur.getName(), ur.getUniqueName(), ur.getSize(),
+      clang::TTK_Union,
       clang::MSInheritanceAttr::Spelling::Keyword_single_inheritance);
 }
 
 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbSymUid type_uid,
                                                 const EnumRecord &er) {
   llvm::StringRef name = DropNameScope(er.getName());
 
   clang::DeclContext *decl_context = m_clang->GetTranslationUnitDecl();