contrib/llvm/tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

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