1 //===-- SymbolFileNativePDB.cpp -------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "SymbolFileNativePDB.h"
10 
11 #include "clang/AST/Attr.h"
12 #include "clang/AST/CharUnits.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/Type.h"
16 
17 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
18 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
19 #include "Plugins/ObjectFile/PDB/ObjectFilePDB.h"
20 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
21 #include "lldb/Core/Module.h"
22 #include "lldb/Core/PluginManager.h"
23 #include "lldb/Core/StreamBuffer.h"
24 #include "lldb/Core/StreamFile.h"
25 #include "lldb/Symbol/CompileUnit.h"
26 #include "lldb/Symbol/LineTable.h"
27 #include "lldb/Symbol/ObjectFile.h"
28 #include "lldb/Symbol/SymbolContext.h"
29 #include "lldb/Symbol/SymbolVendor.h"
30 #include "lldb/Symbol/Variable.h"
31 #include "lldb/Symbol/VariableList.h"
32 #include "lldb/Utility/LLDBLog.h"
33 #include "lldb/Utility/Log.h"
34 
35 #include "llvm/DebugInfo/CodeView/CVRecord.h"
36 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
37 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
38 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
39 #include "llvm/DebugInfo/CodeView/RecordName.h"
40 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
41 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
42 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
43 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
44 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
45 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
46 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
47 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
48 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
49 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
50 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
51 #include "llvm/DebugInfo/PDB/PDB.h"
52 #include "llvm/DebugInfo/PDB/PDBTypes.h"
53 #include "llvm/Demangle/MicrosoftDemangle.h"
54 #include "llvm/Object/COFF.h"
55 #include "llvm/Support/Allocator.h"
56 #include "llvm/Support/BinaryStreamReader.h"
57 #include "llvm/Support/Error.h"
58 #include "llvm/Support/ErrorOr.h"
59 #include "llvm/Support/MemoryBuffer.h"
60 
61 #include "DWARFLocationExpression.h"
62 #include "PdbAstBuilder.h"
63 #include "PdbSymUid.h"
64 #include "PdbUtil.h"
65 #include "UdtRecordCompleter.h"
66 
67 using namespace lldb;
68 using namespace lldb_private;
69 using namespace npdb;
70 using namespace llvm::codeview;
71 using namespace llvm::pdb;
72 
73 char SymbolFileNativePDB::ID;
74 
75 static lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
76   switch (lang) {
77   case PDB_Lang::Cpp:
78     return lldb::LanguageType::eLanguageTypeC_plus_plus;
79   case PDB_Lang::C:
80     return lldb::LanguageType::eLanguageTypeC;
81   case PDB_Lang::Swift:
82     return lldb::LanguageType::eLanguageTypeSwift;
83   case PDB_Lang::Rust:
84     return lldb::LanguageType::eLanguageTypeRust;
85   default:
86     return lldb::LanguageType::eLanguageTypeUnknown;
87   }
88 }
89 
90 static std::unique_ptr<PDBFile>
91 loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
92   // Try to find a matching PDB for an EXE.
93   using namespace llvm::object;
94   auto expected_binary = createBinary(exe_path);
95 
96   // If the file isn't a PE/COFF executable, fail.
97   if (!expected_binary) {
98     llvm::consumeError(expected_binary.takeError());
99     return nullptr;
100   }
101   OwningBinary<Binary> binary = std::move(*expected_binary);
102 
103   // TODO: Avoid opening the PE/COFF binary twice by reading this information
104   // directly from the lldb_private::ObjectFile.
105   auto *obj = llvm::dyn_cast<llvm::object::COFFObjectFile>(binary.getBinary());
106   if (!obj)
107     return nullptr;
108   const llvm::codeview::DebugInfo *pdb_info = nullptr;
109 
110   // If it doesn't have a debug directory, fail.
111   llvm::StringRef pdb_file;
112   if (llvm::Error e = obj->getDebugPDBInfo(pdb_info, pdb_file)) {
113     consumeError(std::move(e));
114     return nullptr;
115   }
116 
117   // If the file doesn't exist, perhaps the path specified at build time
118   // doesn't match the PDB's current location, so check the location of the
119   // executable.
120   if (!FileSystem::Instance().Exists(pdb_file)) {
121     const auto exe_dir = FileSpec(exe_path).CopyByRemovingLastPathComponent();
122     const auto pdb_name = FileSpec(pdb_file).GetFilename().GetCString();
123     pdb_file = exe_dir.CopyByAppendingPathComponent(pdb_name).GetCString();
124   }
125 
126   // If the file is not a PDB or if it doesn't have a matching GUID, fail.
127   auto pdb = ObjectFilePDB::loadPDBFile(std::string(pdb_file), allocator);
128   if (!pdb)
129     return nullptr;
130 
131   auto expected_info = pdb->getPDBInfoStream();
132   if (!expected_info) {
133     llvm::consumeError(expected_info.takeError());
134     return nullptr;
135   }
136   llvm::codeview::GUID guid;
137   memcpy(&guid, pdb_info->PDB70.Signature, 16);
138 
139   if (expected_info->getGuid() != guid)
140     return nullptr;
141   return pdb;
142 }
143 
144 static bool IsFunctionPrologue(const CompilandIndexItem &cci,
145                                lldb::addr_t addr) {
146   // FIXME: Implement this.
147   return false;
148 }
149 
150 static bool IsFunctionEpilogue(const CompilandIndexItem &cci,
151                                lldb::addr_t addr) {
152   // FIXME: Implement this.
153   return false;
154 }
155 
156 static llvm::StringRef GetSimpleTypeName(SimpleTypeKind kind) {
157   switch (kind) {
158   case SimpleTypeKind::Boolean128:
159   case SimpleTypeKind::Boolean16:
160   case SimpleTypeKind::Boolean32:
161   case SimpleTypeKind::Boolean64:
162   case SimpleTypeKind::Boolean8:
163     return "bool";
164   case SimpleTypeKind::Byte:
165   case SimpleTypeKind::UnsignedCharacter:
166     return "unsigned char";
167   case SimpleTypeKind::NarrowCharacter:
168     return "char";
169   case SimpleTypeKind::SignedCharacter:
170   case SimpleTypeKind::SByte:
171     return "signed char";
172   case SimpleTypeKind::Character16:
173     return "char16_t";
174   case SimpleTypeKind::Character32:
175     return "char32_t";
176   case SimpleTypeKind::Character8:
177     return "char8_t";
178   case SimpleTypeKind::Complex80:
179   case SimpleTypeKind::Complex64:
180   case SimpleTypeKind::Complex32:
181     return "complex";
182   case SimpleTypeKind::Float128:
183   case SimpleTypeKind::Float80:
184     return "long double";
185   case SimpleTypeKind::Float64:
186     return "double";
187   case SimpleTypeKind::Float32:
188     return "float";
189   case SimpleTypeKind::Float16:
190     return "single";
191   case SimpleTypeKind::Int128:
192     return "__int128";
193   case SimpleTypeKind::Int64:
194   case SimpleTypeKind::Int64Quad:
195     return "int64_t";
196   case SimpleTypeKind::Int32:
197     return "int";
198   case SimpleTypeKind::Int16:
199     return "short";
200   case SimpleTypeKind::UInt128:
201     return "unsigned __int128";
202   case SimpleTypeKind::UInt64:
203   case SimpleTypeKind::UInt64Quad:
204     return "uint64_t";
205   case SimpleTypeKind::HResult:
206     return "HRESULT";
207   case SimpleTypeKind::UInt32:
208     return "unsigned";
209   case SimpleTypeKind::UInt16:
210   case SimpleTypeKind::UInt16Short:
211     return "unsigned short";
212   case SimpleTypeKind::Int32Long:
213     return "long";
214   case SimpleTypeKind::UInt32Long:
215     return "unsigned long";
216   case SimpleTypeKind::Void:
217     return "void";
218   case SimpleTypeKind::WideCharacter:
219     return "wchar_t";
220   default:
221     return "";
222   }
223 }
224 
225 static bool IsClassRecord(TypeLeafKind kind) {
226   switch (kind) {
227   case LF_STRUCTURE:
228   case LF_CLASS:
229   case LF_INTERFACE:
230     return true;
231   default:
232     return false;
233   }
234 }
235 
236 void SymbolFileNativePDB::Initialize() {
237   PluginManager::RegisterPlugin(GetPluginNameStatic(),
238                                 GetPluginDescriptionStatic(), CreateInstance,
239                                 DebuggerInitialize);
240 }
241 
242 void SymbolFileNativePDB::Terminate() {
243   PluginManager::UnregisterPlugin(CreateInstance);
244 }
245 
246 void SymbolFileNativePDB::DebuggerInitialize(Debugger &debugger) {}
247 
248 llvm::StringRef SymbolFileNativePDB::GetPluginDescriptionStatic() {
249   return "Microsoft PDB debug symbol cross-platform file reader.";
250 }
251 
252 SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
253   return new SymbolFileNativePDB(std::move(objfile_sp));
254 }
255 
256 SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
257     : SymbolFileCommon(std::move(objfile_sp)) {}
258 
259 SymbolFileNativePDB::~SymbolFileNativePDB() = default;
260 
261 uint32_t SymbolFileNativePDB::CalculateAbilities() {
262   uint32_t abilities = 0;
263   if (!m_objfile_sp)
264     return 0;
265 
266   if (!m_index) {
267     // Lazily load and match the PDB file, but only do this once.
268     PDBFile *pdb_file;
269     if (auto *pdb = llvm::dyn_cast<ObjectFilePDB>(m_objfile_sp.get())) {
270       pdb_file = &pdb->GetPDBFile();
271     } else {
272       m_file_up = loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(),
273                                       m_allocator);
274       pdb_file = m_file_up.get();
275     }
276 
277     if (!pdb_file)
278       return 0;
279 
280     auto expected_index = PdbIndex::create(pdb_file);
281     if (!expected_index) {
282       llvm::consumeError(expected_index.takeError());
283       return 0;
284     }
285     m_index = std::move(*expected_index);
286   }
287   if (!m_index)
288     return 0;
289 
290   // We don't especially have to be precise here.  We only distinguish between
291   // stripped and not stripped.
292   abilities = kAllAbilities;
293 
294   if (m_index->dbi().isStripped())
295     abilities &= ~(Blocks | LocalVariables);
296   return abilities;
297 }
298 
299 void SymbolFileNativePDB::InitializeObject() {
300   m_obj_load_address = m_objfile_sp->GetModule()
301                            ->GetObjectFile()
302                            ->GetBaseAddress()
303                            .GetFileAddress();
304   m_index->SetLoadAddress(m_obj_load_address);
305   m_index->ParseSectionContribs();
306 
307   auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
308       lldb::eLanguageTypeC_plus_plus);
309   if (auto err = ts_or_err.takeError()) {
310     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
311                    "Failed to initialize");
312   } else {
313     ts_or_err->SetSymbolFile(this);
314     auto *clang = llvm::cast_or_null<TypeSystemClang>(&ts_or_err.get());
315     lldbassert(clang);
316     m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
317   }
318 }
319 
320 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
321   const DbiModuleList &modules = m_index->dbi().modules();
322   uint32_t count = modules.getModuleCount();
323   if (count == 0)
324     return count;
325 
326   // The linker can inject an additional "dummy" compilation unit into the
327   // PDB. Ignore this special compile unit for our purposes, if it is there.
328   // It is always the last one.
329   DbiModuleDescriptor last = modules.getModuleDescriptor(count - 1);
330   if (last.getModuleName() == "* Linker *")
331     --count;
332   return count;
333 }
334 
335 Block &SymbolFileNativePDB::CreateBlock(PdbCompilandSymId block_id) {
336   CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
337   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);
338   CompUnitSP comp_unit = GetOrCreateCompileUnit(*cii);
339   lldb::user_id_t opaque_block_uid = toOpaqueUid(block_id);
340   BlockSP child_block = std::make_shared<Block>(opaque_block_uid);
341 
342   switch (sym.kind()) {
343   case S_GPROC32:
344   case S_LPROC32: {
345     // This is a function.  It must be global.  Creating the Function entry
346     // for it automatically creates a block for it.
347     FunctionSP func = GetOrCreateFunction(block_id, *comp_unit);
348     Block &block = func->GetBlock(false);
349     if (block.GetNumRanges() == 0)
350       block.AddRange(Block::Range(0, func->GetAddressRange().GetByteSize()));
351     return block;
352   }
353   case S_BLOCK32: {
354     // This is a block.  Its parent is either a function or another block.  In
355     // either case, its parent can be viewed as a block (e.g. a function
356     // contains 1 big block.  So just get the parent block and add this block
357     // to it.
358     BlockSym block(static_cast<SymbolRecordKind>(sym.kind()));
359     cantFail(SymbolDeserializer::deserializeAs<BlockSym>(sym, block));
360     lldbassert(block.Parent != 0);
361     PdbCompilandSymId parent_id(block_id.modi, block.Parent);
362     Block &parent_block = GetOrCreateBlock(parent_id);
363     parent_block.AddChild(child_block);
364     m_ast->GetOrCreateBlockDecl(block_id);
365     m_blocks.insert({opaque_block_uid, child_block});
366     break;
367   }
368   case S_INLINESITE: {
369     // This ensures line table is parsed first so we have inline sites info.
370     comp_unit->GetLineTable();
371 
372     std::shared_ptr<InlineSite> inline_site = m_inline_sites[opaque_block_uid];
373     Block &parent_block = GetOrCreateBlock(inline_site->parent_id);
374     parent_block.AddChild(child_block);
375     m_ast->GetOrCreateInlinedFunctionDecl(block_id);
376     // Copy ranges from InlineSite to Block.
377     for (size_t i = 0; i < inline_site->ranges.GetSize(); ++i) {
378       auto *entry = inline_site->ranges.GetEntryAtIndex(i);
379       child_block->AddRange(
380           Block::Range(entry->GetRangeBase(), entry->GetByteSize()));
381     }
382     child_block->FinalizeRanges();
383 
384     // Get the inlined function callsite info.
385     Declaration &decl = inline_site->inline_function_info->GetDeclaration();
386     Declaration &callsite = inline_site->inline_function_info->GetCallSite();
387     child_block->SetInlinedFunctionInfo(
388         inline_site->inline_function_info->GetName().GetCString(), nullptr,
389         &decl, &callsite);
390     m_blocks.insert({opaque_block_uid, child_block});
391     break;
392   }
393   default:
394     lldbassert(false && "Symbol is not a block!");
395   }
396 
397   return *child_block;
398 }
399 
400 lldb::FunctionSP SymbolFileNativePDB::CreateFunction(PdbCompilandSymId func_id,
401                                                      CompileUnit &comp_unit) {
402   const CompilandIndexItem *cci =
403       m_index->compilands().GetCompiland(func_id.modi);
404   lldbassert(cci);
405   CVSymbol sym_record = cci->m_debug_stream.readSymbolAtOffset(func_id.offset);
406 
407   lldbassert(sym_record.kind() == S_LPROC32 || sym_record.kind() == S_GPROC32);
408   SegmentOffsetLength sol = GetSegmentOffsetAndLength(sym_record);
409 
410   auto file_vm_addr =
411       m_index->MakeVirtualAddress(sol.so.segment, sol.so.offset);
412   if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
413     return nullptr;
414 
415   AddressRange func_range(file_vm_addr, sol.length,
416                           comp_unit.GetModule()->GetSectionList());
417   if (!func_range.GetBaseAddress().IsValid())
418     return nullptr;
419 
420   ProcSym proc(static_cast<SymbolRecordKind>(sym_record.kind()));
421   cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym_record, proc));
422   if (proc.FunctionType == TypeIndex::None())
423     return nullptr;
424   TypeSP func_type = GetOrCreateType(proc.FunctionType);
425   if (!func_type)
426     return nullptr;
427 
428   PdbTypeSymId sig_id(proc.FunctionType, false);
429   Mangled mangled(proc.Name);
430   FunctionSP func_sp = std::make_shared<Function>(
431       &comp_unit, toOpaqueUid(func_id), toOpaqueUid(sig_id), mangled,
432       func_type.get(), func_range);
433 
434   comp_unit.AddFunction(func_sp);
435 
436   m_ast->GetOrCreateFunctionDecl(func_id);
437 
438   return func_sp;
439 }
440 
441 CompUnitSP
442 SymbolFileNativePDB::CreateCompileUnit(const CompilandIndexItem &cci) {
443   lldb::LanguageType lang =
444       cci.m_compile_opts ? TranslateLanguage(cci.m_compile_opts->getLanguage())
445                          : lldb::eLanguageTypeUnknown;
446 
447   LazyBool optimized = eLazyBoolNo;
448   if (cci.m_compile_opts && cci.m_compile_opts->hasOptimizations())
449     optimized = eLazyBoolYes;
450 
451   llvm::SmallString<64> source_file_name =
452       m_index->compilands().GetMainSourceFile(cci);
453   FileSpec fs(llvm::sys::path::convert_to_slash(
454       source_file_name, llvm::sys::path::Style::windows_backslash));
455 
456   CompUnitSP cu_sp =
457       std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr, fs,
458                                     toOpaqueUid(cci.m_id), lang, optimized);
459 
460   SetCompileUnitAtIndex(cci.m_id.modi, cu_sp);
461   return cu_sp;
462 }
463 
464 lldb::TypeSP SymbolFileNativePDB::CreateModifierType(PdbTypeSymId type_id,
465                                                      const ModifierRecord &mr,
466                                                      CompilerType ct) {
467   TpiStream &stream = m_index->tpi();
468 
469   std::string name;
470   if (mr.ModifiedType.isSimple())
471     name = std::string(GetSimpleTypeName(mr.ModifiedType.getSimpleKind()));
472   else
473     name = computeTypeName(stream.typeCollection(), mr.ModifiedType);
474   Declaration decl;
475   lldb::TypeSP modified_type = GetOrCreateType(mr.ModifiedType);
476 
477   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(name),
478                                 modified_type->GetByteSize(nullptr), nullptr,
479                                 LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
480                                 ct, Type::ResolveState::Full);
481 }
482 
483 lldb::TypeSP
484 SymbolFileNativePDB::CreatePointerType(PdbTypeSymId type_id,
485                                        const llvm::codeview::PointerRecord &pr,
486                                        CompilerType ct) {
487   TypeSP pointee = GetOrCreateType(pr.ReferentType);
488   if (!pointee)
489     return nullptr;
490 
491   if (pr.isPointerToMember()) {
492     MemberPointerInfo mpi = pr.getMemberInfo();
493     GetOrCreateType(mpi.ContainingType);
494   }
495 
496   Declaration decl;
497   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(),
498                                 pr.getSize(), nullptr, LLDB_INVALID_UID,
499                                 Type::eEncodingIsUID, decl, ct,
500                                 Type::ResolveState::Full);
501 }
502 
503 lldb::TypeSP SymbolFileNativePDB::CreateSimpleType(TypeIndex ti,
504                                                    CompilerType ct) {
505   uint64_t uid = toOpaqueUid(PdbTypeSymId(ti, false));
506   if (ti == TypeIndex::NullptrT()) {
507     Declaration decl;
508     return std::make_shared<Type>(
509         uid, this, ConstString("std::nullptr_t"), 0, nullptr, LLDB_INVALID_UID,
510         Type::eEncodingIsUID, decl, ct, Type::ResolveState::Full);
511   }
512 
513   if (ti.getSimpleMode() != SimpleTypeMode::Direct) {
514     TypeSP direct_sp = GetOrCreateType(ti.makeDirect());
515     uint32_t pointer_size = 0;
516     switch (ti.getSimpleMode()) {
517     case SimpleTypeMode::FarPointer32:
518     case SimpleTypeMode::NearPointer32:
519       pointer_size = 4;
520       break;
521     case SimpleTypeMode::NearPointer64:
522       pointer_size = 8;
523       break;
524     default:
525       // 128-bit and 16-bit pointers unsupported.
526       return nullptr;
527     }
528     Declaration decl;
529     return std::make_shared<Type>(
530         uid, this, ConstString(), pointer_size, nullptr, LLDB_INVALID_UID,
531         Type::eEncodingIsUID, decl, ct, Type::ResolveState::Full);
532   }
533 
534   if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated)
535     return nullptr;
536 
537   size_t size = GetTypeSizeForSimpleKind(ti.getSimpleKind());
538   llvm::StringRef type_name = GetSimpleTypeName(ti.getSimpleKind());
539 
540   Declaration decl;
541   return std::make_shared<Type>(uid, this, ConstString(type_name), size,
542                                 nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
543                                 decl, ct, Type::ResolveState::Full);
544 }
545 
546 static std::string GetUnqualifiedTypeName(const TagRecord &record) {
547   if (!record.hasUniqueName()) {
548     MSVCUndecoratedNameParser parser(record.Name);
549     llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
550 
551     return std::string(specs.back().GetBaseName());
552   }
553 
554   llvm::ms_demangle::Demangler demangler;
555   StringView sv(record.UniqueName.begin(), record.UniqueName.size());
556   llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
557   if (demangler.Error)
558     return std::string(record.Name);
559 
560   llvm::ms_demangle::IdentifierNode *idn =
561       ttn->QualifiedName->getUnqualifiedIdentifier();
562   return idn->toString();
563 }
564 
565 lldb::TypeSP
566 SymbolFileNativePDB::CreateClassStructUnion(PdbTypeSymId type_id,
567                                             const TagRecord &record,
568                                             size_t size, CompilerType ct) {
569 
570   std::string uname = GetUnqualifiedTypeName(record);
571 
572   // FIXME: Search IPI stream for LF_UDT_MOD_SRC_LINE.
573   Declaration decl;
574   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(uname),
575                                 size, nullptr, LLDB_INVALID_UID,
576                                 Type::eEncodingIsUID, decl, ct,
577                                 Type::ResolveState::Forward);
578 }
579 
580 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
581                                                 const ClassRecord &cr,
582                                                 CompilerType ct) {
583   return CreateClassStructUnion(type_id, cr, cr.getSize(), ct);
584 }
585 
586 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
587                                                 const UnionRecord &ur,
588                                                 CompilerType ct) {
589   return CreateClassStructUnion(type_id, ur, ur.getSize(), ct);
590 }
591 
592 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
593                                                 const EnumRecord &er,
594                                                 CompilerType ct) {
595   std::string uname = GetUnqualifiedTypeName(er);
596 
597   Declaration decl;
598   TypeSP underlying_type = GetOrCreateType(er.UnderlyingType);
599 
600   return std::make_shared<lldb_private::Type>(
601       toOpaqueUid(type_id), this, ConstString(uname),
602       underlying_type->GetByteSize(nullptr), nullptr, LLDB_INVALID_UID,
603       lldb_private::Type::eEncodingIsUID, decl, ct,
604       lldb_private::Type::ResolveState::Forward);
605 }
606 
607 TypeSP SymbolFileNativePDB::CreateArrayType(PdbTypeSymId type_id,
608                                             const ArrayRecord &ar,
609                                             CompilerType ct) {
610   TypeSP element_type = GetOrCreateType(ar.ElementType);
611 
612   Declaration decl;
613   TypeSP array_sp = std::make_shared<lldb_private::Type>(
614       toOpaqueUid(type_id), this, ConstString(), ar.Size, nullptr,
615       LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, ct,
616       lldb_private::Type::ResolveState::Full);
617   array_sp->SetEncodingType(element_type.get());
618   return array_sp;
619 }
620 
621 
622 TypeSP SymbolFileNativePDB::CreateFunctionType(PdbTypeSymId type_id,
623                                                const MemberFunctionRecord &mfr,
624                                                CompilerType ct) {
625   Declaration decl;
626   return std::make_shared<lldb_private::Type>(
627       toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID,
628       lldb_private::Type::eEncodingIsUID, decl, ct,
629       lldb_private::Type::ResolveState::Full);
630 }
631 
632 TypeSP SymbolFileNativePDB::CreateProcedureType(PdbTypeSymId type_id,
633                                                 const ProcedureRecord &pr,
634                                                 CompilerType ct) {
635   Declaration decl;
636   return std::make_shared<lldb_private::Type>(
637       toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID,
638       lldb_private::Type::eEncodingIsUID, decl, ct,
639       lldb_private::Type::ResolveState::Full);
640 }
641 
642 TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
643   if (type_id.index.isSimple())
644     return CreateSimpleType(type_id.index, ct);
645 
646   TpiStream &stream = type_id.is_ipi ? m_index->ipi() : m_index->tpi();
647   CVType cvt = stream.getType(type_id.index);
648 
649   if (cvt.kind() == LF_MODIFIER) {
650     ModifierRecord modifier;
651     llvm::cantFail(
652         TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
653     return CreateModifierType(type_id, modifier, ct);
654   }
655 
656   if (cvt.kind() == LF_POINTER) {
657     PointerRecord pointer;
658     llvm::cantFail(
659         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
660     return CreatePointerType(type_id, pointer, ct);
661   }
662 
663   if (IsClassRecord(cvt.kind())) {
664     ClassRecord cr;
665     llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
666     return CreateTagType(type_id, cr, ct);
667   }
668 
669   if (cvt.kind() == LF_ENUM) {
670     EnumRecord er;
671     llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
672     return CreateTagType(type_id, er, ct);
673   }
674 
675   if (cvt.kind() == LF_UNION) {
676     UnionRecord ur;
677     llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
678     return CreateTagType(type_id, ur, ct);
679   }
680 
681   if (cvt.kind() == LF_ARRAY) {
682     ArrayRecord ar;
683     llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
684     return CreateArrayType(type_id, ar, ct);
685   }
686 
687   if (cvt.kind() == LF_PROCEDURE) {
688     ProcedureRecord pr;
689     llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
690     return CreateProcedureType(type_id, pr, ct);
691   }
692   if (cvt.kind() == LF_MFUNCTION) {
693     MemberFunctionRecord mfr;
694     llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
695     return CreateFunctionType(type_id, mfr, ct);
696   }
697 
698   return nullptr;
699 }
700 
701 TypeSP SymbolFileNativePDB::CreateAndCacheType(PdbTypeSymId type_id) {
702   // If they search for a UDT which is a forward ref, try and resolve the full
703   // decl and just map the forward ref uid to the full decl record.
704   llvm::Optional<PdbTypeSymId> full_decl_uid;
705   if (IsForwardRefUdt(type_id, m_index->tpi())) {
706     auto expected_full_ti =
707         m_index->tpi().findFullDeclForForwardRef(type_id.index);
708     if (!expected_full_ti)
709       llvm::consumeError(expected_full_ti.takeError());
710     else if (*expected_full_ti != type_id.index) {
711       full_decl_uid = PdbTypeSymId(*expected_full_ti, false);
712 
713       // It's possible that a lookup would occur for the full decl causing it
714       // to be cached, then a second lookup would occur for the forward decl.
715       // We don't want to create a second full decl, so make sure the full
716       // decl hasn't already been cached.
717       auto full_iter = m_types.find(toOpaqueUid(*full_decl_uid));
718       if (full_iter != m_types.end()) {
719         TypeSP result = full_iter->second;
720         // Map the forward decl to the TypeSP for the full decl so we can take
721         // the fast path next time.
722         m_types[toOpaqueUid(type_id)] = result;
723         return result;
724       }
725     }
726   }
727 
728   PdbTypeSymId best_decl_id = full_decl_uid ? *full_decl_uid : type_id;
729 
730   clang::QualType qt = m_ast->GetOrCreateType(best_decl_id);
731   if (qt.isNull())
732     return nullptr;
733 
734   TypeSP result = CreateType(best_decl_id, m_ast->ToCompilerType(qt));
735   if (!result)
736     return nullptr;
737 
738   uint64_t best_uid = toOpaqueUid(best_decl_id);
739   m_types[best_uid] = result;
740   // If we had both a forward decl and a full decl, make both point to the new
741   // type.
742   if (full_decl_uid)
743     m_types[toOpaqueUid(type_id)] = result;
744 
745   return result;
746 }
747 
748 TypeSP SymbolFileNativePDB::GetOrCreateType(PdbTypeSymId type_id) {
749   // We can't use try_emplace / overwrite here because the process of creating
750   // a type could create nested types, which could invalidate iterators.  So
751   // we have to do a 2-phase lookup / insert.
752   auto iter = m_types.find(toOpaqueUid(type_id));
753   if (iter != m_types.end())
754     return iter->second;
755 
756   TypeSP type = CreateAndCacheType(type_id);
757   if (type)
758     GetTypeList().Insert(type);
759   return type;
760 }
761 
762 VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
763   CVSymbol sym = m_index->symrecords().readRecord(var_id.offset);
764   if (sym.kind() == S_CONSTANT)
765     return CreateConstantSymbol(var_id, sym);
766 
767   lldb::ValueType scope = eValueTypeInvalid;
768   TypeIndex ti;
769   llvm::StringRef name;
770   lldb::addr_t addr = 0;
771   uint16_t section = 0;
772   uint32_t offset = 0;
773   bool is_external = false;
774   switch (sym.kind()) {
775   case S_GDATA32:
776     is_external = true;
777     LLVM_FALLTHROUGH;
778   case S_LDATA32: {
779     DataSym ds(sym.kind());
780     llvm::cantFail(SymbolDeserializer::deserializeAs<DataSym>(sym, ds));
781     ti = ds.Type;
782     scope = (sym.kind() == S_GDATA32) ? eValueTypeVariableGlobal
783                                       : eValueTypeVariableStatic;
784     name = ds.Name;
785     section = ds.Segment;
786     offset = ds.DataOffset;
787     addr = m_index->MakeVirtualAddress(ds.Segment, ds.DataOffset);
788     break;
789   }
790   case S_GTHREAD32:
791     is_external = true;
792     LLVM_FALLTHROUGH;
793   case S_LTHREAD32: {
794     ThreadLocalDataSym tlds(sym.kind());
795     llvm::cantFail(
796         SymbolDeserializer::deserializeAs<ThreadLocalDataSym>(sym, tlds));
797     ti = tlds.Type;
798     name = tlds.Name;
799     section = tlds.Segment;
800     offset = tlds.DataOffset;
801     addr = m_index->MakeVirtualAddress(tlds.Segment, tlds.DataOffset);
802     scope = eValueTypeVariableThreadLocal;
803     break;
804   }
805   default:
806     llvm_unreachable("unreachable!");
807   }
808 
809   CompUnitSP comp_unit;
810   llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(addr);
811   if (!modi) {
812     return nullptr;
813   }
814 
815   CompilandIndexItem &cci = m_index->compilands().GetOrCreateCompiland(*modi);
816   comp_unit = GetOrCreateCompileUnit(cci);
817 
818   Declaration decl;
819   PdbTypeSymId tid(ti, false);
820   SymbolFileTypeSP type_sp =
821       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
822   Variable::RangeList ranges;
823 
824   m_ast->GetOrCreateVariableDecl(var_id);
825 
826   ModuleSP module_sp = GetObjectFile()->GetModule();
827   DWARFExpressionList location(
828       module_sp, MakeGlobalLocationExpression(section, offset, module_sp),
829       nullptr);
830 
831   std::string global_name("::");
832   global_name += name;
833   bool artificial = false;
834   bool location_is_constant_data = false;
835   bool static_member = false;
836   VariableSP var_sp = std::make_shared<Variable>(
837       toOpaqueUid(var_id), name.str().c_str(), global_name.c_str(), type_sp,
838       scope, comp_unit.get(), ranges, &decl, location, is_external, artificial,
839       location_is_constant_data, static_member);
840 
841   return var_sp;
842 }
843 
844 lldb::VariableSP
845 SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
846                                           const CVSymbol &cvs) {
847   TpiStream &tpi = m_index->tpi();
848   ConstantSym constant(cvs.kind());
849 
850   llvm::cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(cvs, constant));
851   std::string global_name("::");
852   global_name += constant.Name;
853   PdbTypeSymId tid(constant.Type, false);
854   SymbolFileTypeSP type_sp =
855       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
856 
857   Declaration decl;
858   Variable::RangeList ranges;
859   ModuleSP module = GetObjectFile()->GetModule();
860   DWARFExpressionList location(module,
861                                MakeConstantLocationExpression(
862                                    constant.Type, tpi, constant.Value, module),
863                                nullptr);
864 
865   bool external = false;
866   bool artificial = false;
867   bool location_is_constant_data = true;
868   bool static_member = false;
869   VariableSP var_sp = std::make_shared<Variable>(
870       toOpaqueUid(var_id), constant.Name.str().c_str(), global_name.c_str(),
871       type_sp, eValueTypeVariableGlobal, module.get(), ranges, &decl, location,
872       external, artificial, location_is_constant_data, static_member);
873   return var_sp;
874 }
875 
876 VariableSP
877 SymbolFileNativePDB::GetOrCreateGlobalVariable(PdbGlobalSymId var_id) {
878   auto emplace_result = m_global_vars.try_emplace(toOpaqueUid(var_id), nullptr);
879   if (emplace_result.second) {
880     if (VariableSP var_sp = CreateGlobalVariable(var_id))
881       emplace_result.first->second = var_sp;
882     else
883       return nullptr;
884   }
885 
886   return emplace_result.first->second;
887 }
888 
889 lldb::TypeSP SymbolFileNativePDB::GetOrCreateType(TypeIndex ti) {
890   return GetOrCreateType(PdbTypeSymId(ti, false));
891 }
892 
893 FunctionSP SymbolFileNativePDB::GetOrCreateFunction(PdbCompilandSymId func_id,
894                                                     CompileUnit &comp_unit) {
895   auto emplace_result = m_functions.try_emplace(toOpaqueUid(func_id), nullptr);
896   if (emplace_result.second)
897     emplace_result.first->second = CreateFunction(func_id, comp_unit);
898 
899   return emplace_result.first->second;
900 }
901 
902 CompUnitSP
903 SymbolFileNativePDB::GetOrCreateCompileUnit(const CompilandIndexItem &cci) {
904 
905   auto emplace_result =
906       m_compilands.try_emplace(toOpaqueUid(cci.m_id), nullptr);
907   if (emplace_result.second)
908     emplace_result.first->second = CreateCompileUnit(cci);
909 
910   lldbassert(emplace_result.first->second);
911   return emplace_result.first->second;
912 }
913 
914 Block &SymbolFileNativePDB::GetOrCreateBlock(PdbCompilandSymId block_id) {
915   auto iter = m_blocks.find(toOpaqueUid(block_id));
916   if (iter != m_blocks.end())
917     return *iter->second;
918 
919   return CreateBlock(block_id);
920 }
921 
922 void SymbolFileNativePDB::ParseDeclsForContext(
923     lldb_private::CompilerDeclContext decl_ctx) {
924   clang::DeclContext *context = m_ast->FromCompilerDeclContext(decl_ctx);
925   if (!context)
926     return;
927   m_ast->ParseDeclsForContext(*context);
928 }
929 
930 lldb::CompUnitSP SymbolFileNativePDB::ParseCompileUnitAtIndex(uint32_t index) {
931   if (index >= GetNumCompileUnits())
932     return CompUnitSP();
933   lldbassert(index < UINT16_MAX);
934   if (index >= UINT16_MAX)
935     return nullptr;
936 
937   CompilandIndexItem &item = m_index->compilands().GetOrCreateCompiland(index);
938 
939   return GetOrCreateCompileUnit(item);
940 }
941 
942 lldb::LanguageType SymbolFileNativePDB::ParseLanguage(CompileUnit &comp_unit) {
943   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
944   PdbSymUid uid(comp_unit.GetID());
945   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
946 
947   CompilandIndexItem *item =
948       m_index->compilands().GetCompiland(uid.asCompiland().modi);
949   lldbassert(item);
950   if (!item->m_compile_opts)
951     return lldb::eLanguageTypeUnknown;
952 
953   return TranslateLanguage(item->m_compile_opts->getLanguage());
954 }
955 
956 void SymbolFileNativePDB::AddSymbols(Symtab &symtab) {}
957 
958 size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
959   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
960   PdbSymUid uid{comp_unit.GetID()};
961   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
962   uint16_t modi = uid.asCompiland().modi;
963   CompilandIndexItem &cii = m_index->compilands().GetOrCreateCompiland(modi);
964 
965   size_t count = comp_unit.GetNumFunctions();
966   const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray();
967   for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
968     if (iter->kind() != S_LPROC32 && iter->kind() != S_GPROC32)
969       continue;
970 
971     PdbCompilandSymId sym_id{modi, iter.offset()};
972 
973     FunctionSP func = GetOrCreateFunction(sym_id, comp_unit);
974   }
975 
976   size_t new_count = comp_unit.GetNumFunctions();
977   lldbassert(new_count >= count);
978   return new_count - count;
979 }
980 
981 static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
982   // If any of these flags are set, we need to resolve the compile unit.
983   uint32_t flags = eSymbolContextCompUnit;
984   flags |= eSymbolContextVariable;
985   flags |= eSymbolContextFunction;
986   flags |= eSymbolContextBlock;
987   flags |= eSymbolContextLineEntry;
988   return (resolve_scope & flags) != 0;
989 }
990 
991 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
992     const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {
993   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
994   uint32_t resolved_flags = 0;
995   lldb::addr_t file_addr = addr.GetFileAddress();
996 
997   if (NeedsResolvedCompileUnit(resolve_scope)) {
998     llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
999     if (!modi)
1000       return 0;
1001     CompUnitSP cu_sp = GetCompileUnitAtIndex(*modi);
1002     if (!cu_sp)
1003       return 0;
1004 
1005     sc.comp_unit = cu_sp.get();
1006     resolved_flags |= eSymbolContextCompUnit;
1007   }
1008 
1009   if (resolve_scope & eSymbolContextFunction ||
1010       resolve_scope & eSymbolContextBlock) {
1011     lldbassert(sc.comp_unit);
1012     std::vector<SymbolAndUid> matches = m_index->FindSymbolsByVa(file_addr);
1013     // Search the matches in reverse.  This way if there are multiple matches
1014     // (for example we are 3 levels deep in a nested scope) it will find the
1015     // innermost one first.
1016     for (const auto &match : llvm::reverse(matches)) {
1017       if (match.uid.kind() != PdbSymUidKind::CompilandSym)
1018         continue;
1019 
1020       PdbCompilandSymId csid = match.uid.asCompilandSym();
1021       CVSymbol cvs = m_index->ReadSymbolRecord(csid);
1022       PDB_SymType type = CVSymToPDBSym(cvs.kind());
1023       if (type != PDB_SymType::Function && type != PDB_SymType::Block)
1024         continue;
1025       if (type == PDB_SymType::Function) {
1026         sc.function = GetOrCreateFunction(csid, *sc.comp_unit).get();
1027         Block &block = sc.function->GetBlock(true);
1028         addr_t func_base =
1029             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
1030         addr_t offset = file_addr - func_base;
1031         sc.block = block.FindInnermostBlockByOffset(offset);
1032       }
1033 
1034       if (type == PDB_SymType::Block) {
1035         sc.block = &GetOrCreateBlock(csid);
1036         sc.function = sc.block->CalculateSymbolContextFunction();
1037       }
1038       if (sc.function)
1039         resolved_flags |= eSymbolContextFunction;
1040       if (sc.block)
1041         resolved_flags |= eSymbolContextBlock;
1042       break;
1043     }
1044   }
1045 
1046   if (resolve_scope & eSymbolContextLineEntry) {
1047     lldbassert(sc.comp_unit);
1048     if (auto *line_table = sc.comp_unit->GetLineTable()) {
1049       if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
1050         resolved_flags |= eSymbolContextLineEntry;
1051     }
1052   }
1053 
1054   return resolved_flags;
1055 }
1056 
1057 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
1058     const SourceLocationSpec &src_location_spec,
1059     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
1060   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1061   const uint32_t prev_size = sc_list.GetSize();
1062   if (resolve_scope & eSymbolContextCompUnit) {
1063     for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
1064          ++cu_idx) {
1065       CompileUnit *cu = ParseCompileUnitAtIndex(cu_idx).get();
1066       if (!cu)
1067         continue;
1068 
1069       bool file_spec_matches_cu_file_spec = FileSpec::Match(
1070           src_location_spec.GetFileSpec(), cu->GetPrimaryFile());
1071       if (file_spec_matches_cu_file_spec) {
1072         cu->ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
1073         break;
1074       }
1075     }
1076   }
1077   return sc_list.GetSize() - prev_size;
1078 }
1079 
1080 bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
1081   // Unfortunately LLDB is set up to parse the entire compile unit line table
1082   // all at once, even if all it really needs is line info for a specific
1083   // function.  In the future it would be nice if it could set the sc.m_function
1084   // member, and we could only get the line info for the function in question.
1085   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1086   PdbSymUid cu_id(comp_unit.GetID());
1087   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
1088   uint16_t modi = cu_id.asCompiland().modi;
1089   CompilandIndexItem *cii = m_index->compilands().GetCompiland(modi);
1090   lldbassert(cii);
1091 
1092   // Parse DEBUG_S_LINES subsections first, then parse all S_INLINESITE records
1093   // in this CU. Add line entries into the set first so that if there are line
1094   // entries with same addres, the later is always more accurate than the
1095   // former.
1096   std::set<LineTable::Entry, LineTableEntryComparator> line_set;
1097 
1098   // This is basically a copy of the .debug$S subsections from all original COFF
1099   // object files merged together with address relocations applied.  We are
1100   // looking for all DEBUG_S_LINES subsections.
1101   for (const DebugSubsectionRecord &dssr :
1102        cii->m_debug_stream.getSubsectionsArray()) {
1103     if (dssr.kind() != DebugSubsectionKind::Lines)
1104       continue;
1105 
1106     DebugLinesSubsectionRef lines;
1107     llvm::BinaryStreamReader reader(dssr.getRecordData());
1108     if (auto EC = lines.initialize(reader)) {
1109       llvm::consumeError(std::move(EC));
1110       return false;
1111     }
1112 
1113     const LineFragmentHeader *lfh = lines.header();
1114     uint64_t virtual_addr =
1115         m_index->MakeVirtualAddress(lfh->RelocSegment, lfh->RelocOffset);
1116     if (virtual_addr == LLDB_INVALID_ADDRESS)
1117       continue;
1118 
1119     for (const LineColumnEntry &group : lines) {
1120       llvm::Expected<uint32_t> file_index_or_err =
1121           GetFileIndex(*cii, group.NameIndex);
1122       if (!file_index_or_err)
1123         continue;
1124       uint32_t file_index = file_index_or_err.get();
1125       lldbassert(!group.LineNumbers.empty());
1126       CompilandIndexItem::GlobalLineTable::Entry line_entry(
1127           LLDB_INVALID_ADDRESS, 0);
1128       for (const LineNumberEntry &entry : group.LineNumbers) {
1129         LineInfo cur_info(entry.Flags);
1130 
1131         if (cur_info.isAlwaysStepInto() || cur_info.isNeverStepInto())
1132           continue;
1133 
1134         uint64_t addr = virtual_addr + entry.Offset;
1135 
1136         bool is_statement = cur_info.isStatement();
1137         bool is_prologue = IsFunctionPrologue(*cii, addr);
1138         bool is_epilogue = IsFunctionEpilogue(*cii, addr);
1139 
1140         uint32_t lno = cur_info.getStartLine();
1141 
1142         LineTable::Entry new_entry(addr, lno, 0, file_index, is_statement, false,
1143                                  is_prologue, is_epilogue, false);
1144         // Terminal entry has lower precedence than new entry.
1145         auto iter = line_set.find(new_entry);
1146         if (iter != line_set.end() && iter->is_terminal_entry)
1147           line_set.erase(iter);
1148         line_set.insert(new_entry);
1149 
1150         if (line_entry.GetRangeBase() != LLDB_INVALID_ADDRESS) {
1151           line_entry.SetRangeEnd(addr);
1152           cii->m_global_line_table.Append(line_entry);
1153         }
1154         line_entry.SetRangeBase(addr);
1155         line_entry.data = {file_index, lno};
1156       }
1157       LineInfo last_line(group.LineNumbers.back().Flags);
1158       line_set.emplace(virtual_addr + lfh->CodeSize, last_line.getEndLine(), 0,
1159                        file_index, false, false, false, false, true);
1160 
1161       if (line_entry.GetRangeBase() != LLDB_INVALID_ADDRESS) {
1162         line_entry.SetRangeEnd(virtual_addr + lfh->CodeSize);
1163         cii->m_global_line_table.Append(line_entry);
1164       }
1165     }
1166   }
1167 
1168   cii->m_global_line_table.Sort();
1169 
1170   // Parse all S_INLINESITE in this CU.
1171   const CVSymbolArray &syms = cii->m_debug_stream.getSymbolArray();
1172   for (auto iter = syms.begin(); iter != syms.end();) {
1173     if (iter->kind() != S_LPROC32 && iter->kind() != S_GPROC32) {
1174       ++iter;
1175       continue;
1176     }
1177 
1178     uint32_t record_offset = iter.offset();
1179     CVSymbol func_record =
1180         cii->m_debug_stream.readSymbolAtOffset(record_offset);
1181     SegmentOffsetLength sol = GetSegmentOffsetAndLength(func_record);
1182     addr_t file_vm_addr =
1183         m_index->MakeVirtualAddress(sol.so.segment, sol.so.offset);
1184     if (file_vm_addr == LLDB_INVALID_ADDRESS)
1185       continue;
1186 
1187     AddressRange func_range(file_vm_addr, sol.length,
1188                             comp_unit.GetModule()->GetSectionList());
1189     Address func_base = func_range.GetBaseAddress();
1190     PdbCompilandSymId func_id{modi, record_offset};
1191 
1192     // Iterate all S_INLINESITEs in the function.
1193     auto parse_inline_sites = [&](SymbolKind kind, PdbCompilandSymId id) {
1194       if (kind != S_INLINESITE)
1195         return false;
1196 
1197       ParseInlineSite(id, func_base);
1198 
1199       for (const auto &line_entry :
1200            m_inline_sites[toOpaqueUid(id)]->line_entries) {
1201         // If line_entry is not terminal entry, remove previous line entry at
1202         // the same address and insert new one. Terminal entry inside an inline
1203         // site might not be terminal entry for its parent.
1204         if (!line_entry.is_terminal_entry)
1205           line_set.erase(line_entry);
1206         line_set.insert(line_entry);
1207       }
1208       // No longer useful after adding to line_set.
1209       m_inline_sites[toOpaqueUid(id)]->line_entries.clear();
1210       return true;
1211     };
1212     ParseSymbolArrayInScope(func_id, parse_inline_sites);
1213     // Jump to the end of the function record.
1214     iter = syms.at(getScopeEndOffset(func_record));
1215   }
1216 
1217   cii->m_global_line_table.Clear();
1218 
1219   // Add line entries in line_set to line_table.
1220   auto line_table = std::make_unique<LineTable>(&comp_unit);
1221   std::unique_ptr<LineSequence> sequence(
1222       line_table->CreateLineSequenceContainer());
1223   for (const auto &line_entry : line_set) {
1224     line_table->AppendLineEntryToSequence(
1225         sequence.get(), line_entry.file_addr, line_entry.line,
1226         line_entry.column, line_entry.file_idx,
1227         line_entry.is_start_of_statement, line_entry.is_start_of_basic_block,
1228         line_entry.is_prologue_end, line_entry.is_epilogue_begin,
1229         line_entry.is_terminal_entry);
1230   }
1231   line_table->InsertSequence(sequence.get());
1232 
1233   if (line_table->GetSize() == 0)
1234     return false;
1235 
1236   comp_unit.SetLineTable(line_table.release());
1237   return true;
1238 }
1239 
1240 bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
1241   // PDB doesn't contain information about macros
1242   return false;
1243 }
1244 
1245 llvm::Expected<uint32_t>
1246 SymbolFileNativePDB::GetFileIndex(const CompilandIndexItem &cii,
1247                                   uint32_t file_id) {
1248   const auto &checksums = cii.m_strings.checksums().getArray();
1249   const auto &strings = cii.m_strings.strings();
1250   // Indices in this structure are actually offsets of records in the
1251   // DEBUG_S_FILECHECKSUMS subsection.  Those entries then have an index
1252   // into the global PDB string table.
1253   auto iter = checksums.at(file_id);
1254   if (iter == checksums.end())
1255     return llvm::make_error<RawError>(raw_error_code::no_entry);
1256 
1257   llvm::Expected<llvm::StringRef> efn = strings.getString(iter->FileNameOffset);
1258   if (!efn) {
1259     return efn.takeError();
1260   }
1261 
1262   // LLDB wants the index of the file in the list of support files.
1263   auto fn_iter = llvm::find(cii.m_file_list, *efn);
1264   if (fn_iter != cii.m_file_list.end())
1265     return std::distance(cii.m_file_list.begin(), fn_iter);
1266   return llvm::make_error<RawError>(raw_error_code::no_entry);
1267 }
1268 
1269 bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
1270                                             FileSpecList &support_files) {
1271   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1272   PdbSymUid cu_id(comp_unit.GetID());
1273   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
1274   CompilandIndexItem *cci =
1275       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
1276   lldbassert(cci);
1277 
1278   for (llvm::StringRef f : cci->m_file_list) {
1279     FileSpec::Style style =
1280         f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
1281     FileSpec spec(f, style);
1282     support_files.Append(spec);
1283   }
1284   return true;
1285 }
1286 
1287 bool SymbolFileNativePDB::ParseImportedModules(
1288     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
1289   // PDB does not yet support module debug info
1290   return false;
1291 }
1292 
1293 void SymbolFileNativePDB::ParseInlineSite(PdbCompilandSymId id,
1294                                           Address func_addr) {
1295   lldb::user_id_t opaque_uid = toOpaqueUid(id);
1296   if (m_inline_sites.find(opaque_uid) != m_inline_sites.end())
1297     return;
1298 
1299   addr_t func_base = func_addr.GetFileAddress();
1300   CompilandIndexItem *cii = m_index->compilands().GetCompiland(id.modi);
1301   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(id.offset);
1302   CompUnitSP comp_unit = GetOrCreateCompileUnit(*cii);
1303 
1304   InlineSiteSym inline_site(static_cast<SymbolRecordKind>(sym.kind()));
1305   cantFail(SymbolDeserializer::deserializeAs<InlineSiteSym>(sym, inline_site));
1306   PdbCompilandSymId parent_id(id.modi, inline_site.Parent);
1307 
1308   std::shared_ptr<InlineSite> inline_site_sp =
1309       std::make_shared<InlineSite>(parent_id);
1310 
1311   // Get the inlined function declaration info.
1312   auto iter = cii->m_inline_map.find(inline_site.Inlinee);
1313   if (iter == cii->m_inline_map.end())
1314     return;
1315   InlineeSourceLine inlinee_line = iter->second;
1316 
1317   const FileSpecList &files = comp_unit->GetSupportFiles();
1318   FileSpec decl_file;
1319   llvm::Expected<uint32_t> file_index_or_err =
1320       GetFileIndex(*cii, inlinee_line.Header->FileID);
1321   if (!file_index_or_err)
1322     return;
1323   uint32_t file_offset = file_index_or_err.get();
1324   decl_file = files.GetFileSpecAtIndex(file_offset);
1325   uint32_t decl_line = inlinee_line.Header->SourceLineNum;
1326   std::unique_ptr<Declaration> decl_up =
1327       std::make_unique<Declaration>(decl_file, decl_line);
1328 
1329   // Parse range and line info.
1330   uint32_t code_offset = 0;
1331   int32_t line_offset = 0;
1332   llvm::Optional<uint32_t> code_offset_base;
1333   llvm::Optional<uint32_t> code_offset_end;
1334   llvm::Optional<int32_t> cur_line_offset;
1335   llvm::Optional<int32_t> next_line_offset;
1336   llvm::Optional<uint32_t> next_file_offset;
1337 
1338   bool is_terminal_entry = false;
1339   bool is_start_of_statement = true;
1340   // The first instruction is the prologue end.
1341   bool is_prologue_end = true;
1342 
1343   auto update_code_offset = [&](uint32_t code_delta) {
1344     if (!code_offset_base)
1345       code_offset_base = code_offset;
1346     else if (!code_offset_end)
1347       code_offset_end = *code_offset_base + code_delta;
1348   };
1349   auto update_line_offset = [&](int32_t line_delta) {
1350     line_offset += line_delta;
1351     if (!code_offset_base || !cur_line_offset)
1352       cur_line_offset = line_offset;
1353     else
1354       next_line_offset = line_offset;
1355     ;
1356   };
1357   auto update_file_offset = [&](uint32_t offset) {
1358     if (!code_offset_base)
1359       file_offset = offset;
1360     else
1361       next_file_offset = offset;
1362   };
1363 
1364   for (auto &annot : inline_site.annotations()) {
1365     switch (annot.OpCode) {
1366     case BinaryAnnotationsOpCode::CodeOffset:
1367     case BinaryAnnotationsOpCode::ChangeCodeOffset:
1368     case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
1369       code_offset += annot.U1;
1370       update_code_offset(annot.U1);
1371       break;
1372     case BinaryAnnotationsOpCode::ChangeLineOffset:
1373       update_line_offset(annot.S1);
1374       break;
1375     case BinaryAnnotationsOpCode::ChangeCodeLength:
1376       update_code_offset(annot.U1);
1377       code_offset += annot.U1;
1378       is_terminal_entry = true;
1379       break;
1380     case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset:
1381       code_offset += annot.U1;
1382       update_code_offset(annot.U1);
1383       update_line_offset(annot.S1);
1384       break;
1385     case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset:
1386       code_offset += annot.U2;
1387       update_code_offset(annot.U2);
1388       update_code_offset(annot.U1);
1389       code_offset += annot.U1;
1390       is_terminal_entry = true;
1391       break;
1392     case BinaryAnnotationsOpCode::ChangeFile:
1393       update_file_offset(annot.U1);
1394       break;
1395     default:
1396       break;
1397     }
1398 
1399     // Add range if current range is finished.
1400     if (code_offset_base && code_offset_end && cur_line_offset) {
1401       inline_site_sp->ranges.Append(RangeSourceLineVector::Entry(
1402           *code_offset_base, *code_offset_end - *code_offset_base,
1403           decl_line + *cur_line_offset));
1404       // Set base, end, file offset and line offset for next range.
1405       if (next_file_offset)
1406         file_offset = *next_file_offset;
1407       if (next_line_offset) {
1408         cur_line_offset = next_line_offset;
1409         next_line_offset = llvm::None;
1410       }
1411       code_offset_base = is_terminal_entry ? llvm::None : code_offset_end;
1412       code_offset_end = next_file_offset = llvm::None;
1413     }
1414     if (code_offset_base && cur_line_offset) {
1415       if (is_terminal_entry) {
1416         LineTable::Entry line_entry(
1417             func_base + *code_offset_base, decl_line + *cur_line_offset, 0,
1418             file_offset, false, false, false, false, true);
1419         inline_site_sp->line_entries.push_back(line_entry);
1420       } else {
1421         LineTable::Entry line_entry(func_base + *code_offset_base,
1422                                     decl_line + *cur_line_offset, 0,
1423                                     file_offset, is_start_of_statement, false,
1424                                     is_prologue_end, false, false);
1425         inline_site_sp->line_entries.push_back(line_entry);
1426         is_prologue_end = false;
1427         is_start_of_statement = false;
1428       }
1429     }
1430     if (is_terminal_entry)
1431       is_start_of_statement = true;
1432     is_terminal_entry = false;
1433   }
1434 
1435   inline_site_sp->ranges.Sort();
1436 
1437   // Get the inlined function callsite info.
1438   std::unique_ptr<Declaration> callsite_up;
1439   if (!inline_site_sp->ranges.IsEmpty()) {
1440     auto *entry = inline_site_sp->ranges.GetEntryAtIndex(0);
1441     addr_t base_offset = entry->GetRangeBase();
1442     if (cii->m_debug_stream.readSymbolAtOffset(parent_id.offset).kind() ==
1443         S_INLINESITE) {
1444       // Its parent is another inline site, lookup parent site's range vector
1445       // for callsite line.
1446       ParseInlineSite(parent_id, func_base);
1447       std::shared_ptr<InlineSite> parent_site =
1448           m_inline_sites[toOpaqueUid(parent_id)];
1449       FileSpec &parent_decl_file =
1450           parent_site->inline_function_info->GetDeclaration().GetFile();
1451       if (auto *parent_entry =
1452               parent_site->ranges.FindEntryThatContains(base_offset)) {
1453         callsite_up =
1454             std::make_unique<Declaration>(parent_decl_file, parent_entry->data);
1455       }
1456     } else {
1457       // Its parent is a function, lookup global line table for callsite.
1458       if (auto *entry = cii->m_global_line_table.FindEntryThatContains(
1459               func_base + base_offset)) {
1460         const FileSpec &callsite_file =
1461             files.GetFileSpecAtIndex(entry->data.first);
1462         callsite_up =
1463             std::make_unique<Declaration>(callsite_file, entry->data.second);
1464       }
1465     }
1466   }
1467 
1468   // Get the inlined function name.
1469   CVType inlinee_cvt = m_index->ipi().getType(inline_site.Inlinee);
1470   std::string inlinee_name;
1471   if (inlinee_cvt.kind() == LF_MFUNC_ID) {
1472     MemberFuncIdRecord mfr;
1473     cantFail(
1474         TypeDeserializer::deserializeAs<MemberFuncIdRecord>(inlinee_cvt, mfr));
1475     LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
1476     inlinee_name.append(std::string(types.getTypeName(mfr.ClassType)));
1477     inlinee_name.append("::");
1478     inlinee_name.append(mfr.getName().str());
1479   } else if (inlinee_cvt.kind() == LF_FUNC_ID) {
1480     FuncIdRecord fir;
1481     cantFail(TypeDeserializer::deserializeAs<FuncIdRecord>(inlinee_cvt, fir));
1482     TypeIndex parent_idx = fir.getParentScope();
1483     if (!parent_idx.isNoneType()) {
1484       LazyRandomTypeCollection &ids = m_index->ipi().typeCollection();
1485       inlinee_name.append(std::string(ids.getTypeName(parent_idx)));
1486       inlinee_name.append("::");
1487     }
1488     inlinee_name.append(fir.getName().str());
1489   }
1490   inline_site_sp->inline_function_info = std::make_shared<InlineFunctionInfo>(
1491       inlinee_name.c_str(), llvm::StringRef(), decl_up.get(),
1492       callsite_up.get());
1493 
1494   m_inline_sites[opaque_uid] = inline_site_sp;
1495 }
1496 
1497 size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
1498   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1499   PdbCompilandSymId func_id = PdbSymUid(func.GetID()).asCompilandSym();
1500   // After we iterate through inline sites inside the function, we already get
1501   // all the info needed, removing from the map to save memory.
1502   std::set<uint64_t> remove_uids;
1503   auto parse_blocks = [&](SymbolKind kind, PdbCompilandSymId id) {
1504     if (kind == S_GPROC32 || kind == S_LPROC32 || kind == S_BLOCK32 ||
1505         kind == S_INLINESITE) {
1506       GetOrCreateBlock(id);
1507       if (kind == S_INLINESITE)
1508         remove_uids.insert(toOpaqueUid(id));
1509       return true;
1510     }
1511     return false;
1512   };
1513   size_t count = ParseSymbolArrayInScope(func_id, parse_blocks);
1514   for (uint64_t uid : remove_uids) {
1515     m_inline_sites.erase(uid);
1516   }
1517   return count;
1518 }
1519 
1520 size_t SymbolFileNativePDB::ParseSymbolArrayInScope(
1521     PdbCompilandSymId parent_id,
1522     llvm::function_ref<bool(SymbolKind, PdbCompilandSymId)> fn) {
1523   CompilandIndexItem *cii = m_index->compilands().GetCompiland(parent_id.modi);
1524   CVSymbolArray syms =
1525       cii->m_debug_stream.getSymbolArrayForScope(parent_id.offset);
1526 
1527   size_t count = 1;
1528   for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
1529     PdbCompilandSymId child_id(parent_id.modi, iter.offset());
1530     if (fn(iter->kind(), child_id))
1531       ++count;
1532   }
1533 
1534   return count;
1535 }
1536 
1537 void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
1538 
1539 void SymbolFileNativePDB::FindGlobalVariables(
1540     ConstString name, const CompilerDeclContext &parent_decl_ctx,
1541     uint32_t max_matches, VariableList &variables) {
1542   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1543   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
1544 
1545   std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
1546       name.GetStringRef(), m_index->symrecords());
1547   for (const SymbolAndOffset &result : results) {
1548     switch (result.second.kind()) {
1549     case SymbolKind::S_GDATA32:
1550     case SymbolKind::S_LDATA32:
1551     case SymbolKind::S_GTHREAD32:
1552     case SymbolKind::S_LTHREAD32:
1553     case SymbolKind::S_CONSTANT: {
1554       PdbGlobalSymId global(result.first, false);
1555       if (VariableSP var = GetOrCreateGlobalVariable(global))
1556         variables.AddVariable(var);
1557       break;
1558     }
1559     default:
1560       continue;
1561     }
1562   }
1563 }
1564 
1565 void SymbolFileNativePDB::FindFunctions(
1566     ConstString name, const CompilerDeclContext &parent_decl_ctx,
1567     FunctionNameType name_type_mask, bool include_inlines,
1568     SymbolContextList &sc_list) {
1569   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1570   // For now we only support lookup by method name or full name.
1571   if (!(name_type_mask & eFunctionNameTypeFull ||
1572         name_type_mask & eFunctionNameTypeMethod))
1573     return;
1574 
1575   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
1576 
1577   std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(
1578       name.GetStringRef(), m_index->symrecords());
1579   for (const SymbolAndOffset &match : matches) {
1580     if (match.second.kind() != S_PROCREF && match.second.kind() != S_LPROCREF)
1581       continue;
1582     ProcRefSym proc(match.second.kind());
1583     cantFail(SymbolDeserializer::deserializeAs<ProcRefSym>(match.second, proc));
1584 
1585     if (!IsValidRecord(proc))
1586       continue;
1587 
1588     CompilandIndexItem &cci =
1589         m_index->compilands().GetOrCreateCompiland(proc.modi());
1590     SymbolContext sc;
1591 
1592     sc.comp_unit = GetOrCreateCompileUnit(cci).get();
1593     PdbCompilandSymId func_id(proc.modi(), proc.SymOffset);
1594     sc.function = GetOrCreateFunction(func_id, *sc.comp_unit).get();
1595 
1596     sc_list.Append(sc);
1597   }
1598 }
1599 
1600 void SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
1601                                         bool include_inlines,
1602                                         SymbolContextList &sc_list) {}
1603 
1604 void SymbolFileNativePDB::FindTypes(
1605     ConstString name, const CompilerDeclContext &parent_decl_ctx,
1606     uint32_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
1607     TypeMap &types) {
1608   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1609   if (!name)
1610     return;
1611 
1612   searched_symbol_files.clear();
1613   searched_symbol_files.insert(this);
1614 
1615   // There is an assumption 'name' is not a regex
1616   FindTypesByName(name.GetStringRef(), max_matches, types);
1617 }
1618 
1619 void SymbolFileNativePDB::FindTypes(
1620     llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
1621     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {}
1622 
1623 void SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
1624                                           uint32_t max_matches,
1625                                           TypeMap &types) {
1626 
1627   std::vector<TypeIndex> matches = m_index->tpi().findRecordsByName(name);
1628   if (max_matches > 0 && max_matches < matches.size())
1629     matches.resize(max_matches);
1630 
1631   for (TypeIndex ti : matches) {
1632     TypeSP type = GetOrCreateType(ti);
1633     if (!type)
1634       continue;
1635 
1636     types.Insert(type);
1637   }
1638 }
1639 
1640 size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
1641   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1642   // Only do the full type scan the first time.
1643   if (m_done_full_type_scan)
1644     return 0;
1645 
1646   const size_t old_count = GetTypeList().GetSize();
1647   LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
1648 
1649   // First process the entire TPI stream.
1650   for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
1651     TypeSP type = GetOrCreateType(*ti);
1652     if (type)
1653       (void)type->GetFullCompilerType();
1654   }
1655 
1656   // Next look for S_UDT records in the globals stream.
1657   for (const uint32_t gid : m_index->globals().getGlobalsTable()) {
1658     PdbGlobalSymId global{gid, false};
1659     CVSymbol sym = m_index->ReadSymbolRecord(global);
1660     if (sym.kind() != S_UDT)
1661       continue;
1662 
1663     UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
1664     bool is_typedef = true;
1665     if (IsTagRecord(PdbTypeSymId{udt.Type, false}, m_index->tpi())) {
1666       CVType cvt = m_index->tpi().getType(udt.Type);
1667       llvm::StringRef name = CVTagRecord::create(cvt).name();
1668       if (name == udt.Name)
1669         is_typedef = false;
1670     }
1671 
1672     if (is_typedef)
1673       GetOrCreateTypedef(global);
1674   }
1675 
1676   const size_t new_count = GetTypeList().GetSize();
1677 
1678   m_done_full_type_scan = true;
1679 
1680   return new_count - old_count;
1681 }
1682 
1683 size_t
1684 SymbolFileNativePDB::ParseVariablesForCompileUnit(CompileUnit &comp_unit,
1685                                                   VariableList &variables) {
1686   PdbSymUid sym_uid(comp_unit.GetID());
1687   lldbassert(sym_uid.kind() == PdbSymUidKind::Compiland);
1688   return 0;
1689 }
1690 
1691 VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
1692                                                     PdbCompilandSymId var_id,
1693                                                     bool is_param) {
1694   ModuleSP module = GetObjectFile()->GetModule();
1695   Block &block = GetOrCreateBlock(scope_id);
1696   // Get function block.
1697   Block *func_block = &block;
1698   while (func_block->GetParent()) {
1699     func_block = func_block->GetParent();
1700   }
1701   Address addr;
1702   func_block->GetStartAddress(addr);
1703   VariableInfo var_info =
1704       GetVariableLocationInfo(*m_index, var_id, *func_block, module);
1705   if (!var_info.location || !var_info.ranges)
1706     return nullptr;
1707 
1708   CompilandIndexItem *cii = m_index->compilands().GetCompiland(var_id.modi);
1709   CompUnitSP comp_unit_sp = GetOrCreateCompileUnit(*cii);
1710   TypeSP type_sp = GetOrCreateType(var_info.type);
1711   std::string name = var_info.name.str();
1712   Declaration decl;
1713   SymbolFileTypeSP sftype =
1714       std::make_shared<SymbolFileType>(*this, type_sp->GetID());
1715 
1716   is_param |= var_info.is_param;
1717   ValueType var_scope =
1718       is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
1719   bool external = false;
1720   bool artificial = false;
1721   bool location_is_constant_data = false;
1722   bool static_member = false;
1723   DWARFExpressionList locaiton_list = DWARFExpressionList(
1724       module, *var_info.location, nullptr);
1725   VariableSP var_sp = std::make_shared<Variable>(
1726       toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
1727       &block, *var_info.ranges, &decl, locaiton_list, external, artificial,
1728       location_is_constant_data, static_member);
1729   if (!is_param)
1730     m_ast->GetOrCreateVariableDecl(scope_id, var_id);
1731 
1732   m_local_variables[toOpaqueUid(var_id)] = var_sp;
1733   return var_sp;
1734 }
1735 
1736 VariableSP SymbolFileNativePDB::GetOrCreateLocalVariable(
1737     PdbCompilandSymId scope_id, PdbCompilandSymId var_id, bool is_param) {
1738   auto iter = m_local_variables.find(toOpaqueUid(var_id));
1739   if (iter != m_local_variables.end())
1740     return iter->second;
1741 
1742   return CreateLocalVariable(scope_id, var_id, is_param);
1743 }
1744 
1745 TypeSP SymbolFileNativePDB::CreateTypedef(PdbGlobalSymId id) {
1746   CVSymbol sym = m_index->ReadSymbolRecord(id);
1747   lldbassert(sym.kind() == SymbolKind::S_UDT);
1748 
1749   UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
1750 
1751   TypeSP target_type = GetOrCreateType(udt.Type);
1752 
1753   (void)m_ast->GetOrCreateTypedefDecl(id);
1754 
1755   Declaration decl;
1756   return std::make_shared<lldb_private::Type>(
1757       toOpaqueUid(id), this, ConstString(udt.Name),
1758       target_type->GetByteSize(nullptr), nullptr, target_type->GetID(),
1759       lldb_private::Type::eEncodingIsTypedefUID, decl,
1760       target_type->GetForwardCompilerType(),
1761       lldb_private::Type::ResolveState::Forward);
1762 }
1763 
1764 TypeSP SymbolFileNativePDB::GetOrCreateTypedef(PdbGlobalSymId id) {
1765   auto iter = m_types.find(toOpaqueUid(id));
1766   if (iter != m_types.end())
1767     return iter->second;
1768 
1769   return CreateTypedef(id);
1770 }
1771 
1772 size_t SymbolFileNativePDB::ParseVariablesForBlock(PdbCompilandSymId block_id) {
1773   Block &block = GetOrCreateBlock(block_id);
1774 
1775   size_t count = 0;
1776 
1777   CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
1778   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);
1779   uint32_t params_remaining = 0;
1780   switch (sym.kind()) {
1781   case S_GPROC32:
1782   case S_LPROC32: {
1783     ProcSym proc(static_cast<SymbolRecordKind>(sym.kind()));
1784     cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym, proc));
1785     CVType signature = m_index->tpi().getType(proc.FunctionType);
1786     ProcedureRecord sig;
1787     cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(signature, sig));
1788     params_remaining = sig.getParameterCount();
1789     break;
1790   }
1791   case S_BLOCK32:
1792     break;
1793   case S_INLINESITE:
1794     break;
1795   default:
1796     lldbassert(false && "Symbol is not a block!");
1797     return 0;
1798   }
1799 
1800   VariableListSP variables = block.GetBlockVariableList(false);
1801   if (!variables) {
1802     variables = std::make_shared<VariableList>();
1803     block.SetVariableList(variables);
1804   }
1805 
1806   CVSymbolArray syms = limitSymbolArrayToScope(
1807       cii->m_debug_stream.getSymbolArray(), block_id.offset);
1808 
1809   // Skip the first record since it's a PROC32 or BLOCK32, and there's
1810   // no point examining it since we know it's not a local variable.
1811   syms.drop_front();
1812   auto iter = syms.begin();
1813   auto end = syms.end();
1814 
1815   while (iter != end) {
1816     uint32_t record_offset = iter.offset();
1817     CVSymbol variable_cvs = *iter;
1818     PdbCompilandSymId child_sym_id(block_id.modi, record_offset);
1819     ++iter;
1820 
1821     // If this is a block or inline site, recurse into its children and then
1822     // skip it.
1823     if (variable_cvs.kind() == S_BLOCK32 ||
1824         variable_cvs.kind() == S_INLINESITE) {
1825       uint32_t block_end = getScopeEndOffset(variable_cvs);
1826       count += ParseVariablesForBlock(child_sym_id);
1827       iter = syms.at(block_end);
1828       continue;
1829     }
1830 
1831     bool is_param = params_remaining > 0;
1832     VariableSP variable;
1833     switch (variable_cvs.kind()) {
1834     case S_REGREL32:
1835     case S_REGISTER:
1836     case S_LOCAL:
1837       variable = GetOrCreateLocalVariable(block_id, child_sym_id, is_param);
1838       if (is_param)
1839         --params_remaining;
1840       if (variable)
1841         variables->AddVariableIfUnique(variable);
1842       break;
1843     default:
1844       break;
1845     }
1846   }
1847 
1848   // Pass false for set_children, since we call this recursively so that the
1849   // children will call this for themselves.
1850   block.SetDidParseVariables(true, false);
1851 
1852   return count;
1853 }
1854 
1855 size_t SymbolFileNativePDB::ParseVariablesForContext(const SymbolContext &sc) {
1856   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1857   lldbassert(sc.function || sc.comp_unit);
1858 
1859   VariableListSP variables;
1860   if (sc.block) {
1861     PdbSymUid block_id(sc.block->GetID());
1862 
1863     size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
1864     return count;
1865   }
1866 
1867   if (sc.function) {
1868     PdbSymUid block_id(sc.function->GetID());
1869 
1870     size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
1871     return count;
1872   }
1873 
1874   if (sc.comp_unit) {
1875     variables = sc.comp_unit->GetVariableList(false);
1876     if (!variables) {
1877       variables = std::make_shared<VariableList>();
1878       sc.comp_unit->SetVariableList(variables);
1879     }
1880     return ParseVariablesForCompileUnit(*sc.comp_unit, *variables);
1881   }
1882 
1883   llvm_unreachable("Unreachable!");
1884 }
1885 
1886 CompilerDecl SymbolFileNativePDB::GetDeclForUID(lldb::user_id_t uid) {
1887   if (auto decl = m_ast->GetOrCreateDeclForUid(uid))
1888     return *decl;
1889   else
1890     return CompilerDecl();
1891 }
1892 
1893 CompilerDeclContext
1894 SymbolFileNativePDB::GetDeclContextForUID(lldb::user_id_t uid) {
1895   clang::DeclContext *context =
1896       m_ast->GetOrCreateDeclContextForUid(PdbSymUid(uid));
1897   if (!context)
1898     return {};
1899 
1900   return m_ast->ToCompilerDeclContext(*context);
1901 }
1902 
1903 CompilerDeclContext
1904 SymbolFileNativePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
1905   clang::DeclContext *context = m_ast->GetParentDeclContext(PdbSymUid(uid));
1906   return m_ast->ToCompilerDeclContext(*context);
1907 }
1908 
1909 Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
1910   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1911   auto iter = m_types.find(type_uid);
1912   // lldb should not be passing us non-sensical type uids.  the only way it
1913   // could have a type uid in the first place is if we handed it out, in which
1914   // case we should know about the type.  However, that doesn't mean we've
1915   // instantiated it yet.  We can vend out a UID for a future type.  So if the
1916   // type doesn't exist, let's instantiate it now.
1917   if (iter != m_types.end())
1918     return &*iter->second;
1919 
1920   PdbSymUid uid(type_uid);
1921   lldbassert(uid.kind() == PdbSymUidKind::Type);
1922   PdbTypeSymId type_id = uid.asTypeSym();
1923   if (type_id.index.isNoneType())
1924     return nullptr;
1925 
1926   TypeSP type_sp = CreateAndCacheType(type_id);
1927   return &*type_sp;
1928 }
1929 
1930 llvm::Optional<SymbolFile::ArrayInfo>
1931 SymbolFileNativePDB::GetDynamicArrayInfoForUID(
1932     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
1933   return llvm::None;
1934 }
1935 
1936 
1937 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
1938   clang::QualType qt =
1939       clang::QualType::getFromOpaquePtr(compiler_type.GetOpaqueQualType());
1940 
1941   return m_ast->CompleteType(qt);
1942 }
1943 
1944 void SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
1945                                    TypeClass type_mask,
1946                                    lldb_private::TypeList &type_list) {}
1947 
1948 CompilerDeclContext
1949 SymbolFileNativePDB::FindNamespace(ConstString name,
1950                                    const CompilerDeclContext &parent_decl_ctx) {
1951   return {};
1952 }
1953 
1954 llvm::Expected<TypeSystem &>
1955 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
1956   auto type_system_or_err =
1957       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
1958   if (type_system_or_err) {
1959     type_system_or_err->SetSymbolFile(this);
1960   }
1961   return type_system_or_err;
1962 }
1963 
1964 uint64_t SymbolFileNativePDB::GetDebugInfoSize() {
1965   // PDB files are a separate file that contains all debug info.
1966   return m_index->pdb().getFileSize();
1967 }
1968