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