1 //===-- SymbolFileNativePDB.cpp ---------------------------------*- C++ -*-===//
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/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
18 #include "lldb/Core/Module.h"
19 #include "lldb/Core/PluginManager.h"
20 #include "lldb/Core/StreamBuffer.h"
21 #include "lldb/Core/StreamFile.h"
22 #include "lldb/Symbol/ClangASTContext.h"
23 #include "lldb/Symbol/ClangASTImporter.h"
24 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
25 #include "lldb/Symbol/ClangUtil.h"
26 #include "lldb/Symbol/CompileUnit.h"
27 #include "lldb/Symbol/LineTable.h"
28 #include "lldb/Symbol/ObjectFile.h"
29 #include "lldb/Symbol/SymbolContext.h"
30 #include "lldb/Symbol/SymbolVendor.h"
31 #include "lldb/Symbol/Variable.h"
32 #include "lldb/Symbol/VariableList.h"
33 
34 #include "llvm/DebugInfo/CodeView/CVRecord.h"
35 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
36 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
37 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
38 #include "llvm/DebugInfo/CodeView/RecordName.h"
39 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
40 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
41 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
42 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
43 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
44 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
45 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
46 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
47 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
48 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
49 #include "llvm/DebugInfo/PDB/PDBTypes.h"
50 #include "llvm/Demangle/MicrosoftDemangle.h"
51 #include "llvm/Object/COFF.h"
52 #include "llvm/Support/Allocator.h"
53 #include "llvm/Support/BinaryStreamReader.h"
54 #include "llvm/Support/Error.h"
55 #include "llvm/Support/ErrorOr.h"
56 #include "llvm/Support/MemoryBuffer.h"
57 
58 #include "DWARFLocationExpression.h"
59 #include "PdbAstBuilder.h"
60 #include "PdbSymUid.h"
61 #include "PdbUtil.h"
62 #include "UdtRecordCompleter.h"
63 
64 using namespace lldb;
65 using namespace lldb_private;
66 using namespace npdb;
67 using namespace llvm::codeview;
68 using namespace llvm::pdb;
69 
70 static lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
71   switch (lang) {
72   case PDB_Lang::Cpp:
73     return lldb::LanguageType::eLanguageTypeC_plus_plus;
74   case PDB_Lang::C:
75     return lldb::LanguageType::eLanguageTypeC;
76   case PDB_Lang::Swift:
77     return lldb::LanguageType::eLanguageTypeSwift;
78   default:
79     return lldb::LanguageType::eLanguageTypeUnknown;
80   }
81 }
82 
83 static std::unique_ptr<PDBFile> loadPDBFile(std::string PdbPath,
84                                             llvm::BumpPtrAllocator &Allocator) {
85   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
86       llvm::MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
87                                   /*RequiresNullTerminator=*/false);
88   if (!ErrorOrBuffer)
89     return nullptr;
90   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
91 
92   llvm::StringRef Path = Buffer->getBufferIdentifier();
93   auto Stream = llvm::make_unique<llvm::MemoryBufferByteStream>(
94       std::move(Buffer), llvm::support::little);
95 
96   auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
97   if (auto EC = File->parseFileHeaders()) {
98     llvm::consumeError(std::move(EC));
99     return nullptr;
100   }
101   if (auto EC = File->parseStreamData()) {
102     llvm::consumeError(std::move(EC));
103     return nullptr;
104   }
105 
106   return File;
107 }
108 
109 static std::unique_ptr<PDBFile>
110 loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
111   // Try to find a matching PDB for an EXE.
112   using namespace llvm::object;
113   auto expected_binary = createBinary(exe_path);
114 
115   // If the file isn't a PE/COFF executable, fail.
116   if (!expected_binary) {
117     llvm::consumeError(expected_binary.takeError());
118     return nullptr;
119   }
120   OwningBinary<Binary> binary = std::move(*expected_binary);
121 
122   auto *obj = llvm::dyn_cast<llvm::object::COFFObjectFile>(binary.getBinary());
123   if (!obj)
124     return nullptr;
125   const llvm::codeview::DebugInfo *pdb_info = nullptr;
126 
127   // If it doesn't have a debug directory, fail.
128   llvm::StringRef pdb_file;
129   auto ec = obj->getDebugPDBInfo(pdb_info, pdb_file);
130   if (ec)
131     return nullptr;
132 
133   // if the file doesn't exist, is not a pdb, or doesn't have a matching guid,
134   // fail.
135   llvm::file_magic magic;
136   ec = llvm::identify_magic(pdb_file, magic);
137   if (ec || magic != llvm::file_magic::pdb)
138     return nullptr;
139   std::unique_ptr<PDBFile> pdb = loadPDBFile(pdb_file, allocator);
140   if (!pdb)
141     return nullptr;
142 
143   auto expected_info = pdb->getPDBInfoStream();
144   if (!expected_info) {
145     llvm::consumeError(expected_info.takeError());
146     return nullptr;
147   }
148   llvm::codeview::GUID guid;
149   memcpy(&guid, pdb_info->PDB70.Signature, 16);
150 
151   if (expected_info->getGuid() != guid)
152     return nullptr;
153   return pdb;
154 }
155 
156 static bool IsFunctionPrologue(const CompilandIndexItem &cci,
157                                lldb::addr_t addr) {
158   // FIXME: Implement this.
159   return false;
160 }
161 
162 static bool IsFunctionEpilogue(const CompilandIndexItem &cci,
163                                lldb::addr_t addr) {
164   // FIXME: Implement this.
165   return false;
166 }
167 
168 static llvm::StringRef GetSimpleTypeName(SimpleTypeKind kind) {
169   switch (kind) {
170   case SimpleTypeKind::Boolean128:
171   case SimpleTypeKind::Boolean16:
172   case SimpleTypeKind::Boolean32:
173   case SimpleTypeKind::Boolean64:
174   case SimpleTypeKind::Boolean8:
175     return "bool";
176   case SimpleTypeKind::Byte:
177   case SimpleTypeKind::UnsignedCharacter:
178     return "unsigned char";
179   case SimpleTypeKind::NarrowCharacter:
180     return "char";
181   case SimpleTypeKind::SignedCharacter:
182   case SimpleTypeKind::SByte:
183     return "signed char";
184   case SimpleTypeKind::Character16:
185     return "char16_t";
186   case SimpleTypeKind::Character32:
187     return "char32_t";
188   case SimpleTypeKind::Complex80:
189   case SimpleTypeKind::Complex64:
190   case SimpleTypeKind::Complex32:
191     return "complex";
192   case SimpleTypeKind::Float128:
193   case SimpleTypeKind::Float80:
194     return "long double";
195   case SimpleTypeKind::Float64:
196     return "double";
197   case SimpleTypeKind::Float32:
198     return "float";
199   case SimpleTypeKind::Float16:
200     return "single";
201   case SimpleTypeKind::Int128:
202     return "__int128";
203   case SimpleTypeKind::Int64:
204   case SimpleTypeKind::Int64Quad:
205     return "int64_t";
206   case SimpleTypeKind::Int32:
207     return "int";
208   case SimpleTypeKind::Int16:
209     return "short";
210   case SimpleTypeKind::UInt128:
211     return "unsigned __int128";
212   case SimpleTypeKind::UInt64:
213   case SimpleTypeKind::UInt64Quad:
214     return "uint64_t";
215   case SimpleTypeKind::HResult:
216     return "HRESULT";
217   case SimpleTypeKind::UInt32:
218     return "unsigned";
219   case SimpleTypeKind::UInt16:
220   case SimpleTypeKind::UInt16Short:
221     return "unsigned short";
222   case SimpleTypeKind::Int32Long:
223     return "long";
224   case SimpleTypeKind::UInt32Long:
225     return "unsigned long";
226   case SimpleTypeKind::Void:
227     return "void";
228   case SimpleTypeKind::WideCharacter:
229     return "wchar_t";
230   default:
231     return "";
232   }
233 }
234 
235 static bool IsClassRecord(TypeLeafKind kind) {
236   switch (kind) {
237   case LF_STRUCTURE:
238   case LF_CLASS:
239   case LF_INTERFACE:
240     return true;
241   default:
242     return false;
243   }
244 }
245 
246 void SymbolFileNativePDB::Initialize() {
247   PluginManager::RegisterPlugin(GetPluginNameStatic(),
248                                 GetPluginDescriptionStatic(), CreateInstance,
249                                 DebuggerInitialize);
250 }
251 
252 void SymbolFileNativePDB::Terminate() {
253   PluginManager::UnregisterPlugin(CreateInstance);
254 }
255 
256 void SymbolFileNativePDB::DebuggerInitialize(Debugger &debugger) {}
257 
258 ConstString SymbolFileNativePDB::GetPluginNameStatic() {
259   static ConstString g_name("native-pdb");
260   return g_name;
261 }
262 
263 const char *SymbolFileNativePDB::GetPluginDescriptionStatic() {
264   return "Microsoft PDB debug symbol cross-platform file reader.";
265 }
266 
267 SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFile *obj_file) {
268   return new SymbolFileNativePDB(obj_file);
269 }
270 
271 SymbolFileNativePDB::SymbolFileNativePDB(ObjectFile *object_file)
272     : SymbolFile(object_file) {}
273 
274 SymbolFileNativePDB::~SymbolFileNativePDB() {}
275 
276 uint32_t SymbolFileNativePDB::CalculateAbilities() {
277   uint32_t abilities = 0;
278   if (!m_obj_file)
279     return 0;
280 
281   if (!m_index) {
282     // Lazily load and match the PDB file, but only do this once.
283     std::unique_ptr<PDBFile> file_up =
284         loadMatchingPDBFile(m_obj_file->GetFileSpec().GetPath(), m_allocator);
285 
286     if (!file_up) {
287       auto module_sp = m_obj_file->GetModule();
288       if (!module_sp)
289         return 0;
290       // See if any symbol file is specified through `--symfile` option.
291       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
292       if (!symfile)
293         return 0;
294       file_up = loadPDBFile(symfile.GetPath(), m_allocator);
295     }
296 
297     if (!file_up)
298       return 0;
299 
300     auto expected_index = PdbIndex::create(std::move(file_up));
301     if (!expected_index) {
302       llvm::consumeError(expected_index.takeError());
303       return 0;
304     }
305     m_index = std::move(*expected_index);
306   }
307   if (!m_index)
308     return 0;
309 
310   // We don't especially have to be precise here.  We only distinguish between
311   // stripped and not stripped.
312   abilities = kAllAbilities;
313 
314   if (m_index->dbi().isStripped())
315     abilities &= ~(Blocks | LocalVariables);
316   return abilities;
317 }
318 
319 void SymbolFileNativePDB::InitializeObject() {
320   m_obj_load_address = m_obj_file->GetBaseAddress().GetFileAddress();
321   m_index->SetLoadAddress(m_obj_load_address);
322   m_index->ParseSectionContribs();
323 
324   TypeSystem *ts = m_obj_file->GetModule()->GetTypeSystemForLanguage(
325       lldb::eLanguageTypeC_plus_plus);
326   if (ts)
327     ts->SetSymbolFile(this);
328 
329   m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index);
330 }
331 
332 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
333   const DbiModuleList &modules = m_index->dbi().modules();
334   uint32_t count = modules.getModuleCount();
335   if (count == 0)
336     return count;
337 
338   // The linker can inject an additional "dummy" compilation unit into the
339   // PDB. Ignore this special compile unit for our purposes, if it is there.
340   // It is always the last one.
341   DbiModuleDescriptor last = modules.getModuleDescriptor(count - 1);
342   if (last.getModuleName() == "* Linker *")
343     --count;
344   return count;
345 }
346 
347 Block &SymbolFileNativePDB::CreateBlock(PdbCompilandSymId block_id) {
348   CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
349   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);
350 
351   if (sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32) {
352     // This is a function.  It must be global.  Creating the Function entry for
353     // it automatically creates a block for it.
354     CompUnitSP comp_unit = GetOrCreateCompileUnit(*cii);
355     return GetOrCreateFunction(block_id, *comp_unit)->GetBlock(false);
356   }
357 
358   lldbassert(sym.kind() == S_BLOCK32);
359 
360   // This is a block.  Its parent is either a function or another block.  In
361   // either case, its parent can be viewed as a block (e.g. a function contains
362   // 1 big block.  So just get the parent block and add this block to it.
363   BlockSym block(static_cast<SymbolRecordKind>(sym.kind()));
364   cantFail(SymbolDeserializer::deserializeAs<BlockSym>(sym, block));
365   lldbassert(block.Parent != 0);
366   PdbCompilandSymId parent_id(block_id.modi, block.Parent);
367   Block &parent_block = GetOrCreateBlock(parent_id);
368   lldb::user_id_t opaque_block_uid = toOpaqueUid(block_id);
369   BlockSP child_block = std::make_shared<Block>(opaque_block_uid);
370   parent_block.AddChild(child_block);
371 
372   m_ast->GetOrCreateBlockDecl(block_id);
373 
374   m_blocks.insert({opaque_block_uid, child_block});
375   return *child_block;
376 }
377 
378 lldb::FunctionSP SymbolFileNativePDB::CreateFunction(PdbCompilandSymId func_id,
379                                                      CompileUnit &comp_unit) {
380   const CompilandIndexItem *cci =
381       m_index->compilands().GetCompiland(func_id.modi);
382   lldbassert(cci);
383   CVSymbol sym_record = cci->m_debug_stream.readSymbolAtOffset(func_id.offset);
384 
385   lldbassert(sym_record.kind() == S_LPROC32 || sym_record.kind() == S_GPROC32);
386   SegmentOffsetLength sol = GetSegmentOffsetAndLength(sym_record);
387 
388   auto file_vm_addr = m_index->MakeVirtualAddress(sol.so);
389   if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
390     return nullptr;
391 
392   AddressRange func_range(file_vm_addr, sol.length,
393                           comp_unit.GetModule()->GetSectionList());
394   if (!func_range.GetBaseAddress().IsValid())
395     return nullptr;
396 
397   ProcSym proc(static_cast<SymbolRecordKind>(sym_record.kind()));
398   cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym_record, proc));
399   if (proc.FunctionType == TypeIndex::None())
400     return nullptr;
401   TypeSP func_type = GetOrCreateType(proc.FunctionType);
402   if (!func_type)
403     return nullptr;
404 
405   PdbTypeSymId sig_id(proc.FunctionType, false);
406   Mangled mangled(proc.Name);
407   FunctionSP func_sp = std::make_shared<Function>(
408       &comp_unit, toOpaqueUid(func_id), toOpaqueUid(sig_id), mangled,
409       func_type.get(), func_range);
410 
411   comp_unit.AddFunction(func_sp);
412 
413   m_ast->GetOrCreateFunctionDecl(func_id);
414 
415   return func_sp;
416 }
417 
418 CompUnitSP
419 SymbolFileNativePDB::CreateCompileUnit(const CompilandIndexItem &cci) {
420   lldb::LanguageType lang =
421       cci.m_compile_opts ? TranslateLanguage(cci.m_compile_opts->getLanguage())
422                          : lldb::eLanguageTypeUnknown;
423 
424   LazyBool optimized = eLazyBoolNo;
425   if (cci.m_compile_opts && cci.m_compile_opts->hasOptimizations())
426     optimized = eLazyBoolYes;
427 
428   llvm::SmallString<64> source_file_name =
429       m_index->compilands().GetMainSourceFile(cci);
430   FileSpec fs(source_file_name);
431 
432   CompUnitSP cu_sp =
433       std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr, fs,
434                                     toOpaqueUid(cci.m_id), lang, optimized);
435 
436   SetCompileUnitAtIndex(cci.m_id.modi, cu_sp);
437   return cu_sp;
438 }
439 
440 lldb::TypeSP SymbolFileNativePDB::CreateModifierType(PdbTypeSymId type_id,
441                                                      const ModifierRecord &mr,
442                                                      CompilerType ct) {
443   TpiStream &stream = m_index->tpi();
444 
445   std::string name;
446   if (mr.ModifiedType.isSimple())
447     name = GetSimpleTypeName(mr.ModifiedType.getSimpleKind());
448   else
449     name = computeTypeName(stream.typeCollection(), mr.ModifiedType);
450   Declaration decl;
451   lldb::TypeSP modified_type = GetOrCreateType(mr.ModifiedType);
452 
453   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(name),
454                                 modified_type->GetByteSize(), nullptr,
455                                 LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
456                                 ct, Type::eResolveStateFull);
457 }
458 
459 lldb::TypeSP
460 SymbolFileNativePDB::CreatePointerType(PdbTypeSymId type_id,
461                                        const llvm::codeview::PointerRecord &pr,
462                                        CompilerType ct) {
463   TypeSP pointee = GetOrCreateType(pr.ReferentType);
464   if (!pointee)
465     return nullptr;
466 
467   if (pr.isPointerToMember()) {
468     MemberPointerInfo mpi = pr.getMemberInfo();
469     GetOrCreateType(mpi.ContainingType);
470   }
471 
472   Declaration decl;
473   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(),
474                                 pr.getSize(), nullptr, LLDB_INVALID_UID,
475                                 Type::eEncodingIsUID, decl, ct,
476                                 Type::eResolveStateFull);
477 }
478 
479 lldb::TypeSP SymbolFileNativePDB::CreateSimpleType(TypeIndex ti,
480                                                    CompilerType ct) {
481   uint64_t uid = toOpaqueUid(PdbTypeSymId(ti, false));
482   if (ti == TypeIndex::NullptrT()) {
483     Declaration decl;
484     return std::make_shared<Type>(
485         uid, this, ConstString("std::nullptr_t"), 0, nullptr, LLDB_INVALID_UID,
486         Type::eEncodingIsUID, decl, ct, Type::eResolveStateFull);
487   }
488 
489   if (ti.getSimpleMode() != SimpleTypeMode::Direct) {
490     TypeSP direct_sp = GetOrCreateType(ti.makeDirect());
491     uint32_t pointer_size = 0;
492     switch (ti.getSimpleMode()) {
493     case SimpleTypeMode::FarPointer32:
494     case SimpleTypeMode::NearPointer32:
495       pointer_size = 4;
496       break;
497     case SimpleTypeMode::NearPointer64:
498       pointer_size = 8;
499       break;
500     default:
501       // 128-bit and 16-bit pointers unsupported.
502       return nullptr;
503     }
504     Declaration decl;
505     return std::make_shared<Type>(
506         uid, this, ConstString(), pointer_size, nullptr, LLDB_INVALID_UID,
507         Type::eEncodingIsUID, decl, ct, Type::eResolveStateFull);
508   }
509 
510   if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated)
511     return nullptr;
512 
513   size_t size = GetTypeSizeForSimpleKind(ti.getSimpleKind());
514   llvm::StringRef type_name = GetSimpleTypeName(ti.getSimpleKind());
515 
516   Declaration decl;
517   return std::make_shared<Type>(uid, this, ConstString(type_name), size,
518                                 nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
519                                 decl, ct, Type::eResolveStateFull);
520 }
521 
522 static std::string GetUnqualifiedTypeName(const TagRecord &record) {
523   if (!record.hasUniqueName()) {
524     MSVCUndecoratedNameParser parser(record.Name);
525     llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
526 
527     return specs.back().GetBaseName();
528   }
529 
530   llvm::ms_demangle::Demangler demangler;
531   StringView sv(record.UniqueName.begin(), record.UniqueName.size());
532   llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
533   if (demangler.Error)
534     return record.Name;
535 
536   llvm::ms_demangle::IdentifierNode *idn =
537       ttn->QualifiedName->getUnqualifiedIdentifier();
538   return idn->toString();
539 }
540 
541 lldb::TypeSP
542 SymbolFileNativePDB::CreateClassStructUnion(PdbTypeSymId type_id,
543                                             const TagRecord &record,
544                                             size_t size, CompilerType ct) {
545 
546   std::string uname = GetUnqualifiedTypeName(record);
547 
548   // FIXME: Search IPI stream for LF_UDT_MOD_SRC_LINE.
549   Declaration decl;
550   return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(uname),
551                                 size, nullptr, LLDB_INVALID_UID,
552                                 Type::eEncodingIsUID, decl, ct,
553                                 Type::eResolveStateForward);
554 }
555 
556 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
557                                                 const ClassRecord &cr,
558                                                 CompilerType ct) {
559   return CreateClassStructUnion(type_id, cr, cr.getSize(), ct);
560 }
561 
562 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
563                                                 const UnionRecord &ur,
564                                                 CompilerType ct) {
565   return CreateClassStructUnion(type_id, ur, ur.getSize(), ct);
566 }
567 
568 lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
569                                                 const EnumRecord &er,
570                                                 CompilerType ct) {
571   std::string uname = GetUnqualifiedTypeName(er);
572 
573   Declaration decl;
574   TypeSP underlying_type = GetOrCreateType(er.UnderlyingType);
575 
576   return std::make_shared<lldb_private::Type>(
577       toOpaqueUid(type_id), this, ConstString(uname),
578       underlying_type->GetByteSize(), nullptr, LLDB_INVALID_UID,
579       lldb_private::Type::eEncodingIsUID, decl, ct,
580       lldb_private::Type::eResolveStateForward);
581 }
582 
583 TypeSP SymbolFileNativePDB::CreateArrayType(PdbTypeSymId type_id,
584                                             const ArrayRecord &ar,
585                                             CompilerType ct) {
586   TypeSP element_type = GetOrCreateType(ar.ElementType);
587 
588   Declaration decl;
589   TypeSP array_sp = std::make_shared<lldb_private::Type>(
590       toOpaqueUid(type_id), this, ConstString(), ar.Size, nullptr,
591       LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, ct,
592       lldb_private::Type::eResolveStateFull);
593   array_sp->SetEncodingType(element_type.get());
594   return array_sp;
595 }
596 
597 
598 TypeSP SymbolFileNativePDB::CreateFunctionType(PdbTypeSymId type_id,
599                                                const MemberFunctionRecord &mfr,
600                                                CompilerType ct) {
601   Declaration decl;
602   return std::make_shared<lldb_private::Type>(
603       toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID,
604       lldb_private::Type::eEncodingIsUID, decl, ct,
605       lldb_private::Type::eResolveStateFull);
606 }
607 
608 TypeSP SymbolFileNativePDB::CreateProcedureType(PdbTypeSymId type_id,
609                                                 const ProcedureRecord &pr,
610                                                 CompilerType ct) {
611   Declaration decl;
612   return std::make_shared<lldb_private::Type>(
613       toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID,
614       lldb_private::Type::eEncodingIsUID, decl, ct,
615       lldb_private::Type::eResolveStateFull);
616 }
617 
618 TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
619   if (type_id.index.isSimple())
620     return CreateSimpleType(type_id.index, ct);
621 
622   TpiStream &stream = type_id.is_ipi ? m_index->ipi() : m_index->tpi();
623   CVType cvt = stream.getType(type_id.index);
624 
625   if (cvt.kind() == LF_MODIFIER) {
626     ModifierRecord modifier;
627     llvm::cantFail(
628         TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
629     return CreateModifierType(type_id, modifier, ct);
630   }
631 
632   if (cvt.kind() == LF_POINTER) {
633     PointerRecord pointer;
634     llvm::cantFail(
635         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
636     return CreatePointerType(type_id, pointer, ct);
637   }
638 
639   if (IsClassRecord(cvt.kind())) {
640     ClassRecord cr;
641     llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
642     return CreateTagType(type_id, cr, ct);
643   }
644 
645   if (cvt.kind() == LF_ENUM) {
646     EnumRecord er;
647     llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
648     return CreateTagType(type_id, er, ct);
649   }
650 
651   if (cvt.kind() == LF_UNION) {
652     UnionRecord ur;
653     llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
654     return CreateTagType(type_id, ur, ct);
655   }
656 
657   if (cvt.kind() == LF_ARRAY) {
658     ArrayRecord ar;
659     llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
660     return CreateArrayType(type_id, ar, ct);
661   }
662 
663   if (cvt.kind() == LF_PROCEDURE) {
664     ProcedureRecord pr;
665     llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
666     return CreateProcedureType(type_id, pr, ct);
667   }
668   if (cvt.kind() == LF_MFUNCTION) {
669     MemberFunctionRecord mfr;
670     llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
671     return CreateFunctionType(type_id, mfr, ct);
672   }
673 
674   return nullptr;
675 }
676 
677 TypeSP SymbolFileNativePDB::CreateAndCacheType(PdbTypeSymId type_id) {
678   // If they search for a UDT which is a forward ref, try and resolve the full
679   // decl and just map the forward ref uid to the full decl record.
680   llvm::Optional<PdbTypeSymId> full_decl_uid;
681   if (IsForwardRefUdt(type_id, m_index->tpi())) {
682     auto expected_full_ti =
683         m_index->tpi().findFullDeclForForwardRef(type_id.index);
684     if (!expected_full_ti)
685       llvm::consumeError(expected_full_ti.takeError());
686     else if (*expected_full_ti != type_id.index) {
687       full_decl_uid = PdbTypeSymId(*expected_full_ti, false);
688 
689       // It's possible that a lookup would occur for the full decl causing it
690       // to be cached, then a second lookup would occur for the forward decl.
691       // We don't want to create a second full decl, so make sure the full
692       // decl hasn't already been cached.
693       auto full_iter = m_types.find(toOpaqueUid(*full_decl_uid));
694       if (full_iter != m_types.end()) {
695         TypeSP result = full_iter->second;
696         // Map the forward decl to the TypeSP for the full decl so we can take
697         // the fast path next time.
698         m_types[toOpaqueUid(type_id)] = result;
699         return result;
700       }
701     }
702   }
703 
704   PdbTypeSymId best_decl_id = full_decl_uid ? *full_decl_uid : type_id;
705 
706   clang::QualType qt = m_ast->GetOrCreateType(best_decl_id);
707 
708   TypeSP result = CreateType(best_decl_id, m_ast->ToCompilerType(qt));
709   if (!result)
710     return nullptr;
711 
712   uint64_t best_uid = toOpaqueUid(best_decl_id);
713   m_types[best_uid] = result;
714   // If we had both a forward decl and a full decl, make both point to the new
715   // type.
716   if (full_decl_uid)
717     m_types[toOpaqueUid(type_id)] = result;
718 
719   return result;
720 }
721 
722 TypeSP SymbolFileNativePDB::GetOrCreateType(PdbTypeSymId type_id) {
723   // We can't use try_emplace / overwrite here because the process of creating
724   // a type could create nested types, which could invalidate iterators.  So
725   // we have to do a 2-phase lookup / insert.
726   auto iter = m_types.find(toOpaqueUid(type_id));
727   if (iter != m_types.end())
728     return iter->second;
729 
730   TypeSP type = CreateAndCacheType(type_id);
731   if (type)
732     GetTypeList().Insert(type);
733   return type;
734 }
735 
736 VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
737   CVSymbol sym = m_index->symrecords().readRecord(var_id.offset);
738   if (sym.kind() == S_CONSTANT)
739     return CreateConstantSymbol(var_id, sym);
740 
741   lldb::ValueType scope = eValueTypeInvalid;
742   TypeIndex ti;
743   llvm::StringRef name;
744   lldb::addr_t addr = 0;
745   uint16_t section = 0;
746   uint32_t offset = 0;
747   bool is_external = false;
748   switch (sym.kind()) {
749   case S_GDATA32:
750     is_external = true;
751     LLVM_FALLTHROUGH;
752   case S_LDATA32: {
753     DataSym ds(sym.kind());
754     llvm::cantFail(SymbolDeserializer::deserializeAs<DataSym>(sym, ds));
755     ti = ds.Type;
756     scope = (sym.kind() == S_GDATA32) ? eValueTypeVariableGlobal
757                                       : eValueTypeVariableStatic;
758     name = ds.Name;
759     section = ds.Segment;
760     offset = ds.DataOffset;
761     addr = m_index->MakeVirtualAddress(ds.Segment, ds.DataOffset);
762     break;
763   }
764   case S_GTHREAD32:
765     is_external = true;
766     LLVM_FALLTHROUGH;
767   case S_LTHREAD32: {
768     ThreadLocalDataSym tlds(sym.kind());
769     llvm::cantFail(
770         SymbolDeserializer::deserializeAs<ThreadLocalDataSym>(sym, tlds));
771     ti = tlds.Type;
772     name = tlds.Name;
773     section = tlds.Segment;
774     offset = tlds.DataOffset;
775     addr = m_index->MakeVirtualAddress(tlds.Segment, tlds.DataOffset);
776     scope = eValueTypeVariableThreadLocal;
777     break;
778   }
779   default:
780     llvm_unreachable("unreachable!");
781   }
782 
783   CompUnitSP comp_unit;
784   llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(addr);
785   if (modi) {
786     CompilandIndexItem &cci = m_index->compilands().GetOrCreateCompiland(*modi);
787     comp_unit = GetOrCreateCompileUnit(cci);
788   }
789 
790   Declaration decl;
791   PdbTypeSymId tid(ti, false);
792   SymbolFileTypeSP type_sp =
793       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
794   Variable::RangeList ranges;
795 
796   m_ast->GetOrCreateVariableDecl(var_id);
797 
798   DWARFExpression location = MakeGlobalLocationExpression(
799       section, offset, GetObjectFile()->GetModule());
800 
801   std::string global_name("::");
802   global_name += name;
803   VariableSP var_sp = std::make_shared<Variable>(
804       toOpaqueUid(var_id), name.str().c_str(), global_name.c_str(), type_sp,
805       scope, comp_unit.get(), ranges, &decl, location, is_external, false,
806       false);
807   var_sp->SetLocationIsConstantValueData(false);
808 
809   return var_sp;
810 }
811 
812 lldb::VariableSP
813 SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
814                                           const CVSymbol &cvs) {
815   TpiStream &tpi = m_index->tpi();
816   ConstantSym constant(cvs.kind());
817 
818   llvm::cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(cvs, constant));
819   std::string global_name("::");
820   global_name += constant.Name;
821   PdbTypeSymId tid(constant.Type, false);
822   SymbolFileTypeSP type_sp =
823       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
824 
825   Declaration decl;
826   Variable::RangeList ranges;
827   ModuleSP module = GetObjectFile()->GetModule();
828   DWARFExpression location = MakeConstantLocationExpression(
829       constant.Type, tpi, constant.Value, module);
830 
831   VariableSP var_sp = std::make_shared<Variable>(
832       toOpaqueUid(var_id), constant.Name.str().c_str(), global_name.c_str(),
833       type_sp, eValueTypeVariableGlobal, module.get(), ranges, &decl, location,
834       false, false, false);
835   var_sp->SetLocationIsConstantValueData(true);
836   return var_sp;
837 }
838 
839 VariableSP
840 SymbolFileNativePDB::GetOrCreateGlobalVariable(PdbGlobalSymId var_id) {
841   auto emplace_result = m_global_vars.try_emplace(toOpaqueUid(var_id), nullptr);
842   if (emplace_result.second)
843     emplace_result.first->second = CreateGlobalVariable(var_id);
844 
845   return emplace_result.first->second;
846 }
847 
848 lldb::TypeSP SymbolFileNativePDB::GetOrCreateType(TypeIndex ti) {
849   return GetOrCreateType(PdbTypeSymId(ti, false));
850 }
851 
852 FunctionSP SymbolFileNativePDB::GetOrCreateFunction(PdbCompilandSymId func_id,
853                                                     CompileUnit &comp_unit) {
854   auto emplace_result = m_functions.try_emplace(toOpaqueUid(func_id), nullptr);
855   if (emplace_result.second)
856     emplace_result.first->second = CreateFunction(func_id, comp_unit);
857 
858   return emplace_result.first->second;
859 }
860 
861 CompUnitSP
862 SymbolFileNativePDB::GetOrCreateCompileUnit(const CompilandIndexItem &cci) {
863 
864   auto emplace_result =
865       m_compilands.try_emplace(toOpaqueUid(cci.m_id), nullptr);
866   if (emplace_result.second)
867     emplace_result.first->second = CreateCompileUnit(cci);
868 
869   lldbassert(emplace_result.first->second);
870   return emplace_result.first->second;
871 }
872 
873 Block &SymbolFileNativePDB::GetOrCreateBlock(PdbCompilandSymId block_id) {
874   auto iter = m_blocks.find(toOpaqueUid(block_id));
875   if (iter != m_blocks.end())
876     return *iter->second;
877 
878   return CreateBlock(block_id);
879 }
880 
881 void SymbolFileNativePDB::ParseDeclsForContext(
882     lldb_private::CompilerDeclContext decl_ctx) {
883   clang::DeclContext *context = m_ast->FromCompilerDeclContext(decl_ctx);
884   if (!context)
885     return;
886   m_ast->ParseDeclsForContext(*context);
887 }
888 
889 lldb::CompUnitSP SymbolFileNativePDB::ParseCompileUnitAtIndex(uint32_t index) {
890   if (index >= GetNumCompileUnits())
891     return CompUnitSP();
892   lldbassert(index < UINT16_MAX);
893   if (index >= UINT16_MAX)
894     return nullptr;
895 
896   CompilandIndexItem &item = m_index->compilands().GetOrCreateCompiland(index);
897 
898   return GetOrCreateCompileUnit(item);
899 }
900 
901 lldb::LanguageType SymbolFileNativePDB::ParseLanguage(CompileUnit &comp_unit) {
902   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
903   PdbSymUid uid(comp_unit.GetID());
904   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
905 
906   CompilandIndexItem *item =
907       m_index->compilands().GetCompiland(uid.asCompiland().modi);
908   lldbassert(item);
909   if (!item->m_compile_opts)
910     return lldb::eLanguageTypeUnknown;
911 
912   return TranslateLanguage(item->m_compile_opts->getLanguage());
913 }
914 
915 void SymbolFileNativePDB::AddSymbols(Symtab &symtab) { return; }
916 
917 size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
918   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
919   PdbSymUid uid{comp_unit.GetID()};
920   lldbassert(uid.kind() == PdbSymUidKind::Compiland);
921   uint16_t modi = uid.asCompiland().modi;
922   CompilandIndexItem &cii = m_index->compilands().GetOrCreateCompiland(modi);
923 
924   size_t count = comp_unit.GetNumFunctions();
925   const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray();
926   for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
927     if (iter->kind() != S_LPROC32 && iter->kind() != S_GPROC32)
928       continue;
929 
930     PdbCompilandSymId sym_id{modi, iter.offset()};
931 
932     FunctionSP func = GetOrCreateFunction(sym_id, comp_unit);
933   }
934 
935   size_t new_count = comp_unit.GetNumFunctions();
936   lldbassert(new_count >= count);
937   return new_count - count;
938 }
939 
940 static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
941   // If any of these flags are set, we need to resolve the compile unit.
942   uint32_t flags = eSymbolContextCompUnit;
943   flags |= eSymbolContextVariable;
944   flags |= eSymbolContextFunction;
945   flags |= eSymbolContextBlock;
946   flags |= eSymbolContextLineEntry;
947   return (resolve_scope & flags) != 0;
948 }
949 
950 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
951     const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {
952   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
953   uint32_t resolved_flags = 0;
954   lldb::addr_t file_addr = addr.GetFileAddress();
955 
956   if (NeedsResolvedCompileUnit(resolve_scope)) {
957     llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
958     if (!modi)
959       return 0;
960     CompilandIndexItem *cci = m_index->compilands().GetCompiland(*modi);
961     if (!cci)
962       return 0;
963 
964     sc.comp_unit = GetOrCreateCompileUnit(*cci).get();
965     resolved_flags |= eSymbolContextCompUnit;
966   }
967 
968   if (resolve_scope & eSymbolContextFunction ||
969       resolve_scope & eSymbolContextBlock) {
970     lldbassert(sc.comp_unit);
971     std::vector<SymbolAndUid> matches = m_index->FindSymbolsByVa(file_addr);
972     // Search the matches in reverse.  This way if there are multiple matches
973     // (for example we are 3 levels deep in a nested scope) it will find the
974     // innermost one first.
975     for (const auto &match : llvm::reverse(matches)) {
976       if (match.uid.kind() != PdbSymUidKind::CompilandSym)
977         continue;
978 
979       PdbCompilandSymId csid = match.uid.asCompilandSym();
980       CVSymbol cvs = m_index->ReadSymbolRecord(csid);
981       PDB_SymType type = CVSymToPDBSym(cvs.kind());
982       if (type != PDB_SymType::Function && type != PDB_SymType::Block)
983         continue;
984       if (type == PDB_SymType::Function) {
985         sc.function = GetOrCreateFunction(csid, *sc.comp_unit).get();
986         sc.block = sc.GetFunctionBlock();
987       }
988 
989       if (type == PDB_SymType::Block) {
990         sc.block = &GetOrCreateBlock(csid);
991         sc.function = sc.block->CalculateSymbolContextFunction();
992       }
993     resolved_flags |= eSymbolContextFunction;
994     resolved_flags |= eSymbolContextBlock;
995     break;
996     }
997   }
998 
999   if (resolve_scope & eSymbolContextLineEntry) {
1000     lldbassert(sc.comp_unit);
1001     if (auto *line_table = sc.comp_unit->GetLineTable()) {
1002       if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
1003         resolved_flags |= eSymbolContextLineEntry;
1004     }
1005   }
1006 
1007   return resolved_flags;
1008 }
1009 
1010 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
1011     const FileSpec &file_spec, uint32_t line, bool check_inlines,
1012     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
1013   return 0;
1014 }
1015 
1016 static void AppendLineEntryToSequence(LineTable &table, LineSequence &sequence,
1017                                       const CompilandIndexItem &cci,
1018                                       lldb::addr_t base_addr,
1019                                       uint32_t file_number,
1020                                       const LineFragmentHeader &block,
1021                                       const LineNumberEntry &cur) {
1022   LineInfo cur_info(cur.Flags);
1023 
1024   if (cur_info.isAlwaysStepInto() || cur_info.isNeverStepInto())
1025     return;
1026 
1027   uint64_t addr = base_addr + cur.Offset;
1028 
1029   bool is_statement = cur_info.isStatement();
1030   bool is_prologue = IsFunctionPrologue(cci, addr);
1031   bool is_epilogue = IsFunctionEpilogue(cci, addr);
1032 
1033   uint32_t lno = cur_info.getStartLine();
1034 
1035   table.AppendLineEntryToSequence(&sequence, addr, lno, 0, file_number,
1036                                   is_statement, false, is_prologue, is_epilogue,
1037                                   false);
1038 }
1039 
1040 static void TerminateLineSequence(LineTable &table,
1041                                   const LineFragmentHeader &block,
1042                                   lldb::addr_t base_addr, uint32_t file_number,
1043                                   uint32_t last_line,
1044                                   std::unique_ptr<LineSequence> seq) {
1045   // The end is always a terminal entry, so insert it regardless.
1046   table.AppendLineEntryToSequence(seq.get(), base_addr + block.CodeSize,
1047                                   last_line, 0, file_number, false, false,
1048                                   false, false, true);
1049   table.InsertSequence(seq.release());
1050 }
1051 
1052 bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
1053   // Unfortunately LLDB is set up to parse the entire compile unit line table
1054   // all at once, even if all it really needs is line info for a specific
1055   // function.  In the future it would be nice if it could set the sc.m_function
1056   // member, and we could only get the line info for the function in question.
1057   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1058   PdbSymUid cu_id(comp_unit.GetID());
1059   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
1060   CompilandIndexItem *cci =
1061       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
1062   lldbassert(cci);
1063   auto line_table = llvm::make_unique<LineTable>(&comp_unit);
1064 
1065   // This is basically a copy of the .debug$S subsections from all original COFF
1066   // object files merged together with address relocations applied.  We are
1067   // looking for all DEBUG_S_LINES subsections.
1068   for (const DebugSubsectionRecord &dssr :
1069        cci->m_debug_stream.getSubsectionsArray()) {
1070     if (dssr.kind() != DebugSubsectionKind::Lines)
1071       continue;
1072 
1073     DebugLinesSubsectionRef lines;
1074     llvm::BinaryStreamReader reader(dssr.getRecordData());
1075     if (auto EC = lines.initialize(reader)) {
1076       llvm::consumeError(std::move(EC));
1077       return false;
1078     }
1079 
1080     const LineFragmentHeader *lfh = lines.header();
1081     uint64_t virtual_addr =
1082         m_index->MakeVirtualAddress(lfh->RelocSegment, lfh->RelocOffset);
1083 
1084     const auto &checksums = cci->m_strings.checksums().getArray();
1085     const auto &strings = cci->m_strings.strings();
1086     for (const LineColumnEntry &group : lines) {
1087       // Indices in this structure are actually offsets of records in the
1088       // DEBUG_S_FILECHECKSUMS subsection.  Those entries then have an index
1089       // into the global PDB string table.
1090       auto iter = checksums.at(group.NameIndex);
1091       if (iter == checksums.end())
1092         continue;
1093 
1094       llvm::Expected<llvm::StringRef> efn =
1095           strings.getString(iter->FileNameOffset);
1096       if (!efn) {
1097         llvm::consumeError(efn.takeError());
1098         continue;
1099       }
1100 
1101       // LLDB wants the index of the file in the list of support files.
1102       auto fn_iter = llvm::find(cci->m_file_list, *efn);
1103       lldbassert(fn_iter != cci->m_file_list.end());
1104       // LLDB support file indices are 1-based.
1105       uint32_t file_index =
1106           1 + std::distance(cci->m_file_list.begin(), fn_iter);
1107 
1108       std::unique_ptr<LineSequence> sequence(
1109           line_table->CreateLineSequenceContainer());
1110       lldbassert(!group.LineNumbers.empty());
1111 
1112       for (const LineNumberEntry &entry : group.LineNumbers) {
1113         AppendLineEntryToSequence(*line_table, *sequence, *cci, virtual_addr,
1114                                   file_index, *lfh, entry);
1115       }
1116       LineInfo last_line(group.LineNumbers.back().Flags);
1117       TerminateLineSequence(*line_table, *lfh, virtual_addr, file_index,
1118                             last_line.getEndLine(), std::move(sequence));
1119     }
1120   }
1121 
1122   if (line_table->GetSize() == 0)
1123     return false;
1124 
1125   comp_unit.SetLineTable(line_table.release());
1126   return true;
1127 }
1128 
1129 bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
1130   // PDB doesn't contain information about macros
1131   return false;
1132 }
1133 
1134 bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
1135                                             FileSpecList &support_files) {
1136   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1137   PdbSymUid cu_id(comp_unit.GetID());
1138   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
1139   CompilandIndexItem *cci =
1140       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
1141   lldbassert(cci);
1142 
1143   for (llvm::StringRef f : cci->m_file_list) {
1144     FileSpec::Style style =
1145         f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
1146     FileSpec spec(f, style);
1147     support_files.Append(spec);
1148   }
1149 
1150   llvm::SmallString<64> main_source_file =
1151       m_index->compilands().GetMainSourceFile(*cci);
1152   FileSpec::Style style = main_source_file.startswith("/")
1153                               ? FileSpec::Style::posix
1154                               : FileSpec::Style::windows;
1155   FileSpec spec(main_source_file, style);
1156   support_files.Insert(0, spec);
1157   return true;
1158 }
1159 
1160 bool SymbolFileNativePDB::ParseImportedModules(
1161     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
1162   // PDB does not yet support module debug info
1163   return false;
1164 }
1165 
1166 size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
1167   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1168   GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
1169   // FIXME: Parse child blocks
1170   return 1;
1171 }
1172 
1173 void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
1174 
1175 uint32_t SymbolFileNativePDB::FindGlobalVariables(
1176     ConstString name, const CompilerDeclContext *parent_decl_ctx,
1177     uint32_t max_matches, VariableList &variables) {
1178   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1179   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
1180 
1181   std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
1182       name.GetStringRef(), m_index->symrecords());
1183   for (const SymbolAndOffset &result : results) {
1184     VariableSP var;
1185     switch (result.second.kind()) {
1186     case SymbolKind::S_GDATA32:
1187     case SymbolKind::S_LDATA32:
1188     case SymbolKind::S_GTHREAD32:
1189     case SymbolKind::S_LTHREAD32:
1190     case SymbolKind::S_CONSTANT: {
1191       PdbGlobalSymId global(result.first, false);
1192       var = GetOrCreateGlobalVariable(global);
1193       variables.AddVariable(var);
1194       break;
1195     }
1196     default:
1197       continue;
1198     }
1199   }
1200   return variables.GetSize();
1201 }
1202 
1203 uint32_t SymbolFileNativePDB::FindFunctions(
1204     ConstString name, const CompilerDeclContext *parent_decl_ctx,
1205     FunctionNameType name_type_mask, bool include_inlines, bool append,
1206     SymbolContextList &sc_list) {
1207   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1208   // For now we only support lookup by method name.
1209   if (!(name_type_mask & eFunctionNameTypeMethod))
1210     return 0;
1211 
1212   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
1213 
1214   std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(
1215       name.GetStringRef(), m_index->symrecords());
1216   for (const SymbolAndOffset &match : matches) {
1217     if (match.second.kind() != S_PROCREF && match.second.kind() != S_LPROCREF)
1218       continue;
1219     ProcRefSym proc(match.second.kind());
1220     cantFail(SymbolDeserializer::deserializeAs<ProcRefSym>(match.second, proc));
1221 
1222     if (!IsValidRecord(proc))
1223       continue;
1224 
1225     CompilandIndexItem &cci =
1226         m_index->compilands().GetOrCreateCompiland(proc.modi());
1227     SymbolContext sc;
1228 
1229     sc.comp_unit = GetOrCreateCompileUnit(cci).get();
1230     PdbCompilandSymId func_id(proc.modi(), proc.SymOffset);
1231     sc.function = GetOrCreateFunction(func_id, *sc.comp_unit).get();
1232 
1233     sc_list.Append(sc);
1234   }
1235 
1236   return sc_list.GetSize();
1237 }
1238 
1239 uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
1240                                             bool include_inlines, bool append,
1241                                             SymbolContextList &sc_list) {
1242   return 0;
1243 }
1244 
1245 uint32_t SymbolFileNativePDB::FindTypes(
1246     ConstString name, const CompilerDeclContext *parent_decl_ctx,
1247     bool append, uint32_t max_matches,
1248     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
1249   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1250   if (!append)
1251     types.Clear();
1252   if (!name)
1253     return 0;
1254 
1255   searched_symbol_files.clear();
1256   searched_symbol_files.insert(this);
1257 
1258   // There is an assumption 'name' is not a regex
1259   size_t match_count = FindTypesByName(name.GetStringRef(), max_matches, types);
1260 
1261   return match_count;
1262 }
1263 
1264 size_t
1265 SymbolFileNativePDB::FindTypes(const std::vector<CompilerContext> &context,
1266                                bool append, TypeMap &types) {
1267   return 0;
1268 }
1269 
1270 size_t SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
1271                                             uint32_t max_matches,
1272                                             TypeMap &types) {
1273 
1274   size_t match_count = 0;
1275   std::vector<TypeIndex> matches = m_index->tpi().findRecordsByName(name);
1276   if (max_matches > 0 && max_matches < matches.size())
1277     matches.resize(max_matches);
1278 
1279   for (TypeIndex ti : matches) {
1280     TypeSP type = GetOrCreateType(ti);
1281     if (!type)
1282       continue;
1283 
1284     types.Insert(type);
1285     ++match_count;
1286   }
1287   return match_count;
1288 }
1289 
1290 size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
1291   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1292   // Only do the full type scan the first time.
1293   if (m_done_full_type_scan)
1294     return 0;
1295 
1296   const size_t old_count = GetTypeList().GetSize();
1297   LazyRandomTypeCollection &types = m_index->tpi().typeCollection();
1298 
1299   // First process the entire TPI stream.
1300   for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
1301     TypeSP type = GetOrCreateType(*ti);
1302     if (type)
1303       (void)type->GetFullCompilerType();
1304   }
1305 
1306   // Next look for S_UDT records in the globals stream.
1307   for (const uint32_t gid : m_index->globals().getGlobalsTable()) {
1308     PdbGlobalSymId global{gid, false};
1309     CVSymbol sym = m_index->ReadSymbolRecord(global);
1310     if (sym.kind() != S_UDT)
1311       continue;
1312 
1313     UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
1314     bool is_typedef = true;
1315     if (IsTagRecord(PdbTypeSymId{udt.Type, false}, m_index->tpi())) {
1316       CVType cvt = m_index->tpi().getType(udt.Type);
1317       llvm::StringRef name = CVTagRecord::create(cvt).name();
1318       if (name == udt.Name)
1319         is_typedef = false;
1320     }
1321 
1322     if (is_typedef)
1323       GetOrCreateTypedef(global);
1324   }
1325 
1326   const size_t new_count = GetTypeList().GetSize();
1327 
1328   m_done_full_type_scan = true;
1329 
1330   return new_count - old_count;
1331 }
1332 
1333 size_t
1334 SymbolFileNativePDB::ParseVariablesForCompileUnit(CompileUnit &comp_unit,
1335                                                   VariableList &variables) {
1336   PdbSymUid sym_uid(comp_unit.GetID());
1337   lldbassert(sym_uid.kind() == PdbSymUidKind::Compiland);
1338   return 0;
1339 }
1340 
1341 VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
1342                                                     PdbCompilandSymId var_id,
1343                                                     bool is_param) {
1344   ModuleSP module = GetObjectFile()->GetModule();
1345   Block &block = GetOrCreateBlock(scope_id);
1346   VariableInfo var_info =
1347       GetVariableLocationInfo(*m_index, var_id, block, module);
1348   if (!var_info.location || !var_info.ranges)
1349     return nullptr;
1350 
1351   CompilandIndexItem *cii = m_index->compilands().GetCompiland(var_id.modi);
1352   CompUnitSP comp_unit_sp = GetOrCreateCompileUnit(*cii);
1353   TypeSP type_sp = GetOrCreateType(var_info.type);
1354   std::string name = var_info.name.str();
1355   Declaration decl;
1356   SymbolFileTypeSP sftype =
1357       std::make_shared<SymbolFileType>(*this, type_sp->GetID());
1358 
1359   ValueType var_scope =
1360       is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
1361   VariableSP var_sp = std::make_shared<Variable>(
1362       toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
1363       comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, false,
1364       false, false);
1365 
1366   if (!is_param)
1367     m_ast->GetOrCreateVariableDecl(scope_id, var_id);
1368 
1369   m_local_variables[toOpaqueUid(var_id)] = var_sp;
1370   return var_sp;
1371 }
1372 
1373 VariableSP SymbolFileNativePDB::GetOrCreateLocalVariable(
1374     PdbCompilandSymId scope_id, PdbCompilandSymId var_id, bool is_param) {
1375   auto iter = m_local_variables.find(toOpaqueUid(var_id));
1376   if (iter != m_local_variables.end())
1377     return iter->second;
1378 
1379   return CreateLocalVariable(scope_id, var_id, is_param);
1380 }
1381 
1382 TypeSP SymbolFileNativePDB::CreateTypedef(PdbGlobalSymId id) {
1383   CVSymbol sym = m_index->ReadSymbolRecord(id);
1384   lldbassert(sym.kind() == SymbolKind::S_UDT);
1385 
1386   UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
1387 
1388   TypeSP target_type = GetOrCreateType(udt.Type);
1389 
1390   (void)m_ast->GetOrCreateTypedefDecl(id);
1391 
1392   Declaration decl;
1393   return std::make_shared<lldb_private::Type>(
1394       toOpaqueUid(id), this, ConstString(udt.Name), target_type->GetByteSize(),
1395       nullptr, target_type->GetID(), lldb_private::Type::eEncodingIsTypedefUID,
1396       decl, target_type->GetForwardCompilerType(),
1397       lldb_private::Type::eResolveStateForward);
1398 }
1399 
1400 TypeSP SymbolFileNativePDB::GetOrCreateTypedef(PdbGlobalSymId id) {
1401   auto iter = m_types.find(toOpaqueUid(id));
1402   if (iter != m_types.end())
1403     return iter->second;
1404 
1405   return CreateTypedef(id);
1406 }
1407 
1408 size_t SymbolFileNativePDB::ParseVariablesForBlock(PdbCompilandSymId block_id) {
1409   Block &block = GetOrCreateBlock(block_id);
1410 
1411   size_t count = 0;
1412 
1413   CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
1414   CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);
1415   uint32_t params_remaining = 0;
1416   switch (sym.kind()) {
1417   case S_GPROC32:
1418   case S_LPROC32: {
1419     ProcSym proc(static_cast<SymbolRecordKind>(sym.kind()));
1420     cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym, proc));
1421     CVType signature = m_index->tpi().getType(proc.FunctionType);
1422     ProcedureRecord sig;
1423     cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(signature, sig));
1424     params_remaining = sig.getParameterCount();
1425     break;
1426   }
1427   case S_BLOCK32:
1428     break;
1429   default:
1430     lldbassert(false && "Symbol is not a block!");
1431     return 0;
1432   }
1433 
1434   VariableListSP variables = block.GetBlockVariableList(false);
1435   if (!variables) {
1436     variables = std::make_shared<VariableList>();
1437     block.SetVariableList(variables);
1438   }
1439 
1440   CVSymbolArray syms = limitSymbolArrayToScope(
1441       cii->m_debug_stream.getSymbolArray(), block_id.offset);
1442 
1443   // Skip the first record since it's a PROC32 or BLOCK32, and there's
1444   // no point examining it since we know it's not a local variable.
1445   syms.drop_front();
1446   auto iter = syms.begin();
1447   auto end = syms.end();
1448 
1449   while (iter != end) {
1450     uint32_t record_offset = iter.offset();
1451     CVSymbol variable_cvs = *iter;
1452     PdbCompilandSymId child_sym_id(block_id.modi, record_offset);
1453     ++iter;
1454 
1455     // If this is a block, recurse into its children and then skip it.
1456     if (variable_cvs.kind() == S_BLOCK32) {
1457       uint32_t block_end = getScopeEndOffset(variable_cvs);
1458       count += ParseVariablesForBlock(child_sym_id);
1459       iter = syms.at(block_end);
1460       continue;
1461     }
1462 
1463     bool is_param = params_remaining > 0;
1464     VariableSP variable;
1465     switch (variable_cvs.kind()) {
1466     case S_REGREL32:
1467     case S_REGISTER:
1468     case S_LOCAL:
1469       variable = GetOrCreateLocalVariable(block_id, child_sym_id, is_param);
1470       if (is_param)
1471         --params_remaining;
1472       if (variable)
1473         variables->AddVariableIfUnique(variable);
1474       break;
1475     default:
1476       break;
1477     }
1478   }
1479 
1480   // Pass false for set_children, since we call this recursively so that the
1481   // children will call this for themselves.
1482   block.SetDidParseVariables(true, false);
1483 
1484   return count;
1485 }
1486 
1487 size_t SymbolFileNativePDB::ParseVariablesForContext(const SymbolContext &sc) {
1488   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1489   lldbassert(sc.function || sc.comp_unit);
1490 
1491   VariableListSP variables;
1492   if (sc.block) {
1493     PdbSymUid block_id(sc.block->GetID());
1494 
1495     size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
1496     return count;
1497   }
1498 
1499   if (sc.function) {
1500     PdbSymUid block_id(sc.function->GetID());
1501 
1502     size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
1503     return count;
1504   }
1505 
1506   if (sc.comp_unit) {
1507     variables = sc.comp_unit->GetVariableList(false);
1508     if (!variables) {
1509       variables = std::make_shared<VariableList>();
1510       sc.comp_unit->SetVariableList(variables);
1511     }
1512     return ParseVariablesForCompileUnit(*sc.comp_unit, *variables);
1513   }
1514 
1515   llvm_unreachable("Unreachable!");
1516 }
1517 
1518 CompilerDecl SymbolFileNativePDB::GetDeclForUID(lldb::user_id_t uid) {
1519   if (auto decl = m_ast->GetOrCreateDeclForUid(uid))
1520     return decl.getValue();
1521   else
1522     return CompilerDecl();
1523 }
1524 
1525 CompilerDeclContext
1526 SymbolFileNativePDB::GetDeclContextForUID(lldb::user_id_t uid) {
1527   clang::DeclContext *context =
1528       m_ast->GetOrCreateDeclContextForUid(PdbSymUid(uid));
1529   if (!context)
1530     return {};
1531 
1532   return m_ast->ToCompilerDeclContext(*context);
1533 }
1534 
1535 CompilerDeclContext
1536 SymbolFileNativePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
1537   clang::DeclContext *context = m_ast->GetParentDeclContext(PdbSymUid(uid));
1538   return m_ast->ToCompilerDeclContext(*context);
1539 }
1540 
1541 Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
1542   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1543   auto iter = m_types.find(type_uid);
1544   // lldb should not be passing us non-sensical type uids.  the only way it
1545   // could have a type uid in the first place is if we handed it out, in which
1546   // case we should know about the type.  However, that doesn't mean we've
1547   // instantiated it yet.  We can vend out a UID for a future type.  So if the
1548   // type doesn't exist, let's instantiate it now.
1549   if (iter != m_types.end())
1550     return &*iter->second;
1551 
1552   PdbSymUid uid(type_uid);
1553   lldbassert(uid.kind() == PdbSymUidKind::Type);
1554   PdbTypeSymId type_id = uid.asTypeSym();
1555   if (type_id.index.isNoneType())
1556     return nullptr;
1557 
1558   TypeSP type_sp = CreateAndCacheType(type_id);
1559   return &*type_sp;
1560 }
1561 
1562 llvm::Optional<SymbolFile::ArrayInfo>
1563 SymbolFileNativePDB::GetDynamicArrayInfoForUID(
1564     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
1565   return llvm::None;
1566 }
1567 
1568 
1569 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
1570   clang::QualType qt =
1571       clang::QualType::getFromOpaquePtr(compiler_type.GetOpaqueQualType());
1572 
1573   return m_ast->CompleteType(qt);
1574 }
1575 
1576 size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
1577                                      TypeClass type_mask,
1578                                      lldb_private::TypeList &type_list) {
1579   return 0;
1580 }
1581 
1582 CompilerDeclContext
1583 SymbolFileNativePDB::FindNamespace(ConstString name,
1584                                    const CompilerDeclContext *parent_decl_ctx) {
1585   return {};
1586 }
1587 
1588 TypeSystem *
1589 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
1590   auto type_system =
1591       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
1592   if (type_system)
1593     type_system->SetSymbolFile(this);
1594   return type_system;
1595 }
1596 
1597 ConstString SymbolFileNativePDB::GetPluginName() {
1598   static ConstString g_name("pdb");
1599   return g_name;
1600 }
1601 
1602 uint32_t SymbolFileNativePDB::GetPluginVersion() { return 1; }
1603