PdbAstBuilder.cpp revision 353358
153642Sguido#include "PdbAstBuilder.h" 2145522Sdarrenr 353642Sguido#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h" 480482Sdarrenr#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h" 553642Sguido#include "llvm/DebugInfo/CodeView/RecordName.h" 653642Sguido#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h" 757126Sguido#include "llvm/DebugInfo/CodeView/SymbolRecord.h" 8172776Sdarrenr#include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h" 953642Sguido#include "llvm/DebugInfo/CodeView/TypeDeserializer.h" 1053642Sguido#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h" 1153642Sguido#include "llvm/DebugInfo/PDB/Native/DbiStream.h" 1253642Sguido#include "llvm/DebugInfo/PDB/Native/PublicsStream.h" 1353642Sguido#include "llvm/DebugInfo/PDB/Native/SymbolStream.h" 1453642Sguido#include "llvm/DebugInfo/PDB/Native/TpiStream.h" 1553642Sguido#include "llvm/Demangle/MicrosoftDemangle.h" 1653642Sguido 1753642Sguido#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h" 1853642Sguido#include "lldb/Core/Module.h" 1953642Sguido#include "lldb/Symbol/ClangASTContext.h" 2053642Sguido#include "lldb/Symbol/ClangExternalASTSourceCommon.h" 2153642Sguido#include "lldb/Symbol/ClangUtil.h" 2253642Sguido#include "lldb/Symbol/ObjectFile.h" 2353642Sguido#include "lldb/Utility/LLDBAssert.h" 2453642Sguido 2553642Sguido#include "PdbUtil.h" 2653642Sguido#include "UdtRecordCompleter.h" 2753642Sguido 2853642Sguidousing namespace lldb_private; 2953642Sguidousing namespace lldb_private::npdb; 3053642Sguidousing namespace llvm::codeview; 3153642Sguidousing namespace llvm::pdb; 3253642Sguido 3353642Sguidostatic llvm::Optional<PdbCompilandSymId> FindSymbolScope(PdbIndex &index, 3453642Sguido PdbCompilandSymId id) { 35145522Sdarrenr CVSymbol sym = index.ReadSymbolRecord(id); 36145522Sdarrenr if (symbolOpensScope(sym.kind())) { 37145522Sdarrenr // If this exact symbol opens a scope, we can just directly access its 38173181Sdarrenr // parent. 39145522Sdarrenr id.offset = getScopeParentOffset(sym); 40145522Sdarrenr // Global symbols have parent offset of 0. Return llvm::None to indicate 41145522Sdarrenr // this. 42145522Sdarrenr if (id.offset == 0) 43145522Sdarrenr return llvm::None; 44145522Sdarrenr return id; 45145522Sdarrenr } 46145522Sdarrenr 47145522Sdarrenr // Otherwise we need to start at the beginning and iterate forward until we 48145522Sdarrenr // reach (or pass) this particular symbol 49145522Sdarrenr CompilandIndexItem &cii = index.compilands().GetOrCreateCompiland(id.modi); 50145522Sdarrenr const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray(); 51145522Sdarrenr 52145522Sdarrenr auto begin = syms.begin(); 53145522Sdarrenr auto end = syms.at(id.offset); 54145522Sdarrenr std::vector<PdbCompilandSymId> scope_stack; 55145522Sdarrenr 56145522Sdarrenr while (begin != end) { 57145522Sdarrenr if (id.offset == begin.offset()) { 58145522Sdarrenr // We have a match! Return the top of the stack 59145522Sdarrenr if (scope_stack.empty()) 60145522Sdarrenr return llvm::None; 61145522Sdarrenr return scope_stack.back(); 62145522Sdarrenr } 63145522Sdarrenr if (begin.offset() > id.offset) { 64145522Sdarrenr // We passed it. We couldn't even find this symbol record. 65145522Sdarrenr lldbassert(false && "Invalid compiland symbol id!"); 66145522Sdarrenr return llvm::None; 67145522Sdarrenr } 68145522Sdarrenr 69145522Sdarrenr // We haven't found the symbol yet. Check if we need to open or close the 70145522Sdarrenr // scope stack. 7153642Sguido if (symbolOpensScope(begin->kind())) { 72145522Sdarrenr // We can use the end offset of the scope to determine whether or not 73145522Sdarrenr // we can just outright skip this entire scope. 7453642Sguido uint32_t scope_end = getScopeEndOffset(*begin); 7553642Sguido if (scope_end < id.modi) { 7653642Sguido begin = syms.at(scope_end); 7753642Sguido } else { 7853642Sguido // The symbol we're looking for is somewhere in this scope. 7953642Sguido scope_stack.emplace_back(id.modi, begin.offset()); 80145522Sdarrenr } 81145522Sdarrenr } else if (symbolEndsScope(begin->kind())) { 8292685Sdarrenr scope_stack.pop_back(); 8392685Sdarrenr } 8492685Sdarrenr ++begin; 8592685Sdarrenr } 8692685Sdarrenr 8792685Sdarrenr return llvm::None; 8892685Sdarrenr} 8992685Sdarrenr 9092685Sdarrenrstatic clang::TagTypeKind TranslateUdtKind(const TagRecord &cr) { 9192685Sdarrenr switch (cr.Kind) { 92145522Sdarrenr case TypeRecordKind::Class: 93145522Sdarrenr return clang::TTK_Class; 94145522Sdarrenr case TypeRecordKind::Struct: 95145522Sdarrenr return clang::TTK_Struct; 96145522Sdarrenr case TypeRecordKind::Union: 97145522Sdarrenr return clang::TTK_Union; 9853642Sguido case TypeRecordKind::Interface: 9953642Sguido return clang::TTK_Interface; 10053642Sguido case TypeRecordKind::Enum: 10153642Sguido return clang::TTK_Enum; 10253642Sguido default: 10353642Sguido lldbassert(false && "Invalid tag record kind!"); 10453642Sguido return clang::TTK_Struct; 10553642Sguido } 10653642Sguido} 10753642Sguido 10853642Sguidostatic bool IsCVarArgsFunction(llvm::ArrayRef<TypeIndex> args) { 10953642Sguido if (args.empty()) 11053642Sguido return false; 11153642Sguido return args.back() == TypeIndex::None(); 11292685Sdarrenr} 11392685Sdarrenr 11492685Sdarrenrstatic bool 115145522SdarrenrAnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node *> scopes) { 116145522Sdarrenr for (llvm::ms_demangle::Node *n : scopes) { 117145522Sdarrenr auto *idn = static_cast<llvm::ms_demangle::IdentifierNode *>(n); 118145522Sdarrenr if (idn->TemplateParams) 119145522Sdarrenr return true; 120145522Sdarrenr } 121145522Sdarrenr return false; 12292685Sdarrenr} 123145522Sdarrenr 124145522Sdarrenrstatic ClangASTContext &GetClangASTContext(ObjectFile &obj) { 125145522Sdarrenr TypeSystem *ts = 126145522Sdarrenr obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); 127145522Sdarrenr lldbassert(ts); 128145522Sdarrenr return static_cast<ClangASTContext &>(*ts); 12992685Sdarrenr} 13092685Sdarrenr 131145522Sdarrenrstatic llvm::Optional<clang::CallingConv> 132145522SdarrenrTranslateCallingConvention(llvm::codeview::CallingConvention conv) { 133145522Sdarrenr using CC = llvm::codeview::CallingConvention; 134145522Sdarrenr switch (conv) { 135145522Sdarrenr 136145522Sdarrenr case CC::NearC: 137145522Sdarrenr case CC::FarC: 138145522Sdarrenr return clang::CallingConv::CC_C; 139145522Sdarrenr case CC::NearPascal: 14053642Sguido case CC::FarPascal: 14153642Sguido return clang::CallingConv::CC_X86Pascal; 14253642Sguido case CC::NearFast: 143153084Sru case CC::FarFast: 144145522Sdarrenr return clang::CallingConv::CC_X86FastCall; 145145522Sdarrenr case CC::NearStdCall: 146145522Sdarrenr case CC::FarStdCall: 147145522Sdarrenr return clang::CallingConv::CC_X86StdCall; 148145522Sdarrenr case CC::ThisCall: 14953642Sguido return clang::CallingConv::CC_X86ThisCall; 15053642Sguido case CC::NearVector: 15153642Sguido return clang::CallingConv::CC_X86VectorCall; 152145522Sdarrenr default: 153145522Sdarrenr return llvm::None; 154145522Sdarrenr } 155145522Sdarrenr} 156145522Sdarrenr 157153084Srustatic llvm::Optional<CVTagRecord> 158145522SdarrenrGetNestedTagDefinition(const NestedTypeRecord &Record, 159145522Sdarrenr const CVTagRecord &parent, TpiStream &tpi) { 160145522Sdarrenr // An LF_NESTTYPE is essentially a nested typedef / using declaration, but it 161145522Sdarrenr // is also used to indicate the primary definition of a nested class. That is 162145522Sdarrenr // to say, if you have: 163145522Sdarrenr // struct A { 16453642Sguido // struct B {}; 16553642Sguido // using C = B; 16653642Sguido // }; 16753642Sguido // Then in the debug info, this will appear as: 16853642Sguido // LF_STRUCTURE `A::B` [type index = N] 169145522Sdarrenr // LF_STRUCTURE `A` 170145522Sdarrenr // LF_NESTTYPE [name = `B`, index = N] 171145522Sdarrenr // LF_NESTTYPE [name = `C`, index = N] 172172776Sdarrenr // In order to accurately reconstruct the decl context hierarchy, we need to 173172776Sdarrenr // know which ones are actual definitions and which ones are just aliases. 174172776Sdarrenr 175172776Sdarrenr // If it's a simple type, then this is something like `using foo = int`. 176172776Sdarrenr if (Record.Type.isSimple()) 177145522Sdarrenr return llvm::None; 178145522Sdarrenr 179145522Sdarrenr CVType cvt = tpi.getType(Record.Type); 18053642Sguido 18153642Sguido if (!IsTagRecord(cvt)) 182145522Sdarrenr return llvm::None; 183153084Sru 184145522Sdarrenr // If it's an inner definition, then treat whatever name we have here as a 185145522Sdarrenr // single component of a mangled name. So we can inject it into the parent's 18660857Sdarrenr // mangled name to see if it matches. 18755929Sguido CVTagRecord child = CVTagRecord::create(cvt); 18860857Sdarrenr std::string qname = parent.asTag().getUniqueName(); 18960857Sdarrenr if (qname.size() < 4 || child.asTag().getUniqueName().size() < 4) 19060857Sdarrenr return llvm::None; 19160857Sdarrenr 192145522Sdarrenr // qname[3] is the tag type identifier (struct, class, union, etc). Since the 193145522Sdarrenr // inner tag type is not necessarily the same as the outer tag type, re-write 194145522Sdarrenr // it to match the inner tag type. 195145522Sdarrenr qname[3] = child.asTag().getUniqueName()[3]; 196145522Sdarrenr std::string piece; 197145522Sdarrenr if (qname[3] == 'W') 198153084Sru piece = "4"; 199145522Sdarrenr piece += Record.Name; 200145522Sdarrenr piece.push_back('@'); 201145522Sdarrenr qname.insert(4, std::move(piece)); 202145522Sdarrenr if (qname != child.asTag().UniqueName) 20355929Sguido return llvm::None; 204145522Sdarrenr 20580482Sdarrenr return std::move(child); 206145522Sdarrenr} 207180778Sdarrenr 208180778Sdarrenrstatic bool IsAnonymousNamespaceName(llvm::StringRef name) { 209145522Sdarrenr return name == "`anonymous namespace'" || name == "`anonymous-namespace'"; 210145522Sdarrenr} 211172776Sdarrenr 212172776SdarrenrPdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index) 213172776Sdarrenr : m_index(index), m_clang(GetClangASTContext(obj)) { 214172776Sdarrenr BuildParentMap(); 215172776Sdarrenr} 216172776Sdarrenr 217172776Sdarrenrlldb_private::CompilerDeclContext PdbAstBuilder::GetTranslationUnitDecl() { 218172776Sdarrenr return ToCompilerDeclContext(*m_clang.GetTranslationUnitDecl()); 219172776Sdarrenr} 220172776Sdarrenr 221172776Sdarrenrstd::pair<clang::DeclContext *, std::string> 222172776SdarrenrPdbAstBuilder::CreateDeclInfoForType(const TagRecord &record, TypeIndex ti) { 223172776Sdarrenr // FIXME: Move this to GetDeclContextContainingUID. 224172776Sdarrenr if (!record.hasUniqueName()) 225172776Sdarrenr return CreateDeclInfoForUndecoratedName(record.Name); 226172776Sdarrenr 227172776Sdarrenr llvm::ms_demangle::Demangler demangler; 228172776Sdarrenr StringView sv(record.UniqueName.begin(), record.UniqueName.size()); 229172776Sdarrenr llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv); 230172776Sdarrenr if (demangler.Error) 231172776Sdarrenr return {m_clang.GetTranslationUnitDecl(), record.UniqueName}; 232172776Sdarrenr 233172776Sdarrenr llvm::ms_demangle::IdentifierNode *idn = 234145522Sdarrenr ttn->QualifiedName->getUnqualifiedIdentifier(); 235145522Sdarrenr std::string uname = idn->toString(llvm::ms_demangle::OF_NoTagSpecifier); 236145522Sdarrenr 237145522Sdarrenr llvm::ms_demangle::NodeArrayNode *name_components = 238145522Sdarrenr ttn->QualifiedName->Components; 239145522Sdarrenr llvm::ArrayRef<llvm::ms_demangle::Node *> scopes(name_components->Nodes, 240145522Sdarrenr name_components->Count - 1); 241145522Sdarrenr 242145522Sdarrenr clang::DeclContext *context = m_clang.GetTranslationUnitDecl(); 243145522Sdarrenr 244145522Sdarrenr // If this type doesn't have a parent type in the debug info, then the best we 245145522Sdarrenr // can do is to say that it's either a series of namespaces (if the scope is 246145522Sdarrenr // non-empty), or the translation unit (if the scope is empty). 247145522Sdarrenr auto parent_iter = m_parent_types.find(ti); 248145522Sdarrenr if (parent_iter == m_parent_types.end()) { 249145522Sdarrenr if (scopes.empty()) 250145522Sdarrenr return {context, uname}; 251145522Sdarrenr 252145522Sdarrenr // If there is no parent in the debug info, but some of the scopes have 253145522Sdarrenr // template params, then this is a case of bad debug info. See, for 254145522Sdarrenr // example, llvm.org/pr39607. We don't want to create an ambiguity between 255145522Sdarrenr // a NamespaceDecl and a CXXRecordDecl, so instead we create a class at 256145522Sdarrenr // global scope with the fully qualified name. 257145522Sdarrenr if (AnyScopesHaveTemplateParams(scopes)) 258145522Sdarrenr return {context, record.Name}; 259145522Sdarrenr 260145522Sdarrenr for (llvm::ms_demangle::Node *scope : scopes) { 261145522Sdarrenr auto *nii = static_cast<llvm::ms_demangle::NamedIdentifierNode *>(scope); 262145522Sdarrenr std::string str = nii->toString(); 263145522Sdarrenr context = GetOrCreateNamespaceDecl(str.c_str(), *context); 264145522Sdarrenr } 265145522Sdarrenr return {context, uname}; 266145522Sdarrenr } 267145522Sdarrenr 268145522Sdarrenr // Otherwise, all we need to do is get the parent type of this type and 269170268Sdarrenr // recurse into our lazy type creation / AST reconstruction logic to get an 270170268Sdarrenr // LLDB TypeSP for the parent. This will cause the AST to automatically get 271145522Sdarrenr // the right DeclContext created for any parent. 272145522Sdarrenr clang::QualType parent_qt = GetOrCreateType(parent_iter->second); 273145522Sdarrenr 274170268Sdarrenr context = clang::TagDecl::castToDeclContext(parent_qt->getAsTagDecl()); 275145522Sdarrenr return {context, uname}; 276145522Sdarrenr} 277145522Sdarrenr 278145522Sdarrenrvoid PdbAstBuilder::BuildParentMap() { 279145522Sdarrenr LazyRandomTypeCollection &types = m_index.tpi().typeCollection(); 280145522Sdarrenr 281145522Sdarrenr llvm::DenseMap<TypeIndex, TypeIndex> forward_to_full; 282145522Sdarrenr llvm::DenseMap<TypeIndex, TypeIndex> full_to_forward; 283145522Sdarrenr 284145522Sdarrenr struct RecordIndices { 285145522Sdarrenr TypeIndex forward; 286145522Sdarrenr TypeIndex full; 287145522Sdarrenr }; 288145522Sdarrenr 289145522Sdarrenr llvm::StringMap<RecordIndices> record_indices; 290172776Sdarrenr 291172776Sdarrenr for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) { 292172776Sdarrenr CVType type = types.getType(*ti); 293172776Sdarrenr if (!IsTagRecord(type)) 294172776Sdarrenr continue; 295172776Sdarrenr 296172776Sdarrenr CVTagRecord tag = CVTagRecord::create(type); 297172776Sdarrenr 298172776Sdarrenr RecordIndices &indices = record_indices[tag.asTag().getUniqueName()]; 299172776Sdarrenr if (tag.asTag().isForwardRef()) 300172776Sdarrenr indices.forward = *ti; 301172776Sdarrenr else 302172776Sdarrenr indices.full = *ti; 303172776Sdarrenr 304172776Sdarrenr if (indices.full != TypeIndex::None() && 305145522Sdarrenr indices.forward != TypeIndex::None()) { 306145522Sdarrenr forward_to_full[indices.forward] = indices.full; 307172776Sdarrenr full_to_forward[indices.full] = indices.forward; 308145522Sdarrenr } 309145522Sdarrenr 310145522Sdarrenr // We're looking for LF_NESTTYPE records in the field list, so ignore 311145522Sdarrenr // forward references (no field list), and anything without a nested class 312145522Sdarrenr // (since there won't be any LF_NESTTYPE records). 313145522Sdarrenr if (tag.asTag().isForwardRef() || !tag.asTag().containsNestedClass()) 314145522Sdarrenr continue; 315145522Sdarrenr 316172776Sdarrenr struct ProcessTpiStream : public TypeVisitorCallbacks { 317172776Sdarrenr ProcessTpiStream(PdbIndex &index, TypeIndex parent, 318172776Sdarrenr const CVTagRecord &parent_cvt, 319172776Sdarrenr llvm::DenseMap<TypeIndex, TypeIndex> &parents) 320172776Sdarrenr : index(index), parents(parents), parent(parent), 321145522Sdarrenr parent_cvt(parent_cvt) {} 322145522Sdarrenr 323145522Sdarrenr PdbIndex &index; 324145522Sdarrenr llvm::DenseMap<TypeIndex, TypeIndex> &parents; 325153084Sru 326145522Sdarrenr unsigned unnamed_type_index = 1; 327145522Sdarrenr TypeIndex parent; 328145522Sdarrenr const CVTagRecord &parent_cvt; 329145522Sdarrenr 330145522Sdarrenr llvm::Error visitKnownMember(CVMemberRecord &CVR, 331145522Sdarrenr NestedTypeRecord &Record) override { 332145522Sdarrenr std::string unnamed_type_name; 33380482Sdarrenr if (Record.Name.empty()) { 334145522Sdarrenr unnamed_type_name = 335153084Sru llvm::formatv("<unnamed-type-$S{0}>", unnamed_type_index).str(); 336145522Sdarrenr Record.Name = unnamed_type_name; 337145522Sdarrenr ++unnamed_type_index; 338145522Sdarrenr } 339180778Sdarrenr llvm::Optional<CVTagRecord> tag = 340145522Sdarrenr GetNestedTagDefinition(Record, parent_cvt, index.tpi()); 341145522Sdarrenr if (!tag) 342145522Sdarrenr return llvm::ErrorSuccess(); 34353642Sguido 34453642Sguido parents[Record.Type] = parent; 345145522Sdarrenr return llvm::ErrorSuccess(); 346145522Sdarrenr } 347145522Sdarrenr }; 348145522Sdarrenr 349145522Sdarrenr CVType field_list = m_index.tpi().getType(tag.asTag().FieldList); 350145522Sdarrenr ProcessTpiStream process(m_index, *ti, tag, m_parent_types); 351145522Sdarrenr llvm::Error error = visitMemberRecordStream(field_list.data(), process); 352145522Sdarrenr if (error) 353145522Sdarrenr llvm::consumeError(std::move(error)); 354145522Sdarrenr } 355145522Sdarrenr 356145522Sdarrenr // Now that we know the forward -> full mapping of all type indices, we can 357145522Sdarrenr // re-write all the indices. At the end of this process, we want a mapping 358145522Sdarrenr // consisting of fwd -> full and full -> full for all child -> parent indices. 359145522Sdarrenr // We can re-write the values in place, but for the keys, we must save them 36053642Sguido // off so that we don't modify the map in place while also iterating it. 361145522Sdarrenr std::vector<TypeIndex> full_keys; 362145522Sdarrenr std::vector<TypeIndex> fwd_keys; 363145522Sdarrenr for (auto &entry : m_parent_types) { 364145522Sdarrenr TypeIndex key = entry.first; 365145522Sdarrenr TypeIndex value = entry.second; 366145522Sdarrenr 367145522Sdarrenr auto iter = forward_to_full.find(value); 368145522Sdarrenr if (iter != forward_to_full.end()) 36953642Sguido entry.second = iter->second; 370145522Sdarrenr 371145522Sdarrenr iter = forward_to_full.find(key); 372145522Sdarrenr if (iter != forward_to_full.end()) 373145522Sdarrenr fwd_keys.push_back(key); 374145522Sdarrenr else 375145522Sdarrenr full_keys.push_back(key); 37660857Sdarrenr } 377145522Sdarrenr for (TypeIndex fwd : fwd_keys) { 378145522Sdarrenr TypeIndex full = forward_to_full[fwd]; 379145522Sdarrenr m_parent_types[full] = m_parent_types[fwd]; 380145522Sdarrenr } 38198004Sdarrenr for (TypeIndex full : full_keys) { 382145522Sdarrenr TypeIndex fwd = full_to_forward[full]; 38398004Sdarrenr m_parent_types[fwd] = m_parent_types[full]; 384145522Sdarrenr } 385145522Sdarrenr 386145522Sdarrenr // Now that 387145522Sdarrenr} 388145522Sdarrenr 389145522Sdarrenrstatic bool isLocalVariableType(SymbolKind K) { 390145522Sdarrenr switch (K) { 391145522Sdarrenr case S_REGISTER: 392145522Sdarrenr case S_REGREL32: 393145522Sdarrenr case S_LOCAL: 394145522Sdarrenr return true; 395145522Sdarrenr default: 396145522Sdarrenr break; 397145522Sdarrenr } 398145522Sdarrenr return false; 399145522Sdarrenr} 400145522Sdarrenr 401145522Sdarrenrstatic std::string 402145522SdarrenrRenderScopeList(llvm::ArrayRef<llvm::ms_demangle::Node *> nodes) { 403145522Sdarrenr lldbassert(!nodes.empty()); 404145522Sdarrenr 405145522Sdarrenr std::string result = nodes.front()->toString(); 406145522Sdarrenr nodes = nodes.drop_front(); 407145522Sdarrenr while (!nodes.empty()) { 408145522Sdarrenr result += "::"; 409145522Sdarrenr result += nodes.front()->toString(llvm::ms_demangle::OF_NoTagSpecifier); 410145522Sdarrenr nodes = nodes.drop_front(); 411145522Sdarrenr } 412145522Sdarrenr return result; 413145522Sdarrenr} 414145522Sdarrenr 415145522Sdarrenrstatic llvm::Optional<PublicSym32> FindPublicSym(const SegmentOffset &addr, 416145522Sdarrenr SymbolStream &syms, 417145522Sdarrenr PublicsStream &publics) { 418145522Sdarrenr llvm::FixedStreamArray<ulittle32_t> addr_map = publics.getAddressMap(); 419145522Sdarrenr auto iter = std::lower_bound( 420145522Sdarrenr addr_map.begin(), addr_map.end(), addr, 421145522Sdarrenr [&](const ulittle32_t &x, const SegmentOffset &y) { 422145522Sdarrenr CVSymbol s1 = syms.readRecord(x); 423145522Sdarrenr lldbassert(s1.kind() == S_PUB32); 424145522Sdarrenr PublicSym32 p1; 425145522Sdarrenr llvm::cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(s1, p1)); 426145522Sdarrenr if (p1.Segment < y.segment) 427145522Sdarrenr return true; 428145522Sdarrenr return p1.Offset < y.offset; 429145522Sdarrenr }); 430145522Sdarrenr if (iter == addr_map.end()) 431145522Sdarrenr return llvm::None; 432145522Sdarrenr CVSymbol sym = syms.readRecord(*iter); 433145522Sdarrenr lldbassert(sym.kind() == S_PUB32); 434145522Sdarrenr PublicSym32 p; 435145522Sdarrenr llvm::cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(sym, p)); 436145522Sdarrenr if (p.Segment == addr.segment && p.Offset == addr.offset) 437145522Sdarrenr return p; 438145522Sdarrenr return llvm::None; 439145522Sdarrenr} 440145522Sdarrenr 441145522Sdarrenrclang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) { 442145522Sdarrenr CVSymbol cvs = m_index.ReadSymbolRecord(id); 443145522Sdarrenr 444145522Sdarrenr if (isLocalVariableType(cvs.kind())) { 445145522Sdarrenr clang::DeclContext *scope = GetParentDeclContext(id); 446145522Sdarrenr clang::Decl *scope_decl = clang::Decl::castFromDeclContext(scope); 447145522Sdarrenr PdbCompilandSymId scope_id(id.modi, m_decl_to_status[scope_decl].uid); 448145522Sdarrenr return GetOrCreateVariableDecl(scope_id, id); 449145522Sdarrenr } 450145522Sdarrenr 451145522Sdarrenr switch (cvs.kind()) { 452145522Sdarrenr case S_GPROC32: 453145522Sdarrenr case S_LPROC32: 454145522Sdarrenr return GetOrCreateFunctionDecl(id); 455145522Sdarrenr case S_GDATA32: 456145522Sdarrenr case S_LDATA32: 457145522Sdarrenr case S_GTHREAD32: 458145522Sdarrenr case S_CONSTANT: 459145522Sdarrenr // global variable 460145522Sdarrenr return nullptr; 461145522Sdarrenr case S_BLOCK32: 462145522Sdarrenr return GetOrCreateBlockDecl(id); 463145522Sdarrenr default: 464145522Sdarrenr return nullptr; 465145522Sdarrenr } 466170268Sdarrenr} 467145522Sdarrenr 468145522Sdarrenrclang::Decl *PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) { 469145522Sdarrenr if (clang::Decl *result = TryGetDecl(uid)) 470145522Sdarrenr return result; 471145522Sdarrenr 472145522Sdarrenr clang::Decl *result = nullptr; 473172776Sdarrenr switch (uid.kind()) { 474145522Sdarrenr case PdbSymUidKind::CompilandSym: 475145522Sdarrenr result = GetOrCreateSymbolForId(uid.asCompilandSym()); 476145522Sdarrenr break; 477145522Sdarrenr case PdbSymUidKind::Type: { 478145522Sdarrenr clang::QualType qt = GetOrCreateType(uid.asTypeSym()); 479145522Sdarrenr if (auto *tag = qt->getAsTagDecl()) { 480145522Sdarrenr result = tag; 481145522Sdarrenr break; 482145522Sdarrenr } 483145522Sdarrenr return nullptr; 484145522Sdarrenr } 485161356Sguido default: 486145522Sdarrenr return nullptr; 487145522Sdarrenr } 488145522Sdarrenr m_uid_to_decl[toOpaqueUid(uid)] = result; 489145522Sdarrenr return result; 490145522Sdarrenr} 491145522Sdarrenr 492145522Sdarrenrclang::DeclContext *PdbAstBuilder::GetOrCreateDeclContextForUid(PdbSymUid uid) { 493145522Sdarrenr if (uid.kind() == PdbSymUidKind::CompilandSym) { 494145522Sdarrenr if (uid.asCompilandSym().offset == 0) 495145522Sdarrenr return FromCompilerDeclContext(GetTranslationUnitDecl()); 496145522Sdarrenr } 497145522Sdarrenr 498145522Sdarrenr clang::Decl *decl = GetOrCreateDeclForUid(uid); 499145522Sdarrenr if (!decl) 500145522Sdarrenr return nullptr; 501145522Sdarrenr 502145522Sdarrenr return clang::Decl::castToDeclContext(decl); 503145522Sdarrenr} 504145522Sdarrenr 505145522Sdarrenrstd::pair<clang::DeclContext *, std::string> 506145522SdarrenrPdbAstBuilder::CreateDeclInfoForUndecoratedName(llvm::StringRef name) { 507145522Sdarrenr MSVCUndecoratedNameParser parser(name); 508145522Sdarrenr llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers(); 509145522Sdarrenr 510145522Sdarrenr auto context = FromCompilerDeclContext(GetTranslationUnitDecl()); 511145522Sdarrenr 512145522Sdarrenr llvm::StringRef uname = specs.back().GetBaseName(); 513145522Sdarrenr specs = specs.drop_back(); 514145522Sdarrenr if (specs.empty()) 515145522Sdarrenr return {context, name}; 516145522Sdarrenr 517145522Sdarrenr llvm::StringRef scope_name = specs.back().GetFullName(); 518145522Sdarrenr 519145522Sdarrenr // It might be a class name, try that first. 520145522Sdarrenr std::vector<TypeIndex> types = m_index.tpi().findRecordsByName(scope_name); 521145522Sdarrenr while (!types.empty()) { 522145522Sdarrenr clang::QualType qt = GetOrCreateType(types.back()); 523145522Sdarrenr clang::TagDecl *tag = qt->getAsTagDecl(); 52495418Sdarrenr if (tag) 525145522Sdarrenr return {clang::TagDecl::castToDeclContext(tag), uname}; 526145522Sdarrenr types.pop_back(); 527145522Sdarrenr } 528145522Sdarrenr 529145522Sdarrenr // If that fails, treat it as a series of namespaces. 530145522Sdarrenr for (const MSVCUndecoratedNameSpecifier &spec : specs) { 531145522Sdarrenr std::string ns_name = spec.GetBaseName().str(); 532145522Sdarrenr context = GetOrCreateNamespaceDecl(ns_name.c_str(), *context); 533145522Sdarrenr } 534145522Sdarrenr return {context, uname}; 535145522Sdarrenr} 536145522Sdarrenr 537145522Sdarrenrclang::DeclContext * 538145522SdarrenrPdbAstBuilder::GetParentDeclContextForSymbol(const CVSymbol &sym) { 539145522Sdarrenr if (!SymbolHasAddress(sym)) 540145522Sdarrenr return CreateDeclInfoForUndecoratedName(getSymbolName(sym)).first; 541145522Sdarrenr SegmentOffset addr = GetSegmentAndOffset(sym); 542145522Sdarrenr llvm::Optional<PublicSym32> pub = 54395418Sdarrenr FindPublicSym(addr, m_index.symrecords(), m_index.publics()); 544145522Sdarrenr if (!pub) 545145522Sdarrenr return CreateDeclInfoForUndecoratedName(getSymbolName(sym)).first; 546145522Sdarrenr 547145522Sdarrenr llvm::ms_demangle::Demangler demangler; 548145522Sdarrenr StringView name{pub->Name.begin(), pub->Name.size()}; 549145522Sdarrenr llvm::ms_demangle::SymbolNode *node = demangler.parse(name); 550145522Sdarrenr if (!node) 551145522Sdarrenr return FromCompilerDeclContext(GetTranslationUnitDecl()); 552145522Sdarrenr llvm::ArrayRef<llvm::ms_demangle::Node *> name_components{ 553145522Sdarrenr node->Name->Components->Nodes, node->Name->Components->Count - 1}; 554145522Sdarrenr 555145522Sdarrenr if (!name_components.empty()) { 556145522Sdarrenr // Render the current list of scope nodes as a fully qualified name, and 557145522Sdarrenr // look it up in the debug info as a type name. If we find something, 558145522Sdarrenr // this is a type (which may itself be prefixed by a namespace). If we 559145522Sdarrenr // don't, this is a list of namespaces. 560145522Sdarrenr std::string qname = RenderScopeList(name_components); 561145522Sdarrenr std::vector<TypeIndex> matches = m_index.tpi().findRecordsByName(qname); 562145522Sdarrenr while (!matches.empty()) { 563145522Sdarrenr clang::QualType qt = GetOrCreateType(matches.back()); 56495418Sdarrenr clang::TagDecl *tag = qt->getAsTagDecl(); 565145522Sdarrenr if (tag) 566145522Sdarrenr return clang::TagDecl::castToDeclContext(tag); 567145522Sdarrenr matches.pop_back(); 568145522Sdarrenr } 569145522Sdarrenr } 570180778Sdarrenr 571180778Sdarrenr // It's not a type. It must be a series of namespaces. 572145522Sdarrenr auto context = FromCompilerDeclContext(GetTranslationUnitDecl()); 573145522Sdarrenr while (!name_components.empty()) { 574145522Sdarrenr std::string ns = name_components.front()->toString(); 575145522Sdarrenr context = GetOrCreateNamespaceDecl(ns.c_str(), *context); 576145522Sdarrenr name_components = name_components.drop_front(); 577145522Sdarrenr } 578145522Sdarrenr return context; 579145522Sdarrenr} 580145522Sdarrenr 581145522Sdarrenrclang::DeclContext *PdbAstBuilder::GetParentDeclContext(PdbSymUid uid) { 582145522Sdarrenr // We must do this *without* calling GetOrCreate on the current uid, as 583145522Sdarrenr // that would be an infinite recursion. 584145522Sdarrenr switch (uid.kind()) { 585145522Sdarrenr case PdbSymUidKind::CompilandSym: { 586145522Sdarrenr llvm::Optional<PdbCompilandSymId> scope = 587145522Sdarrenr FindSymbolScope(m_index, uid.asCompilandSym()); 588145522Sdarrenr if (scope) 589145522Sdarrenr return GetOrCreateDeclContextForUid(*scope); 590145522Sdarrenr 591145522Sdarrenr CVSymbol sym = m_index.ReadSymbolRecord(uid.asCompilandSym()); 592145522Sdarrenr return GetParentDeclContextForSymbol(sym); 593145522Sdarrenr } 594145522Sdarrenr case PdbSymUidKind::Type: { 595145522Sdarrenr // It could be a namespace, class, or global. We don't support nested 596145522Sdarrenr // functions yet. Anyway, we just need to consult the parent type map. 597145522Sdarrenr PdbTypeSymId type_id = uid.asTypeSym(); 598145522Sdarrenr auto iter = m_parent_types.find(type_id.index); 599145522Sdarrenr if (iter == m_parent_types.end()) 600145522Sdarrenr return FromCompilerDeclContext(GetTranslationUnitDecl()); 601145522Sdarrenr return GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second)); 602145522Sdarrenr } 603145522Sdarrenr case PdbSymUidKind::FieldListMember: 604145522Sdarrenr // In this case the parent DeclContext is the one for the class that this 605145522Sdarrenr // member is inside of. 606145522Sdarrenr break; 607145522Sdarrenr case PdbSymUidKind::GlobalSym: { 608145522Sdarrenr // If this refers to a compiland symbol, just recurse in with that symbol. 609145522Sdarrenr // The only other possibilities are S_CONSTANT and S_UDT, in which case we 610145522Sdarrenr // need to parse the undecorated name to figure out the scope, then look 611145522Sdarrenr // that up in the TPI stream. If it's found, it's a type, othewrise it's 612145522Sdarrenr // a series of namespaces. 613145522Sdarrenr // FIXME: do this. 61495418Sdarrenr CVSymbol global = m_index.ReadSymbolRecord(uid.asGlobalSym()); 615145522Sdarrenr switch (global.kind()) { 616145522Sdarrenr case SymbolKind::S_GDATA32: 617145522Sdarrenr case SymbolKind::S_LDATA32: 618145522Sdarrenr return GetParentDeclContextForSymbol(global); 619145522Sdarrenr case SymbolKind::S_PROCREF: 620145522Sdarrenr case SymbolKind::S_LPROCREF: { 621145522Sdarrenr ProcRefSym ref{global.kind()}; 622145522Sdarrenr llvm::cantFail( 623161356Sguido SymbolDeserializer::deserializeAs<ProcRefSym>(global, ref)); 624145522Sdarrenr PdbCompilandSymId cu_sym_id{ref.modi(), ref.SymOffset}; 625145522Sdarrenr return GetParentDeclContext(cu_sym_id); 626145522Sdarrenr } 627145522Sdarrenr case SymbolKind::S_CONSTANT: 628145522Sdarrenr case SymbolKind::S_UDT: 629145522Sdarrenr return CreateDeclInfoForUndecoratedName(getSymbolName(global)).first; 630145522Sdarrenr default: 631145522Sdarrenr break; 632145522Sdarrenr } 633145522Sdarrenr break; 634145522Sdarrenr } 635170268Sdarrenr default: 636145522Sdarrenr break; 637145522Sdarrenr } 638145522Sdarrenr return FromCompilerDeclContext(GetTranslationUnitDecl()); 639145522Sdarrenr} 640145522Sdarrenr 641145522Sdarrenrbool PdbAstBuilder::CompleteType(clang::QualType qt) { 642145522Sdarrenr clang::TagDecl *tag = qt->getAsTagDecl(); 643172776Sdarrenr if (!tag) 644145522Sdarrenr return false; 645145522Sdarrenr 646145522Sdarrenr return CompleteTagDecl(*tag); 647145522Sdarrenr} 648145522Sdarrenr 649145522Sdarrenrbool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) { 650145522Sdarrenr // If this is not in our map, it's an error. 651145522Sdarrenr auto status_iter = m_decl_to_status.find(&tag); 652145522Sdarrenr lldbassert(status_iter != m_decl_to_status.end()); 653145522Sdarrenr 654145522Sdarrenr // If it's already complete, just return. 655145522Sdarrenr DeclStatus &status = status_iter->second; 656145522Sdarrenr if (status.resolved) 657145522Sdarrenr return true; 658145522Sdarrenr 659145522Sdarrenr PdbTypeSymId type_id = PdbSymUid(status.uid).asTypeSym(); 660145522Sdarrenr 661145522Sdarrenr lldbassert(IsTagRecord(type_id, m_index.tpi())); 662145522Sdarrenr 663145522Sdarrenr clang::QualType tag_qt = m_clang.getASTContext()->getTypeDeclType(&tag); 664145522Sdarrenr ClangASTContext::SetHasExternalStorage(tag_qt.getAsOpaquePtr(), false); 665145522Sdarrenr 666145522Sdarrenr TypeIndex tag_ti = type_id.index; 667145522Sdarrenr CVType cvt = m_index.tpi().getType(tag_ti); 668180778Sdarrenr if (cvt.kind() == LF_MODIFIER) 669180778Sdarrenr tag_ti = LookThroughModifierRecord(cvt); 670145522Sdarrenr 671145522Sdarrenr PdbTypeSymId best_ti = GetBestPossibleDecl(tag_ti, m_index.tpi()); 672145522Sdarrenr cvt = m_index.tpi().getType(best_ti.index); 673145522Sdarrenr lldbassert(IsTagRecord(cvt)); 674145522Sdarrenr 675145522Sdarrenr if (IsForwardRefUdt(cvt)) { 676145522Sdarrenr // If we can't find a full decl for this forward ref anywhere in the debug 677145522Sdarrenr // info, then we have no way to complete it. 678145522Sdarrenr return false; 679145522Sdarrenr } 680145522Sdarrenr 681145522Sdarrenr TypeIndex field_list_ti = GetFieldListIndex(cvt); 682145522Sdarrenr CVType field_list_cvt = m_index.tpi().getType(field_list_ti); 683145522Sdarrenr if (field_list_cvt.kind() != LF_FIELDLIST) 684145522Sdarrenr return false; 685145522Sdarrenr 686145522Sdarrenr // Visit all members of this class, then perform any finalization necessary 687145522Sdarrenr // to complete the class. 688145522Sdarrenr CompilerType ct = ToCompilerType(tag_qt); 689145522Sdarrenr UdtRecordCompleter completer(best_ti, ct, tag, *this, m_index.tpi()); 690145522Sdarrenr auto error = 691145522Sdarrenr llvm::codeview::visitMemberRecordStream(field_list_cvt.data(), completer); 692145522Sdarrenr completer.complete(); 693145522Sdarrenr 694145522Sdarrenr status.resolved = true; 695145522Sdarrenr if (!error) 696145522Sdarrenr return true; 697145522Sdarrenr 698145522Sdarrenr llvm::consumeError(std::move(error)); 699170268Sdarrenr return false; 700145522Sdarrenr} 701145522Sdarrenr 702145522Sdarrenrclang::QualType PdbAstBuilder::CreateSimpleType(TypeIndex ti) { 703145522Sdarrenr if (ti == TypeIndex::NullptrT()) 704145522Sdarrenr return GetBasicType(lldb::eBasicTypeNullPtr); 705145522Sdarrenr 706145522Sdarrenr if (ti.getSimpleMode() != SimpleTypeMode::Direct) { 707145522Sdarrenr clang::QualType direct_type = GetOrCreateType(ti.makeDirect()); 708145522Sdarrenr return m_clang.getASTContext()->getPointerType(direct_type); 709145522Sdarrenr } 710161356Sguido 711145522Sdarrenr if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated) 712145522Sdarrenr return {}; 713145522Sdarrenr 714145522Sdarrenr lldb::BasicType bt = GetCompilerTypeForSimpleKind(ti.getSimpleKind()); 715145522Sdarrenr if (bt == lldb::eBasicTypeInvalid) 716145522Sdarrenr return {}; 717145522Sdarrenr 718145522Sdarrenr return GetBasicType(bt); 719145522Sdarrenr} 720145522Sdarrenr 721145522Sdarrenrclang::QualType PdbAstBuilder::CreatePointerType(const PointerRecord &pointer) { 722172776Sdarrenr clang::QualType pointee_type = GetOrCreateType(pointer.ReferentType); 723145522Sdarrenr 724145522Sdarrenr // This can happen for pointers to LF_VTSHAPE records, which we shouldn't 725145522Sdarrenr // create in the AST. 726145522Sdarrenr if (pointee_type.isNull()) 727145522Sdarrenr return {}; 728145522Sdarrenr 729145522Sdarrenr if (pointer.isPointerToMember()) { 730145522Sdarrenr MemberPointerInfo mpi = pointer.getMemberInfo(); 731145522Sdarrenr clang::QualType class_type = GetOrCreateType(mpi.ContainingType); 732145522Sdarrenr 733145522Sdarrenr return m_clang.getASTContext()->getMemberPointerType( 734145522Sdarrenr pointee_type, class_type.getTypePtr()); 735145522Sdarrenr } 736145522Sdarrenr 737145522Sdarrenr clang::QualType pointer_type; 73895418Sdarrenr if (pointer.getMode() == PointerMode::LValueReference) 73995418Sdarrenr pointer_type = 740145522Sdarrenr m_clang.getASTContext()->getLValueReferenceType(pointee_type); 741145522Sdarrenr else if (pointer.getMode() == PointerMode::RValueReference) 742145522Sdarrenr pointer_type = 743145522Sdarrenr m_clang.getASTContext()->getRValueReferenceType(pointee_type); 744145522Sdarrenr else 745145522Sdarrenr pointer_type = m_clang.getASTContext()->getPointerType(pointee_type); 74695418Sdarrenr 747145522Sdarrenr if ((pointer.getOptions() & PointerOptions::Const) != PointerOptions::None) 748145522Sdarrenr pointer_type.addConst(); 749145522Sdarrenr 750145522Sdarrenr if ((pointer.getOptions() & PointerOptions::Volatile) != PointerOptions::None) 751145522Sdarrenr pointer_type.addVolatile(); 752145522Sdarrenr 75353642Sguido if ((pointer.getOptions() & PointerOptions::Restrict) != PointerOptions::None) 754145522Sdarrenr pointer_type.addRestrict(); 75553642Sguido 756145522Sdarrenr return pointer_type; 757145522Sdarrenr} 758145522Sdarrenr 759145522Sdarrenrclang::QualType 760145522SdarrenrPdbAstBuilder::CreateModifierType(const ModifierRecord &modifier) { 761145522Sdarrenr clang::QualType unmodified_type = GetOrCreateType(modifier.ModifiedType); 762145522Sdarrenr if (unmodified_type.isNull()) 763145522Sdarrenr return {}; 764145522Sdarrenr 765145522Sdarrenr if ((modifier.Modifiers & ModifierOptions::Const) != ModifierOptions::None) 766170268Sdarrenr unmodified_type.addConst(); 767170268Sdarrenr if ((modifier.Modifiers & ModifierOptions::Volatile) != ModifierOptions::None) 768170268Sdarrenr unmodified_type.addVolatile(); 769170268Sdarrenr 770170268Sdarrenr return unmodified_type; 771170268Sdarrenr} 772170268Sdarrenr 773170268Sdarrenrclang::QualType PdbAstBuilder::CreateRecordType(PdbTypeSymId id, 77460857Sdarrenr const TagRecord &record) { 775145522Sdarrenr clang::DeclContext *context = nullptr; 77660857Sdarrenr std::string uname; 77760857Sdarrenr std::tie(context, uname) = CreateDeclInfoForType(record, id.index); 77860857Sdarrenr clang::TagTypeKind ttk = TranslateUdtKind(record); 779145522Sdarrenr lldb::AccessType access = 780145522Sdarrenr (ttk == clang::TTK_Class) ? lldb::eAccessPrivate : lldb::eAccessPublic; 781145522Sdarrenr 782145522Sdarrenr ClangASTMetadata metadata; 783145522Sdarrenr metadata.SetUserID(toOpaqueUid(id)); 784145522Sdarrenr metadata.SetIsDynamicCXXType(false); 785145522Sdarrenr 786145522Sdarrenr CompilerType ct = 787170268Sdarrenr m_clang.CreateRecordType(context, access, uname.c_str(), ttk, 788170268Sdarrenr lldb::eLanguageTypeC_plus_plus, &metadata); 789170268Sdarrenr 790170268Sdarrenr lldbassert(ct.IsValid()); 791180778Sdarrenr 792180778Sdarrenr ClangASTContext::StartTagDeclarationDefinition(ct); 793145522Sdarrenr 794170268Sdarrenr // Even if it's possible, don't complete it at this point. Just mark it 795170268Sdarrenr // forward resolved, and if/when LLDB needs the full definition, it can 796170268Sdarrenr // ask us. 797145522Sdarrenr clang::QualType result = 798145522Sdarrenr clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType()); 799145522Sdarrenr 800145522Sdarrenr ClangASTContext::SetHasExternalStorage(result.getAsOpaquePtr(), true); 801145522Sdarrenr return result; 802145522Sdarrenr} 803145522Sdarrenr 804145522Sdarrenrclang::Decl *PdbAstBuilder::TryGetDecl(PdbSymUid uid) const { 805145522Sdarrenr auto iter = m_uid_to_decl.find(toOpaqueUid(uid)); 806145522Sdarrenr if (iter != m_uid_to_decl.end()) 807145522Sdarrenr return iter->second; 808172776Sdarrenr return nullptr; 809145522Sdarrenr} 810145522Sdarrenr 811145522Sdarrenrclang::NamespaceDecl * 812145522SdarrenrPdbAstBuilder::GetOrCreateNamespaceDecl(const char *name, 813145522Sdarrenr clang::DeclContext &context) { 814172776Sdarrenr return m_clang.GetUniqueNamespaceDeclaration( 815145522Sdarrenr IsAnonymousNamespaceName(name) ? nullptr : name, &context); 816145522Sdarrenr} 817145522Sdarrenr 818145522Sdarrenrclang::BlockDecl * 819145522SdarrenrPdbAstBuilder::GetOrCreateBlockDecl(PdbCompilandSymId block_id) { 820145522Sdarrenr if (clang::Decl *decl = TryGetDecl(block_id)) 821145522Sdarrenr return llvm::dyn_cast<clang::BlockDecl>(decl); 822145522Sdarrenr 823145522Sdarrenr clang::DeclContext *scope = GetParentDeclContext(block_id); 824145522Sdarrenr 825145522Sdarrenr clang::BlockDecl *block_decl = m_clang.CreateBlockDeclaration(scope); 826145522Sdarrenr m_uid_to_decl.insert({toOpaqueUid(block_id), block_decl}); 827145522Sdarrenr 828145522Sdarrenr DeclStatus status; 829145522Sdarrenr status.resolved = true; 830145522Sdarrenr status.uid = toOpaqueUid(block_id); 831145522Sdarrenr m_decl_to_status.insert({block_decl, status}); 832180778Sdarrenr 833180778Sdarrenr return block_decl; 834180778Sdarrenr} 835180778Sdarrenr 836180778Sdarrenrclang::VarDecl *PdbAstBuilder::CreateVariableDecl(PdbSymUid uid, CVSymbol sym, 837146229Sdarrenr clang::DeclContext &scope) { 838145522Sdarrenr VariableInfo var_info = GetVariableNameInfo(sym); 839145522Sdarrenr clang::QualType qt = GetOrCreateType(var_info.type); 840145522Sdarrenr 841145522Sdarrenr clang::VarDecl *var_decl = m_clang.CreateVariableDeclaration( 842145522Sdarrenr &scope, var_info.name.str().c_str(), qt); 843145522Sdarrenr 84460857Sdarrenr m_uid_to_decl[toOpaqueUid(uid)] = var_decl; 84560857Sdarrenr DeclStatus status; 846145522Sdarrenr status.resolved = true; 84760857Sdarrenr status.uid = toOpaqueUid(uid); 84860857Sdarrenr m_decl_to_status.insert({var_decl, status}); 84960857Sdarrenr return var_decl; 850145522Sdarrenr} 851145522Sdarrenr 852145522Sdarrenrclang::VarDecl * 85353642SguidoPdbAstBuilder::GetOrCreateVariableDecl(PdbCompilandSymId scope_id, 854145522Sdarrenr PdbCompilandSymId var_id) { 855145522Sdarrenr if (clang::Decl *decl = TryGetDecl(var_id)) 85653642Sguido return llvm::dyn_cast<clang::VarDecl>(decl); 857145522Sdarrenr 858145522Sdarrenr clang::DeclContext *scope = GetOrCreateDeclContextForUid(scope_id); 859145522Sdarrenr 860145522Sdarrenr CVSymbol sym = m_index.ReadSymbolRecord(var_id); 861145522Sdarrenr return CreateVariableDecl(PdbSymUid(var_id), sym, *scope); 862145522Sdarrenr} 863145522Sdarrenr 864145522Sdarrenrclang::VarDecl *PdbAstBuilder::GetOrCreateVariableDecl(PdbGlobalSymId var_id) { 865145522Sdarrenr if (clang::Decl *decl = TryGetDecl(var_id)) 866145522Sdarrenr return llvm::dyn_cast<clang::VarDecl>(decl); 867145522Sdarrenr 868145522Sdarrenr CVSymbol sym = m_index.ReadSymbolRecord(var_id); 869145522Sdarrenr auto context = FromCompilerDeclContext(GetTranslationUnitDecl()); 870145522Sdarrenr return CreateVariableDecl(PdbSymUid(var_id), sym, *context); 871145522Sdarrenr} 872172776Sdarrenr 873172776Sdarrenrclang::TypedefNameDecl * 874172776SdarrenrPdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) { 875172776Sdarrenr if (clang::Decl *decl = TryGetDecl(id)) 876172776Sdarrenr return llvm::dyn_cast<clang::TypedefNameDecl>(decl); 877172776Sdarrenr 878172776Sdarrenr CVSymbol sym = m_index.ReadSymbolRecord(id); 879172776Sdarrenr lldbassert(sym.kind() == S_UDT); 880172776Sdarrenr UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym)); 881172776Sdarrenr 882172776Sdarrenr clang::DeclContext *scope = GetParentDeclContext(id); 883172776Sdarrenr 884172776Sdarrenr PdbTypeSymId real_type_id{udt.Type, false}; 885172776Sdarrenr clang::QualType qt = GetOrCreateType(real_type_id); 886172776Sdarrenr 887172776Sdarrenr std::string uname = DropNameScope(udt.Name); 888172776Sdarrenr 889172776Sdarrenr CompilerType ct = m_clang.CreateTypedefType(ToCompilerType(qt), uname.c_str(), 890145522Sdarrenr ToCompilerDeclContext(*scope)); 891145522Sdarrenr clang::TypedefNameDecl *tnd = m_clang.GetAsTypedefDecl(ct); 892145522Sdarrenr DeclStatus status; 893145522Sdarrenr status.resolved = true; 894145522Sdarrenr status.uid = toOpaqueUid(id); 895172776Sdarrenr m_decl_to_status.insert({tnd, status}); 896172776Sdarrenr return tnd; 897172776Sdarrenr} 898172776Sdarrenr 899172776Sdarrenrclang::QualType PdbAstBuilder::GetBasicType(lldb::BasicType type) { 900172776Sdarrenr CompilerType ct = m_clang.GetBasicType(type); 901172776Sdarrenr return clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType()); 902172776Sdarrenr} 903172776Sdarrenr 904172776Sdarrenrclang::QualType PdbAstBuilder::CreateType(PdbTypeSymId type) { 905172776Sdarrenr if (type.index.isSimple()) 906172776Sdarrenr return CreateSimpleType(type.index); 907172776Sdarrenr 908172776Sdarrenr CVType cvt = m_index.tpi().getType(type.index); 909172776Sdarrenr 910172776Sdarrenr if (cvt.kind() == LF_MODIFIER) { 911172776Sdarrenr ModifierRecord modifier; 912172776Sdarrenr llvm::cantFail( 913172776Sdarrenr TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier)); 914172776Sdarrenr return CreateModifierType(modifier); 915172776Sdarrenr } 916172776Sdarrenr 917172776Sdarrenr if (cvt.kind() == LF_POINTER) { 918172776Sdarrenr PointerRecord pointer; 919172776Sdarrenr llvm::cantFail( 920172776Sdarrenr TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer)); 921172776Sdarrenr return CreatePointerType(pointer); 922172776Sdarrenr } 923172776Sdarrenr 924172776Sdarrenr if (IsTagRecord(cvt)) { 925145522Sdarrenr CVTagRecord tag = CVTagRecord::create(cvt); 92653642Sguido if (tag.kind() == CVTagRecord::Union) 92753642Sguido return CreateRecordType(type.index, tag.asUnion()); 928145522Sdarrenr if (tag.kind() == CVTagRecord::Enum) 929145522Sdarrenr return CreateEnumType(type.index, tag.asEnum()); 930145522Sdarrenr return CreateRecordType(type.index, tag.asClass()); 931172776Sdarrenr } 932145522Sdarrenr 933145522Sdarrenr if (cvt.kind() == LF_ARRAY) { 934145522Sdarrenr ArrayRecord ar; 935145522Sdarrenr llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar)); 936145522Sdarrenr return CreateArrayType(ar); 937145522Sdarrenr } 938145522Sdarrenr 939172776Sdarrenr if (cvt.kind() == LF_PROCEDURE) { 940145522Sdarrenr ProcedureRecord pr; 941145522Sdarrenr llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr)); 942145522Sdarrenr return CreateFunctionType(pr.ArgumentList, pr.ReturnType, pr.CallConv); 943145522Sdarrenr } 944145522Sdarrenr 945145522Sdarrenr if (cvt.kind() == LF_MFUNCTION) { 946145522Sdarrenr MemberFunctionRecord mfr; 947145522Sdarrenr llvm::cantFail( 948145522Sdarrenr TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr)); 949145522Sdarrenr return CreateFunctionType(mfr.ArgumentList, mfr.ReturnType, mfr.CallConv); 950145522Sdarrenr } 951145522Sdarrenr 952145522Sdarrenr return {}; 953145522Sdarrenr} 954145522Sdarrenr 955145522Sdarrenrclang::QualType PdbAstBuilder::GetOrCreateType(PdbTypeSymId type) { 956145522Sdarrenr lldb::user_id_t uid = toOpaqueUid(type); 957145522Sdarrenr auto iter = m_uid_to_type.find(uid); 958145522Sdarrenr if (iter != m_uid_to_type.end()) 959145522Sdarrenr return iter->second; 960145522Sdarrenr 961145522Sdarrenr PdbTypeSymId best_type = GetBestPossibleDecl(type, m_index.tpi()); 962145522Sdarrenr 963145522Sdarrenr clang::QualType qt; 964145522Sdarrenr if (best_type.index != type.index) { 965145522Sdarrenr // This is a forward decl. Call GetOrCreate on the full decl, then map the 966145522Sdarrenr // forward decl id to the full decl QualType. 967145522Sdarrenr clang::QualType qt = GetOrCreateType(best_type); 968170268Sdarrenr m_uid_to_type[toOpaqueUid(type)] = qt; 969145522Sdarrenr return qt; 970145522Sdarrenr } 971145522Sdarrenr 972170268Sdarrenr // This is either a full decl, or a forward decl with no matching full decl 973145522Sdarrenr // in the debug info. 974145522Sdarrenr qt = CreateType(type); 975145522Sdarrenr m_uid_to_type[toOpaqueUid(type)] = qt; 976145522Sdarrenr if (IsTagRecord(type, m_index.tpi())) { 977170268Sdarrenr clang::TagDecl *tag = qt->getAsTagDecl(); 978172776Sdarrenr lldbassert(m_decl_to_status.count(tag) == 0); 979172776Sdarrenr 980145522Sdarrenr DeclStatus &status = m_decl_to_status[tag]; 981145522Sdarrenr status.uid = uid; 982145522Sdarrenr status.resolved = false; 983145522Sdarrenr } 984145522Sdarrenr return qt; 985145522Sdarrenr} 986145522Sdarrenr 987145522Sdarrenrclang::FunctionDecl * 988145522SdarrenrPdbAstBuilder::GetOrCreateFunctionDecl(PdbCompilandSymId func_id) { 989145522Sdarrenr if (clang::Decl *decl = TryGetDecl(func_id)) 990145522Sdarrenr return llvm::dyn_cast<clang::FunctionDecl>(decl); 991145522Sdarrenr 992145522Sdarrenr clang::DeclContext *parent = GetParentDeclContext(PdbSymUid(func_id)); 993145522Sdarrenr std::string context_name; 994145522Sdarrenr if (clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(parent)) { 995145522Sdarrenr context_name = ns->getQualifiedNameAsString(); 996145522Sdarrenr } else if (clang::TagDecl *tag = llvm::dyn_cast<clang::TagDecl>(parent)) { 997145522Sdarrenr context_name = tag->getQualifiedNameAsString(); 998145522Sdarrenr } 999145522Sdarrenr 1000145522Sdarrenr CVSymbol cvs = m_index.ReadSymbolRecord(func_id); 1001145522Sdarrenr ProcSym proc(static_cast<SymbolRecordKind>(cvs.kind())); 1002145522Sdarrenr llvm::cantFail(SymbolDeserializer::deserializeAs<ProcSym>(cvs, proc)); 1003145522Sdarrenr 1004145522Sdarrenr PdbTypeSymId type_id(proc.FunctionType); 1005145522Sdarrenr clang::QualType qt = GetOrCreateType(type_id); 1006145522Sdarrenr if (qt.isNull()) 1007145522Sdarrenr return nullptr; 1008145522Sdarrenr 1009145522Sdarrenr clang::StorageClass storage = clang::SC_None; 1010145522Sdarrenr if (proc.Kind == SymbolRecordKind::ProcSym) 1011145522Sdarrenr storage = clang::SC_Static; 1012145522Sdarrenr 1013145522Sdarrenr const clang::FunctionProtoType *func_type = 1014145522Sdarrenr llvm::dyn_cast<clang::FunctionProtoType>(qt); 1015145522Sdarrenr 1016145522Sdarrenr CompilerType func_ct = ToCompilerType(qt); 1017145522Sdarrenr 1018145522Sdarrenr llvm::StringRef proc_name = proc.Name; 1019145522Sdarrenr proc_name.consume_front(context_name); 1020145522Sdarrenr proc_name.consume_front("::"); 1021145522Sdarrenr 1022145522Sdarrenr clang::FunctionDecl *function_decl = m_clang.CreateFunctionDeclaration( 1023145522Sdarrenr parent, proc_name.str().c_str(), func_ct, storage, false); 1024145522Sdarrenr 1025145522Sdarrenr lldbassert(m_uid_to_decl.count(toOpaqueUid(func_id)) == 0); 1026145522Sdarrenr m_uid_to_decl[toOpaqueUid(func_id)] = function_decl; 1027145522Sdarrenr DeclStatus status; 1028145522Sdarrenr status.resolved = true; 1029145522Sdarrenr status.uid = toOpaqueUid(func_id); 1030145522Sdarrenr m_decl_to_status.insert({function_decl, status}); 1031145522Sdarrenr 1032145522Sdarrenr CreateFunctionParameters(func_id, *function_decl, func_type->getNumParams()); 1033145522Sdarrenr 1034145522Sdarrenr return function_decl; 1035145522Sdarrenr} 1036145522Sdarrenr 1037145522Sdarrenrvoid PdbAstBuilder::CreateFunctionParameters(PdbCompilandSymId func_id, 1038145522Sdarrenr clang::FunctionDecl &function_decl, 1039145522Sdarrenr uint32_t param_count) { 1040145522Sdarrenr CompilandIndexItem *cii = m_index.compilands().GetCompiland(func_id.modi); 1041145522Sdarrenr CVSymbolArray scope = 1042145522Sdarrenr cii->m_debug_stream.getSymbolArrayForScope(func_id.offset); 1043145522Sdarrenr 1044145522Sdarrenr auto begin = scope.begin(); 1045172776Sdarrenr auto end = scope.end(); 1046145522Sdarrenr std::vector<clang::ParmVarDecl *> params; 1047145522Sdarrenr while (begin != end && param_count > 0) { 1048145522Sdarrenr uint32_t record_offset = begin.offset(); 1049145522Sdarrenr CVSymbol sym = *begin++; 1050145522Sdarrenr 1051172776Sdarrenr TypeIndex param_type; 1052145522Sdarrenr llvm::StringRef param_name; 1053145522Sdarrenr switch (sym.kind()) { 1054145522Sdarrenr case S_REGREL32: { 1055145522Sdarrenr RegRelativeSym reg(SymbolRecordKind::RegRelativeSym); 1056145522Sdarrenr cantFail(SymbolDeserializer::deserializeAs<RegRelativeSym>(sym, reg)); 1057145522Sdarrenr param_type = reg.Type; 1058145522Sdarrenr param_name = reg.Name; 1059145522Sdarrenr break; 1060145522Sdarrenr } 1061145522Sdarrenr case S_REGISTER: { 1062145522Sdarrenr RegisterSym reg(SymbolRecordKind::RegisterSym); 1063145522Sdarrenr cantFail(SymbolDeserializer::deserializeAs<RegisterSym>(sym, reg)); 1064145522Sdarrenr param_type = reg.Index; 1065145522Sdarrenr param_name = reg.Name; 1066145522Sdarrenr break; 1067145522Sdarrenr } 1068145522Sdarrenr case S_LOCAL: { 1069145522Sdarrenr LocalSym local(SymbolRecordKind::LocalSym); 1070145522Sdarrenr cantFail(SymbolDeserializer::deserializeAs<LocalSym>(sym, local)); 1071145522Sdarrenr if ((local.Flags & LocalSymFlags::IsParameter) == LocalSymFlags::None) 1072145522Sdarrenr continue; 1073145522Sdarrenr param_type = local.Type; 1074145522Sdarrenr param_name = local.Name; 1075145522Sdarrenr break; 1076145522Sdarrenr } 1077145522Sdarrenr case S_BLOCK32: 1078145522Sdarrenr // All parameters should come before the first block. If that isn't the 1079172776Sdarrenr // case, then perhaps this is bad debug info that doesn't contain 1080145522Sdarrenr // information about all parameters. 1081145522Sdarrenr return; 1082145522Sdarrenr default: 1083145522Sdarrenr continue; 1084145522Sdarrenr } 1085145522Sdarrenr 1086145522Sdarrenr PdbCompilandSymId param_uid(func_id.modi, record_offset); 1087145522Sdarrenr clang::QualType qt = GetOrCreateType(param_type); 1088145522Sdarrenr 1089145522Sdarrenr CompilerType param_type_ct(&m_clang, qt.getAsOpaquePtr()); 1090145522Sdarrenr clang::ParmVarDecl *param = m_clang.CreateParameterDeclaration( 1091145522Sdarrenr &function_decl, param_name.str().c_str(), param_type_ct, 1092145522Sdarrenr clang::SC_None); 1093145522Sdarrenr lldbassert(m_uid_to_decl.count(toOpaqueUid(param_uid)) == 0); 1094145522Sdarrenr 1095145522Sdarrenr m_uid_to_decl[toOpaqueUid(param_uid)] = param; 1096145522Sdarrenr params.push_back(param); 1097145522Sdarrenr --param_count; 1098145522Sdarrenr } 1099145522Sdarrenr 1100145522Sdarrenr if (!params.empty()) 1101145522Sdarrenr m_clang.SetFunctionParameters(&function_decl, params.data(), params.size()); 1102145522Sdarrenr} 1103145522Sdarrenr 1104145522Sdarrenrclang::QualType PdbAstBuilder::CreateEnumType(PdbTypeSymId id, 1105145522Sdarrenr const EnumRecord &er) { 1106172776Sdarrenr clang::DeclContext *decl_context = nullptr; 1107145522Sdarrenr std::string uname; 1108145522Sdarrenr std::tie(decl_context, uname) = CreateDeclInfoForType(er, id.index); 1109145522Sdarrenr clang::QualType underlying_type = GetOrCreateType(er.UnderlyingType); 1110145522Sdarrenr 1111145522Sdarrenr Declaration declaration; 1112145522Sdarrenr CompilerType enum_ct = m_clang.CreateEnumerationType( 1113145522Sdarrenr uname.c_str(), decl_context, declaration, ToCompilerType(underlying_type), 1114161356Sguido er.isScoped()); 1115145522Sdarrenr 1116145522Sdarrenr ClangASTContext::StartTagDeclarationDefinition(enum_ct); 1117145522Sdarrenr ClangASTContext::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true); 1118145522Sdarrenr 1119145522Sdarrenr return clang::QualType::getFromOpaquePtr(enum_ct.GetOpaqueQualType()); 1120145522Sdarrenr} 1121145522Sdarrenr 1122145522Sdarrenrclang::QualType PdbAstBuilder::CreateArrayType(const ArrayRecord &ar) { 1123145522Sdarrenr clang::QualType element_type = GetOrCreateType(ar.ElementType); 1124145522Sdarrenr 1125145522Sdarrenr uint64_t element_count = 1126145522Sdarrenr ar.Size / GetSizeOfType({ar.ElementType}, m_index.tpi()); 1127145522Sdarrenr 1128145522Sdarrenr CompilerType array_ct = m_clang.CreateArrayType(ToCompilerType(element_type), 1129145522Sdarrenr element_count, false); 1130145522Sdarrenr return clang::QualType::getFromOpaquePtr(array_ct.GetOpaqueQualType()); 1131145522Sdarrenr} 1132145522Sdarrenr 1133145522Sdarrenrclang::QualType PdbAstBuilder::CreateFunctionType( 1134145522Sdarrenr TypeIndex args_type_idx, TypeIndex return_type_idx, 1135145522Sdarrenr llvm::codeview::CallingConvention calling_convention) { 1136145522Sdarrenr TpiStream &stream = m_index.tpi(); 1137145522Sdarrenr CVType args_cvt = stream.getType(args_type_idx); 1138145522Sdarrenr ArgListRecord args; 1139145522Sdarrenr llvm::cantFail( 1140170268Sdarrenr TypeDeserializer::deserializeAs<ArgListRecord>(args_cvt, args)); 1141145522Sdarrenr 1142145522Sdarrenr llvm::ArrayRef<TypeIndex> arg_indices = llvm::makeArrayRef(args.ArgIndices); 1143145522Sdarrenr bool is_variadic = IsCVarArgsFunction(arg_indices); 1144145522Sdarrenr if (is_variadic) 1145145522Sdarrenr arg_indices = arg_indices.drop_back(); 1146145522Sdarrenr 1147145522Sdarrenr std::vector<CompilerType> arg_types; 1148145522Sdarrenr arg_types.reserve(arg_indices.size()); 1149145522Sdarrenr 1150145522Sdarrenr for (TypeIndex arg_index : arg_indices) { 1151145522Sdarrenr clang::QualType arg_type = GetOrCreateType(arg_index); 1152145522Sdarrenr arg_types.push_back(ToCompilerType(arg_type)); 1153145522Sdarrenr } 1154145522Sdarrenr 1155145522Sdarrenr clang::QualType return_type = GetOrCreateType(return_type_idx); 1156145522Sdarrenr 1157161356Sguido llvm::Optional<clang::CallingConv> cc = 1158170268Sdarrenr TranslateCallingConvention(calling_convention); 1159170268Sdarrenr if (!cc) 1160170268Sdarrenr return {}; 1161170268Sdarrenr 1162170268Sdarrenr CompilerType return_ct = ToCompilerType(return_type); 1163170268Sdarrenr CompilerType func_sig_ast_type = m_clang.CreateFunctionType( 1164172776Sdarrenr return_ct, arg_types.data(), arg_types.size(), is_variadic, 0, *cc); 1165145522Sdarrenr 1166145522Sdarrenr return clang::QualType::getFromOpaquePtr( 1167145522Sdarrenr func_sig_ast_type.GetOpaqueQualType()); 1168145522Sdarrenr} 1169145522Sdarrenr 1170145522Sdarrenrstatic bool isTagDecl(clang::DeclContext &context) { 1171145522Sdarrenr return !!llvm::dyn_cast<clang::TagDecl>(&context); 1172145522Sdarrenr} 1173145522Sdarrenr 1174145522Sdarrenrstatic bool isFunctionDecl(clang::DeclContext &context) { 1175170268Sdarrenr return !!llvm::dyn_cast<clang::FunctionDecl>(&context); 1176145522Sdarrenr} 1177145522Sdarrenr 1178145522Sdarrenrstatic bool isBlockDecl(clang::DeclContext &context) { 1179145522Sdarrenr return !!llvm::dyn_cast<clang::BlockDecl>(&context); 1180145522Sdarrenr} 1181145522Sdarrenr 1182145522Sdarrenrvoid PdbAstBuilder::ParseAllNamespacesPlusChildrenOf( 1183145522Sdarrenr llvm::Optional<llvm::StringRef> parent) { 1184145522Sdarrenr TypeIndex ti{m_index.tpi().TypeIndexBegin()}; 1185145522Sdarrenr for (const CVType &cvt : m_index.tpi().typeArray()) { 1186145522Sdarrenr PdbTypeSymId tid{ti}; 1187145522Sdarrenr ++ti; 1188145522Sdarrenr 1189145522Sdarrenr if (!IsTagRecord(cvt)) 1190145522Sdarrenr continue; 1191145522Sdarrenr 1192145522Sdarrenr CVTagRecord tag = CVTagRecord::create(cvt); 1193145522Sdarrenr 1194145522Sdarrenr if (!parent.hasValue()) { 1195170268Sdarrenr clang::QualType qt = GetOrCreateType(tid); 1196145522Sdarrenr CompleteType(qt); 1197145522Sdarrenr continue; 1198145522Sdarrenr } 1199145522Sdarrenr 1200145522Sdarrenr // Call CreateDeclInfoForType unconditionally so that the namespace info 1201145522Sdarrenr // gets created. But only call CreateRecordType if the namespace name 1202145522Sdarrenr // matches. 1203145522Sdarrenr clang::DeclContext *context = nullptr; 1204145522Sdarrenr std::string uname; 1205145522Sdarrenr std::tie(context, uname) = CreateDeclInfoForType(tag.asTag(), tid.index); 1206145522Sdarrenr if (!context->isNamespace()) 1207145522Sdarrenr continue; 1208145522Sdarrenr 1209145522Sdarrenr clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(context); 1210153876Sguido std::string actual_ns = ns->getQualifiedNameAsString(); 1211145522Sdarrenr if (llvm::StringRef(actual_ns).startswith(*parent)) { 1212145522Sdarrenr clang::QualType qt = GetOrCreateType(tid); 1213145522Sdarrenr CompleteType(qt); 1214145522Sdarrenr continue; 1215145522Sdarrenr } 1216145522Sdarrenr } 1217145522Sdarrenr 1218145522Sdarrenr uint32_t module_count = m_index.dbi().modules().getModuleCount(); 1219145522Sdarrenr for (uint16_t modi = 0; modi < module_count; ++modi) { 1220145522Sdarrenr CompilandIndexItem &cii = m_index.compilands().GetOrCreateCompiland(modi); 1221145522Sdarrenr const CVSymbolArray &symbols = cii.m_debug_stream.getSymbolArray(); 1222145522Sdarrenr auto iter = symbols.begin(); 1223145522Sdarrenr while (iter != symbols.end()) { 1224145522Sdarrenr PdbCompilandSymId sym_id{modi, iter.offset()}; 1225145522Sdarrenr 1226145522Sdarrenr switch (iter->kind()) { 1227145522Sdarrenr case S_GPROC32: 1228145522Sdarrenr case S_LPROC32: 1229145522Sdarrenr GetOrCreateFunctionDecl(sym_id); 1230145522Sdarrenr iter = symbols.at(getScopeEndOffset(*iter)); 1231145522Sdarrenr break; 1232145522Sdarrenr case S_GDATA32: 1233145522Sdarrenr case S_GTHREAD32: 1234145522Sdarrenr case S_LDATA32: 1235145522Sdarrenr case S_LTHREAD32: 1236145522Sdarrenr GetOrCreateVariableDecl(PdbCompilandSymId(modi, 0), sym_id); 1237145522Sdarrenr ++iter; 1238145522Sdarrenr break; 1239145522Sdarrenr default: 1240145522Sdarrenr ++iter; 1241145522Sdarrenr continue; 1242145522Sdarrenr } 1243145522Sdarrenr } 1244145522Sdarrenr } 1245145522Sdarrenr} 1246145522Sdarrenr 1247145522Sdarrenrstatic CVSymbolArray skipFunctionParameters(clang::Decl &decl, 1248145522Sdarrenr const CVSymbolArray &symbols) { 1249145522Sdarrenr clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>(&decl); 1250145522Sdarrenr if (!func_decl) 1251145522Sdarrenr return symbols; 1252145522Sdarrenr unsigned int params = func_decl->getNumParams(); 1253145522Sdarrenr if (params == 0) 1254145522Sdarrenr return symbols; 1255145522Sdarrenr 1256145522Sdarrenr CVSymbolArray result = symbols; 1257145522Sdarrenr 1258172776Sdarrenr while (!result.empty()) { 1259145522Sdarrenr if (params == 0) 1260145522Sdarrenr return result; 1261145522Sdarrenr 1262145522Sdarrenr CVSymbol sym = *result.begin(); 1263145522Sdarrenr result.drop_front(); 1264145522Sdarrenr 1265145522Sdarrenr if (!isLocalVariableType(sym.kind())) 1266145522Sdarrenr continue; 1267145522Sdarrenr 1268145522Sdarrenr --params; 1269145522Sdarrenr } 1270145522Sdarrenr return result; 1271145522Sdarrenr} 1272145522Sdarrenr 1273145522Sdarrenrvoid PdbAstBuilder::ParseBlockChildren(PdbCompilandSymId block_id) { 1274145522Sdarrenr CVSymbol sym = m_index.ReadSymbolRecord(block_id); 1275145522Sdarrenr lldbassert(sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32 || 1276145522Sdarrenr sym.kind() == S_BLOCK32); 1277145522Sdarrenr CompilandIndexItem &cii = 1278145522Sdarrenr m_index.compilands().GetOrCreateCompiland(block_id.modi); 1279145522Sdarrenr CVSymbolArray symbols = 1280145522Sdarrenr cii.m_debug_stream.getSymbolArrayForScope(block_id.offset); 1281145522Sdarrenr 1282145522Sdarrenr // Function parameters should already have been created when the function was 1283145522Sdarrenr // parsed. 1284145522Sdarrenr if (sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32) 1285145522Sdarrenr symbols = 1286145522Sdarrenr skipFunctionParameters(*m_uid_to_decl[toOpaqueUid(block_id)], symbols); 1287145522Sdarrenr 1288145522Sdarrenr auto begin = symbols.begin(); 1289145522Sdarrenr while (begin != symbols.end()) { 1290145522Sdarrenr PdbCompilandSymId child_sym_id(block_id.modi, begin.offset()); 1291145522Sdarrenr GetOrCreateSymbolForId(child_sym_id); 1292145522Sdarrenr if (begin->kind() == S_BLOCK32) { 1293145522Sdarrenr ParseBlockChildren(child_sym_id); 1294145522Sdarrenr begin = symbols.at(getScopeEndOffset(*begin)); 1295153876Sguido } 1296153876Sguido ++begin; 1297153876Sguido } 1298153876Sguido} 1299153876Sguido 1300153876Sguidovoid PdbAstBuilder::ParseDeclsForSimpleContext(clang::DeclContext &context) { 1301153876Sguido 1302153876Sguido clang::Decl *decl = clang::Decl::castFromDeclContext(&context); 1303153876Sguido lldbassert(decl); 1304153876Sguido 1305153876Sguido auto iter = m_decl_to_status.find(decl); 1306153876Sguido lldbassert(iter != m_decl_to_status.end()); 1307153876Sguido 1308153876Sguido if (auto *tag = llvm::dyn_cast<clang::TagDecl>(&context)) { 1309153876Sguido CompleteTagDecl(*tag); 1310153876Sguido return; 1311153876Sguido } 1312153876Sguido 1313153876Sguido if (isFunctionDecl(context) || isBlockDecl(context)) { 1314153876Sguido PdbCompilandSymId block_id = PdbSymUid(iter->second.uid).asCompilandSym(); 1315153876Sguido ParseBlockChildren(block_id); 1316153876Sguido } 1317153876Sguido} 1318153876Sguido 1319153876Sguidovoid PdbAstBuilder::ParseDeclsForContext(clang::DeclContext &context) { 1320153876Sguido // Namespaces aren't explicitly represented in the debug info, and the only 1321153876Sguido // way to parse them is to parse all type info, demangling every single type 1322153876Sguido // and trying to reconstruct the DeclContext hierarchy this way. Since this 1323153876Sguido // is an expensive operation, we have to special case it so that we do other 1324153876Sguido // work (such as parsing the items that appear within the namespaces) at the 1325153876Sguido // same time. 1326153876Sguido if (context.isTranslationUnit()) { 1327153876Sguido ParseAllNamespacesPlusChildrenOf(llvm::None); 1328153876Sguido return; 1329153876Sguido } 1330153876Sguido 1331153876Sguido if (context.isNamespace()) { 1332153876Sguido clang::NamespaceDecl &ns = *llvm::dyn_cast<clang::NamespaceDecl>(&context); 1333153876Sguido std::string qname = ns.getQualifiedNameAsString(); 1334153876Sguido ParseAllNamespacesPlusChildrenOf(llvm::StringRef{qname}); 1335153876Sguido return; 1336153876Sguido } 1337153876Sguido 1338153876Sguido if (isTagDecl(context) || isFunctionDecl(context) || isBlockDecl(context)) { 1339153876Sguido ParseDeclsForSimpleContext(context); 1340153876Sguido return; 1341153876Sguido } 1342153876Sguido} 1343153876Sguido 1344153876SguidoCompilerDecl PdbAstBuilder::ToCompilerDecl(clang::Decl &decl) { 1345170268Sdarrenr return {&m_clang, &decl}; 1346153876Sguido} 1347153876Sguido 1348153876SguidoCompilerType PdbAstBuilder::ToCompilerType(clang::QualType qt) { 1349153876Sguido return {&m_clang, qt.getAsOpaquePtr()}; 1350153876Sguido} 1351153876Sguido 1352153876SguidoCompilerDeclContext 1353153876SguidoPdbAstBuilder::ToCompilerDeclContext(clang::DeclContext &context) { 1354153876Sguido return {&m_clang, &context}; 1355153876Sguido} 1356161356Sguido 1357153876Sguidoclang::Decl * PdbAstBuilder::FromCompilerDecl(CompilerDecl decl) { 1358153876Sguido return static_cast<clang::Decl *>(decl.GetOpaqueDecl()); 1359153876Sguido} 1360153876Sguido 1361153876Sguidoclang::DeclContext * 1362153876SguidoPdbAstBuilder::FromCompilerDeclContext(CompilerDeclContext context) { 1363153876Sguido return static_cast<clang::DeclContext *>(context.GetOpaqueDeclContext()); 1364153876Sguido} 1365153876Sguido 1366153876Sguidovoid PdbAstBuilder::Dump(Stream &stream) { m_clang.Dump(stream); } 1367153876Sguido