xref: /openbsd-src/gnu/llvm/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp (revision f6aab3d83b51b91c24247ad2c2573574de475a82)
1061da546Spatrick #include "PdbAstBuilder.h"
2061da546Spatrick 
3061da546Spatrick #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
4061da546Spatrick #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
5061da546Spatrick #include "llvm/DebugInfo/CodeView/RecordName.h"
6061da546Spatrick #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
7061da546Spatrick #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
8061da546Spatrick #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
9061da546Spatrick #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
10061da546Spatrick #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
11061da546Spatrick #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
12061da546Spatrick #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
13061da546Spatrick #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
14061da546Spatrick #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
15061da546Spatrick #include "llvm/Demangle/MicrosoftDemangle.h"
16061da546Spatrick 
17dda28197Spatrick #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
18dda28197Spatrick #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
19061da546Spatrick #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
20dda28197Spatrick #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
21061da546Spatrick #include "lldb/Core/Module.h"
22061da546Spatrick #include "lldb/Symbol/ObjectFile.h"
23061da546Spatrick #include "lldb/Utility/LLDBAssert.h"
24061da546Spatrick #include "PdbUtil.h"
25061da546Spatrick #include "UdtRecordCompleter.h"
26*f6aab3d8Srobert #include "SymbolFileNativePDB.h"
27*f6aab3d8Srobert #include <optional>
28061da546Spatrick 
29061da546Spatrick using namespace lldb_private;
30061da546Spatrick using namespace lldb_private::npdb;
31061da546Spatrick using namespace llvm::codeview;
32061da546Spatrick using namespace llvm::pdb;
33061da546Spatrick 
34*f6aab3d8Srobert namespace {
35*f6aab3d8Srobert struct CreateMethodDecl : public TypeVisitorCallbacks {
CreateMethodDecl__anonf875fb6b0111::CreateMethodDecl36*f6aab3d8Srobert   CreateMethodDecl(PdbIndex &m_index, TypeSystemClang &m_clang,
37*f6aab3d8Srobert                    TypeIndex func_type_index,
38*f6aab3d8Srobert                    clang::FunctionDecl *&function_decl,
39*f6aab3d8Srobert                    lldb::opaque_compiler_type_t parent_ty,
40*f6aab3d8Srobert                    llvm::StringRef proc_name, CompilerType func_ct)
41*f6aab3d8Srobert       : m_index(m_index), m_clang(m_clang), func_type_index(func_type_index),
42*f6aab3d8Srobert         function_decl(function_decl), parent_ty(parent_ty),
43*f6aab3d8Srobert         proc_name(proc_name), func_ct(func_ct) {}
44*f6aab3d8Srobert   PdbIndex &m_index;
45*f6aab3d8Srobert   TypeSystemClang &m_clang;
46*f6aab3d8Srobert   TypeIndex func_type_index;
47*f6aab3d8Srobert   clang::FunctionDecl *&function_decl;
48*f6aab3d8Srobert   lldb::opaque_compiler_type_t parent_ty;
49*f6aab3d8Srobert   llvm::StringRef proc_name;
50*f6aab3d8Srobert   CompilerType func_ct;
51*f6aab3d8Srobert 
visitKnownMember__anonf875fb6b0111::CreateMethodDecl52*f6aab3d8Srobert   llvm::Error visitKnownMember(CVMemberRecord &cvr,
53*f6aab3d8Srobert                                OverloadedMethodRecord &overloaded) override {
54*f6aab3d8Srobert     TypeIndex method_list_idx = overloaded.MethodList;
55*f6aab3d8Srobert 
56*f6aab3d8Srobert     CVType method_list_type = m_index.tpi().getType(method_list_idx);
57*f6aab3d8Srobert     assert(method_list_type.kind() == LF_METHODLIST);
58*f6aab3d8Srobert 
59*f6aab3d8Srobert     MethodOverloadListRecord method_list;
60*f6aab3d8Srobert     llvm::cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>(
61*f6aab3d8Srobert         method_list_type, method_list));
62*f6aab3d8Srobert 
63*f6aab3d8Srobert     for (const OneMethodRecord &method : method_list.Methods) {
64*f6aab3d8Srobert       if (method.getType().getIndex() == func_type_index.getIndex())
65*f6aab3d8Srobert         AddMethod(overloaded.Name, method.getAccess(), method.getOptions(),
66*f6aab3d8Srobert                   method.Attrs);
67061da546Spatrick     }
68061da546Spatrick 
69*f6aab3d8Srobert     return llvm::Error::success();
70061da546Spatrick   }
71061da546Spatrick 
visitKnownMember__anonf875fb6b0111::CreateMethodDecl72*f6aab3d8Srobert   llvm::Error visitKnownMember(CVMemberRecord &cvr,
73*f6aab3d8Srobert                                OneMethodRecord &record) override {
74*f6aab3d8Srobert     AddMethod(record.getName(), record.getAccess(), record.getOptions(),
75*f6aab3d8Srobert               record.Attrs);
76*f6aab3d8Srobert     return llvm::Error::success();
77061da546Spatrick   }
78061da546Spatrick 
AddMethod__anonf875fb6b0111::CreateMethodDecl79*f6aab3d8Srobert   void AddMethod(llvm::StringRef name, MemberAccess access,
80*f6aab3d8Srobert                  MethodOptions options, MemberAttributes attrs) {
81*f6aab3d8Srobert     if (name != proc_name || function_decl)
82*f6aab3d8Srobert       return;
83*f6aab3d8Srobert     lldb::AccessType access_type = TranslateMemberAccess(access);
84*f6aab3d8Srobert     bool is_virtual = attrs.isVirtual();
85*f6aab3d8Srobert     bool is_static = attrs.isStatic();
86*f6aab3d8Srobert     bool is_artificial = (options & MethodOptions::CompilerGenerated) ==
87*f6aab3d8Srobert                          MethodOptions::CompilerGenerated;
88*f6aab3d8Srobert     function_decl = m_clang.AddMethodToCXXRecordType(
89*f6aab3d8Srobert         parent_ty, proc_name,
90*f6aab3d8Srobert         /*mangled_name=*/nullptr, func_ct, /*access=*/access_type,
91*f6aab3d8Srobert         /*is_virtual=*/is_virtual, /*is_static=*/is_static,
92*f6aab3d8Srobert         /*is_inline=*/false, /*is_explicit=*/false,
93*f6aab3d8Srobert         /*is_attr_used=*/false, /*is_artificial=*/is_artificial);
94061da546Spatrick   }
95*f6aab3d8Srobert };
96*f6aab3d8Srobert } // namespace
97061da546Spatrick 
TranslateUdtKind(const TagRecord & cr)98061da546Spatrick static clang::TagTypeKind TranslateUdtKind(const TagRecord &cr) {
99061da546Spatrick   switch (cr.Kind) {
100061da546Spatrick   case TypeRecordKind::Class:
101061da546Spatrick     return clang::TTK_Class;
102061da546Spatrick   case TypeRecordKind::Struct:
103061da546Spatrick     return clang::TTK_Struct;
104061da546Spatrick   case TypeRecordKind::Union:
105061da546Spatrick     return clang::TTK_Union;
106061da546Spatrick   case TypeRecordKind::Interface:
107061da546Spatrick     return clang::TTK_Interface;
108061da546Spatrick   case TypeRecordKind::Enum:
109061da546Spatrick     return clang::TTK_Enum;
110061da546Spatrick   default:
111061da546Spatrick     lldbassert(false && "Invalid tag record kind!");
112061da546Spatrick     return clang::TTK_Struct;
113061da546Spatrick   }
114061da546Spatrick }
115061da546Spatrick 
IsCVarArgsFunction(llvm::ArrayRef<TypeIndex> args)116061da546Spatrick static bool IsCVarArgsFunction(llvm::ArrayRef<TypeIndex> args) {
117061da546Spatrick   if (args.empty())
118061da546Spatrick     return false;
119061da546Spatrick   return args.back() == TypeIndex::None();
120061da546Spatrick }
121061da546Spatrick 
122061da546Spatrick static bool
AnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node * > scopes)123061da546Spatrick AnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node *> scopes) {
124061da546Spatrick   for (llvm::ms_demangle::Node *n : scopes) {
125061da546Spatrick     auto *idn = static_cast<llvm::ms_demangle::IdentifierNode *>(n);
126061da546Spatrick     if (idn->TemplateParams)
127061da546Spatrick       return true;
128061da546Spatrick   }
129061da546Spatrick   return false;
130061da546Spatrick }
131061da546Spatrick 
132*f6aab3d8Srobert static std::optional<clang::CallingConv>
TranslateCallingConvention(llvm::codeview::CallingConvention conv)133061da546Spatrick TranslateCallingConvention(llvm::codeview::CallingConvention conv) {
134061da546Spatrick   using CC = llvm::codeview::CallingConvention;
135061da546Spatrick   switch (conv) {
136061da546Spatrick 
137061da546Spatrick   case CC::NearC:
138061da546Spatrick   case CC::FarC:
139061da546Spatrick     return clang::CallingConv::CC_C;
140061da546Spatrick   case CC::NearPascal:
141061da546Spatrick   case CC::FarPascal:
142061da546Spatrick     return clang::CallingConv::CC_X86Pascal;
143061da546Spatrick   case CC::NearFast:
144061da546Spatrick   case CC::FarFast:
145061da546Spatrick     return clang::CallingConv::CC_X86FastCall;
146061da546Spatrick   case CC::NearStdCall:
147061da546Spatrick   case CC::FarStdCall:
148061da546Spatrick     return clang::CallingConv::CC_X86StdCall;
149061da546Spatrick   case CC::ThisCall:
150061da546Spatrick     return clang::CallingConv::CC_X86ThisCall;
151061da546Spatrick   case CC::NearVector:
152061da546Spatrick     return clang::CallingConv::CC_X86VectorCall;
153061da546Spatrick   default:
154*f6aab3d8Srobert     return std::nullopt;
155061da546Spatrick   }
156061da546Spatrick }
157061da546Spatrick 
IsAnonymousNamespaceName(llvm::StringRef name)158061da546Spatrick static bool IsAnonymousNamespaceName(llvm::StringRef name) {
159061da546Spatrick   return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
160061da546Spatrick }
161061da546Spatrick 
PdbAstBuilder(TypeSystemClang & clang)162*f6aab3d8Srobert PdbAstBuilder::PdbAstBuilder(TypeSystemClang &clang) : m_clang(clang) {}
163061da546Spatrick 
GetTranslationUnitDecl()164061da546Spatrick lldb_private::CompilerDeclContext PdbAstBuilder::GetTranslationUnitDecl() {
165061da546Spatrick   return ToCompilerDeclContext(*m_clang.GetTranslationUnitDecl());
166061da546Spatrick }
167061da546Spatrick 
168061da546Spatrick std::pair<clang::DeclContext *, std::string>
CreateDeclInfoForType(const TagRecord & record,TypeIndex ti)169061da546Spatrick PdbAstBuilder::CreateDeclInfoForType(const TagRecord &record, TypeIndex ti) {
170*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
171*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
172061da546Spatrick   // FIXME: Move this to GetDeclContextContainingUID.
173061da546Spatrick   if (!record.hasUniqueName())
174061da546Spatrick     return CreateDeclInfoForUndecoratedName(record.Name);
175061da546Spatrick 
176061da546Spatrick   llvm::ms_demangle::Demangler demangler;
177061da546Spatrick   StringView sv(record.UniqueName.begin(), record.UniqueName.size());
178061da546Spatrick   llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
179061da546Spatrick   if (demangler.Error)
180dda28197Spatrick     return {m_clang.GetTranslationUnitDecl(), std::string(record.UniqueName)};
181061da546Spatrick 
182061da546Spatrick   llvm::ms_demangle::IdentifierNode *idn =
183061da546Spatrick       ttn->QualifiedName->getUnqualifiedIdentifier();
184061da546Spatrick   std::string uname = idn->toString(llvm::ms_demangle::OF_NoTagSpecifier);
185061da546Spatrick 
186061da546Spatrick   llvm::ms_demangle::NodeArrayNode *name_components =
187061da546Spatrick       ttn->QualifiedName->Components;
188061da546Spatrick   llvm::ArrayRef<llvm::ms_demangle::Node *> scopes(name_components->Nodes,
189061da546Spatrick                                                    name_components->Count - 1);
190061da546Spatrick 
191061da546Spatrick   clang::DeclContext *context = m_clang.GetTranslationUnitDecl();
192061da546Spatrick 
193061da546Spatrick   // If this type doesn't have a parent type in the debug info, then the best we
194061da546Spatrick   // can do is to say that it's either a series of namespaces (if the scope is
195061da546Spatrick   // non-empty), or the translation unit (if the scope is empty).
196*f6aab3d8Srobert   std::optional<TypeIndex> parent_index = pdb->GetParentType(ti);
197*f6aab3d8Srobert   if (!parent_index) {
198061da546Spatrick     if (scopes.empty())
199061da546Spatrick       return {context, uname};
200061da546Spatrick 
201061da546Spatrick     // If there is no parent in the debug info, but some of the scopes have
202061da546Spatrick     // template params, then this is a case of bad debug info.  See, for
203061da546Spatrick     // example, llvm.org/pr39607.  We don't want to create an ambiguity between
204061da546Spatrick     // a NamespaceDecl and a CXXRecordDecl, so instead we create a class at
205061da546Spatrick     // global scope with the fully qualified name.
206061da546Spatrick     if (AnyScopesHaveTemplateParams(scopes))
207dda28197Spatrick       return {context, std::string(record.Name)};
208061da546Spatrick 
209061da546Spatrick     for (llvm::ms_demangle::Node *scope : scopes) {
210061da546Spatrick       auto *nii = static_cast<llvm::ms_demangle::NamedIdentifierNode *>(scope);
211061da546Spatrick       std::string str = nii->toString();
212061da546Spatrick       context = GetOrCreateNamespaceDecl(str.c_str(), *context);
213061da546Spatrick     }
214061da546Spatrick     return {context, uname};
215061da546Spatrick   }
216061da546Spatrick 
217061da546Spatrick   // Otherwise, all we need to do is get the parent type of this type and
218061da546Spatrick   // recurse into our lazy type creation / AST reconstruction logic to get an
219061da546Spatrick   // LLDB TypeSP for the parent.  This will cause the AST to automatically get
220061da546Spatrick   // the right DeclContext created for any parent.
221*f6aab3d8Srobert   clang::QualType parent_qt = GetOrCreateType(*parent_index);
222*f6aab3d8Srobert   if (parent_qt.isNull())
223*f6aab3d8Srobert     return {nullptr, ""};
224061da546Spatrick 
225061da546Spatrick   context = clang::TagDecl::castToDeclContext(parent_qt->getAsTagDecl());
226061da546Spatrick   return {context, uname};
227061da546Spatrick }
228061da546Spatrick 
isLocalVariableType(SymbolKind K)229061da546Spatrick static bool isLocalVariableType(SymbolKind K) {
230061da546Spatrick   switch (K) {
231061da546Spatrick   case S_REGISTER:
232061da546Spatrick   case S_REGREL32:
233061da546Spatrick   case S_LOCAL:
234061da546Spatrick     return true;
235061da546Spatrick   default:
236061da546Spatrick     break;
237061da546Spatrick   }
238061da546Spatrick   return false;
239061da546Spatrick }
240061da546Spatrick 
GetOrCreateSymbolForId(PdbCompilandSymId id)241061da546Spatrick clang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) {
242*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
243*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
244*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
245*f6aab3d8Srobert   CVSymbol cvs = index.ReadSymbolRecord(id);
246061da546Spatrick 
247061da546Spatrick   if (isLocalVariableType(cvs.kind())) {
248061da546Spatrick     clang::DeclContext *scope = GetParentDeclContext(id);
249*f6aab3d8Srobert     if (!scope)
250*f6aab3d8Srobert       return nullptr;
251061da546Spatrick     clang::Decl *scope_decl = clang::Decl::castFromDeclContext(scope);
252*f6aab3d8Srobert     PdbCompilandSymId scope_id =
253*f6aab3d8Srobert         PdbSymUid(m_decl_to_status[scope_decl].uid).asCompilandSym();
254061da546Spatrick     return GetOrCreateVariableDecl(scope_id, id);
255061da546Spatrick   }
256061da546Spatrick 
257061da546Spatrick   switch (cvs.kind()) {
258061da546Spatrick   case S_GPROC32:
259061da546Spatrick   case S_LPROC32:
260061da546Spatrick     return GetOrCreateFunctionDecl(id);
261061da546Spatrick   case S_GDATA32:
262061da546Spatrick   case S_LDATA32:
263061da546Spatrick   case S_GTHREAD32:
264061da546Spatrick   case S_CONSTANT:
265061da546Spatrick     // global variable
266061da546Spatrick     return nullptr;
267061da546Spatrick   case S_BLOCK32:
268061da546Spatrick     return GetOrCreateBlockDecl(id);
269*f6aab3d8Srobert   case S_INLINESITE:
270*f6aab3d8Srobert     return GetOrCreateInlinedFunctionDecl(id);
271061da546Spatrick   default:
272061da546Spatrick     return nullptr;
273061da546Spatrick   }
274061da546Spatrick }
275061da546Spatrick 
276*f6aab3d8Srobert std::optional<CompilerDecl>
GetOrCreateDeclForUid(PdbSymUid uid)277*f6aab3d8Srobert PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) {
278061da546Spatrick   if (clang::Decl *result = TryGetDecl(uid))
279061da546Spatrick     return ToCompilerDecl(*result);
280061da546Spatrick 
281061da546Spatrick   clang::Decl *result = nullptr;
282061da546Spatrick   switch (uid.kind()) {
283061da546Spatrick   case PdbSymUidKind::CompilandSym:
284061da546Spatrick     result = GetOrCreateSymbolForId(uid.asCompilandSym());
285061da546Spatrick     break;
286061da546Spatrick   case PdbSymUidKind::Type: {
287061da546Spatrick     clang::QualType qt = GetOrCreateType(uid.asTypeSym());
288*f6aab3d8Srobert     if (qt.isNull())
289*f6aab3d8Srobert       return std::nullopt;
290061da546Spatrick     if (auto *tag = qt->getAsTagDecl()) {
291061da546Spatrick       result = tag;
292061da546Spatrick       break;
293061da546Spatrick     }
294*f6aab3d8Srobert     return std::nullopt;
295061da546Spatrick   }
296061da546Spatrick   default:
297*f6aab3d8Srobert     return std::nullopt;
298061da546Spatrick   }
299*f6aab3d8Srobert 
300*f6aab3d8Srobert   if (!result)
301*f6aab3d8Srobert     return std::nullopt;
302061da546Spatrick   m_uid_to_decl[toOpaqueUid(uid)] = result;
303061da546Spatrick   return ToCompilerDecl(*result);
304061da546Spatrick }
305061da546Spatrick 
GetOrCreateDeclContextForUid(PdbSymUid uid)306061da546Spatrick clang::DeclContext *PdbAstBuilder::GetOrCreateDeclContextForUid(PdbSymUid uid) {
307061da546Spatrick   if (uid.kind() == PdbSymUidKind::CompilandSym) {
308061da546Spatrick     if (uid.asCompilandSym().offset == 0)
309061da546Spatrick       return FromCompilerDeclContext(GetTranslationUnitDecl());
310061da546Spatrick   }
311061da546Spatrick   auto option = GetOrCreateDeclForUid(uid);
312061da546Spatrick   if (!option)
313061da546Spatrick     return nullptr;
314*f6aab3d8Srobert   clang::Decl *decl = FromCompilerDecl(*option);
315061da546Spatrick   if (!decl)
316061da546Spatrick     return nullptr;
317061da546Spatrick 
318061da546Spatrick   return clang::Decl::castToDeclContext(decl);
319061da546Spatrick }
320061da546Spatrick 
321061da546Spatrick std::pair<clang::DeclContext *, std::string>
CreateDeclInfoForUndecoratedName(llvm::StringRef name)322061da546Spatrick PdbAstBuilder::CreateDeclInfoForUndecoratedName(llvm::StringRef name) {
323*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
324*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
325*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
326061da546Spatrick   MSVCUndecoratedNameParser parser(name);
327061da546Spatrick   llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
328061da546Spatrick 
329*f6aab3d8Srobert   auto *context = FromCompilerDeclContext(GetTranslationUnitDecl());
330061da546Spatrick 
331061da546Spatrick   llvm::StringRef uname = specs.back().GetBaseName();
332061da546Spatrick   specs = specs.drop_back();
333061da546Spatrick   if (specs.empty())
334dda28197Spatrick     return {context, std::string(name)};
335061da546Spatrick 
336061da546Spatrick   llvm::StringRef scope_name = specs.back().GetFullName();
337061da546Spatrick 
338061da546Spatrick   // It might be a class name, try that first.
339*f6aab3d8Srobert   std::vector<TypeIndex> types = index.tpi().findRecordsByName(scope_name);
340061da546Spatrick   while (!types.empty()) {
341061da546Spatrick     clang::QualType qt = GetOrCreateType(types.back());
342*f6aab3d8Srobert     if (qt.isNull())
343*f6aab3d8Srobert       continue;
344061da546Spatrick     clang::TagDecl *tag = qt->getAsTagDecl();
345061da546Spatrick     if (tag)
346dda28197Spatrick       return {clang::TagDecl::castToDeclContext(tag), std::string(uname)};
347061da546Spatrick     types.pop_back();
348061da546Spatrick   }
349061da546Spatrick 
350061da546Spatrick   // If that fails, treat it as a series of namespaces.
351061da546Spatrick   for (const MSVCUndecoratedNameSpecifier &spec : specs) {
352061da546Spatrick     std::string ns_name = spec.GetBaseName().str();
353061da546Spatrick     context = GetOrCreateNamespaceDecl(ns_name.c_str(), *context);
354061da546Spatrick   }
355dda28197Spatrick   return {context, std::string(uname)};
356061da546Spatrick }
357061da546Spatrick 
GetParentDeclContext(PdbSymUid uid)358061da546Spatrick clang::DeclContext *PdbAstBuilder::GetParentDeclContext(PdbSymUid uid) {
359061da546Spatrick   // We must do this *without* calling GetOrCreate on the current uid, as
360061da546Spatrick   // that would be an infinite recursion.
361*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
362*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
363*f6aab3d8Srobert   PdbIndex& index = pdb->GetIndex();
364061da546Spatrick   switch (uid.kind()) {
365061da546Spatrick   case PdbSymUidKind::CompilandSym: {
366*f6aab3d8Srobert     std::optional<PdbCompilandSymId> scope =
367*f6aab3d8Srobert         pdb->FindSymbolScope(uid.asCompilandSym());
368061da546Spatrick     if (scope)
369061da546Spatrick       return GetOrCreateDeclContextForUid(*scope);
370061da546Spatrick 
371*f6aab3d8Srobert     CVSymbol sym = index.ReadSymbolRecord(uid.asCompilandSym());
372*f6aab3d8Srobert     return CreateDeclInfoForUndecoratedName(getSymbolName(sym)).first;
373061da546Spatrick   }
374061da546Spatrick   case PdbSymUidKind::Type: {
375061da546Spatrick     // It could be a namespace, class, or global.  We don't support nested
376061da546Spatrick     // functions yet.  Anyway, we just need to consult the parent type map.
377061da546Spatrick     PdbTypeSymId type_id = uid.asTypeSym();
378*f6aab3d8Srobert     std::optional<TypeIndex> parent_index = pdb->GetParentType(type_id.index);
379*f6aab3d8Srobert     if (!parent_index)
380061da546Spatrick       return FromCompilerDeclContext(GetTranslationUnitDecl());
381*f6aab3d8Srobert     return GetOrCreateDeclContextForUid(PdbTypeSymId(*parent_index));
382061da546Spatrick   }
383061da546Spatrick   case PdbSymUidKind::FieldListMember:
384061da546Spatrick     // In this case the parent DeclContext is the one for the class that this
385061da546Spatrick     // member is inside of.
386061da546Spatrick     break;
387061da546Spatrick   case PdbSymUidKind::GlobalSym: {
388061da546Spatrick     // If this refers to a compiland symbol, just recurse in with that symbol.
389061da546Spatrick     // The only other possibilities are S_CONSTANT and S_UDT, in which case we
390061da546Spatrick     // need to parse the undecorated name to figure out the scope, then look
391061da546Spatrick     // that up in the TPI stream.  If it's found, it's a type, othewrise it's
392061da546Spatrick     // a series of namespaces.
393061da546Spatrick     // FIXME: do this.
394*f6aab3d8Srobert     CVSymbol global = index.ReadSymbolRecord(uid.asGlobalSym());
395061da546Spatrick     switch (global.kind()) {
396061da546Spatrick     case SymbolKind::S_GDATA32:
397061da546Spatrick     case SymbolKind::S_LDATA32:
398*f6aab3d8Srobert       return CreateDeclInfoForUndecoratedName(getSymbolName(global)).first;;
399061da546Spatrick     case SymbolKind::S_PROCREF:
400061da546Spatrick     case SymbolKind::S_LPROCREF: {
401061da546Spatrick       ProcRefSym ref{global.kind()};
402061da546Spatrick       llvm::cantFail(
403061da546Spatrick           SymbolDeserializer::deserializeAs<ProcRefSym>(global, ref));
404061da546Spatrick       PdbCompilandSymId cu_sym_id{ref.modi(), ref.SymOffset};
405061da546Spatrick       return GetParentDeclContext(cu_sym_id);
406061da546Spatrick     }
407061da546Spatrick     case SymbolKind::S_CONSTANT:
408061da546Spatrick     case SymbolKind::S_UDT:
409061da546Spatrick       return CreateDeclInfoForUndecoratedName(getSymbolName(global)).first;
410061da546Spatrick     default:
411061da546Spatrick       break;
412061da546Spatrick     }
413061da546Spatrick     break;
414061da546Spatrick   }
415061da546Spatrick   default:
416061da546Spatrick     break;
417061da546Spatrick   }
418061da546Spatrick   return FromCompilerDeclContext(GetTranslationUnitDecl());
419061da546Spatrick }
420061da546Spatrick 
CompleteType(clang::QualType qt)421061da546Spatrick bool PdbAstBuilder::CompleteType(clang::QualType qt) {
422*f6aab3d8Srobert   if (qt.isNull())
423*f6aab3d8Srobert     return false;
424061da546Spatrick   clang::TagDecl *tag = qt->getAsTagDecl();
425*f6aab3d8Srobert   if (qt->isArrayType()) {
426*f6aab3d8Srobert     const clang::Type *element_type = qt->getArrayElementTypeNoTypeQual();
427*f6aab3d8Srobert     tag = element_type->getAsTagDecl();
428*f6aab3d8Srobert   }
429061da546Spatrick   if (!tag)
430061da546Spatrick     return false;
431061da546Spatrick 
432061da546Spatrick   return CompleteTagDecl(*tag);
433061da546Spatrick }
434061da546Spatrick 
CompleteTagDecl(clang::TagDecl & tag)435061da546Spatrick bool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) {
436061da546Spatrick   // If this is not in our map, it's an error.
437061da546Spatrick   auto status_iter = m_decl_to_status.find(&tag);
438061da546Spatrick   lldbassert(status_iter != m_decl_to_status.end());
439061da546Spatrick 
440061da546Spatrick   // If it's already complete, just return.
441061da546Spatrick   DeclStatus &status = status_iter->second;
442061da546Spatrick   if (status.resolved)
443061da546Spatrick     return true;
444061da546Spatrick 
445061da546Spatrick   PdbTypeSymId type_id = PdbSymUid(status.uid).asTypeSym();
446*f6aab3d8Srobert   PdbIndex &index = static_cast<SymbolFileNativePDB *>(
447*f6aab3d8Srobert                         m_clang.GetSymbolFile()->GetBackingSymbolFile())
448*f6aab3d8Srobert                         ->GetIndex();
449*f6aab3d8Srobert   lldbassert(IsTagRecord(type_id, index.tpi()));
450061da546Spatrick 
451061da546Spatrick   clang::QualType tag_qt = m_clang.getASTContext().getTypeDeclType(&tag);
452dda28197Spatrick   TypeSystemClang::SetHasExternalStorage(tag_qt.getAsOpaquePtr(), false);
453061da546Spatrick 
454061da546Spatrick   TypeIndex tag_ti = type_id.index;
455*f6aab3d8Srobert   CVType cvt = index.tpi().getType(tag_ti);
456061da546Spatrick   if (cvt.kind() == LF_MODIFIER)
457061da546Spatrick     tag_ti = LookThroughModifierRecord(cvt);
458061da546Spatrick 
459*f6aab3d8Srobert   PdbTypeSymId best_ti = GetBestPossibleDecl(tag_ti, index.tpi());
460*f6aab3d8Srobert   cvt = index.tpi().getType(best_ti.index);
461061da546Spatrick   lldbassert(IsTagRecord(cvt));
462061da546Spatrick 
463061da546Spatrick   if (IsForwardRefUdt(cvt)) {
464061da546Spatrick     // If we can't find a full decl for this forward ref anywhere in the debug
465061da546Spatrick     // info, then we have no way to complete it.
466061da546Spatrick     return false;
467061da546Spatrick   }
468061da546Spatrick 
469061da546Spatrick   TypeIndex field_list_ti = GetFieldListIndex(cvt);
470*f6aab3d8Srobert   CVType field_list_cvt = index.tpi().getType(field_list_ti);
471061da546Spatrick   if (field_list_cvt.kind() != LF_FIELDLIST)
472061da546Spatrick     return false;
473*f6aab3d8Srobert   FieldListRecord field_list;
474*f6aab3d8Srobert   if (llvm::Error error = TypeDeserializer::deserializeAs<FieldListRecord>(
475*f6aab3d8Srobert           field_list_cvt, field_list))
476*f6aab3d8Srobert     llvm::consumeError(std::move(error));
477061da546Spatrick 
478061da546Spatrick   // Visit all members of this class, then perform any finalization necessary
479061da546Spatrick   // to complete the class.
480061da546Spatrick   CompilerType ct = ToCompilerType(tag_qt);
481*f6aab3d8Srobert   UdtRecordCompleter completer(best_ti, ct, tag, *this, index, m_decl_to_status,
482*f6aab3d8Srobert                                m_cxx_record_map);
483*f6aab3d8Srobert   llvm::Error error =
484*f6aab3d8Srobert       llvm::codeview::visitMemberRecordStream(field_list.Data, completer);
485061da546Spatrick   completer.complete();
486061da546Spatrick 
487*f6aab3d8Srobert   m_decl_to_status[&tag].resolved = true;
488*f6aab3d8Srobert   if (error) {
489061da546Spatrick     llvm::consumeError(std::move(error));
490061da546Spatrick     return false;
491061da546Spatrick   }
492*f6aab3d8Srobert   return true;
493*f6aab3d8Srobert }
494061da546Spatrick 
CreateSimpleType(TypeIndex ti)495061da546Spatrick clang::QualType PdbAstBuilder::CreateSimpleType(TypeIndex ti) {
496061da546Spatrick   if (ti == TypeIndex::NullptrT())
497061da546Spatrick     return GetBasicType(lldb::eBasicTypeNullPtr);
498061da546Spatrick 
499061da546Spatrick   if (ti.getSimpleMode() != SimpleTypeMode::Direct) {
500061da546Spatrick     clang::QualType direct_type = GetOrCreateType(ti.makeDirect());
501*f6aab3d8Srobert     if (direct_type.isNull())
502*f6aab3d8Srobert       return {};
503061da546Spatrick     return m_clang.getASTContext().getPointerType(direct_type);
504061da546Spatrick   }
505061da546Spatrick 
506061da546Spatrick   if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated)
507061da546Spatrick     return {};
508061da546Spatrick 
509061da546Spatrick   lldb::BasicType bt = GetCompilerTypeForSimpleKind(ti.getSimpleKind());
510061da546Spatrick   if (bt == lldb::eBasicTypeInvalid)
511061da546Spatrick     return {};
512061da546Spatrick 
513061da546Spatrick   return GetBasicType(bt);
514061da546Spatrick }
515061da546Spatrick 
CreatePointerType(const PointerRecord & pointer)516061da546Spatrick clang::QualType PdbAstBuilder::CreatePointerType(const PointerRecord &pointer) {
517061da546Spatrick   clang::QualType pointee_type = GetOrCreateType(pointer.ReferentType);
518061da546Spatrick 
519061da546Spatrick   // This can happen for pointers to LF_VTSHAPE records, which we shouldn't
520061da546Spatrick   // create in the AST.
521061da546Spatrick   if (pointee_type.isNull())
522061da546Spatrick     return {};
523061da546Spatrick 
524061da546Spatrick   if (pointer.isPointerToMember()) {
525061da546Spatrick     MemberPointerInfo mpi = pointer.getMemberInfo();
526061da546Spatrick     clang::QualType class_type = GetOrCreateType(mpi.ContainingType);
527*f6aab3d8Srobert     if (class_type.isNull())
528*f6aab3d8Srobert       return {};
529*f6aab3d8Srobert     if (clang::TagDecl *tag = class_type->getAsTagDecl()) {
530*f6aab3d8Srobert       clang::MSInheritanceAttr::Spelling spelling;
531*f6aab3d8Srobert       switch (mpi.Representation) {
532*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::SingleInheritanceData:
533*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::
534*f6aab3d8Srobert           SingleInheritanceFunction:
535*f6aab3d8Srobert         spelling =
536*f6aab3d8Srobert             clang::MSInheritanceAttr::Spelling::Keyword_single_inheritance;
537*f6aab3d8Srobert         break;
538*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::
539*f6aab3d8Srobert           MultipleInheritanceData:
540*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::
541*f6aab3d8Srobert           MultipleInheritanceFunction:
542*f6aab3d8Srobert         spelling =
543*f6aab3d8Srobert             clang::MSInheritanceAttr::Spelling::Keyword_multiple_inheritance;
544*f6aab3d8Srobert         break;
545*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::
546*f6aab3d8Srobert           VirtualInheritanceData:
547*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::
548*f6aab3d8Srobert           VirtualInheritanceFunction:
549*f6aab3d8Srobert         spelling =
550*f6aab3d8Srobert             clang::MSInheritanceAttr::Spelling::Keyword_virtual_inheritance;
551*f6aab3d8Srobert         break;
552*f6aab3d8Srobert       case llvm::codeview::PointerToMemberRepresentation::Unknown:
553*f6aab3d8Srobert         spelling =
554*f6aab3d8Srobert             clang::MSInheritanceAttr::Spelling::Keyword_unspecified_inheritance;
555*f6aab3d8Srobert         break;
556*f6aab3d8Srobert       default:
557*f6aab3d8Srobert         spelling = clang::MSInheritanceAttr::Spelling::SpellingNotCalculated;
558*f6aab3d8Srobert         break;
559*f6aab3d8Srobert       }
560*f6aab3d8Srobert       tag->addAttr(clang::MSInheritanceAttr::CreateImplicit(
561*f6aab3d8Srobert           m_clang.getASTContext(), spelling));
562*f6aab3d8Srobert     }
563061da546Spatrick     return m_clang.getASTContext().getMemberPointerType(
564061da546Spatrick         pointee_type, class_type.getTypePtr());
565061da546Spatrick   }
566061da546Spatrick 
567061da546Spatrick   clang::QualType pointer_type;
568061da546Spatrick   if (pointer.getMode() == PointerMode::LValueReference)
569061da546Spatrick     pointer_type = m_clang.getASTContext().getLValueReferenceType(pointee_type);
570061da546Spatrick   else if (pointer.getMode() == PointerMode::RValueReference)
571061da546Spatrick     pointer_type = m_clang.getASTContext().getRValueReferenceType(pointee_type);
572061da546Spatrick   else
573061da546Spatrick     pointer_type = m_clang.getASTContext().getPointerType(pointee_type);
574061da546Spatrick 
575061da546Spatrick   if ((pointer.getOptions() & PointerOptions::Const) != PointerOptions::None)
576061da546Spatrick     pointer_type.addConst();
577061da546Spatrick 
578061da546Spatrick   if ((pointer.getOptions() & PointerOptions::Volatile) != PointerOptions::None)
579061da546Spatrick     pointer_type.addVolatile();
580061da546Spatrick 
581061da546Spatrick   if ((pointer.getOptions() & PointerOptions::Restrict) != PointerOptions::None)
582061da546Spatrick     pointer_type.addRestrict();
583061da546Spatrick 
584061da546Spatrick   return pointer_type;
585061da546Spatrick }
586061da546Spatrick 
587061da546Spatrick clang::QualType
CreateModifierType(const ModifierRecord & modifier)588061da546Spatrick PdbAstBuilder::CreateModifierType(const ModifierRecord &modifier) {
589061da546Spatrick   clang::QualType unmodified_type = GetOrCreateType(modifier.ModifiedType);
590061da546Spatrick   if (unmodified_type.isNull())
591061da546Spatrick     return {};
592061da546Spatrick 
593061da546Spatrick   if ((modifier.Modifiers & ModifierOptions::Const) != ModifierOptions::None)
594061da546Spatrick     unmodified_type.addConst();
595061da546Spatrick   if ((modifier.Modifiers & ModifierOptions::Volatile) != ModifierOptions::None)
596061da546Spatrick     unmodified_type.addVolatile();
597061da546Spatrick 
598061da546Spatrick   return unmodified_type;
599061da546Spatrick }
600061da546Spatrick 
CreateRecordType(PdbTypeSymId id,const TagRecord & record)601061da546Spatrick clang::QualType PdbAstBuilder::CreateRecordType(PdbTypeSymId id,
602061da546Spatrick                                                 const TagRecord &record) {
603061da546Spatrick   clang::DeclContext *context = nullptr;
604061da546Spatrick   std::string uname;
605061da546Spatrick   std::tie(context, uname) = CreateDeclInfoForType(record, id.index);
606*f6aab3d8Srobert   if (!context)
607*f6aab3d8Srobert     return {};
608*f6aab3d8Srobert 
609061da546Spatrick   clang::TagTypeKind ttk = TranslateUdtKind(record);
610061da546Spatrick   lldb::AccessType access =
611061da546Spatrick       (ttk == clang::TTK_Class) ? lldb::eAccessPrivate : lldb::eAccessPublic;
612061da546Spatrick 
613061da546Spatrick   ClangASTMetadata metadata;
614061da546Spatrick   metadata.SetUserID(toOpaqueUid(id));
615061da546Spatrick   metadata.SetIsDynamicCXXType(false);
616061da546Spatrick 
617dda28197Spatrick   CompilerType ct =
618dda28197Spatrick       m_clang.CreateRecordType(context, OptionalClangModuleID(), access, uname,
619dda28197Spatrick                                ttk, lldb::eLanguageTypeC_plus_plus, &metadata);
620061da546Spatrick 
621061da546Spatrick   lldbassert(ct.IsValid());
622061da546Spatrick 
623dda28197Spatrick   TypeSystemClang::StartTagDeclarationDefinition(ct);
624061da546Spatrick 
625061da546Spatrick   // Even if it's possible, don't complete it at this point. Just mark it
626061da546Spatrick   // forward resolved, and if/when LLDB needs the full definition, it can
627061da546Spatrick   // ask us.
628061da546Spatrick   clang::QualType result =
629061da546Spatrick       clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
630061da546Spatrick 
631dda28197Spatrick   TypeSystemClang::SetHasExternalStorage(result.getAsOpaquePtr(), true);
632061da546Spatrick   return result;
633061da546Spatrick }
634061da546Spatrick 
TryGetDecl(PdbSymUid uid) const635061da546Spatrick clang::Decl *PdbAstBuilder::TryGetDecl(PdbSymUid uid) const {
636061da546Spatrick   auto iter = m_uid_to_decl.find(toOpaqueUid(uid));
637061da546Spatrick   if (iter != m_uid_to_decl.end())
638061da546Spatrick     return iter->second;
639061da546Spatrick   return nullptr;
640061da546Spatrick }
641061da546Spatrick 
642061da546Spatrick clang::NamespaceDecl *
GetOrCreateNamespaceDecl(const char * name,clang::DeclContext & context)643061da546Spatrick PdbAstBuilder::GetOrCreateNamespaceDecl(const char *name,
644061da546Spatrick                                         clang::DeclContext &context) {
645061da546Spatrick   return m_clang.GetUniqueNamespaceDeclaration(
646dda28197Spatrick       IsAnonymousNamespaceName(name) ? nullptr : name, &context,
647dda28197Spatrick       OptionalClangModuleID());
648061da546Spatrick }
649061da546Spatrick 
650061da546Spatrick clang::BlockDecl *
GetOrCreateBlockDecl(PdbCompilandSymId block_id)651061da546Spatrick PdbAstBuilder::GetOrCreateBlockDecl(PdbCompilandSymId block_id) {
652061da546Spatrick   if (clang::Decl *decl = TryGetDecl(block_id))
653061da546Spatrick     return llvm::dyn_cast<clang::BlockDecl>(decl);
654061da546Spatrick 
655061da546Spatrick   clang::DeclContext *scope = GetParentDeclContext(block_id);
656061da546Spatrick 
657dda28197Spatrick   clang::BlockDecl *block_decl =
658dda28197Spatrick       m_clang.CreateBlockDeclaration(scope, OptionalClangModuleID());
659061da546Spatrick   m_uid_to_decl.insert({toOpaqueUid(block_id), block_decl});
660061da546Spatrick 
661061da546Spatrick   DeclStatus status;
662061da546Spatrick   status.resolved = true;
663061da546Spatrick   status.uid = toOpaqueUid(block_id);
664061da546Spatrick   m_decl_to_status.insert({block_decl, status});
665061da546Spatrick 
666061da546Spatrick   return block_decl;
667061da546Spatrick }
668061da546Spatrick 
CreateVariableDecl(PdbSymUid uid,CVSymbol sym,clang::DeclContext & scope)669061da546Spatrick clang::VarDecl *PdbAstBuilder::CreateVariableDecl(PdbSymUid uid, CVSymbol sym,
670061da546Spatrick                                                   clang::DeclContext &scope) {
671061da546Spatrick   VariableInfo var_info = GetVariableNameInfo(sym);
672061da546Spatrick   clang::QualType qt = GetOrCreateType(var_info.type);
673*f6aab3d8Srobert   if (qt.isNull())
674*f6aab3d8Srobert     return nullptr;
675061da546Spatrick 
676061da546Spatrick   clang::VarDecl *var_decl = m_clang.CreateVariableDeclaration(
677dda28197Spatrick       &scope, OptionalClangModuleID(), var_info.name.str().c_str(), qt);
678061da546Spatrick 
679061da546Spatrick   m_uid_to_decl[toOpaqueUid(uid)] = var_decl;
680061da546Spatrick   DeclStatus status;
681061da546Spatrick   status.resolved = true;
682061da546Spatrick   status.uid = toOpaqueUid(uid);
683061da546Spatrick   m_decl_to_status.insert({var_decl, status});
684061da546Spatrick   return var_decl;
685061da546Spatrick }
686061da546Spatrick 
687061da546Spatrick clang::VarDecl *
GetOrCreateVariableDecl(PdbCompilandSymId scope_id,PdbCompilandSymId var_id)688061da546Spatrick PdbAstBuilder::GetOrCreateVariableDecl(PdbCompilandSymId scope_id,
689061da546Spatrick                                        PdbCompilandSymId var_id) {
690061da546Spatrick   if (clang::Decl *decl = TryGetDecl(var_id))
691061da546Spatrick     return llvm::dyn_cast<clang::VarDecl>(decl);
692061da546Spatrick 
693061da546Spatrick   clang::DeclContext *scope = GetOrCreateDeclContextForUid(scope_id);
694*f6aab3d8Srobert   if (!scope)
695*f6aab3d8Srobert     return nullptr;
696061da546Spatrick 
697*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
698*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
699*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
700*f6aab3d8Srobert   CVSymbol sym = index.ReadSymbolRecord(var_id);
701061da546Spatrick   return CreateVariableDecl(PdbSymUid(var_id), sym, *scope);
702061da546Spatrick }
703061da546Spatrick 
GetOrCreateVariableDecl(PdbGlobalSymId var_id)704061da546Spatrick clang::VarDecl *PdbAstBuilder::GetOrCreateVariableDecl(PdbGlobalSymId var_id) {
705061da546Spatrick   if (clang::Decl *decl = TryGetDecl(var_id))
706061da546Spatrick     return llvm::dyn_cast<clang::VarDecl>(decl);
707061da546Spatrick 
708*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
709*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
710*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
711*f6aab3d8Srobert   CVSymbol sym = index.ReadSymbolRecord(var_id);
712061da546Spatrick   auto context = FromCompilerDeclContext(GetTranslationUnitDecl());
713061da546Spatrick   return CreateVariableDecl(PdbSymUid(var_id), sym, *context);
714061da546Spatrick }
715061da546Spatrick 
716061da546Spatrick clang::TypedefNameDecl *
GetOrCreateTypedefDecl(PdbGlobalSymId id)717061da546Spatrick PdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) {
718061da546Spatrick   if (clang::Decl *decl = TryGetDecl(id))
719061da546Spatrick     return llvm::dyn_cast<clang::TypedefNameDecl>(decl);
720061da546Spatrick 
721*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
722*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
723*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
724*f6aab3d8Srobert   CVSymbol sym = index.ReadSymbolRecord(id);
725061da546Spatrick   lldbassert(sym.kind() == S_UDT);
726061da546Spatrick   UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
727061da546Spatrick 
728061da546Spatrick   clang::DeclContext *scope = GetParentDeclContext(id);
729061da546Spatrick 
730061da546Spatrick   PdbTypeSymId real_type_id{udt.Type, false};
731061da546Spatrick   clang::QualType qt = GetOrCreateType(real_type_id);
732*f6aab3d8Srobert   if (qt.isNull() || !scope)
733*f6aab3d8Srobert     return nullptr;
734061da546Spatrick 
735dda28197Spatrick   std::string uname = std::string(DropNameScope(udt.Name));
736061da546Spatrick 
737be691f3bSpatrick   CompilerType ct = ToCompilerType(qt).CreateTypedef(
738be691f3bSpatrick       uname.c_str(), ToCompilerDeclContext(*scope), 0);
739061da546Spatrick   clang::TypedefNameDecl *tnd = m_clang.GetAsTypedefDecl(ct);
740061da546Spatrick   DeclStatus status;
741061da546Spatrick   status.resolved = true;
742061da546Spatrick   status.uid = toOpaqueUid(id);
743061da546Spatrick   m_decl_to_status.insert({tnd, status});
744061da546Spatrick   return tnd;
745061da546Spatrick }
746061da546Spatrick 
GetBasicType(lldb::BasicType type)747061da546Spatrick clang::QualType PdbAstBuilder::GetBasicType(lldb::BasicType type) {
748061da546Spatrick   CompilerType ct = m_clang.GetBasicType(type);
749061da546Spatrick   return clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
750061da546Spatrick }
751061da546Spatrick 
CreateType(PdbTypeSymId type)752061da546Spatrick clang::QualType PdbAstBuilder::CreateType(PdbTypeSymId type) {
753061da546Spatrick   if (type.index.isSimple())
754061da546Spatrick     return CreateSimpleType(type.index);
755061da546Spatrick 
756*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
757*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
758*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
759*f6aab3d8Srobert   CVType cvt = index.tpi().getType(type.index);
760061da546Spatrick 
761061da546Spatrick   if (cvt.kind() == LF_MODIFIER) {
762061da546Spatrick     ModifierRecord modifier;
763061da546Spatrick     llvm::cantFail(
764061da546Spatrick         TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
765061da546Spatrick     return CreateModifierType(modifier);
766061da546Spatrick   }
767061da546Spatrick 
768061da546Spatrick   if (cvt.kind() == LF_POINTER) {
769061da546Spatrick     PointerRecord pointer;
770061da546Spatrick     llvm::cantFail(
771061da546Spatrick         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
772061da546Spatrick     return CreatePointerType(pointer);
773061da546Spatrick   }
774061da546Spatrick 
775061da546Spatrick   if (IsTagRecord(cvt)) {
776061da546Spatrick     CVTagRecord tag = CVTagRecord::create(cvt);
777061da546Spatrick     if (tag.kind() == CVTagRecord::Union)
778061da546Spatrick       return CreateRecordType(type.index, tag.asUnion());
779061da546Spatrick     if (tag.kind() == CVTagRecord::Enum)
780061da546Spatrick       return CreateEnumType(type.index, tag.asEnum());
781061da546Spatrick     return CreateRecordType(type.index, tag.asClass());
782061da546Spatrick   }
783061da546Spatrick 
784061da546Spatrick   if (cvt.kind() == LF_ARRAY) {
785061da546Spatrick     ArrayRecord ar;
786061da546Spatrick     llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
787061da546Spatrick     return CreateArrayType(ar);
788061da546Spatrick   }
789061da546Spatrick 
790061da546Spatrick   if (cvt.kind() == LF_PROCEDURE) {
791061da546Spatrick     ProcedureRecord pr;
792061da546Spatrick     llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
793061da546Spatrick     return CreateFunctionType(pr.ArgumentList, pr.ReturnType, pr.CallConv);
794061da546Spatrick   }
795061da546Spatrick 
796061da546Spatrick   if (cvt.kind() == LF_MFUNCTION) {
797061da546Spatrick     MemberFunctionRecord mfr;
798061da546Spatrick     llvm::cantFail(
799061da546Spatrick         TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
800061da546Spatrick     return CreateFunctionType(mfr.ArgumentList, mfr.ReturnType, mfr.CallConv);
801061da546Spatrick   }
802061da546Spatrick 
803061da546Spatrick   return {};
804061da546Spatrick }
805061da546Spatrick 
GetOrCreateType(PdbTypeSymId type)806061da546Spatrick clang::QualType PdbAstBuilder::GetOrCreateType(PdbTypeSymId type) {
807*f6aab3d8Srobert   if (type.index.isNoneType())
808*f6aab3d8Srobert     return {};
809*f6aab3d8Srobert 
810061da546Spatrick   lldb::user_id_t uid = toOpaqueUid(type);
811061da546Spatrick   auto iter = m_uid_to_type.find(uid);
812061da546Spatrick   if (iter != m_uid_to_type.end())
813061da546Spatrick     return iter->second;
814061da546Spatrick 
815*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
816*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
817*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
818*f6aab3d8Srobert   PdbTypeSymId best_type = GetBestPossibleDecl(type, index.tpi());
819061da546Spatrick 
820061da546Spatrick   clang::QualType qt;
821061da546Spatrick   if (best_type.index != type.index) {
822061da546Spatrick     // This is a forward decl.  Call GetOrCreate on the full decl, then map the
823061da546Spatrick     // forward decl id to the full decl QualType.
824061da546Spatrick     clang::QualType qt = GetOrCreateType(best_type);
825*f6aab3d8Srobert     if (qt.isNull())
826*f6aab3d8Srobert       return {};
827061da546Spatrick     m_uid_to_type[toOpaqueUid(type)] = qt;
828061da546Spatrick     return qt;
829061da546Spatrick   }
830061da546Spatrick 
831061da546Spatrick   // This is either a full decl, or a forward decl with no matching full decl
832061da546Spatrick   // in the debug info.
833061da546Spatrick   qt = CreateType(type);
834*f6aab3d8Srobert   if (qt.isNull())
835*f6aab3d8Srobert     return {};
836*f6aab3d8Srobert 
837061da546Spatrick   m_uid_to_type[toOpaqueUid(type)] = qt;
838*f6aab3d8Srobert   if (IsTagRecord(type, index.tpi())) {
839061da546Spatrick     clang::TagDecl *tag = qt->getAsTagDecl();
840061da546Spatrick     lldbassert(m_decl_to_status.count(tag) == 0);
841061da546Spatrick 
842061da546Spatrick     DeclStatus &status = m_decl_to_status[tag];
843061da546Spatrick     status.uid = uid;
844061da546Spatrick     status.resolved = false;
845061da546Spatrick   }
846061da546Spatrick   return qt;
847061da546Spatrick }
848061da546Spatrick 
849061da546Spatrick clang::FunctionDecl *
CreateFunctionDecl(PdbCompilandSymId func_id,llvm::StringRef func_name,TypeIndex func_ti,CompilerType func_ct,uint32_t param_count,clang::StorageClass func_storage,bool is_inline,clang::DeclContext * parent)850*f6aab3d8Srobert PdbAstBuilder::CreateFunctionDecl(PdbCompilandSymId func_id,
851*f6aab3d8Srobert                                   llvm::StringRef func_name, TypeIndex func_ti,
852*f6aab3d8Srobert                                   CompilerType func_ct, uint32_t param_count,
853*f6aab3d8Srobert                                   clang::StorageClass func_storage,
854*f6aab3d8Srobert                                   bool is_inline, clang::DeclContext *parent) {
855*f6aab3d8Srobert   clang::FunctionDecl *function_decl = nullptr;
856*f6aab3d8Srobert   if (parent->isRecord()) {
857*f6aab3d8Srobert     SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
858*f6aab3d8Srobert         m_clang.GetSymbolFile()->GetBackingSymbolFile());
859*f6aab3d8Srobert     PdbIndex &index = pdb->GetIndex();
860*f6aab3d8Srobert     clang::QualType parent_qt = llvm::cast<clang::TypeDecl>(parent)
861*f6aab3d8Srobert                                     ->getTypeForDecl()
862*f6aab3d8Srobert                                     ->getCanonicalTypeInternal();
863*f6aab3d8Srobert     lldb::opaque_compiler_type_t parent_opaque_ty =
864*f6aab3d8Srobert         ToCompilerType(parent_qt).GetOpaqueQualType();
865*f6aab3d8Srobert     // FIXME: Remove this workaround.
866*f6aab3d8Srobert     auto iter = m_cxx_record_map.find(parent_opaque_ty);
867*f6aab3d8Srobert     if (iter != m_cxx_record_map.end()) {
868*f6aab3d8Srobert       if (iter->getSecond().contains({func_name, func_ct})) {
869*f6aab3d8Srobert         return nullptr;
870*f6aab3d8Srobert       }
871*f6aab3d8Srobert     }
872*f6aab3d8Srobert 
873*f6aab3d8Srobert     CVType cvt = index.tpi().getType(func_ti);
874*f6aab3d8Srobert     MemberFunctionRecord func_record(static_cast<TypeRecordKind>(cvt.kind()));
875*f6aab3d8Srobert     llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(
876*f6aab3d8Srobert         cvt, func_record));
877*f6aab3d8Srobert     TypeIndex class_index = func_record.getClassType();
878*f6aab3d8Srobert 
879*f6aab3d8Srobert     CVType parent_cvt = index.tpi().getType(class_index);
880*f6aab3d8Srobert     TagRecord tag_record = CVTagRecord::create(parent_cvt).asTag();
881*f6aab3d8Srobert     // If it's a forward reference, try to get the real TypeIndex.
882*f6aab3d8Srobert     if (tag_record.isForwardRef()) {
883*f6aab3d8Srobert       llvm::Expected<TypeIndex> eti =
884*f6aab3d8Srobert           index.tpi().findFullDeclForForwardRef(class_index);
885*f6aab3d8Srobert       if (eti) {
886*f6aab3d8Srobert         tag_record = CVTagRecord::create(index.tpi().getType(*eti)).asTag();
887*f6aab3d8Srobert       }
888*f6aab3d8Srobert     }
889*f6aab3d8Srobert     if (!tag_record.FieldList.isSimple()) {
890*f6aab3d8Srobert       CVType field_list_cvt = index.tpi().getType(tag_record.FieldList);
891*f6aab3d8Srobert       FieldListRecord field_list;
892*f6aab3d8Srobert       if (llvm::Error error = TypeDeserializer::deserializeAs<FieldListRecord>(
893*f6aab3d8Srobert               field_list_cvt, field_list))
894*f6aab3d8Srobert         llvm::consumeError(std::move(error));
895*f6aab3d8Srobert       CreateMethodDecl process(index, m_clang, func_ti, function_decl,
896*f6aab3d8Srobert                                parent_opaque_ty, func_name, func_ct);
897*f6aab3d8Srobert       if (llvm::Error err = visitMemberRecordStream(field_list.Data, process))
898*f6aab3d8Srobert         llvm::consumeError(std::move(err));
899*f6aab3d8Srobert     }
900*f6aab3d8Srobert 
901*f6aab3d8Srobert     if (!function_decl) {
902*f6aab3d8Srobert       function_decl = m_clang.AddMethodToCXXRecordType(
903*f6aab3d8Srobert           parent_opaque_ty, func_name,
904*f6aab3d8Srobert           /*mangled_name=*/nullptr, func_ct,
905*f6aab3d8Srobert           /*access=*/lldb::AccessType::eAccessPublic,
906*f6aab3d8Srobert           /*is_virtual=*/false, /*is_static=*/false,
907*f6aab3d8Srobert           /*is_inline=*/false, /*is_explicit=*/false,
908*f6aab3d8Srobert           /*is_attr_used=*/false, /*is_artificial=*/false);
909*f6aab3d8Srobert     }
910*f6aab3d8Srobert     m_cxx_record_map[parent_opaque_ty].insert({func_name, func_ct});
911*f6aab3d8Srobert   } else {
912*f6aab3d8Srobert     function_decl = m_clang.CreateFunctionDeclaration(
913*f6aab3d8Srobert         parent, OptionalClangModuleID(), func_name, func_ct, func_storage,
914*f6aab3d8Srobert         is_inline);
915*f6aab3d8Srobert     CreateFunctionParameters(func_id, *function_decl, param_count);
916*f6aab3d8Srobert   }
917*f6aab3d8Srobert   return function_decl;
918*f6aab3d8Srobert }
919*f6aab3d8Srobert 
920*f6aab3d8Srobert clang::FunctionDecl *
GetOrCreateInlinedFunctionDecl(PdbCompilandSymId inlinesite_id)921*f6aab3d8Srobert PdbAstBuilder::GetOrCreateInlinedFunctionDecl(PdbCompilandSymId inlinesite_id) {
922*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
923*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
924*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
925*f6aab3d8Srobert   CompilandIndexItem *cii =
926*f6aab3d8Srobert       index.compilands().GetCompiland(inlinesite_id.modi);
927*f6aab3d8Srobert   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(inlinesite_id.offset);
928*f6aab3d8Srobert   InlineSiteSym inline_site(static_cast<SymbolRecordKind>(sym.kind()));
929*f6aab3d8Srobert   cantFail(SymbolDeserializer::deserializeAs<InlineSiteSym>(sym, inline_site));
930*f6aab3d8Srobert 
931*f6aab3d8Srobert   // Inlinee is the id index to the function id record that is inlined.
932*f6aab3d8Srobert   PdbTypeSymId func_id(inline_site.Inlinee, true);
933*f6aab3d8Srobert   // Look up the function decl by the id index to see if we have created a
934*f6aab3d8Srobert   // function decl for a different inlinesite that refers the same function.
935*f6aab3d8Srobert   if (clang::Decl *decl = TryGetDecl(func_id))
936*f6aab3d8Srobert     return llvm::dyn_cast<clang::FunctionDecl>(decl);
937*f6aab3d8Srobert   clang::FunctionDecl *function_decl =
938*f6aab3d8Srobert       CreateFunctionDeclFromId(func_id, inlinesite_id);
939*f6aab3d8Srobert   if (function_decl == nullptr)
940*f6aab3d8Srobert     return nullptr;
941*f6aab3d8Srobert 
942*f6aab3d8Srobert   // Use inline site id in m_decl_to_status because it's expected to be a
943*f6aab3d8Srobert   // PdbCompilandSymId so that we can parse local variables info after it.
944*f6aab3d8Srobert   uint64_t inlinesite_uid = toOpaqueUid(inlinesite_id);
945*f6aab3d8Srobert   DeclStatus status;
946*f6aab3d8Srobert   status.resolved = true;
947*f6aab3d8Srobert   status.uid = inlinesite_uid;
948*f6aab3d8Srobert   m_decl_to_status.insert({function_decl, status});
949*f6aab3d8Srobert   // Use the index in IPI stream as uid in m_uid_to_decl, because index in IPI
950*f6aab3d8Srobert   // stream are unique and there could be multiple inline sites (different ids)
951*f6aab3d8Srobert   // referring the same inline function. This avoid creating multiple same
952*f6aab3d8Srobert   // inline function delcs.
953*f6aab3d8Srobert   uint64_t func_uid = toOpaqueUid(func_id);
954*f6aab3d8Srobert   lldbassert(m_uid_to_decl.count(func_uid) == 0);
955*f6aab3d8Srobert   m_uid_to_decl[func_uid] = function_decl;
956*f6aab3d8Srobert   return function_decl;
957*f6aab3d8Srobert }
958*f6aab3d8Srobert 
959*f6aab3d8Srobert clang::FunctionDecl *
CreateFunctionDeclFromId(PdbTypeSymId func_tid,PdbCompilandSymId func_sid)960*f6aab3d8Srobert PdbAstBuilder::CreateFunctionDeclFromId(PdbTypeSymId func_tid,
961*f6aab3d8Srobert                                         PdbCompilandSymId func_sid) {
962*f6aab3d8Srobert   lldbassert(func_tid.is_ipi);
963*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
964*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
965*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
966*f6aab3d8Srobert   CVType func_cvt = index.ipi().getType(func_tid.index);
967*f6aab3d8Srobert   llvm::StringRef func_name;
968*f6aab3d8Srobert   TypeIndex func_ti;
969*f6aab3d8Srobert   clang::DeclContext *parent = nullptr;
970*f6aab3d8Srobert   switch (func_cvt.kind()) {
971*f6aab3d8Srobert   case LF_MFUNC_ID: {
972*f6aab3d8Srobert     MemberFuncIdRecord mfr;
973*f6aab3d8Srobert     cantFail(
974*f6aab3d8Srobert         TypeDeserializer::deserializeAs<MemberFuncIdRecord>(func_cvt, mfr));
975*f6aab3d8Srobert     func_name = mfr.getName();
976*f6aab3d8Srobert     func_ti = mfr.getFunctionType();
977*f6aab3d8Srobert     PdbTypeSymId class_type_id(mfr.ClassType, false);
978*f6aab3d8Srobert     parent = GetOrCreateDeclContextForUid(class_type_id);
979*f6aab3d8Srobert     break;
980*f6aab3d8Srobert   }
981*f6aab3d8Srobert   case LF_FUNC_ID: {
982*f6aab3d8Srobert     FuncIdRecord fir;
983*f6aab3d8Srobert     cantFail(TypeDeserializer::deserializeAs<FuncIdRecord>(func_cvt, fir));
984*f6aab3d8Srobert     func_name = fir.getName();
985*f6aab3d8Srobert     func_ti = fir.getFunctionType();
986*f6aab3d8Srobert     parent = FromCompilerDeclContext(GetTranslationUnitDecl());
987*f6aab3d8Srobert     if (!fir.ParentScope.isNoneType()) {
988*f6aab3d8Srobert       CVType parent_cvt = index.ipi().getType(fir.ParentScope);
989*f6aab3d8Srobert       if (parent_cvt.kind() == LF_STRING_ID) {
990*f6aab3d8Srobert         StringIdRecord sir;
991*f6aab3d8Srobert         cantFail(
992*f6aab3d8Srobert             TypeDeserializer::deserializeAs<StringIdRecord>(parent_cvt, sir));
993*f6aab3d8Srobert         parent = GetOrCreateNamespaceDecl(sir.String.data(), *parent);
994*f6aab3d8Srobert       }
995*f6aab3d8Srobert     }
996*f6aab3d8Srobert     break;
997*f6aab3d8Srobert   }
998*f6aab3d8Srobert   default:
999*f6aab3d8Srobert     lldbassert(false && "Invalid function id type!");
1000*f6aab3d8Srobert   }
1001*f6aab3d8Srobert   clang::QualType func_qt = GetOrCreateType(func_ti);
1002*f6aab3d8Srobert   if (func_qt.isNull() || !parent)
1003*f6aab3d8Srobert     return nullptr;
1004*f6aab3d8Srobert   CompilerType func_ct = ToCompilerType(func_qt);
1005*f6aab3d8Srobert   uint32_t param_count =
1006*f6aab3d8Srobert       llvm::cast<clang::FunctionProtoType>(func_qt)->getNumParams();
1007*f6aab3d8Srobert   return CreateFunctionDecl(func_sid, func_name, func_ti, func_ct, param_count,
1008*f6aab3d8Srobert                             clang::SC_None, true, parent);
1009*f6aab3d8Srobert }
1010*f6aab3d8Srobert 
1011*f6aab3d8Srobert clang::FunctionDecl *
GetOrCreateFunctionDecl(PdbCompilandSymId func_id)1012061da546Spatrick PdbAstBuilder::GetOrCreateFunctionDecl(PdbCompilandSymId func_id) {
1013061da546Spatrick   if (clang::Decl *decl = TryGetDecl(func_id))
1014061da546Spatrick     return llvm::dyn_cast<clang::FunctionDecl>(decl);
1015061da546Spatrick 
1016061da546Spatrick   clang::DeclContext *parent = GetParentDeclContext(PdbSymUid(func_id));
1017*f6aab3d8Srobert   if (!parent)
1018*f6aab3d8Srobert     return nullptr;
1019061da546Spatrick   std::string context_name;
1020061da546Spatrick   if (clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(parent)) {
1021061da546Spatrick     context_name = ns->getQualifiedNameAsString();
1022061da546Spatrick   } else if (clang::TagDecl *tag = llvm::dyn_cast<clang::TagDecl>(parent)) {
1023061da546Spatrick     context_name = tag->getQualifiedNameAsString();
1024061da546Spatrick   }
1025061da546Spatrick 
1026*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1027*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1028*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1029*f6aab3d8Srobert   CVSymbol cvs = index.ReadSymbolRecord(func_id);
1030061da546Spatrick   ProcSym proc(static_cast<SymbolRecordKind>(cvs.kind()));
1031061da546Spatrick   llvm::cantFail(SymbolDeserializer::deserializeAs<ProcSym>(cvs, proc));
1032061da546Spatrick 
1033061da546Spatrick   PdbTypeSymId type_id(proc.FunctionType);
1034061da546Spatrick   clang::QualType qt = GetOrCreateType(type_id);
1035061da546Spatrick   if (qt.isNull())
1036061da546Spatrick     return nullptr;
1037061da546Spatrick 
1038061da546Spatrick   clang::StorageClass storage = clang::SC_None;
1039061da546Spatrick   if (proc.Kind == SymbolRecordKind::ProcSym)
1040061da546Spatrick     storage = clang::SC_Static;
1041061da546Spatrick 
1042061da546Spatrick   const clang::FunctionProtoType *func_type =
1043061da546Spatrick       llvm::dyn_cast<clang::FunctionProtoType>(qt);
1044061da546Spatrick 
1045061da546Spatrick   CompilerType func_ct = ToCompilerType(qt);
1046061da546Spatrick 
1047061da546Spatrick   llvm::StringRef proc_name = proc.Name;
1048061da546Spatrick   proc_name.consume_front(context_name);
1049061da546Spatrick   proc_name.consume_front("::");
1050*f6aab3d8Srobert   clang::FunctionDecl *function_decl =
1051*f6aab3d8Srobert       CreateFunctionDecl(func_id, proc_name, proc.FunctionType, func_ct,
1052*f6aab3d8Srobert                          func_type->getNumParams(), storage, false, parent);
1053*f6aab3d8Srobert   if (function_decl == nullptr)
1054*f6aab3d8Srobert     return nullptr;
1055061da546Spatrick 
1056061da546Spatrick   lldbassert(m_uid_to_decl.count(toOpaqueUid(func_id)) == 0);
1057061da546Spatrick   m_uid_to_decl[toOpaqueUid(func_id)] = function_decl;
1058061da546Spatrick   DeclStatus status;
1059061da546Spatrick   status.resolved = true;
1060061da546Spatrick   status.uid = toOpaqueUid(func_id);
1061061da546Spatrick   m_decl_to_status.insert({function_decl, status});
1062061da546Spatrick 
1063061da546Spatrick   return function_decl;
1064061da546Spatrick }
1065061da546Spatrick 
CreateFunctionParameters(PdbCompilandSymId func_id,clang::FunctionDecl & function_decl,uint32_t param_count)1066061da546Spatrick void PdbAstBuilder::CreateFunctionParameters(PdbCompilandSymId func_id,
1067061da546Spatrick                                              clang::FunctionDecl &function_decl,
1068061da546Spatrick                                              uint32_t param_count) {
1069*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1070*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1071*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1072*f6aab3d8Srobert   CompilandIndexItem *cii = index.compilands().GetCompiland(func_id.modi);
1073061da546Spatrick   CVSymbolArray scope =
1074061da546Spatrick       cii->m_debug_stream.getSymbolArrayForScope(func_id.offset);
1075061da546Spatrick 
1076*f6aab3d8Srobert   scope.drop_front();
1077061da546Spatrick   auto begin = scope.begin();
1078061da546Spatrick   auto end = scope.end();
1079061da546Spatrick   std::vector<clang::ParmVarDecl *> params;
1080*f6aab3d8Srobert   for (uint32_t i = 0; i < param_count && begin != end;) {
1081061da546Spatrick     uint32_t record_offset = begin.offset();
1082061da546Spatrick     CVSymbol sym = *begin++;
1083061da546Spatrick 
1084061da546Spatrick     TypeIndex param_type;
1085061da546Spatrick     llvm::StringRef param_name;
1086061da546Spatrick     switch (sym.kind()) {
1087061da546Spatrick     case S_REGREL32: {
1088061da546Spatrick       RegRelativeSym reg(SymbolRecordKind::RegRelativeSym);
1089061da546Spatrick       cantFail(SymbolDeserializer::deserializeAs<RegRelativeSym>(sym, reg));
1090061da546Spatrick       param_type = reg.Type;
1091061da546Spatrick       param_name = reg.Name;
1092061da546Spatrick       break;
1093061da546Spatrick     }
1094061da546Spatrick     case S_REGISTER: {
1095061da546Spatrick       RegisterSym reg(SymbolRecordKind::RegisterSym);
1096061da546Spatrick       cantFail(SymbolDeserializer::deserializeAs<RegisterSym>(sym, reg));
1097061da546Spatrick       param_type = reg.Index;
1098061da546Spatrick       param_name = reg.Name;
1099061da546Spatrick       break;
1100061da546Spatrick     }
1101061da546Spatrick     case S_LOCAL: {
1102061da546Spatrick       LocalSym local(SymbolRecordKind::LocalSym);
1103061da546Spatrick       cantFail(SymbolDeserializer::deserializeAs<LocalSym>(sym, local));
1104061da546Spatrick       if ((local.Flags & LocalSymFlags::IsParameter) == LocalSymFlags::None)
1105061da546Spatrick         continue;
1106061da546Spatrick       param_type = local.Type;
1107061da546Spatrick       param_name = local.Name;
1108061da546Spatrick       break;
1109061da546Spatrick     }
1110061da546Spatrick     case S_BLOCK32:
1111*f6aab3d8Srobert     case S_INLINESITE:
1112*f6aab3d8Srobert     case S_INLINESITE2:
1113*f6aab3d8Srobert       // All parameters should come before the first block/inlinesite.  If that
1114*f6aab3d8Srobert       // isn't the case, then perhaps this is bad debug info that doesn't
1115*f6aab3d8Srobert       // contain information about all parameters.
1116061da546Spatrick       return;
1117061da546Spatrick     default:
1118061da546Spatrick       continue;
1119061da546Spatrick     }
1120061da546Spatrick 
1121061da546Spatrick     PdbCompilandSymId param_uid(func_id.modi, record_offset);
1122061da546Spatrick     clang::QualType qt = GetOrCreateType(param_type);
1123*f6aab3d8Srobert     if (qt.isNull())
1124*f6aab3d8Srobert       return;
1125061da546Spatrick 
1126061da546Spatrick     CompilerType param_type_ct = m_clang.GetType(qt);
1127061da546Spatrick     clang::ParmVarDecl *param = m_clang.CreateParameterDeclaration(
1128dda28197Spatrick         &function_decl, OptionalClangModuleID(), param_name.str().c_str(),
1129dda28197Spatrick         param_type_ct, clang::SC_None, true);
1130061da546Spatrick     lldbassert(m_uid_to_decl.count(toOpaqueUid(param_uid)) == 0);
1131061da546Spatrick 
1132061da546Spatrick     m_uid_to_decl[toOpaqueUid(param_uid)] = param;
1133061da546Spatrick     params.push_back(param);
1134*f6aab3d8Srobert     ++i;
1135061da546Spatrick   }
1136061da546Spatrick 
1137*f6aab3d8Srobert   if (!params.empty() && params.size() == param_count)
1138be691f3bSpatrick     m_clang.SetFunctionParameters(&function_decl, params);
1139061da546Spatrick }
1140061da546Spatrick 
CreateEnumType(PdbTypeSymId id,const EnumRecord & er)1141061da546Spatrick clang::QualType PdbAstBuilder::CreateEnumType(PdbTypeSymId id,
1142061da546Spatrick                                               const EnumRecord &er) {
1143061da546Spatrick   clang::DeclContext *decl_context = nullptr;
1144061da546Spatrick   std::string uname;
1145061da546Spatrick   std::tie(decl_context, uname) = CreateDeclInfoForType(er, id.index);
1146*f6aab3d8Srobert   if (!decl_context)
1147*f6aab3d8Srobert     return {};
1148*f6aab3d8Srobert 
1149061da546Spatrick   clang::QualType underlying_type = GetOrCreateType(er.UnderlyingType);
1150*f6aab3d8Srobert   if (underlying_type.isNull())
1151*f6aab3d8Srobert     return {};
1152061da546Spatrick 
1153061da546Spatrick   Declaration declaration;
1154061da546Spatrick   CompilerType enum_ct = m_clang.CreateEnumerationType(
1155*f6aab3d8Srobert       uname, decl_context, OptionalClangModuleID(), declaration,
1156dda28197Spatrick       ToCompilerType(underlying_type), er.isScoped());
1157061da546Spatrick 
1158dda28197Spatrick   TypeSystemClang::StartTagDeclarationDefinition(enum_ct);
1159dda28197Spatrick   TypeSystemClang::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true);
1160061da546Spatrick 
1161061da546Spatrick   return clang::QualType::getFromOpaquePtr(enum_ct.GetOpaqueQualType());
1162061da546Spatrick }
1163061da546Spatrick 
CreateArrayType(const ArrayRecord & ar)1164061da546Spatrick clang::QualType PdbAstBuilder::CreateArrayType(const ArrayRecord &ar) {
1165061da546Spatrick   clang::QualType element_type = GetOrCreateType(ar.ElementType);
1166061da546Spatrick 
1167*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1168*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1169*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1170*f6aab3d8Srobert   uint64_t element_size = GetSizeOfType({ar.ElementType}, index.tpi());
1171*f6aab3d8Srobert   if (element_type.isNull() || element_size == 0)
1172*f6aab3d8Srobert     return {};
1173*f6aab3d8Srobert   uint64_t element_count = ar.Size / element_size;
1174061da546Spatrick 
1175061da546Spatrick   CompilerType array_ct = m_clang.CreateArrayType(ToCompilerType(element_type),
1176061da546Spatrick                                                   element_count, false);
1177061da546Spatrick   return clang::QualType::getFromOpaquePtr(array_ct.GetOpaqueQualType());
1178061da546Spatrick }
1179061da546Spatrick 
CreateFunctionType(TypeIndex args_type_idx,TypeIndex return_type_idx,llvm::codeview::CallingConvention calling_convention)1180061da546Spatrick clang::QualType PdbAstBuilder::CreateFunctionType(
1181061da546Spatrick     TypeIndex args_type_idx, TypeIndex return_type_idx,
1182061da546Spatrick     llvm::codeview::CallingConvention calling_convention) {
1183*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1184*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1185*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1186*f6aab3d8Srobert   TpiStream &stream = index.tpi();
1187061da546Spatrick   CVType args_cvt = stream.getType(args_type_idx);
1188061da546Spatrick   ArgListRecord args;
1189061da546Spatrick   llvm::cantFail(
1190061da546Spatrick       TypeDeserializer::deserializeAs<ArgListRecord>(args_cvt, args));
1191061da546Spatrick 
1192*f6aab3d8Srobert   llvm::ArrayRef<TypeIndex> arg_indices = llvm::ArrayRef(args.ArgIndices);
1193061da546Spatrick   bool is_variadic = IsCVarArgsFunction(arg_indices);
1194061da546Spatrick   if (is_variadic)
1195061da546Spatrick     arg_indices = arg_indices.drop_back();
1196061da546Spatrick 
1197061da546Spatrick   std::vector<CompilerType> arg_types;
1198061da546Spatrick   arg_types.reserve(arg_indices.size());
1199061da546Spatrick 
1200061da546Spatrick   for (TypeIndex arg_index : arg_indices) {
1201061da546Spatrick     clang::QualType arg_type = GetOrCreateType(arg_index);
1202*f6aab3d8Srobert     if (arg_type.isNull())
1203*f6aab3d8Srobert       continue;
1204061da546Spatrick     arg_types.push_back(ToCompilerType(arg_type));
1205061da546Spatrick   }
1206061da546Spatrick 
1207061da546Spatrick   clang::QualType return_type = GetOrCreateType(return_type_idx);
1208*f6aab3d8Srobert   if (return_type.isNull())
1209*f6aab3d8Srobert     return {};
1210061da546Spatrick 
1211*f6aab3d8Srobert   std::optional<clang::CallingConv> cc =
1212061da546Spatrick       TranslateCallingConvention(calling_convention);
1213061da546Spatrick   if (!cc)
1214061da546Spatrick     return {};
1215061da546Spatrick 
1216061da546Spatrick   CompilerType return_ct = ToCompilerType(return_type);
1217061da546Spatrick   CompilerType func_sig_ast_type = m_clang.CreateFunctionType(
1218061da546Spatrick       return_ct, arg_types.data(), arg_types.size(), is_variadic, 0, *cc);
1219061da546Spatrick 
1220061da546Spatrick   return clang::QualType::getFromOpaquePtr(
1221061da546Spatrick       func_sig_ast_type.GetOpaqueQualType());
1222061da546Spatrick }
1223061da546Spatrick 
isTagDecl(clang::DeclContext & context)1224061da546Spatrick static bool isTagDecl(clang::DeclContext &context) {
1225*f6aab3d8Srobert   return llvm::isa<clang::TagDecl>(&context);
1226061da546Spatrick }
1227061da546Spatrick 
isFunctionDecl(clang::DeclContext & context)1228061da546Spatrick static bool isFunctionDecl(clang::DeclContext &context) {
1229*f6aab3d8Srobert   return llvm::isa<clang::FunctionDecl>(&context);
1230061da546Spatrick }
1231061da546Spatrick 
isBlockDecl(clang::DeclContext & context)1232061da546Spatrick static bool isBlockDecl(clang::DeclContext &context) {
1233*f6aab3d8Srobert   return llvm::isa<clang::BlockDecl>(&context);
1234061da546Spatrick }
1235061da546Spatrick 
ParseNamespace(clang::DeclContext & context)1236*f6aab3d8Srobert void PdbAstBuilder::ParseNamespace(clang::DeclContext &context) {
1237*f6aab3d8Srobert   clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(&context);
1238*f6aab3d8Srobert   if (m_parsed_namespaces.contains(ns))
1239*f6aab3d8Srobert     return;
1240*f6aab3d8Srobert   std::string qname = ns->getQualifiedNameAsString();
1241*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1242*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1243*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1244*f6aab3d8Srobert   TypeIndex ti{index.tpi().TypeIndexBegin()};
1245*f6aab3d8Srobert   for (const CVType &cvt : index.tpi().typeArray()) {
1246061da546Spatrick     PdbTypeSymId tid{ti};
1247061da546Spatrick     ++ti;
1248061da546Spatrick 
1249061da546Spatrick     if (!IsTagRecord(cvt))
1250061da546Spatrick       continue;
1251061da546Spatrick 
1252061da546Spatrick     CVTagRecord tag = CVTagRecord::create(cvt);
1253061da546Spatrick 
1254061da546Spatrick     // Call CreateDeclInfoForType unconditionally so that the namespace info
1255061da546Spatrick     // gets created.  But only call CreateRecordType if the namespace name
1256061da546Spatrick     // matches.
1257061da546Spatrick     clang::DeclContext *context = nullptr;
1258061da546Spatrick     std::string uname;
1259061da546Spatrick     std::tie(context, uname) = CreateDeclInfoForType(tag.asTag(), tid.index);
1260*f6aab3d8Srobert     if (!context || !context->isNamespace())
1261061da546Spatrick       continue;
1262061da546Spatrick 
1263*f6aab3d8Srobert     clang::NamespaceDecl *ns = llvm::cast<clang::NamespaceDecl>(context);
1264*f6aab3d8Srobert     llvm::StringRef ns_name = ns->getName();
1265*f6aab3d8Srobert     if (ns_name.startswith(qname)) {
1266*f6aab3d8Srobert       ns_name = ns_name.drop_front(qname.size());
1267*f6aab3d8Srobert       if (ns_name.startswith("::"))
1268*f6aab3d8Srobert         GetOrCreateType(tid);
1269061da546Spatrick     }
1270061da546Spatrick   }
1271*f6aab3d8Srobert   ParseAllFunctionsAndNonLocalVars();
1272*f6aab3d8Srobert   m_parsed_namespaces.insert(ns);
1273*f6aab3d8Srobert }
1274061da546Spatrick 
ParseAllTypes()1275*f6aab3d8Srobert void PdbAstBuilder::ParseAllTypes() {
1276*f6aab3d8Srobert   llvm::call_once(m_parse_all_types, [this]() {
1277*f6aab3d8Srobert     SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1278*f6aab3d8Srobert         m_clang.GetSymbolFile()->GetBackingSymbolFile());
1279*f6aab3d8Srobert     PdbIndex &index = pdb->GetIndex();
1280*f6aab3d8Srobert     TypeIndex ti{index.tpi().TypeIndexBegin()};
1281*f6aab3d8Srobert     for (const CVType &cvt : index.tpi().typeArray()) {
1282*f6aab3d8Srobert       PdbTypeSymId tid{ti};
1283*f6aab3d8Srobert       ++ti;
1284*f6aab3d8Srobert 
1285*f6aab3d8Srobert       if (!IsTagRecord(cvt))
1286*f6aab3d8Srobert         continue;
1287*f6aab3d8Srobert 
1288*f6aab3d8Srobert       GetOrCreateType(tid);
1289*f6aab3d8Srobert     }
1290*f6aab3d8Srobert   });
1291*f6aab3d8Srobert }
1292*f6aab3d8Srobert 
ParseAllFunctionsAndNonLocalVars()1293*f6aab3d8Srobert void PdbAstBuilder::ParseAllFunctionsAndNonLocalVars() {
1294*f6aab3d8Srobert   llvm::call_once(m_parse_functions_and_non_local_vars, [this]() {
1295*f6aab3d8Srobert     SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1296*f6aab3d8Srobert         m_clang.GetSymbolFile()->GetBackingSymbolFile());
1297*f6aab3d8Srobert     PdbIndex &index = pdb->GetIndex();
1298*f6aab3d8Srobert     uint32_t module_count = index.dbi().modules().getModuleCount();
1299061da546Spatrick     for (uint16_t modi = 0; modi < module_count; ++modi) {
1300*f6aab3d8Srobert       CompilandIndexItem &cii = index.compilands().GetOrCreateCompiland(modi);
1301061da546Spatrick       const CVSymbolArray &symbols = cii.m_debug_stream.getSymbolArray();
1302061da546Spatrick       auto iter = symbols.begin();
1303061da546Spatrick       while (iter != symbols.end()) {
1304061da546Spatrick         PdbCompilandSymId sym_id{modi, iter.offset()};
1305061da546Spatrick 
1306061da546Spatrick         switch (iter->kind()) {
1307061da546Spatrick         case S_GPROC32:
1308061da546Spatrick         case S_LPROC32:
1309061da546Spatrick           GetOrCreateFunctionDecl(sym_id);
1310061da546Spatrick           iter = symbols.at(getScopeEndOffset(*iter));
1311061da546Spatrick           break;
1312061da546Spatrick         case S_GDATA32:
1313061da546Spatrick         case S_GTHREAD32:
1314061da546Spatrick         case S_LDATA32:
1315061da546Spatrick         case S_LTHREAD32:
1316061da546Spatrick           GetOrCreateVariableDecl(PdbCompilandSymId(modi, 0), sym_id);
1317061da546Spatrick           ++iter;
1318061da546Spatrick           break;
1319061da546Spatrick         default:
1320061da546Spatrick           ++iter;
1321061da546Spatrick           continue;
1322061da546Spatrick         }
1323061da546Spatrick       }
1324061da546Spatrick     }
1325*f6aab3d8Srobert   });
1326061da546Spatrick }
1327061da546Spatrick 
skipFunctionParameters(clang::Decl & decl,const CVSymbolArray & symbols)1328061da546Spatrick static CVSymbolArray skipFunctionParameters(clang::Decl &decl,
1329061da546Spatrick                                             const CVSymbolArray &symbols) {
1330061da546Spatrick   clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>(&decl);
1331061da546Spatrick   if (!func_decl)
1332061da546Spatrick     return symbols;
1333061da546Spatrick   unsigned int params = func_decl->getNumParams();
1334061da546Spatrick   if (params == 0)
1335061da546Spatrick     return symbols;
1336061da546Spatrick 
1337061da546Spatrick   CVSymbolArray result = symbols;
1338061da546Spatrick 
1339061da546Spatrick   while (!result.empty()) {
1340061da546Spatrick     if (params == 0)
1341061da546Spatrick       return result;
1342061da546Spatrick 
1343061da546Spatrick     CVSymbol sym = *result.begin();
1344061da546Spatrick     result.drop_front();
1345061da546Spatrick 
1346061da546Spatrick     if (!isLocalVariableType(sym.kind()))
1347061da546Spatrick       continue;
1348061da546Spatrick 
1349061da546Spatrick     --params;
1350061da546Spatrick   }
1351061da546Spatrick   return result;
1352061da546Spatrick }
1353061da546Spatrick 
ParseBlockChildren(PdbCompilandSymId block_id)1354061da546Spatrick void PdbAstBuilder::ParseBlockChildren(PdbCompilandSymId block_id) {
1355*f6aab3d8Srobert   SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>(
1356*f6aab3d8Srobert       m_clang.GetSymbolFile()->GetBackingSymbolFile());
1357*f6aab3d8Srobert   PdbIndex &index = pdb->GetIndex();
1358*f6aab3d8Srobert   CVSymbol sym = index.ReadSymbolRecord(block_id);
1359061da546Spatrick   lldbassert(sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32 ||
1360*f6aab3d8Srobert              sym.kind() == S_BLOCK32 || sym.kind() == S_INLINESITE);
1361061da546Spatrick   CompilandIndexItem &cii =
1362*f6aab3d8Srobert       index.compilands().GetOrCreateCompiland(block_id.modi);
1363061da546Spatrick   CVSymbolArray symbols =
1364061da546Spatrick       cii.m_debug_stream.getSymbolArrayForScope(block_id.offset);
1365061da546Spatrick 
1366061da546Spatrick   // Function parameters should already have been created when the function was
1367061da546Spatrick   // parsed.
1368061da546Spatrick   if (sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32)
1369061da546Spatrick     symbols =
1370061da546Spatrick         skipFunctionParameters(*m_uid_to_decl[toOpaqueUid(block_id)], symbols);
1371061da546Spatrick 
1372*f6aab3d8Srobert   symbols.drop_front();
1373061da546Spatrick   auto begin = symbols.begin();
1374061da546Spatrick   while (begin != symbols.end()) {
1375061da546Spatrick     PdbCompilandSymId child_sym_id(block_id.modi, begin.offset());
1376061da546Spatrick     GetOrCreateSymbolForId(child_sym_id);
1377*f6aab3d8Srobert     if (begin->kind() == S_BLOCK32 || begin->kind() == S_INLINESITE) {
1378061da546Spatrick       ParseBlockChildren(child_sym_id);
1379061da546Spatrick       begin = symbols.at(getScopeEndOffset(*begin));
1380061da546Spatrick     }
1381061da546Spatrick     ++begin;
1382061da546Spatrick   }
1383061da546Spatrick }
1384061da546Spatrick 
ParseDeclsForSimpleContext(clang::DeclContext & context)1385061da546Spatrick void PdbAstBuilder::ParseDeclsForSimpleContext(clang::DeclContext &context) {
1386061da546Spatrick 
1387061da546Spatrick   clang::Decl *decl = clang::Decl::castFromDeclContext(&context);
1388061da546Spatrick   lldbassert(decl);
1389061da546Spatrick 
1390061da546Spatrick   auto iter = m_decl_to_status.find(decl);
1391061da546Spatrick   lldbassert(iter != m_decl_to_status.end());
1392061da546Spatrick 
1393061da546Spatrick   if (auto *tag = llvm::dyn_cast<clang::TagDecl>(&context)) {
1394061da546Spatrick     CompleteTagDecl(*tag);
1395061da546Spatrick     return;
1396061da546Spatrick   }
1397061da546Spatrick 
1398061da546Spatrick   if (isFunctionDecl(context) || isBlockDecl(context)) {
1399061da546Spatrick     PdbCompilandSymId block_id = PdbSymUid(iter->second.uid).asCompilandSym();
1400061da546Spatrick     ParseBlockChildren(block_id);
1401061da546Spatrick   }
1402061da546Spatrick }
1403061da546Spatrick 
ParseDeclsForContext(clang::DeclContext & context)1404061da546Spatrick void PdbAstBuilder::ParseDeclsForContext(clang::DeclContext &context) {
1405061da546Spatrick   // Namespaces aren't explicitly represented in the debug info, and the only
1406061da546Spatrick   // way to parse them is to parse all type info, demangling every single type
1407061da546Spatrick   // and trying to reconstruct the DeclContext hierarchy this way.  Since this
1408061da546Spatrick   // is an expensive operation, we have to special case it so that we do other
1409061da546Spatrick   // work (such as parsing the items that appear within the namespaces) at the
1410061da546Spatrick   // same time.
1411061da546Spatrick   if (context.isTranslationUnit()) {
1412*f6aab3d8Srobert     ParseAllTypes();
1413*f6aab3d8Srobert     ParseAllFunctionsAndNonLocalVars();
1414061da546Spatrick     return;
1415061da546Spatrick   }
1416061da546Spatrick 
1417061da546Spatrick   if (context.isNamespace()) {
1418*f6aab3d8Srobert     ParseNamespace(context);
1419061da546Spatrick     return;
1420061da546Spatrick   }
1421061da546Spatrick 
1422061da546Spatrick   if (isTagDecl(context) || isFunctionDecl(context) || isBlockDecl(context)) {
1423061da546Spatrick     ParseDeclsForSimpleContext(context);
1424061da546Spatrick     return;
1425061da546Spatrick   }
1426061da546Spatrick }
1427061da546Spatrick 
ToCompilerDecl(clang::Decl & decl)1428061da546Spatrick CompilerDecl PdbAstBuilder::ToCompilerDecl(clang::Decl &decl) {
1429dda28197Spatrick   return m_clang.GetCompilerDecl(&decl);
1430061da546Spatrick }
1431061da546Spatrick 
ToCompilerType(clang::QualType qt)1432061da546Spatrick CompilerType PdbAstBuilder::ToCompilerType(clang::QualType qt) {
1433*f6aab3d8Srobert   return {m_clang.weak_from_this(), qt.getAsOpaquePtr()};
1434061da546Spatrick }
1435061da546Spatrick 
1436061da546Spatrick CompilerDeclContext
ToCompilerDeclContext(clang::DeclContext & context)1437061da546Spatrick PdbAstBuilder::ToCompilerDeclContext(clang::DeclContext &context) {
1438061da546Spatrick   return m_clang.CreateDeclContext(&context);
1439061da546Spatrick }
1440061da546Spatrick 
FromCompilerDecl(CompilerDecl decl)1441061da546Spatrick clang::Decl * PdbAstBuilder::FromCompilerDecl(CompilerDecl decl) {
1442dda28197Spatrick   return ClangUtil::GetDecl(decl);
1443061da546Spatrick }
1444061da546Spatrick 
1445061da546Spatrick clang::DeclContext *
FromCompilerDeclContext(CompilerDeclContext context)1446061da546Spatrick PdbAstBuilder::FromCompilerDeclContext(CompilerDeclContext context) {
1447061da546Spatrick   return static_cast<clang::DeclContext *>(context.GetOpaqueDeclContext());
1448061da546Spatrick }
1449061da546Spatrick 
Dump(Stream & stream)1450*f6aab3d8Srobert void PdbAstBuilder::Dump(Stream &stream) {
1451*f6aab3d8Srobert   m_clang.Dump(stream.AsRawOstream());
1452*f6aab3d8Srobert }
1453